MCP Chinese Getting Started Guide

You can test your SSE-based MCP server using the mcp dev command. When prompted or configuring the tool:

1. Set Transport Type to SSE.
2. Provide the local service URL (e.g., http://localhost:9000/sse).

To use a custom MCP server with the Claude Desktop application, you must edit the claude_desktop_config.json file. Access this by opening Claude Desktop, navigating to the Developer menu, and selecting Edit Config.

Add your server under the mcpServers key. Each server configuration requires a command, args, and optionally env. These parameters match the StdioServerParameters object used in the SDK.

Alternatively, you can install a server directly from its directory using the CLI.

{
  "mcpServers": {
    "web-search-server": {
      "command": "uv",
      "args": [
        "--directory",
        "D:/projects/mcp_getting_started",
        "run",
        "web_search.py"
      ]
    }
  }
}

mcp install web_search.py

To deploy an MCP service to the cloud and avoid local setup, use the Server-Sent Events (SSE) protocol. In FastMCP, you can enable this by setting the transport parameter to 'sse' in the app.run() method.

FastMCP SSE Configuration Options

• host: The service address (defaults to 0.0.0.0).
• port: The service port (defaults to 8000).
• sse_path: The SSE route (defaults to /sse).

from mcp.server import FastMCP

app = FastMCP('web-search', port=9000)

@app.tool()
async def web_search(query: str) -> str:
    # ... tool implementation ...
    pass

if __name__ == "__main__":
    app.run(transport='sse')

The Sampling feature allows an MCP server to request user input or LLM generation during tool execution. This is useful for sensitive operations like file deletion.

Server Side: Use app.get_context().session.create_message() with a SamplingMessage to trigger a callback in the client.

Client Side: When initializing ClientSession, provide a sampling_callback function. This function receives CreateMessageRequestParams and must return a CreateMessageResult containing the user's response.

To use a remote MCP server (deployed via SSE) in Cursor, add the server configuration to your settings using the following JSON format:

{
  "mcpServers": {
    "web-search": {
      "url": "https://your-deployed-service-url/sse"
    }
  }
}

{
  "mcpServers": {
    "web-search": {
      "url": "https://mcp-test-whhergsbso.cn-hangzhou.fcapp.run/sse"
    }
  }
}

When using stdio_client, tool output (like print() statements) may not appear in the terminal. For easier debugging, use mcp.shared.memory.create_connected_server_and_client_session to run the server and client in the same process via memory.

from mcp.shared.memory import create_connected_server_and_client_session as create_session
from file_server import app # Import your FastMCP app

async def main():
    async with create_session(
        app._mcp_server,
        sampling_callback=sampling_callback
    ) as client_session:
        await client_session.call_tool('delete_file', {'file_path': 'test.txt'})

To consume an MCP service running over SSE, use the sse_client from mcp.client.sse to establish a connection, then wrap the streams in a ClientSession.

import asyncio
from mcp.client.sse import sse_client
from mcp import ClientSession

async def main():
    # Replace with your server's SSE URL
    async with sse_client('http://localhost:9000/sse') as streams:
        async with ClientSession(*streams) as session:
            await session.initialize()
            res = await session.call_tool('web_search', {'query': '杭州今天天气'})
            print(res)

if __name__ == '__main__':
    asyncio.run(main())