MCP(大模型上下文)

为什么是 MCP？

一、什么是MCP（Model Context Protocol）

定义

Function Calling是AI模型调用函数的机制，MCP是一个标准协议，使AI模型与API无缝交互，而AI Agent是一个自主运行的智能系统，利用Function Calling和MCP来分析和执行任务，实现特定目标。

MCP 的价值

MCP 与 Function Calling 的区别

• MCP（Model Context Protocol），模型上下文协议

• Function Calling，函数调用

数据安全性

工作原理

• 初始化连接：客户端向服务器发送连接请求，建立通信通道。

• 发送请求：客户端根据需求构建请求消息，并发送给服务器。

• 处理请求：服务器接收到请求后，解析请求内容，执行相应的操作（如查询数据库、读取文件等）。

• 返回结果：服务器将处理结果封装成响应消息，发送回客户端。

• 断开连接：任务完成后，客户端可以主动关闭连接或等待服务器超时关闭。

MCP 核心架构

• MCP 主机（MCP Hosts）：发起请求的 LLM 应用程序（例如 Claude Desktop、IDE 或 AI 工具）。

• MCP 客户端（MCP Clients）：在主机程序内部，与 MCP server 保持 1:1 的连接。

• MCP 服务器（MCP Servers）：为 MCP client 提供上下文、工具和 prompt 信息。

• 本地资源（Local Resources）：本地计算机中可供 MCP server 安全访问的资源（例如文件、数据库）。

• 远程资源（Remote Resources）：MCP server 可以连接到的远程资源（例如通过 API）。

• MCP client 首先从 MCP server 获取可用的工具列表。

• 将用户的查询连同工具描述通过 function calling 一起发送给 LLM。

• LLM 决定是否需要使用工具以及使用哪些工具。

• 如果需要使用工具，MCP client 会通过 MCP server 执行相应的工具调用。

• 工具调用的结果会被发送回 LLM。

• LLM 基于所有信息生成自然语言响应。

• 最后将响应展示给用户。

• 资源（Resources）：类似文件的数据，可以被客户端读取，如 API 响应或文件内容。

• 工具（Tools）：可以被 LLM 调用的函数（需要用户批准）。

• 提示（Prompts）：预先编写的模板，帮助用户完成特定任务。

通信机制

• 本地通信：通过 stdio 传输数据，适用于在同一台机器上运行的客户端和服务器之间的通信。

• 远程通信：利用 SSE 与 HTTP 结合，实现跨网络的实时数据传输，适用于需要访问远程资源或分布式部署的场景。

二、MCP的功能与应用：

如何使用 MCP

MCP的功能

1. 数据与文件系统：
• 文件系统：提供安全文件操作，带可配置的访问控制。
• PostgreSQL：提供只读数据库访问，具备架构检查功能。
• SQLite：支持数据库交互和商业智能功能。
• Google Drive：实现Google Drive的文件访问和搜索功能。

2. 开发工具：
• Git：工具用于读取、搜索和操作Git仓库。
• GitHub：集成仓库管理、文件操作和GitHub API。
• GitLab：支持项目管理的GitLab API集成。
• Sentry：从http://Sentry.io获取并分析问题。

3. 网络与浏览器自动化：
• Brave Search：利用Brave的搜索API进行网络和本地搜索。
• Fetch：为LLM优化的网络内容获取和转换。
• Puppeteer：提供浏览器自动化和网页抓取功能。

4. 生产力和通信：
• Slack：支持频道管理和消息功能。
• Google Maps：提供位置服务、路线和地点详情。
• Memory：基于知识图谱的持久记忆系统。

5. AI与专业工具：
• EverArt：使用多种模型进行AI图像生成。
• Sequential Thinking：通过思维序列进行动态问题解决。
• AWS KB Retrieval：使用Bedrock Agent Runtime从AWS知识库检索。

6. 官方集成工具：
• Axiom：使用自然语言查询和分析日志、跟踪和事件数据。
• Browserbase：云端自动化浏览器交互。
• Cloudflare：在Cloudflare开发者平台上部署和管理资源。
• E2B：在安全的云沙箱中执行代码。
• Neon：与Neon无服务器Postgres平台交互。
• Obsidian Markdown Notes：读取和搜索Obsidian知识库中的Markdown笔记。
• Qdrant：使用Qdrant向量搜索引擎实现语义记忆。
• Raygun：访问崩溃报告和监控数据。
• Search1API：统一的API用于搜索、爬虫和网站地图。
• Tinybird：与Tinybird无服务器ClickHouse平台交互。

7. 集成工具：
• Docker：管理容器、镜像、卷和网络。
• Kubernetes：管理pod、部署和服务。
• Linear：项目管理和问题跟踪。
• Snowflake：与Snowflake数据库交互。
• Spotify：控制Spotify播放和管理播放列表。
• Todoist：任务管理集成。

三、怎么使用和开发MCP Server

使用

Claude Desktop 使用示例

1. 安装 Claude Desktop： 确保已在 macOS 或 Windows 系统上安装最新版本的 Claude Desktop。

2. 配置 MCP 服务器： 在 Claude Desktop 的配置文件中，配置入口Claude Desktop—>菜单—>Settings—>Developer—>Edit Config：

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/files"]
    },
    "git": {
      "command": "uvx",
      "args": ["mcp-server-git", "--repository", "path/to/git/repo"]
    }
  }
}

Cursor中 使用示例

VS Code中使用

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/mark3labs/mcp-go/mcp"
	"github.com/mark3labs/mcp-go/server"
)


func main() {
	// Create MCP server
	s := server.NewMCPServer(
		"Demo 🚀",
		"1.0.0",
	)
	// Add tool
	tool := mcp.NewTool("current time",
		mcp.WithDescription("Get current time with timezone, Asia/Shanghai is default"),
		mcp.WithString("timezone",
			mcp.Required(),
			mcp.Description("current time timezone"),
		),
	)
	// Add tool handler
	s.AddTool(tool, currentTimeHandler)
	// Start the stdio server
	if err := server.ServeStdio(s); err != nil {
		fmt.Printf("Server error: %v\n", err)
	}
}

func currentTimeHandler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
	timezone, ok := request.Params.Arguments["timezone"].(string)
	if !ok {
		return mcp.NewToolResultError("timezone must be a string"), nil
	}

	loc, err := time.LoadLocation(timezone)
	if err != nil {
		return mcp.NewToolResultError(fmt.Sprintf("parse timezone with error: %v", err)), nil
	}
	return mcp.NewToolResultText(fmt.Sprintf(`current time is %s`, time.Now().In(loc))), nil
}

• 通过 mcp.NewTool 定义一个叫做 “current time” 的 tool，它能接受一个叫做 timezone 的参数，默认值为 Asia/Shanghai。

• currentTimeHandler 返回对应时区的当前时间。

• server.ServeStdio 表示通过标准 I/O 进行 PRC 通信。

go build -o bin/current_time_mcp ./cmd/current_time_mcp

{
  "mcpServers": {
    "current_time_mcp": {
      "command": "/Users/huyida/TCYLPRO/code/ai/wow/bin/current_time_mcp",
      "args": [],
      "env": {}
    }
  }
}

告诉我北京时间

MCP 如何工作

• MCP Hosts: Hosts 是指 LLM 启动连接的应用程序，像 Cursor, Claude Desktop、Cline 这样的应用程序。

• MCP Clients: 客户端是用来在 Hosts 应用程序内维护与 Server 之间 1:1 连接。

• MCP Servers: 通过标准化的协议，为 Client 端提供上下文、工具和提示。

• Local Data Sources: 本地的文件、数据库和 API。

• Remote Services: 外部的文件、数据库和 API。

MCP Server 的工作原理

const server = new Server(
  {
    name: "github-mcp-server",
    version: VERSION,
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "search_repositories",
        description: "Search for GitHub repositories",
        inputSchema: zodToJsonSchema(repository.SearchRepositoriesSchema),
      },
      {
        name: "create_issue",
        description: "Create a new issue in a GitHub repository",
        inputSchema: zodToJsonSchema(issues.CreateIssueSchema),
      },
      {
        name: "search_issues",
        description: "Search for issues and pull requests across GitHub repositories",
        inputSchema: zodToJsonSchema(search.SearchIssuesSchema),
      }
    ],
  };
});

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  try {
    if (!request.params.arguments) {
      throw new Error("Arguments are required");
    }

    switch (request.params.name) {
      case "search_repositories": {
        const args = repository.SearchRepositoriesSchema.parse(request.params.arguments);
        const results = await repository.searchRepositories(
          args.query,
          args.page,
          args.perPage
        );
        return {
          content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
        };
      }

      case "create_issue": {
        const args = issues.CreateIssueSchema.parse(request.params.arguments);
        const { owner, repo, ...options } = args;
        const issue = await issues.createIssue(owner, repo, options);
        return {
          content: [{ type: "text", text: JSON.stringify(issue, null, 2) }],
        };
      }

      case "search_issues": {
        const args = search.SearchIssuesSchema.parse(request.params.arguments);
        const results = await search.searchIssues(args);
        return {
          content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
        };
      }

      default:
        throw new Error(`Unknown tool: ${request.params.name}`);
    }
  } catch (error) {}
});

async function runServer() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("GitHub MCP Server running on stdio");
}

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

export const SearchOptions = z.object({
  q: z.string(),
  order: z.enum(["asc", "desc"]).optional(),
  page: z.number().min(1).optional(),
  per_page: z.number().min(1).max(100).optional(),
});

export const SearchIssuesOptions = SearchOptions.extend({
  sort: z.enum([
    "comments",
    ...
  ]).optional(),
});

export async function searchUsers(params: z.infer<typeof SearchUsersSchema>) {
  return githubRequest(buildUrl("https://api.github.com/search/users", params));
}

export const SearchRepositoriesSchema = z.object({
  query: z.string().describe("Search query (see GitHub search syntax)"),
  page: z.number().optional().describe("Page number for pagination (default: 1)"),
  perPage: z.number().optional().describe("Number of results per page (default: 30, max: 100)"),
});

export async function searchRepositories(
  query: string,
  page: number = 1,
  perPage: number = 30
) {
  const url = new URL("https://api.github.com/search/repositories");
  url.searchParams.append("q", query);
  url.searchParams.append("page", page.toString());
  url.searchParams.append("per_page", perPage.toString());

  const response = await githubRequest(url.toString());
  return GitHubSearchResponseSchema.parse(response);
}