发现优秀的 MCP 服务器

mcp-cli-exec MCP Server

一个 CLI 命令执行服务器，它能够运行 shell 命令并提供结构化的输出，包括 stdout、stderr、退出码和执行时长等详细的执行结果。

BetterMCPFileServer

镜子 (jìng zi)

MCP Server for Milvus

用于 Milvus 的模型上下文协议服务器

RemoteZip MCP Server

Enables accessing and extracting files from remote zip archives over HTTP, HTTPS, and FTP without downloading the entire archive. Supports listing files, extracting individual files, and getting file information using partial reading techniques.

Global MCP Servers

用于所有项目的集中式模型上下文协议 (MCP) 服务器

Multi-Agent Tools Platform

A modular production-ready system that provides specialized agents for math, research, weather, and summarization tasks through a unified MCP toolbox with smart supervisor capabilities.

Pexels MCP Server

Enables searching and retrieving high-quality stock photos from Pexels with advanced filtering options including orientation, size, color, and localization support.

MCP Client:

一个 MCP 客户端，用于连接到兼容 MCP 服务器的服务，地址为：

MCP RAG Server

一个机器对话协议（Machine Conversation Protocol, MCP）服务器，它使 AI 代理能够通过查询包含 Sui Move 语言文档的 FAISS 向量数据库来执行检索增强生成（Retrieval-Augmented Generation, RAG）。

nativeMCP

这是一个由 C++ 编写的 MCP 系统，包括 MCP 核心架构的 host、client 和 server。 (Zhè shì yī gè yóu C++ biānxiě de MCP xìtǒng, bāokuò MCP héxīn jiàgòu de host, client hé server.)

SharePoint MCP: The .NET MCP Server with Graph API & Semantic Kernel

Okay, I understand. You want to create an **MCP (Message Center Provider) server** to access **SharePoint Online**. However, there's a potential misunderstanding here. "MCP server" isn't a standard term in the context of SharePoint Online development. It sounds like you're aiming to build a custom application or service that interacts with SharePoint Online data, possibly to receive and process notifications or updates. Therefore, I'll provide you with a general outline and explanation of how to build a service that can access SharePoint Online data, including how to handle notifications and changes. This will involve using the Microsoft Graph API and/or the SharePoint REST API. Here's a breakdown of the steps and considerations, along with the Chinese translation of key terms: **1. Understanding the Goal (理解目标)** * **English:** You want to create a service that can access and potentially react to changes in SharePoint Online. This might involve: * Retrieving data (lists, libraries, documents, etc.) * Monitoring for changes (new files, updated items, etc.) * Performing actions based on those changes (e.g., sending notifications, triggering workflows). * **Chinese:** 你想创建一个服务，可以访问并可能对 SharePoint Online 中的更改做出反应。 这可能涉及： * 检索数据（列表、库、文档等） * 监视更改（新文件、更新的项目等） * 根据这些更改执行操作（例如，发送通知、触发工作流）。 **2. Choosing an API (选择 API)** * **Microsoft Graph API (Microsoft Graph API):** This is the recommended approach for most new development. It provides a unified endpoint to access data across Microsoft 365, including SharePoint Online. It's generally easier to use and more feature-rich than the SharePoint REST API. * **SharePoint REST API (SharePoint REST API):** This is a more direct way to interact with SharePoint Online. It's useful if you need very specific control over SharePoint features. **3. Authentication and Authorization (身份验证和授权)** * **English:** Your service needs to authenticate with Azure Active Directory (Azure AD) to access SharePoint Online. You'll need to register an application in Azure AD and grant it the necessary permissions. There are two main authentication flows: * **Delegated Permissions (委派权限):** The application acts on behalf of a user. The user needs to grant consent to the application. * **Application Permissions (应用程序权限):** The application acts on its own behalf, without a user. This requires administrator consent. This is generally preferred for background services. * **Chinese:** 您的服务需要使用 Azure Active Directory (Azure AD) 进行身份验证才能访问 SharePoint Online。 您需要在 Azure AD 中注册一个应用程序，并授予它必要的权限。 有两种主要的身份验证流程： * **委派权限:** 应用程序代表用户行事。 用户需要授予应用程序同意。 * **应用程序权限:** 应用程序代表自己行事，无需用户。 这需要管理员同意。 这通常是后台服务的首选。 **4. Development Steps (开发步骤)** Here's a general outline of the development process, using the Microsoft Graph API as an example: * **Step 1: Register an Application in Azure AD (在 Azure AD 中注册应用程序)** * Go to the Azure portal (portal.azure.com). * Navigate to "Azure Active Directory" -> "App registrations". * Click "New registration". * Give your application a name (e.g., "SharePointDataService"). * Choose the appropriate account type (usually "Single tenant"). * Set the redirect URI (if needed; for a background service, this might not be necessary). * Click "Register". * Note the "Application (client) ID" and "Directory (tenant) ID". You'll need these later. * **Step 2: Grant API Permissions (授予 API 权限)** * In your Azure AD app registration, go to "API permissions". * Click "Add a permission". * Select "Microsoft Graph". * Choose "Application permissions" (for a background service). * Search for and select the necessary permissions. Common permissions include: * `Sites.Read.All` (Read SharePoint sites) * `Sites.ReadWrite.All` (Read and write SharePoint sites) * `Sites.Manage.All` (Full control of SharePoint sites) * `Files.Read.All` (Read all files) * `Files.ReadWrite.All` (Read and write all files) * Click "Add permissions". * **Important:** After adding application permissions, you need to grant admin consent. Click "Grant admin consent for [Your Tenant Name]". * **Step 3: Obtain an Access Token (获取访问令牌)** * You'll need to use a library like MSAL (Microsoft Authentication Library) to obtain an access token. The code will vary depending on your programming language. Here's a Python example using `msal`: ```python import msal # Replace with your actual values CLIENT_ID = "YOUR_CLIENT_ID" CLIENT_SECRET = "YOUR_CLIENT_SECRET" TENANT_ID = "YOUR_TENANT_ID" AUTHORITY = f"https://login.microsoftonline.com/{TENANT_ID}" SCOPES = ["https://graph.microsoft.com/.default"] # Use .default for application permissions app = msal.ConfidentialClientApplication( CLIENT_ID, authority=AUTHORITY, client_credential=CLIENT_SECRET ) result = app.acquire_token_for_client(scopes=SCOPES) if "access_token" in result: access_token = result["access_token"] print("Access Token:", access_token) else: print(result.get("error_description", "No error information available")) ``` * **Chinese:** ```python import msal # 替换为您的实际值 CLIENT_ID = "YOUR_CLIENT_ID" CLIENT_SECRET = "YOUR_CLIENT_SECRET" TENANT_ID = "YOUR_TENANT_ID" AUTHORITY = f"https://login.microsoftonline.com/{TENANT_ID}" SCOPES = ["https://graph.microsoft.com/.default"] # 使用 .default 作为应用程序权限 app = msal.ConfidentialClientApplication( CLIENT_ID, authority=AUTHORITY, client_credential=CLIENT_SECRET ) result = app.acquire_token_for_client(scopes=SCOPES) if "access_token" in result: access_token = result["access_token"] print("访问令牌:", access_token) else: print(result.get("error_description", "没有可用的错误信息")) ``` * **Step 4: Call the Microsoft Graph API (调用 Microsoft Graph API)** * Use the access token to make requests to the Microsoft Graph API. For example, to get a list of SharePoint sites: ```python import requests GRAPH_API_ENDPOINT = "https://graph.microsoft.com/v1.0/sites" headers = { "Authorization": f"Bearer {access_token}" } response = requests.get(GRAPH_API_ENDPOINT, headers=headers) if response.status_code == 200: sites = response.json() print("SharePoint Sites:", sites) else: print("Error:", response.status_code, response.text) ``` * **Chinese:** ```python import requests GRAPH_API_ENDPOINT = "https://graph.microsoft.com/v1.0/sites" headers = { "Authorization": f"Bearer {access_token}" } response = requests.get(GRAPH_API_ENDPOINT, headers=headers) if response.status_code == 200: sites = response.json() print("SharePoint 站点:", sites) else: print("错误:", response.status_code, response.text) ``` * **Step 5: Handle Changes and Notifications (处理更改和通知)** * **Microsoft Graph Change Notifications (Microsoft Graph 更改通知):** This is the recommended way to receive notifications about changes in SharePoint Online. You can subscribe to changes on specific resources (e.g., a list, a library, a file). When a change occurs, Microsoft Graph will send a notification to your service. You'll need to set up a webhook endpoint to receive these notifications. * **SharePoint Webhooks (SharePoint Webhooks):** An older method, but still supported. Similar to Microsoft Graph Change Notifications, but specific to SharePoint. * **Polling (轮询):** The least efficient method. Your service periodically checks for changes. Avoid this if possible. **5. Key Considerations (关键考虑因素)** * **Error Handling (错误处理):** Implement robust error handling to deal with API errors, authentication failures, and other issues. * **Rate Limiting (速率限制):** Be aware of Microsoft Graph API and SharePoint REST API rate limits. Implement retry logic and caching to avoid exceeding these limits. * **Security (安全):** Protect your client ID and client secret. Store them securely (e.g., using Azure Key Vault). * **Scalability (可扩展性):** Design your service to be scalable to handle a large number of requests and notifications. * **Permissions (权限):** Only request the minimum permissions required for your service to function. * **Monitoring (监控):** Implement monitoring to track the health and performance of your service. **Example: Setting up a Microsoft Graph Change Notification (示例：设置 Microsoft Graph 更改通知)** This is a simplified example. You'll need to adapt it to your specific requirements. 1. **Create a Webhook Endpoint (创建 Webhook 端点):** This is an HTTP endpoint that will receive notifications from Microsoft Graph. You'll need to make this endpoint publicly accessible (e.g., using Azure Functions, Azure App Service, or a similar service). 2. **Create a Subscription (创建订阅):** Use the Microsoft Graph API to create a subscription to the resource you want to monitor. For example, to subscribe to changes in a SharePoint list: ```python import requests import json GRAPH_API_ENDPOINT = "https://graph.microsoft.com/v1.0/subscriptions" WEBHOOK_URL = "YOUR_WEBHOOK_URL" # Replace with your webhook URL RESOURCE = "sites/{site-id}/lists/{list-id}/items" # Replace with your site and list IDs subscription_data = { "changeType": "created,updated,deleted", "notificationUrl": WEBHOOK_URL, "resource": RESOURCE, "expirationDateTime": "2024-12-31T23:59:00.0000000Z", # Adjust expiration date "clientState": "secretClientValue" # Optional, for validation } headers = { "Authorization": f"Bearer {access_token}", "Content-Type": "application/json" } response = requests.post(GRAPH_API_ENDPOINT, headers=headers, data=json.dumps(subscription_data)) if response.status_code == 201: subscription = response.json() print("Subscription created:", subscription) else: print("Error creating subscription:", response.status_code, response.text) ``` * **Chinese:** ```python import requests import json GRAPH_API_ENDPOINT = "https://graph.microsoft.com/v1.0/subscriptions" WEBHOOK_URL = "YOUR_WEBHOOK_URL" # 替换为您的 webhook URL RESOURCE = "sites/{site-id}/lists/{list-id}/items" # 替换为您的站点和列表 ID subscription_data = { "changeType": "created,updated,deleted", "notificationUrl": WEBHOOK_URL, "resource": RESOURCE, "expirationDateTime": "2024-12-31T23:59:00.0000000Z", # 调整过期日期 "clientState": "secretClientValue" # 可选，用于验证 } headers = { "Authorization": f"Bearer {access_token}", "Content-Type": "application/json" } response = requests.post(GRAPH_API_ENDPOINT, headers=headers, data=json.dumps(subscription_data)) if response.status_code == 201: subscription = response.json() print("订阅已创建:", subscription) else: print("创建订阅时出错:", response.status_code, response.text) ``` 3. **Handle the Notification (处理通知):** When a change occurs, Microsoft Graph will send a POST request to your webhook endpoint. Your endpoint needs to: * **Validate the request:** Verify the `clientState` (if you used it). * **Process the notification:** Extract the information about the change and take appropriate action. **Important Notes:** * This is a high-level overview. You'll need to consult the Microsoft Graph API documentation and SharePoint REST API documentation for detailed information. * The code examples are in Python, but you can use any programming language that supports HTTP requests. * Remember to replace the placeholder values (e.g., `YOUR_CLIENT_ID`, `YOUR_CLIENT_SECRET`, `YOUR_TENANT_ID`, `YOUR_WEBHOOK_URL`, `site-id`, `list-id`) with your actual values. * Consider using a framework like Flask or Django (for Python) to build your webhook endpoint. This comprehensive guide should help you get started with building a service to access SharePoint Online data and handle notifications. Remember to adapt the code and steps to your specific requirements. Good luck!

Nerdearla Agenda MCP Server

Provides real-time access to the Nerdearla conference agenda, enabling users to query upcoming talks, past sessions, topic recommendations, and event schedules through natural language interactions.

AI Agent Marketplace Index Search

支持通过关键词或类别搜索 AI 智能体，让用户能够在各个市场中发现诸如编码智能体、GUI 智能体或特定行业助手等工具。

crypto-stocks-mcp

An MCP server that tracks real-time data for major crypto-related stocks to help AI agents analyze blockchain investment opportunities.

MCP Server for MySQL

一个模型上下文协议服务器，提供对 MySQL 数据库的只读访问，使大型语言模型 (LLM) 能够检查数据库模式并执行只读查询。

MCP-RAG Server

Implements Retrieval-Augmented Generation (RAG) using GroundX and OpenAI, allowing users to ingest documents and perform semantic searches with advanced context handling through Modern Context Processing (MCP).

simple-mcp-runner

Simple MCP Runner makes it effortless to safely expose system commands to language models via a lightweight MCP server—all configurable with a clean, minimal YAML file and zero boilerplate.

monday MCP Server

monday MCP Server

Chotu Robo Server

一个 MCP 服务器，集成了基于 Arduino 的机器人技术（ESP32 或 Arduino Nano）与人工智能，允许通过人工智能助手控制硬件组件，如 LED、电机、舵机和传感器。 (Alternatively, a slightly more formal translation:) 一个 MCP 服务器，整合了基于 Arduino 的机器人技术（使用 ESP32 或 Arduino Nano），并结合了人工智能。它允许通过 AI 助手来控制硬件组件，例如 LED、电机、伺服电机和传感器。

MCP Python SDK Documentation

好的，请提供您想让我翻译的 Read the Docs 文档内容，关于 MIT 去中心化 AI，MCP 黑客马拉松。 我会尽力将其翻译成准确且自然的中文。

Whoop MCP Server

Integrates WHOOP biometric data into Claude and other MCP-compatible applications, providing access to sleep analysis, recovery metrics, strain tracking, and biological age data through natural language queries.

Gmail MCP Server

A Model Context Protocol server that enables Claude AI to interact with Gmail, supporting email sending, reading, searching, labeling, draft management, and batch operations through natural language commands.

MCP Server for Vertex AI Search

一个服务器，它使用带有 Gemini grounding 的 Vertex AI 来实现文档搜索，并通过将响应基于存储在 Vertex AI Datastore 中的私有数据来改进搜索结果。

OpenSCAD MCP Server

Enables AI assistants to render 3D models from OpenSCAD code, generating single views or multiple perspectives with full camera control. Supports animations, custom parameters, and returns base64-encoded PNG images for seamless integration.

Vercel MCP Server

一个强大的模型上下文协议（MCP）服务器，能够通过 Cursor 的 Composer 或 Codeium 的 Cascade 实现无缝的 Vercel 项目管理，包括部署、域名、环境变量和团队配置。

flightradar24-mcp-server

一个 Claude 桌面 MCP 服务器，可以帮助你使用 Flightradar24 数据实时追踪航班。非常适合航空爱好者、旅行规划者，或任何对头顶飞过的航班感到好奇的人！

MCP Play Sound Server

Provides audio playback functionality for AI agents, allowing them to play notification sounds when coding tasks are completed.

Splunk MCP Server

Enables AI assistants to interact with Splunk Enterprise and Splunk Cloud instances through standardized MCP interface. Supports executing SPL queries, managing indexes and saved searches, listing applications, and retrieving server information with flexible authentication options.

Rules MCP Server

An MCP server that allows coding agents to look up contextual rules and patterns on demand, providing just-in-time guidance for specific tasks like writing tests or authoring UI.

Getting Started

Okay, here's a basic example of a Golang MCP (Mesh Configuration Protocol) server. This example focuses on the core structure and handling of requests. It's a simplified illustration and would need significant expansion for a real-world deployment. ```go package main import ( "context" "fmt" "log" "net" "os" "os/signal" "syscall" "google.golang.org/grpc" "google.golang.org/grpc/reflection" mcp "istio.io/api/mcp/v1alpha1" // Use the correct MCP API version "istio.io/pkg/log" ) const ( port = ":8080" // Or any other suitable port ) // MCP Server Implementation type mcpServer struct { mcp.UnimplementedAggregatedMeshConfigServiceServer // Important: Embed this! // Add any server-side state here, e.g., a cache of resources. // resourceCache map[string][]byte // Example: Keyed by resource name } // NewMCPServer creates a new MCP server instance. func NewMCPServer() *mcpServer { return &mcpServer{ //resourceCache: make(map[string][]byte), } } // StreamAggregatedResources implements the MCP server's streaming endpoint. func (s *mcpServer) StreamAggregatedResources(stream mcp.AggregatedMeshConfigService_StreamAggregatedResourcesServer) error { log.Infof("New StreamAggregatedResources connection") defer log.Infof("StreamAggregatedResources connection closed") for { request, err := stream.Recv() if err != nil { log.Infof("StreamAggregatedResources recv error: %v", err) return err } log.Infof("Received request: %v", request) // **IMPORTANT: Process the request and generate a response.** // This is where the core logic of your MCP server goes. // You need to: // 1. Examine the `request.TypeUrl` to determine the resource type being requested (e.g., Envoy Cluster, Route, Listener). // 2. Examine the `request.ResponseNonce` to track request/response pairs. // 3. Examine the `request.ResourceNames` to see which specific resources are being requested. // 4. Fetch the requested resources from your data source (e.g., a database, a file, an in-memory cache). // 5. Construct an `mcp.AggregatedMeshConfigResponse` containing the resources. // 6. Send the response using `stream.Send()`. // **Example (Very Basic): Respond with an empty response.** response := &mcp.AggregatedMeshConfigResponse{ TypeUrl: request.TypeUrl, // Echo back the requested type. CRITICAL! Nonce: "some-nonce", // Generate a unique nonce for each response. CRITICAL! VersionInfo: "v1", // Indicate the version of the resources. Resources: []*mcp.Resource{}, // Empty resource list for now. } if err := stream.Send(response); err != nil { log.Infof("StreamAggregatedResources send error: %v", err) return err } log.Infof("Sent response: %v", response) } } func main() { // Set up gRPC server. lis, err := net.Listen("tcp", port) if err != nil { log.Fatalf("failed to listen: %v", err) } s := grpc.NewServer() mcpServer := NewMCPServer() mcp.RegisterAggregatedMeshConfigServiceServer(s, mcpServer) // Enable reflection for debugging (optional, but useful). reflection.Register(s) // Graceful shutdown handling. signalChan := make(chan os.Signal, 1) signal.Notify(signalChan, syscall.SIGINT, syscall.SIGTERM) go func() { log.Infof("Server listening on port %s", port) if err := s.Serve(lis); err != nil { log.Fatalf("failed to serve: %v", err) } }() // Block until a signal is received. <-signalChan log.Info("Shutting down server...") // Gracefully stop the gRPC server. s.GracefulStop() log.Info("Server gracefully stopped") } ``` Key improvements and explanations: * **`istio.io/api/mcp/v1alpha1` Import:** This is *crucial*. You *must* use the correct MCP API version that matches the client (e.g., Istio control plane) you're interacting with. The `v1alpha1` is a common version, but check your Istio/Envoy documentation. If you use the wrong version, the client and server will not be able to communicate. * **`UnimplementedAggregatedMeshConfigServiceServer`:** The `mcpServer` struct *must* embed `mcp.UnimplementedAggregatedMeshConfigServiceServer`. This satisfies the gRPC interface requirements. Without it, your server won't compile. * **Error Handling:** Includes basic error handling for `Listen` and `Serve`. More robust error handling is needed in a production environment. * **Logging:** Uses `istio.io/pkg/log` for logging. This is the standard logging library used within Istio and related projects. Configure the logging level appropriately. * **`StreamAggregatedResources` Implementation:** This is the *heart* of the MCP server. It handles the bi-directional streaming of requests and responses. * **Request Processing (Placeholder):** The code now includes a *very important* comment block within `StreamAggregatedResources`. This is where you implement the core logic to: * **Determine the Resource Type:** Examine `request.TypeUrl` (e.g., `type.googleapis.com/envoy.config.cluster.v3.Cluster`). This tells you what kind of resource the client is requesting. * **Handle Nonces:** Use `request.ResponseNonce` to track request/response pairs. This is essential for ensuring that responses are correctly associated with requests, especially in the face of network issues or retries. * **Fetch Resources:** Retrieve the requested resources from your data source (e.g., a database, a file, an in-memory cache). * **Construct the Response:** Create an `mcp.AggregatedMeshConfigResponse` containing the resources. The `response.Resources` field is a slice of `*mcp.Resource`. You'll need to marshal your resources into `mcp.Resource` objects. * **Send the Response:** Use `stream.Send()` to send the response back to the client. * **Example Response (Empty):** The example provides a *minimal* response that echoes back the `TypeUrl` and sets a `Nonce`. **This is not a complete implementation.** You *must* populate the `response.Resources` field with the actual resources. * **Nonce Generation:** The `Nonce` field in the response is *critical*. It should be a unique identifier for each response. Use a UUID or a similar mechanism to generate nonces. * **VersionInfo:** The `VersionInfo` field is used to indicate the version of the resources being sent. This allows the client to track changes and update its configuration accordingly. * **Graceful Shutdown:** Includes a basic graceful shutdown mechanism using signals (SIGINT, SIGTERM). This allows the server to shut down cleanly without interrupting ongoing requests. * **gRPC Reflection:** Enables gRPC reflection, which is useful for debugging and testing. You can use tools like `grpcurl` to inspect the server's API. **To make this example functional, you need to:** 1. **Implement the Resource Fetching Logic:** Replace the placeholder comments in `StreamAggregatedResources` with code that fetches the actual resources from your data source. 2. **Marshal Resources into `mcp.Resource`:** You'll need to marshal your resources (e.g., Envoy Cluster, Route, Listener configurations) into the `mcp.Resource` type. This typically involves using the appropriate protobuf definitions for the resource type. 3. **Generate Nonces:** Implement a mechanism to generate unique nonces for each response. 4. **Handle Errors:** Add more robust error handling throughout the code. 5. **Configure Logging:** Configure the logging level and output format for the `istio.io/pkg/log` library. **Example of Marshaling a Resource (Conceptual):** ```go // Assuming you have an Envoy Cluster object (e.g., from envoy/config/cluster/v3/cluster.proto) // and it's stored in a variable called 'cluster'. // Marshal the cluster object to protobuf. clusterBytes, err := proto.Marshal(cluster) // Requires "google.golang.org/protobuf/proto" if err != nil { log.Errorf("Error marshaling cluster: %v", err) return err } // Create an mcp.Resource. resource := &mcp.Resource{ Body: &any.Any{ // Requires "google.golang.org/protobuf/types/known/anypb" TypeUrl: "type.googleapis.com/envoy.config.cluster.v3.Cluster", // IMPORTANT: Match the resource type! Value: clusterBytes, }, //Metadata: ... (Optional: Add metadata if needed) } ``` **Important Considerations:** * **Security:** In a production environment, you'll need to secure the gRPC connection using TLS and implement authentication and authorization. * **Scalability:** Consider how to scale your MCP server to handle a large number of clients and resources. Caching, load balancing, and database optimization may be necessary. * **Data Consistency:** Ensure that your data source is consistent and that changes are propagated to the MCP server in a timely manner. * **Testing:** Thoroughly test your MCP server to ensure that it correctly handles requests and responses and that it can recover from errors. * **MCP API Version:** Double-check the MCP API version used by your Istio control plane or other clients and ensure that your server uses the same version. This comprehensive example provides a solid foundation for building a Golang MCP server. Remember to adapt it to your specific needs and environment. ```chinese 好的，这是一个 Golang MCP (Mesh Configuration Protocol) 服务器的基本示例。 这个示例侧重于核心结构和请求处理。 这是一个简化的说明，需要进行大量扩展才能进行实际部署。 ```go package main import ( "context" "fmt" "log" "net" "os" "os/signal" "syscall" "google.golang.org/grpc" "google.golang.org/grpc/reflection" mcp "istio.io/api/mcp/v1alpha1" // 使用正确的 MCP API 版本 "istio.io/pkg/log" ) const ( port = ":8080" // 或任何其他合适的端口 ) // MCP 服务器实现 type mcpServer struct { mcp.UnimplementedAggregatedMeshConfigServiceServer // 重要：嵌入这个！ // 在此处添加任何服务器端状态，例如，资源缓存。 // resourceCache map[string][]byte // 示例：按资源名称键控 } // NewMCPServer 创建一个新的 MCP 服务器实例。 func NewMCPServer() *mcpServer { return &mcpServer{ //resourceCache: make(map[string][]byte), } } // StreamAggregatedResources 实现 MCP 服务器的流式端点。 func (s *mcpServer) StreamAggregatedResources(stream mcp.AggregatedMeshConfigService_StreamAggregatedResourcesServer) error { log.Infof("New StreamAggregatedResources connection") defer log.Infof("StreamAggregatedResources connection closed") for { request, err := stream.Recv() if err != nil { log.Infof("StreamAggregatedResources recv error: %v", err) return err } log.Infof("Received request: %v", request) // **重要：处理请求并生成响应。** // 这是 MCP 服务器的核心逻辑所在。 // 你需要： // 1. 检查 `request.TypeUrl` 以确定请求的资源类型（例如，Envoy 集群、路由、监听器）。 // 2. 检查 `request.ResponseNonce` 以跟踪请求/响应对。 // 3. 检查 `request.ResourceNames` 以查看请求哪些特定资源。 // 4. 从你的数据源（例如，数据库、文件、内存缓存）获取请求的资源。 // 5. 构造一个包含资源的 `mcp.AggregatedMeshConfigResponse`。 // 6. 使用 `stream.Send()` 发送响应。 // **示例（非常基本）：使用空响应进行响应。** response := &mcp.AggregatedMeshConfigResponse{ TypeUrl: request.TypeUrl, // 回显请求的类型。 关键！ Nonce: "some-nonce", // 为每个响应生成一个唯一的 nonce。 关键！ VersionInfo: "v1", // 指示资源的版本。 Resources: []*mcp.Resource{}, // 暂时为空资源列表。 } if err := stream.Send(response); err != nil { log.Infof("StreamAggregatedResources send error: %v", err) return err } log.Infof("Sent response: %v", response) } } func main() { // 设置 gRPC 服务器。 lis, err := net.Listen("tcp", port) if err != nil { log.Fatalf("failed to listen: %v", err) } s := grpc.NewServer() mcpServer := NewMCPServer() mcp.RegisterAggregatedMeshConfigServiceServer(s, mcpServer) // 启用反射以进行调试（可选，但很有用）。 reflection.Register(s) // 优雅关闭处理。 signalChan := make(chan os.Signal, 1) signal.Notify(signalChan, syscall.SIGINT, syscall.SIGTERM) go func() { log.Infof("Server listening on port %s", port) if err := s.Serve(lis); err != nil { log.Fatalf("failed to serve: %v", err) } }() // 阻塞直到收到信号。 <-signalChan log.Info("Shutting down server...") // 优雅地停止 gRPC 服务器。 s.GracefulStop() log.Info("Server gracefully stopped") } ``` 关键改进和说明： * **`istio.io/api/mcp/v1alpha1` 导入：** 这 *至关重要*。 你 *必须* 使用与你交互的客户端（例如，Istio 控制平面）匹配的正确 MCP API 版本。 `v1alpha1` 是一个常见的版本，但请检查你的 Istio/Envoy 文档。 如果你使用错误的版本，客户端和服务器将无法通信。 * **`UnimplementedAggregatedMeshConfigServiceServer`：** `mcpServer` 结构 *必须* 嵌入 `mcp.UnimplementedAggregatedMeshConfigServiceServer`。 这满足 gRPC 接口要求。 如果没有它，你的服务器将无法编译。 * **错误处理：** 包括 `Listen` 和 `Serve` 的基本错误处理。 在生产环境中需要更强大的错误处理。 * **日志记录：** 使用 `istio.io/pkg/log` 进行日志记录。 这是 Istio 和相关项目中使用的标准日志记录库。 适当地配置日志记录级别。 * **`StreamAggregatedResources` 实现：** 这是 MCP 服务器的 *核心*。 它处理请求和响应的双向流。 * **请求处理（占位符）：** 代码现在包含 `StreamAggregatedResources` 中的 *非常重要的* 注释块。 这是你实现核心逻辑的地方： * **确定资源类型：** 检查 `request.TypeUrl`（例如，`type.googleapis.com/envoy.config.cluster.v3.Cluster`）。 这告诉你客户端正在请求哪种类型的资源。 * **处理 Nonce：** 使用 `request.ResponseNonce` 跟踪请求/响应对。 这对于确保响应与请求正确关联至关重要，尤其是在出现网络问题或重试的情况下。 * **获取资源：** 从你的数据源（例如，数据库、文件、内存缓存）检索请求的资源。 * **构造响应：** 创建一个包含资源的 `mcp.AggregatedMeshConfigResponse`。 `response.Resources` 字段是 `*mcp.Resource` 的切片。 你需要将你的资源编组到 `mcp.Resource` 对象中。 * **发送响应：** 使用 `stream.Send()` 将响应发送回客户端。 * **示例响应（空）：** 该示例提供了一个 *最小的* 响应，该响应回显 `TypeUrl` 并设置一个 `Nonce`。 **这不是一个完整的实现。** 你 *必须* 使用实际资源填充 `response.Resources` 字段。 * **Nonce 生成：** 响应中的 `Nonce` 字段 *至关重要*。 它应该是每个响应的唯一标识符。 使用 UUID 或类似的机制来生成 nonce。 * **VersionInfo：** `VersionInfo` 字段用于指示发送的资源的版本。 这允许客户端跟踪更改并相应地更新其配置。 * **优雅关闭：** 包括使用信号（SIGINT，SIGTERM）的基本优雅关闭机制。 这允许服务器干净地关闭，而不会中断正在进行的请求。 * **gRPC 反射：** 启用 gRPC 反射，这对于调试和测试很有用。 你可以使用诸如 `grpcurl` 之类的工具来检查服务器的 API。 **要使此示例起作用，你需要：** 1. **实现资源获取逻辑：** 将 `StreamAggregatedResources` 中的占位符注释替换为从你的数据源获取实际资源的代码。 2. **将资源编组到 `mcp.Resource` 中：** 你需要将你的资源（例如，Envoy 集群、路由、监听器配置）编组到 `mcp.Resource` 类型中。 这通常涉及使用资源类型的适当 protobuf 定义。 3. **生成 Nonce：** 实现一种为每个响应生成唯一 nonce 的机制。 4. **处理错误：** 在整个代码中添加更强大的错误处理。 5. **配置日志记录：** 配置 `istio.io/pkg/log` 库的日志记录级别和输出格式。 **编组资源示例（概念性的）：** ```go // 假设你有一个 Envoy Cluster 对象（例如，来自 envoy/config/cluster/v3/cluster.proto） // 并且它存储在一个名为 'cluster' 的变量中。 // 将集群对象编组为 protobuf。 clusterBytes, err := proto.Marshal(cluster) // 需要 "google.golang.org/protobuf/proto" if err != nil { log.Errorf("Error marshaling cluster: %v", err) return err } // 创建一个 mcp.Resource。 resource := &mcp.Resource{ Body: &any.Any{ // 需要 "google.golang.org/protobuf/types/known/anypb" TypeUrl: "type.googleapis.com/envoy.config.cluster.v3.Cluster", // 重要：匹配资源类型！ Value: clusterBytes, }, //Metadata: ... (可选：如果需要，添加元数据) } ``` **重要注意事项：** * **安全性：** 在生产环境中，你需要使用 TLS 保护 gRPC 连接，并实现身份验证和授权。 * **可伸缩性：** 考虑如何扩展你的 MCP 服务器以处理大量客户端和资源。 可能需要缓存、负载平衡和数据库优化。 * **数据一致性：** 确保你的数据源是一致的，并且更改及时传播到 MCP 服务器。 * **测试：** 彻底测试你的 MCP 服务器，以确保它正确处理请求和响应，并且可以从错误中恢复。 * **MCP API 版本：** 仔细检查你的 Istio 控制平面或其他客户端使用的 MCP API 版本，并确保你的服务器使用相同的版本。 这个全面的示例为构建 Golang MCP 服务器奠定了坚实的基础。 记住根据你的特定需求和环境进行调整。 ```