发现优秀的 MCP 服务器

Heim MCP

A MCP server do create and deploy backend applications using https://heim.dev

MCP Documentation Server

Provides comprehensive access to MCP documentation through structured guides, full-text search, and interactive development workflows for building servers and clients.

Clockify Master MCP

Integrates Clockify time tracking directly into Claude Desktop, enabling users to start/stop timers, manage projects and clients, create tasks, generate reports, and track productivity through natural language commands.

weather-mcp-server

天气 MCP 服务器 (Tiānqì MCP fúwùqì)

Terminal MCP Server

This request is a bit ambiguous. "MCP server" could refer to a few things, and the desired functionality isn't entirely clear. Here are a few possible interpretations and their corresponding Chinese translations, along with explanations: **Interpretation 1: A server that allows you to remotely execute terminal commands on a machine running Claude Desktop.** This is the most likely interpretation. You want a server component that can receive commands from Claude Desktop and execute them on the host machine's terminal. * **Chinese Translation:** 用于通过 Claude Desktop 执行终端命令的 MCP 服务器 (Yòng yú tōngguò Claude Desktop zhíxíng zhōngduān mìnglìng de MCP fúwùqì) * **Breakdown:** * 用于 (yòng yú): used for * 通过 (tōngguò): through, via * Claude Desktop: Claude Desktop (no translation needed) * 执行 (zhíxíng): to execute, to run * 终端命令 (zhōngduān mìnglìng): terminal commands * 的 (de): possessive particle (of) * MCP 服务器 (MCP fúwùqì): MCP server **Interpretation 2: A server that *is* Claude Desktop, and it allows you to execute terminal commands.** This is less likely, as Claude Desktop is primarily an interface to a large language model. However, if you're thinking of Claude Desktop *itself* acting as the server. * **Chinese Translation:** 作为 Claude Desktop 的服务器，用于执行终端命令 (Zuòwéi Claude Desktop de fúwùqì, yòng yú zhíxíng zhōngduān mìnglìng) * **Breakdown:** * 作为 (zuòwéi): as, acting as * Claude Desktop: Claude Desktop (no translation needed) * 的 (de): possessive particle (of) * 服务器 (fúwùqì): server * 用于 (yòng yú): used for * 执行 (zhíxíng): to execute, to run * 终端命令 (zhōngduān mìnglìng): terminal commands **Interpretation 3: MCP refers to a specific technology or protocol, and you want a server implementing that protocol for terminal command execution via Claude Desktop.** If "MCP" has a specific technical meaning in your context, please provide more details. Without that context, I can't provide a more accurate translation. For example, if MCP is a messaging protocol: * **Chinese Translation (Example - assuming MCP is a messaging protocol):** 使用 MCP 协议通过 Claude Desktop 执行终端命令的服务器 (Shǐyòng MCP xiéyì tōngguò Claude Desktop zhíxíng zhōngduān mìnglìng de fúwùqì) * **Breakdown:** * 使用 (shǐyòng): to use * MCP 协议 (MCP xiéyì): MCP protocol * 通过 (tōngguò): through, via * Claude Desktop: Claude Desktop (no translation needed) * 执行 (zhíxíng): to execute, to run * 终端命令 (zhōngduān mìnglìng): terminal commands * 的 (de): possessive particle (of) * 服务器 (fúwùqì): server **Important Considerations and Questions for Clarification:** * **Security:** Executing arbitrary terminal commands from a remote source is a *major* security risk. You need to carefully consider authentication, authorization, and input sanitization. * **What is "MCP"?** Knowing what "MCP" refers to is crucial for a precise answer. * **How does Claude Desktop interact with the server?** What protocol (e.g., HTTP, gRPC, custom protocol) will be used for communication? * **What operating system is the server running on?** (Windows, Linux, macOS) This affects the specific terminal commands that can be executed. * **What is the purpose of executing terminal commands?** Understanding the use case will help determine the best approach. To get the most accurate translation and helpful advice, please provide more context about what you're trying to achieve.

BBQ MCP Server

Provides BBQ cooking guidance with live ThermoWorks Cloud integration for real-time temperature monitoring, stall detection, cook time estimation, and expert recommendations for 20+ proteins across various cooking methods.

Open-E JovianDSS REST API Documentation MCP Server

Provides access to Open-E JovianDSS REST API documentation for intelligent search, endpoint analysis, and version comparison. It enables developers to integrate and interact with JovianDSS storage services through natural language via the Model Context Protocol.

MCP Server Boilerplate

这是一个 Model Context Protocol (MCP) 服务器的简单样板实现。

SSH MCP Remote

Enables remote command execution on SSH hosts (NAS, Linux, VPS) through an HTTP+SSE server, allowing users to run shell commands and receive results via the ssh.exec tool.

STAC MCP Server

Enables AI assistants to search and access geospatial datasets through STAC (SpatioTemporal Asset Catalog) APIs. Supports querying satellite imagery, weather data, and other geospatial assets with spatial, temporal, and attribute filters.

Stack AI MCP Server

Enables users to connect and run Stack AI workflows directly through MCP-compatible clients. It allows for passing user inputs to specific projects and receiving structured responses from deployed AI applications.

ClinicalTrials.gov Natural Language API Server

Enables users to query ClinicalTrials.gov using natural language instead of complex API parameters, translating plain English requests into structured API calls and returning organized clinical trial data.

Polymarket MCP

A Model Context Protocol (MCP) server for Polymarket prediction markets, providing real-time market data, prices, and AI-powered analysis tools for Claude Desktop integration.

Jokes MCP Server

An MCP server that delivers random jokes from multiple sources including Chuck Norris jokes, Dad jokes, and Yo Mama jokes for Microsoft Copilot Studio integration.

StreamSets MCP Server

Enables complete StreamSets Control Hub integration through conversational AI, allowing users to manage data pipelines, monitor jobs, and interactively build new pipelines with 44 tools across 9 StreamSets services. Features persistent pipeline builder sessions that let users create complete ETL workflows through natural language conversations.

Roblox MCP Server

Enables AI assistants to interact with running Roblox game instances by inspecting the game hierarchy, reading client-side scripts, and executing Lua code directly within the Roblox client through a WebSocket bridge.

Upstox MCP Server

Enables AI-powered trading and portfolio management through Upstox API integration. Supports portfolio rebalancing strategies with LLM inference for automated trading decisions.

Mcp_proxy_pydantic_agent

好的，以下是将 MCP 服务器暴露给 Pydantic Agents 的一个例子： **英文:** Here's an example of exposing MCP (Model Control Plane) servers to Pydantic Agents: **Conceptual Overview:** 1. **MCP Server:** Imagine you have an MCP server that manages machine learning models. It might provide endpoints for: * Listing available models. * Getting model metadata (e.g., input/output schema). * Making predictions using a specific model. 2. **Pydantic Agent:** You want to create a Pydantic Agent that can interact with this MCP server. The agent should be able to: * Discover available models. * Choose the appropriate model for a given task. * Call the model with the correct input format. * Process the model's output. 3. **Pydantic Models for MCP Interaction:** You'll define Pydantic models to represent the data structures used when communicating with the MCP server. This includes: * A model for representing a model's metadata (name, description, input schema, output schema). * A model for representing the input to a model. * A model for representing the output from a model. 4. **Agent Tools:** You'll create agent tools that use these Pydantic models to interact with the MCP server. These tools will handle the HTTP requests to the MCP server and parse the responses into Pydantic objects. **Simplified Example (using Python and `requests` library):** ```python from pydantic import BaseModel, Field from typing import List, Dict, Any import requests # 1. Pydantic Models for MCP Data class ModelMetadata(BaseModel): name: str = Field(..., description="The name of the model.") description: str = Field(..., description="A description of the model.") input_schema: Dict[str, Any] = Field(..., description="The input schema of the model.") output_schema: Dict[str, Any] = Field(..., description="The output schema of the model.") class ModelInput(BaseModel): data: Dict[str, Any] = Field(..., description="The input data for the model.") class ModelOutput(BaseModel): result: Any = Field(..., description="The output from the model.") # 2. Agent Tools for MCP Interaction class MCPClient: def __init__(self, mcp_server_url: str): self.mcp_server_url = mcp_server_url def list_models(self) -> List[ModelMetadata]: """Lists all available models on the MCP server.""" response = requests.get(f"{self.mcp_server_url}/models") response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) model_data = response.json() return [ModelMetadata(**model) for model in model_data] def get_model_metadata(self, model_name: str) -> ModelMetadata: """Gets the metadata for a specific model.""" response = requests.get(f"{self.mcp_server_url}/models/{model_name}") response.raise_for_status() model_data = response.json() return ModelMetadata(**model_data) def predict(self, model_name: str, input_data: ModelInput) -> ModelOutput: """Makes a prediction using the specified model.""" response = requests.post(f"{self.mcp_server_url}/models/{model_name}/predict", json=input_data.dict()) response.raise_for_status() output_data = response.json() return ModelOutput(**output_data) # 3. Example Usage (Conceptual - needs integration with a Pydantic Agent framework) # Assuming you have a Pydantic Agent framework set up (e.g., using LangChain) # Initialize the MCP client mcp_client = MCPClient(mcp_server_url="http://your-mcp-server.com") # Example: List available models available_models = mcp_client.list_models() print("Available Models:", available_models) # Example: Get metadata for a specific model if available_models: first_model_name = available_models[0].name model_metadata = mcp_client.get_model_metadata(first_model_name) print("Model Metadata:", model_metadata) # Example: Make a prediction input_data = ModelInput(data={"feature1": 1.0, "feature2": 2.0}) # Replace with actual input data prediction = mcp_client.predict(first_model_name, input_data) print("Prediction:", prediction) # In a real Pydantic Agent setup, you would: # 1. Define tools that wrap the MCPClient methods. # 2. Use the Pydantic models to define the input and output types of the tools. # 3. Register these tools with your Pydantic Agent. # 4. The agent can then use these tools to interact with the MCP server based on the user's instructions. ``` **Explanation:** * **Pydantic Models:** `ModelMetadata`, `ModelInput`, and `ModelOutput` define the structure of the data exchanged with the MCP server. The `Field` annotations provide descriptions that can be used by the agent framework for tool selection and parameter validation. * **MCPClient:** This class encapsulates the logic for interacting with the MCP server. It uses the `requests` library to make HTTP requests and parses the responses into Pydantic objects. * **Example Usage:** This section shows how you would use the `MCPClient` to interact with the MCP server. It's a simplified example and would need to be integrated with a Pydantic Agent framework like LangChain. * **Important Considerations for Pydantic Agents:** * **Tool Definition:** You would need to define tools that wrap the `MCPClient` methods. Each tool would have a name, description, and input/output types defined using Pydantic models. * **Agent Integration:** You would register these tools with your Pydantic Agent framework. The agent would then be able to use these tools to interact with the MCP server based on the user's instructions. * **Error Handling:** The `response.raise_for_status()` method is used for basic error handling. You might need to add more sophisticated error handling to your agent. * **Authentication:** If your MCP server requires authentication, you would need to add authentication logic to the `MCPClient`. **中文:** 以下是将 MCP (模型控制平面) 服务器暴露给 Pydantic Agents 的一个例子： **概念概述:** 1. **MCP 服务器:** 假设你有一个 MCP 服务器，用于管理机器学习模型。它可能提供以下端点： * 列出可用的模型。 * 获取模型元数据（例如，输入/输出模式）。 * 使用特定模型进行预测。 2. **Pydantic Agent:** 你想创建一个可以与此 MCP 服务器交互的 Pydantic Agent。该 Agent 应该能够： * 发现可用的模型。 * 为给定的任务选择合适的模型。 * 使用正确的输入格式调用模型。 * 处理模型的输出。 3. **用于 MCP 交互的 Pydantic 模型:** 你将定义 Pydantic 模型来表示与 MCP 服务器通信时使用的数据结构。 这包括： * 一个用于表示模型元数据的模型（名称、描述、输入模式、输出模式）。 * 一个用于表示模型输入的模型。 * 一个用于表示模型输出的模型。 4. **Agent 工具:** 你将创建 Agent 工具，这些工具使用这些 Pydantic 模型与 MCP 服务器交互。 这些工具将处理到 MCP 服务器的 HTTP 请求，并将响应解析为 Pydantic 对象。 **简化示例 (使用 Python 和 `requests` 库):** ```python from pydantic import BaseModel, Field from typing import List, Dict, Any import requests # 1. 用于 MCP 数据的 Pydantic 模型 class ModelMetadata(BaseModel): name: str = Field(..., description="模型的名称。") description: str = Field(..., description="模型的描述。") input_schema: Dict[str, Any] = Field(..., description="模型的输入模式。") output_schema: Dict[str, Any] = Field(..., description="模型的输出模式。") class ModelInput(BaseModel): data: Dict[str, Any] = Field(..., description="模型的输入数据。") class ModelOutput(BaseModel): result: Any = Field(..., description="模型的输出。") # 2. 用于 MCP 交互的 Agent 工具 class MCPClient: def __init__(self, mcp_server_url: str): self.mcp_server_url = mcp_server_url def list_models(self) -> List[ModelMetadata]: """列出 MCP 服务器上所有可用的模型。""" response = requests.get(f"{self.mcp_server_url}/models") response.raise_for_status() # 为错误的响应（4xx 或 5xx）引发 HTTPError model_data = response.json() return [ModelMetadata(**model) for model in model_data] def get_model_metadata(self, model_name: str) -> ModelMetadata: """获取特定模型的元数据。""" response = requests.get(f"{self.mcp_server_url}/models/{model_name}") response.raise_for_status() model_data = response.json() return ModelMetadata(**model_data) def predict(self, model_name: str, input_data: ModelInput) -> ModelOutput: """使用指定的模型进行预测。""" response = requests.post(f"{self.mcp_server_url}/models/{model_name}/predict", json=input_data.dict()) response.raise_for_status() output_data = response.json() return ModelOutput(**output_data) # 3. 示例用法 (概念性的 - 需要与 Pydantic Agent 框架集成) # 假设你已经设置了一个 Pydantic Agent 框架（例如，使用 LangChain） # 初始化 MCP 客户端 mcp_client = MCPClient(mcp_server_url="http://your-mcp-server.com") # 示例：列出可用的模型 available_models = mcp_client.list_models() print("可用的模型:", available_models) # 示例：获取特定模型的元数据 if available_models: first_model_name = available_models[0].name model_metadata = mcp_client.get_model_metadata(first_model_name) print("模型元数据:", model_metadata) # 示例：进行预测 input_data = ModelInput(data={"feature1": 1.0, "feature2": 2.0}) # 替换为实际的输入数据 prediction = mcp_client.predict(first_model_name, input_data) print("预测:", prediction) # 在实际的 Pydantic Agent 设置中，你需要： # 1. 定义包装 MCPClient 方法的工具。 # 2. 使用 Pydantic 模型定义工具的输入和输出类型。 # 3. 将这些工具注册到你的 Pydantic Agent。 # 4. 然后，Agent 可以使用这些工具根据用户的指令与 MCP 服务器交互。 ``` **解释:** * **Pydantic 模型:** `ModelMetadata`、`ModelInput` 和 `ModelOutput` 定义了与 MCP 服务器交换的数据的结构。 `Field` 注释提供了描述，Agent 框架可以使用这些描述进行工具选择和参数验证。 * **MCPClient:** 此类封装了与 MCP 服务器交互的逻辑。 它使用 `requests` 库发出 HTTP 请求并将响应解析为 Pydantic 对象。 * **示例用法:** 本节展示了如何使用 `MCPClient` 与 MCP 服务器交互。 这是一个简化的示例，需要与像 LangChain 这样的 Pydantic Agent 框架集成。 * **Pydantic Agents 的重要注意事项:** * **工具定义:** 你需要定义包装 `MCPClient` 方法的工具。 每个工具都将具有一个名称、描述以及使用 Pydantic 模型定义的输入/输出类型。 * **Agent 集成:** 你需要将这些工具注册到你的 Pydantic Agent 框架。 然后，Agent 将能够使用这些工具根据用户的指令与 MCP 服务器交互。 * **错误处理:** `response.raise_for_status()` 方法用于基本的错误处理。 你可能需要在你的 Agent 中添加更复杂的错误处理。 * **身份验证:** 如果你的 MCP 服务器需要身份验证，你需要将身份验证逻辑添加到 `MCPClient`。 This translation aims to be accurate and maintain the technical nuances of the original English text. It also provides explanations to help understand the code and concepts.

Python Simple MCP Weather Server

A tutorial-based MCP server that fetches real-time weather data from the OpenWeatherMap API for specified locations. It serves as a practical example for implementing the Model Context Protocol using Python and the FastMCP library.

OpenWeatherMap MCP Server

Provides weather data integration using the OpenWeatherMap API, enabling users to fetch current weather conditions, hourly and daily forecasts, weather alerts, and geocoding services for any location worldwide.

Stocks MCP Server

Provides real-time access to financial market data including stock quotes, company information, cryptocurrency exchange rates, historical options chains, and time series data through the Alpha Vantage API.

Obsidian MCP Server

Enables Claude to read, write, search, and manage Obsidian vault notes with Git-backed sync support for multi-device access and extensible AI workflows.

MCP Logger

A personal fitness tracking server that enables logging and querying workouts, nutrition, and body metrics through a local SQLite database. Integrates with OpenNutrition MCP for food logging and supports exercise history tracking for workout progression.

Excel MCP Server

Enables AI agents to create, read, and manipulate Excel workbooks without Microsoft Excel installed, supporting formulas, formatting, charts, pivot tables, and data validation operations.

MCP Swagger Server

Automatically generates MCP servers from OpenAPI/Swagger specifications, enabling users to interact with any REST API through natural language with flexible endpoint filtering and authentication support.

cryptopanic-mcp-server

Provides AI agents with real-time cryptocurrency news and media updates sourced from CryptoPanic. It allows users to fetch multiple pages of content to track market sentiment and the latest developments in the crypto space.

Korea Weather MCP Server

使用韩国气象厅 (KWS) 的 MCP 服务器