MCP Typed Prompts

🚀 Model Context Protocol (MCP) Python SDK Documentation

The Model Context Protocol (MCP) is an open protocol designed to establish a standardized interface between language models and applications. Through MCP, developers can create highly interactive applications where models can directly call external tools and resources.

The MCP Python SDK offers a set of easy - to - use APIs that assist developers in quickly integrating MCP functionality into their projects.

🚀 Quick Start

✨ Features

• The Model Context Protocol (MCP) is an open protocol, enabling a standardized interface between language models and applications.
• MCP allows models to directly call external tools and resources, facilitating the creation of highly interactive applications.
• The MCP Python SDK provides simple and user - friendly APIs for seamless integration of MCP features into projects.

📦 Installation

Install the latest version of the MCP SDK using pip:

pip install mcp-sdk

💻 Usage Examples

Basic Usage

The following is a basic usage example of MCP:

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

# Create parameters for connecting to the MCP server
server_params = StdioServerParameters(
    command="python", # Execution file path
    args=["example_server.py"], # Optional command - line arguments
    env=None # Optional environment variables
)

async def run():
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            # Initialize the connection
            await session.initialize()

            # List available prompt templates
            prompts = await session.list_prompts()

            # Get a prompt template
            prompt = await session.get_prompt("example-prompt", arguments={"arg1": "value"})

if __name__ == "__main__":
    import asyncio
    asyncio.run(run())

Advanced Usage

Low - level Server Implementation

If you need more low - level control, you can directly use the low - level server implementation:

from mcp.server.lowlevel import Server, NotificationOptions
from mcp.server.models import InitializationOptions
import mcp.server.stdio
import mcp.types as types

# Create a server instance
server = Server("example-server")

@server.list_prompts()
async def handle_list_prompts() -> list[types.Prompt]:
    return [
        types.Prompt(
            name="example-prompt",
            description="An example prompt template",
            arguments=[
                types.PromptArgument(
                    name="arg1",
                    description="Example parameter",
                    required=True
                )
            ]
        )
    ]

@server.get_prompt()
async def handle_get_prompt(
    name: str,
    arguments: dict[str, Any] | None
) -> types.GetPromptResult:
    if name != "example-prompt":
        raise ValueError(f"Unknown prompt template: {name}")

    return types.GetPromptResult(
        description="Example prompt",
        messages=[
            types.PromptMessage(
                role="user",
                content=types.TextContent(
                    type="text",
                    text="Example prompt text"
                )
            )
        ]
    )

async def run():
    async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
        await server.run(
            read_stream,
            write_stream,
            InitializationOptions(
                server_name="example",
                server_version="0.1.0",
                capabilities=server.get_capabilities(
                    notification_options=NotificationOptions(),
                ),
            ),
        )

if __name__ == "__main__":
    import asyncio
    asyncio.run(run())

Prompt Templates

# Create a prompt template
from mcp.types import Prompt, PromptArgument

prompt = Prompt(
    name="example-prompt",
    description="This is an example prompt template.",
    arguments=[
        PromptArgument(
            name="input_text",
            description="Input text.",
            required=True
        )
    ]
)

# Get a prompt template
async def get_prompt():
    prompt = await session.get_prompt("example-prompt", arguments={"input_text": "Hello, world!"})
    print(prompt)

Resources

# Create a resource
from mcp.types import Resource, FileResource

resource = Resource(
    name="example-resource",
    description="This is an example resource.",
    type=FileResource,
    path="path/to/resource"
)

# Get a resource
async def get_resource():
    resource = await session.get_resource("example-resource")
    print(resource)

Tools

# Create a tool
from mcp.types import Tool, FunctionTool

tool = Tool(
    name="example-tool",
    description="This is an example tool.",
    type=FunctionTool,
    function=lambda x: f"Hello, {x}"
)

# Get a tool
async def get_tool():
    tool = await session.get_tool("example-tool")
    print(tool)

📚 Documentation

MCP Basic Primitives

Prompts

Prompts are the means of interaction between the model and the user. MCP defines the following types of prompt templates:

• SystemPrompt: Defines the role and behavior of the system.
• UserPrompt: Receives user input and generates responses.
• ExamplePrompt: Provides examples to the model to help it understand how to handle specific tasks.

Resources

Resources are an important part of MCP. MCP supports the following types of resources:

• FileResource: Loads and manages files.
• URLResource: Loads content from a network URL.
• MemoryResource: Temporarily stores data in memory.

Tools

Tools allow the model to call external services or scripts to perform specific tasks. MCP defines multiple tool types:

• FunctionTool: Registers a function as a tool, which the model can directly call.
• WebServiceTool: Interacts with HTTP services.
• ScriptTool: Executes pre - written scripts.

Server Capabilities

MCP defines a series of server capabilities that enable the model to dynamically load and manage resources as needed:

• BasicCapability: The most basic capability, providing basic operations on prompt templates, tools, and resources.
• ExtendedCapability: Extended functionality, including advanced querying, filtering, and sorting.
• CustomCapability: Allows developers to customize server functions.

📄 License

The MCP Python SDK is licensed under the MIT License. For more detailed information, please refer to the license file.

📚 Documentation

Reference Documents

• MCP Protocol Specification
• MCP Official Documentation

Example Code Repositories

• Official Examples
• Community - contributed Examples

Contributing

If you wish to contribute to the MCP project, please refer to our Contribution Guide to learn how to participate in code development, report issues, or propose new features.