MCP（Model Context Protocol）

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params":{
    //...
  }
}

Accept: application/json, text/event-stream

{
    "id": 3,
    "jsonrpc": "2.0",
    "result": {
      //...
    }
}

{
  "method": "initialize",
  "params": {
    "protocolVersion": "2025-06-18",
    "capabilities": {},
    "clientInfo": {
      "name": "Cherry Studio",
      "version": "1.5.9"
    }
  },
  "jsonrpc": "2.0",
  "id": 0
}

{
  "jsonrpc": "2.0",
  "id": 0,
  "result": {
    "protocolVersion": "2025-06-18",
    "capabilities": {
      "completions": {},
      "prompts": {
        "listChanged": false
      },
      "resources": {
        "subscribe": false,
        "listChanged": false
      },
      "tools": {
        "listChanged": false
      }
    },
    "serverInfo": {
      "name": "mcp-server",
      "version": "1.0.0"
    }
  }
}

{
    "method": "notifications/initialized",
    "jsonrpc": "2.0"
}

{
    "method": "ping",
    "jsonrpc": "2.0",
    "id": 1
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {}
}

{
    "method": "tools/list",
    "jsonrpc": "2.0",
    "id": 2
}

{
    "id": 2,
    "jsonrpc": "2.0",
    "result": {
        "tools": [
            {
                "description": "获取城市天气",
                "inputSchema": {
                    "type": "object",
                    "properties": {
                        "city": {
                            "type": "string"
                        }
                    },
                    "required": [
                        "city"
                    ],
                    "additionalProperties": false
                },
                "name": "getWeather"
            }
        ]
    }
}

{
  "jsonrpc": "2.0",
  "id": 3,
  "method": "tools/call",
  "params": {
    "name": "getWeather",
    "arguments": { "city": "杭州" }
  }
}

{
    "id": 3,
    "jsonrpc": "2.0",
    "result": {
        "content": [
            {
                "type": "text",
                "text": "杭州今日晴转多云"
            }
        ],
        "isError": false
    }
}

request: {"id":0,"jsonrpc":"2.0","method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"Cherry Studio","version":"1.5.9"}}}
response: {"id":0,"jsonrpc":"2.0","result":{"capabilities":{"tools":{"listChanged":false}},"protocolVersion":"2025-06-18","serverInfo":{"name":"mcp-weather-server","version":"1.0.0"}}}
-------------------
request: {"jsonrpc":"2.0","method":"notifications/initialized"}
response: null
-------------------
request: {"id":1,"jsonrpc":"2.0","method":"tools/list"}
response: {"id":1,"jsonrpc":"2.0","result":{"tools":[{"description":"获取指定城市的天气预报","inputSchema":{"type":"object","properties":{"city":{"type":"string","description":"城市名"}},"required":["city"],"additionalProperties":false},"name":"getWeather"}]}}
-------------------
request: {"id":2,"jsonrpc":"2.0","method":"ping"}
response: {"id":2,"jsonrpc":"2.0","result":{}}
-------------------
request: {"id":3,"jsonrpc":"2.0","method":"prompts/list"}
response: null
-------------------
request: {"id":4,"jsonrpc":"2.0","method":"ping"}
response: {"id":4,"jsonrpc":"2.0","result":{}}
-------------------
request: {"id":5,"jsonrpc":"2.0","method":"resources/list"}
response: null
-------------------
request: {"id":6,"jsonrpc":"2.0","method":"ping"}
response: {"id":6,"jsonrpc":"2.0","result":{}}
-------------------
request: {"id":7,"jsonrpc":"2.0","method":"tools/call","params":{"name":"getWeather","arguments":{"city":"北京"},"_meta":{"progressToken":9}}}
response: {"id":7,"jsonrpc":"2.0","result":{"content":[{"text":"北京今日雷暴雨，建议居家","type":"text"}],"isError":false}}

# pip install mcp
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import (
    Tool, TextContent, CallToolResult,
    ListToolsResult
)

# 创建 MCP Server
server = Server("my-tools-server")

# 声明可用工具
@server.list_tools()
async def list_tools() -> ListToolsResult:
    return ListToolsResult(tools=[
        Tool(
            name="calculate",
            description="计算数学表达式",
            inputSchema={
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "要计算的数学表达式"
                    }
                },
                "required": ["expression"]
            }
        ),
        Tool(
            name="read_file",
            description="读取文件内容",
            inputSchema={
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "文件路径"
                    }
                },
                "required": ["path"]
            }
        )
    ])

# 实现工具逻辑
@server.call_tool()
async def call_tool(name: str, arguments: dict) -> CallToolResult:
    if name == "calculate":
        import math
        try:
            expression = arguments["expression"]
            safe_env = {k: getattr(math, k) for k in dir(math) if not k.startswith('_')}
            # ⚠️ 安全警告：eval() 在生产环境中有安全风险
            # 建议使用 simpleeval 库替代：pip install simpleeval
            result = eval(expression, {"__builtins__": {}}, safe_env)
            return CallToolResult(
                content=[TextContent(type="text", text=f"{expression} = {result}")]
            )
        except Exception as e:
            return CallToolResult(
                content=[TextContent(type="text", text=f"错误：{e}")],
                isError=True
            )

    elif name == "read_file":
        path = arguments["path"]
        try:
            with open(path, 'r', encoding='utf-8') as f:
                content = f.read()
            return CallToolResult(
                content=[TextContent(type="text", text=content)]
            )
        except Exception as e:
            return CallToolResult(
                content=[TextContent(type="text", text=f"读取失败：{e}")],
                isError=True
            )

    else:
        return CallToolResult(
            content=[TextContent(type="text", text=f"未知工具：{name}")],
            isError=True
        )

# 以 stdio 模式运行（供 Claude Desktop 等客户端连接）
async def main():
    async with stdio_server() as (read_stream, write_stream):
        await server.run(read_stream, write_stream)

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

# MCP 除了工具(Tools)，还支持：

# 1. 资源(Resources)：静态数据源
@server.list_resources()
async def list_resources():
    return [
        Resource(
            uri="file:///docs/readme.md",
            name="项目文档",
            mimeType="text/markdown"
        )
    ]

# 2. 提示词模板(Prompts)
@server.list_prompts()
async def list_prompts():
    return [
        Prompt(
            name="code_review",
            description="代码审查模板",
            arguments=[
                PromptArgument(name="code", required=True)
            ]
        )
    ]

# pip install mcp anthropic
import anthropic
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
import asyncio

async def use_mcp_tools(query: str):
    """使用 MCP 工具的 Agent"""

    # 连接到 MCP Server
    server_params = StdioServerParameters(
        command="python",
        args=["my_mcp_server.py"],  # 上面定义的服务器文件
    )

    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize() # 初始化连接
            tools_result = await session.list_tools() # 获取可用工具

            # 将 MCP 工具转换为 Anthropic 格式
            anthropic_tools = [
                {
                    "name": tool.name,
                    "description": tool.description,
                    "input_schema": tool.inputSchema
                }
                for tool in tools_result.tools
            ]

            client = anthropic.Anthropic()

            # 调用 Claude 并允许使用工具
            response = client.messages.create(
                model="claude-4-sonnet-20250514",
                max_tokens=1024,
                tools=anthropic_tools,
                messages=[{"role": "user", "content": query}]
            )

            # 处理工具调用
            while response.stop_reason == "tool_use":
                tool_results = []
                for content_block in response.content:
                    if content_block.type == "tool_use":
                        # 通过 MCP 执行工具
                        tool_result = await session.call_tool(
                            content_block.name,
                            content_block.input
                        )

                        tool_results.append({
                            "type": "tool_result",
                            "tool_use_id": content_block.id,
                            "content": tool_result.content[0].text
                        })

                # 继续对话
                response = client.messages.create(
                    model="claude-4-sonnet-20250514",
                    max_tokens=1024,
                    tools=anthropic_tools,
                    messages=[
                        {"role": "user", "content": query},
                        {"role": "assistant", "content": response.content},
                        {"role": "user", "content": tool_results}
                    ]
                )

            # 返回最终文本回复
            for block in response.content:
                if hasattr(block, "text"):
                    return block.text

# 测试
asyncio.run(use_mcp_tools("计算 sqrt(144) + pi * 2"))

async with stdio_client(server_params) as (read, write):

async with ClientSession(read, write) as session:

my-mcp-server/
├── src/            # 源码
│   └── index.ts              # 主入口
├── build/              # 编译输出（gitignored）
│   └── index.js
├── node_modules/
├── package.json        # 依赖和脚本
├── tsconfig.json        # 编译器配置
├── dependencies.sh           # 全局依赖安装脚本（可选）
├── Dockerfile
├── dockerBuild.sh
├── dockerPublish.sh
├── publish.sh
├── start.sh                  # 本地开发启动脚本
└── README.md

{
  "name": "@yourname/my-mcp-server",
  "version": "1.0.0",
  "description": "MCP server for ...",
  "main": "build/index.js",
  "bin": {
    "my-mcp-server": "build/index.js"
  },
  "scripts": {
    "build": "tsc",
    "start": "node build/index.js",
    "dev": "tsx watch src/index.ts"
  },
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.0.0"
  },
  "devDependencies": {
    "@types/node": "^20.0.0",
    "tsx": "^4.0.0",
    "typescript": "^5.0.0"
  },
  "keywords": ["mcp", "model-context-protocol"],
  "author": "yourname",
  "license": "MIT"
}

#!/usr/bin/env node
// 第一行是 Shebang（解释器指令）：用 env 找到 node 的位置，然后用 node 解释器执行脚本

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
  ListResourcesRequestSchema,
  ReadResourceRequestSchema,
  ListPromptsRequestSchema,
  GetPromptRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";

// ============= 工具定义 =============
const TOOLS = [
  {
    name: "hello",
    description: "返回问候语",
    inputSchema: {
      type: "object",
      properties: {
        name: { type: "string", description: "要问候的名字" },
      },
      required: ["name"],
    },
  },
  {
    name: "echo",
    description: "返回输入的消息",
    inputSchema: {
      type: "object",
      properties: {
        message: { type: "string", description: "要回显的消息" },
      },
      required: ["message"],
    },
  },
];

// ============= 资源定义 =============
const RESOURCES = [
  {
    uri: "info://status",
    name: "服务状态",
    description: "返回 MCP Server 的运行状态",
    mimeType: "application/json",
  },
];

// ============= Prompt 定义 =============
const PROMPTS = [
  {
    name: "greet",
    description: "生成一个友好的问候提示",
    arguments: [
      {
        name: "user",
        description: "用户名",
        required: true,
      },
    ],
  },
];

// ============= 工具处理函数 =============
async function handleToolCall(name: string, args: any) {
  switch (name) {
    case "hello":
      return {
        content: [{ type: "text", text: `Hello, ${args.name}!` }],
      };
    case "echo":
      return {
        content: [{ type: "text", text: args.message }],
      };
    default:
      throw new Error(`Unknown tool: ${name}`);
  }
}

// ============= 资源处理函数 =============
async function handleResourceRead(uri: string) {
  if (uri === "info://status") {
    return {
      contents: [
        {
          uri,
          mimeType: "application/json",
          text: JSON.stringify({ status: "running", timestamp: Date.now() }),
        },
      ],
    };
  }
  throw new Error(`Unknown resource: ${uri}`);
}

// ============= Prompt 处理函数 =============
async function handlePromptGet(name: string, args: any) {
  if (name === "greet") {
    const userName = args?.user || "there";
    return {
      messages: [
        {
          role: "user",
          content: {
            type: "text",
            text: `Please generate a warm greeting for ${userName}.`,
          },
        },
      ],
    };
  }
  throw new Error(`Unknown prompt: ${name}`);
}

// ============= 主函数 =============
async function main() {
  const server = new Server(
    {
      name: "my-mcp-server",
      version: "1.0.0",
    },
    {
      capabilities: {
        tools: {},
        resources: {},
        prompts: {},
      },
    }
  );

  // 注册工具列表处理器
  server.setRequestHandler(ListToolsRequestSchema, async () => ({
    tools: TOOLS,
  }));

  // 注册工具调用处理器
  server.setRequestHandler(CallToolRequestSchema, async (request) => {
    const { name, arguments: args } = request.params;
    return handleToolCall(name, args);
  });

  // 注册资源列表处理器
  server.setRequestHandler(ListResourcesRequestSchema, async () => ({
    resources: RESOURCES,
  }));

  // 注册资源读取处理器
  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
    const { uri } = request.params;
    return handleResourceRead(uri);
  });

  // 注册 Prompt 列表处理器
  server.setRequestHandler(ListPromptsRequestSchema, async () => ({
    prompts: PROMPTS,
  }));

  // 注册 Prompt 获取处理器
  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
    const { name, arguments: args } = request.params;
    return handlePromptGet(name, args);
  });

  // 启动 stdio 传输
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("MCP Server running on stdio");
}

main().catch((error) => {
  console.error("Server error:", error);
  process.exit(1);
});

#!/bin/bash
set -e

# 运行测试（如果有）
# npm test

# 构建
npm run build

# 发布到 npm
npm publish --access public

echo "Published to npm"

#!/bin/bash
VERSION=${1:-1.0.0}
IMAGE_NAME="yourname/my-mcp-server"

echo "Building ${IMAGE_NAME}:${VERSION}..."
docker build -t ${IMAGE_NAME}:${VERSION} .
docker tag ${IMAGE_NAME}:${VERSION} ${IMAGE_NAME}:latest
echo "Done"

#!/bin/bash
VERSION=${1:-1.0.0}
IMAGE_NAME="yourname/my-mcp-server"

echo "Pushing ${IMAGE_NAME}:${VERSION}..."
docker push ${IMAGE_NAME}:${VERSION}
docker push ${IMAGE_NAME}:latest
echo "Done"

{
  "mcpServers": {
    "my-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "yourname/my-mcp-server:latest"
      ],
      "autoApprove": ["hello", "echo"]
    }
  }
}

{
  "mcpServers": {
    "my-mcp-server": {
      "command": "npx",
      "args": [
        "-y",
        "@yourname/my-mcp-server"
      ],
      "autoApprove": ["hello", "echo"]
    }
  }
}

#!/bin/bash
# 用 /bin/bash 这个程序来执行当前脚本

# 如果使用 nvm
# nvm use 20

# 全局安装 TypeScript 相关工具（可选）
npm install -g typescript
npm install -g @types/node

# 如果有其他全局依赖
# npm install -g some-global-tool

{
  "mcpServers": {
    "my-mcp-server-dev": {
      "command": "node",
      "args": ["/absolute/path/to/my-mcp-server/build/index.js", "--api-url", "http://localhost:8224/pi/api/v2"],
      "autoApprove": ["hello", "echo"]
    }
  }
}

#!/usr/bin/env node

import { Anthropic } from "@anthropic-ai/sdk";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
import { CallToolResultSchema, ListToolsResultSchema } from "@modelcontextprotocol/sdk/types.js";

interface McpTool {
  name: string;
  description?: string;
  inputSchema: {
    type: "object";
    properties?: Record<string, unknown>;
    required?: string[];
  };
}

interface ToolCallContent {
  type: "tool_use";
  id: string;
  name: string;
  input: Record<string, unknown>;
}

interface AssistantContent {
  type: "text";
  text: string;
}

interface ToolResultContent {
  type: "tool_result";
  tool_use_id: string;
  content: string;
}

async function useMcpTools(query: string): Promise<string> {
  // 1. 连接到 MCP Server
  const transport = new StdioClientTransport({
    command: "node",  // 或 "python"，取决于你的 MCP Server
    args: ["./path/to/your-mcp-server.js"],  // 你的 MCP Server 路径
  });

  const client = new Client(
    { name: "my-agent", version: "1.0.0" },
    { capabilities: {} }
  );

  await client.connect(transport);

  try {
    // 2. 获取可用工具
    const toolsResult = await client.request(
      { method: "tools/list" },
      ListToolsResultSchema
    );

    // 3. 转换 MCP 工具为 Anthropic 格式
    const anthropicTools: Anthropic.Tool[] = toolsResult.tools.map((tool: McpTool) => ({
      name: tool.name,
      description: tool.description || "",
      input_schema: tool.inputSchema,
    }));

    const anthropic = new Anthropic();

    // 4. 初始消息
    let messages: Anthropic.MessageParam[] = [
      { role: "user", content: query }
    ];

    let response = await anthropic.messages.create({
      model: "claude-3-sonnet-20241022",  // 或 "claude-4-sonnet-20250514"
      max_tokens: 1024,
      tools: anthropicTools,
      messages: messages,
    });

    // 5. 处理工具调用循环
    while (response.stop_reason === "tool_use") {
      // 保存 assistant 的响应
      messages.push({
        role: "assistant",
        content: response.content,
      });

      const toolResults: ToolResultContent[] = [];

      // 处理每个 tool_use 块
      for (const block of response.content) {
        if (block.type === "tool_use") {
          // 通过 MCP 执行工具
          const toolResult = await client.request(
            {
              method: "tools/call",
              params: {
                name: block.name,
                arguments: block.input,
              },
            },
            CallToolResultSchema
          );

          // 提取结果文本
          let resultText = "";
          for (const content of toolResult.content) {
            if (content.type === "text") {
              resultText += content.text;
            }
          }

          toolResults.push({
            type: "tool_result",
            tool_use_id: block.id,
            content: resultText,
          });
        }
      }

      // 添加 tool_result 消息
      messages.push({
        role: "user",
        content: toolResults as any, // ToolResultBlock 类型
      });

      // 继续对话
      response = await anthropic.messages.create({
        model: "claude-3-sonnet-20241022",
        max_tokens: 1024,
        tools: anthropicTools,
        messages: messages,
      });
    }

    // 6. 返回最终文本回复
    for (const block of response.content) {
      if (block.type === "text") {
        return block.text;
      }
    }

    return "No text response from Claude";
  } finally {
    await client.close();
  }
}

// 测试
async function main() {
  const result = await useMcpTools("计算 sqrt(144) + pi * 2");
  console.log(result);
}

if (require.main === module) {
  main().catch(console.error);
}

export { useMcpTools };