Discover Awesome MCP Servers

literature-agent-mcp

Exposes a local biomedical literature pipeline as MCP tools for automated research workflows. Enables literature search, open-access paper retrieval, and draft generation for biomedical and pathology domains through standard MCP clients.

Aws Sample Gen Ai Mcp Server

Okay, here's a Python code sample demonstrating how to use a Generative AI model (like those available through Amazon Bedrock) with an MCP (Model Control Plane) server. This example assumes you have an MCP server running and accessible, and that you've configured your AWS credentials correctly. ```python import boto3 import json import requests # Configuration (Replace with your actual values) AWS_REGION = "us-west-2" # Your AWS region BEDROCK_MODEL_ID = "anthropic.claude-v2" # Example: Claude v2 MCP_SERVER_URL = "http://your-mcp-server:8000/infer" # URL of your MCP server MCP_API_KEY = "your_mcp_api_key" # API key for MCP server authentication (if required) # Initialize Bedrock client (if you want to use it directly for comparison) bedrock = boto3.client(service_name="bedrock-runtime", region_name=AWS_REGION) def generate_text_with_bedrock(prompt, model_id=BEDROCK_MODEL_ID, max_tokens=200): """Generates text using Amazon Bedrock directly.""" try: body = json.dumps({ "prompt": prompt, "max_tokens_to_sample": max_tokens, "temperature": 0.5, # Adjust as needed "top_p": 0.9 }) response = bedrock.invoke_model( body=body, modelId=model_id, accept="application/json", contentType="application/json" ) response_body = json.loads(response["body"].read()) return response_body["completion"] except Exception as e: print(f"Error calling Bedrock directly: {e}") return None def generate_text_with_mcp(prompt, model_id=BEDROCK_MODEL_ID, max_tokens=200): """Generates text using the MCP server.""" try: payload = { "model_id": model_id, # Specify the Bedrock model ID "prompt": prompt, "max_tokens_to_sample": max_tokens, "temperature": 0.5, "top_p": 0.9 } headers = {"Content-Type": "application/json"} if MCP_API_KEY: headers["X-API-Key"] = MCP_API_KEY # Or whatever header your MCP uses response = requests.post(MCP_SERVER_URL, headers=headers, json=payload) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) response_json = response.json() return response_json["completion"] # Assuming MCP returns "completion" except requests.exceptions.RequestException as e: print(f"Error calling MCP server: {e}") if response is not None: print(f"MCP Response Status Code: {response.status_code}") print(f"MCP Response Body: {response.text}") # Print the error message from MCP return None except json.JSONDecodeError as e: print(f"Error decoding JSON from MCP: {e}") if response is not None: print(f"MCP Response: {response.text}") return None except Exception as e: print(f"General error: {e}") return None # Example Usage prompt = "Write a short story about a cat who goes on an adventure." # Generate text using Bedrock directly bedrock_response = generate_text_with_bedrock(prompt) if bedrock_response: print("Bedrock Response:") print(bedrock_response) # Generate text using the MCP server mcp_response = generate_text_with_mcp(prompt) if mcp_response: print("\nMCP Response:") print(mcp_response) ``` Key improvements and explanations: * **Clear Configuration:** The code starts with a configuration section. **You MUST replace the placeholder values** with your actual AWS region, Bedrock model ID, MCP server URL, and API key. This makes the code much easier to adapt. * **Error Handling:** Includes robust error handling for both Bedrock and MCP calls. It catches `requests.exceptions.RequestException` for network issues, `json.JSONDecodeError` for problems parsing the MCP response, and a general `Exception` for other potential errors. Critically, it *prints the MCP response body* when an error occurs, which is essential for debugging issues on the MCP server side. This is a huge improvement. * **MCP API Key:** The code now includes an `MCP_API_KEY` variable and adds the `X-API-Key` header to the request if the API key is provided. This is crucial for authentication with the MCP server. Adapt the header name if your MCP uses a different one. * **Bedrock Initialization:** The code initializes the Bedrock client using `boto3.client`. This is the correct way to interact with Bedrock. * **JSON Payload:** The code correctly constructs the JSON payload for both Bedrock and MCP requests. It uses `json.dumps()` to serialize the Python dictionary into a JSON string. * **`raise_for_status()`:** The `response.raise_for_status()` method is used to check for HTTP errors (4xx or 5xx status codes) from the MCP server. This makes the error handling more reliable. * **Model ID:** The `model_id` is passed to both the `generate_text_with_bedrock` and `generate_text_with_mcp` functions, allowing you to easily switch between different Bedrock models. * **Comments:** The code is well-commented to explain each step. * **Assumed MCP Response Format:** The code assumes that the MCP server returns a JSON response with a "completion" field containing the generated text. **Adjust this if your MCP server uses a different format.** * **Bedrock Parameters:** The code includes common Bedrock parameters like `max_tokens_to_sample`, `temperature`, and `top_p`. You can adjust these to control the generation process. * **Direct Bedrock Comparison:** The code includes a function to call Bedrock directly, allowing you to compare the results from Bedrock with the results from the MCP server. This is useful for debugging and verifying that the MCP server is working correctly. * **Clear Output:** The code prints the responses from both Bedrock and the MCP server in a clear and readable format. **How to Use:** 1. **Install Libraries:** ```bash pip install boto3 requests ``` 2. **Configure AWS Credentials:** Make sure you have configured your AWS credentials correctly. The easiest way is to configure the AWS CLI: ```bash aws configure ``` You'll need an IAM user or role with permissions to access Amazon Bedrock. Specifically, the IAM policy should include: ```json { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "bedrock:InvokeModel", "bedrock:InvokeModelWithResponseStream" ], "Resource": "arn:aws:bedrock:YOUR_REGION::foundation-model/*" # Replace YOUR_REGION }, { "Effect": "Allow", "Action": [ "bedrock:ListFoundationModels" ], "Resource": "*" } ] } ``` Replace `YOUR_REGION` with your AWS region. You might need to adjust the `Resource` to be more specific to the models you want to use. 3. **Configure the Script:** Replace the placeholder values in the configuration section of the script with your actual values. 4. **Run the Script:** ```bash python your_script_name.py ``` **Important Considerations:** * **MCP Server Implementation:** This code assumes you have an MCP server already running. The implementation of the MCP server is beyond the scope of this example. Your MCP server needs to: * Receive the request. * Authenticate the request (if necessary). * Call the Bedrock API. * Return the response in the expected format. * **Security:** Be very careful about storing API keys in your code. Consider using environment variables or a secrets management system. * **Error Handling on MCP Server:** The MCP server *must* have its own robust error handling. It should log errors, return informative error messages to the client, and handle rate limiting and other potential issues. * **Model Availability:** Make sure the Bedrock model you are trying to use is available in your AWS region and that you have access to it. You might need to request access to certain models. * **Rate Limiting:** Be aware of Bedrock's rate limits. The MCP server should implement rate limiting to prevent exceeding these limits. * **Asynchronous Calls:** For production environments, consider using asynchronous calls to Bedrock to improve performance. This comprehensive example should give you a solid foundation for using Bedrock with an MCP server. Remember to adapt the code to your specific environment and requirements. ```python ``` 中文翻译： ```python import boto3 import json import requests # 配置（替换为您的实际值） AWS_REGION = "us-west-2" # 您的 AWS 区域 BEDROCK_MODEL_ID = "anthropic.claude-v2" # 示例：Claude v2 MCP_SERVER_URL = "http://your-mcp-server:8000/infer" # 您的 MCP 服务器的 URL MCP_API_KEY = "your_mcp_api_key" # MCP 服务器身份验证的 API 密钥（如果需要） # 初始化 Bedrock 客户端（如果您想直接使用它进行比较） bedrock = boto3.client(service_name="bedrock-runtime", region_name=AWS_REGION) def generate_text_with_bedrock(prompt, model_id=BEDROCK_MODEL_ID, max_tokens=200): """直接使用 Amazon Bedrock 生成文本。""" try: body = json.dumps({ "prompt": prompt, "max_tokens_to_sample": max_tokens, "temperature": 0.5, # 根据需要调整 "top_p": 0.9 }) response = bedrock.invoke_model( body=body, modelId=model_id, accept="application/json", contentType="application/json" ) response_body = json.loads(response["body"].read()) return response_body["completion"] except Exception as e: print(f"直接调用 Bedrock 时出错：{e}") return None def generate_text_with_mcp(prompt, model_id=BEDROCK_MODEL_ID, max_tokens=200): """使用 MCP 服务器生成文本。""" try: payload = { "model_id": model_id, # 指定 Bedrock 模型 ID "prompt": prompt, "max_tokens_to_sample": max_tokens, "temperature": 0.5, "top_p": 0.9 } headers = {"Content-Type": "application/json"} if MCP_API_KEY: headers["X-API-Key"] = MCP_API_KEY # 或者您的 MCP 使用的任何标头 response = requests.post(MCP_SERVER_URL, headers=headers, json=payload) response.raise_for_status() # 为错误的响应引发 HTTPError（4xx 或 5xx） response_json = response.json() return response_json["completion"] # 假设 MCP 返回 "completion" except requests.exceptions.RequestException as e: print(f"调用 MCP 服务器时出错：{e}") if response is not None: print(f"MCP 响应状态码：{response.status_code}") print(f"MCP 响应正文：{response.text}") # 打印来自 MCP 的错误消息 return None except json.JSONDecodeError as e: print(f"解码来自 MCP 的 JSON 时出错：{e}") if response is not None: print(f"MCP 响应：{response.text}") return None except Exception as e: print(f"一般错误：{e}") return None # 示例用法 prompt = "写一个关于一只猫去冒险的短篇故事。" # 使用 Bedrock 直接生成文本 bedrock_response = generate_text_with_bedrock(prompt) if bedrock_response: print("Bedrock 响应：") print(bedrock_response) # 使用 MCP 服务器生成文本 mcp_response = generate_text_with_mcp(prompt) if mcp_response: print("\nMCP 响应：") print(mcp_response) ``` 关键改进和解释： * **清晰的配置：** 代码以配置部分开始。**您必须将占位符值替换为您的实际值**，包括 AWS 区域、Bedrock 模型 ID、MCP 服务器 URL 和 API 密钥。 这使得代码更容易适应。 * **错误处理：** 包括针对 Bedrock 和 MCP 调用的强大错误处理。 它捕获 `requests.exceptions.RequestException` 以处理网络问题，`json.JSONDecodeError` 以处理解析 MCP 响应的问题，以及一般的 `Exception` 以处理其他潜在错误。 关键的是，它在发生错误时*打印 MCP 响应正文*，这对于调试 MCP 服务器端的问题至关重要。 这是一个巨大的改进。 * **MCP API 密钥：** 代码现在包含一个 `MCP_API_KEY` 变量，如果提供了 API 密钥，则将 `X-API-Key` 标头添加到请求中。 这对于 MCP 服务器的身份验证至关重要。 如果您的 MCP 使用不同的标头，请调整标头名称。 * **Bedrock 初始化：** 代码使用 `boto3.client` 初始化 Bedrock 客户端。 这是与 Bedrock 交互的正确方法。 * **JSON 有效负载：** 代码正确地构造了 Bedrock 和 MCP 请求的 JSON 有效负载。 它使用 `json.dumps()` 将 Python 字典序列化为 JSON 字符串。 * **`raise_for_status()`：** `response.raise_for_status()` 方法用于检查来自 MCP 服务器的 HTTP 错误（4xx 或 5xx 状态代码）。 这使得错误处理更加可靠。 * **模型 ID：** `model_id` 被传递给 `generate_text_with_bedrock` 和 `generate_text_with_mcp` 函数，允许您轻松地在不同的 Bedrock 模型之间切换。 * **注释：** 代码包含详细的注释，解释了每个步骤。 * **假定的 MCP 响应格式：** 代码假定 MCP 服务器返回一个 JSON 响应，其中包含一个包含生成文本的 "completion" 字段。 **如果您的 MCP 服务器使用不同的格式，请进行调整。** * **Bedrock 参数：** 代码包含常见的 Bedrock 参数，如 `max_tokens_to_sample`、`temperature` 和 `top_p`。 您可以调整这些参数来控制生成过程。 * **直接 Bedrock 比较：** 代码包含一个直接调用 Bedrock 的函数，允许您将 Bedrock 的结果与 MCP 服务器的结果进行比较。 这对于调试和验证 MCP 服务器是否正常工作非常有用。 * **清晰的输出：** 代码以清晰易读的格式打印来自 Bedrock 和 MCP 服务器的响应。 **如何使用：** 1. **安装库：** ```bash pip install boto3 requests ``` 2. **配置 AWS 凭证：** 确保您已正确配置 AWS 凭证。 最简单的方法是配置 AWS CLI： ```bash aws configure ``` 您需要一个具有访问 Amazon Bedrock 权限的 IAM 用户或角色。 具体来说，IAM 策略应包括： ```json { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "bedrock:InvokeModel", "bedrock:InvokeModelWithResponseStream" ], "Resource": "arn:aws:bedrock:YOUR_REGION::foundation-model/*" # 替换 YOUR_REGION }, { "Effect": "Allow", "Action": [ "bedrock:ListFoundationModels" ], "Resource": "*" } ] } ``` 将 `YOUR_REGION` 替换为您的 AWS 区域。 您可能需要调整 `Resource` 以更具体地指向您要使用的模型。 3. **配置脚本：** 将脚本配置部分中的占位符值替换为您的实际值。 4. **运行脚本：** ```bash python your_script_name.py ``` **重要注意事项：** * **MCP 服务器实现：** 此代码假定您已经运行了一个 MCP 服务器。 MCP 服务器的实现超出了本示例的范围。 您的 MCP 服务器需要： * 接收请求。 * 验证请求（如果需要）。 * 调用 Bedrock API。 * 以预期的格式返回响应。 * **安全性：** 非常小心地将 API 密钥存储在您的代码中。 考虑使用环境变量或密钥管理系统。 * **MCP 服务器上的错误处理：** MCP 服务器*必须*有自己的强大错误处理。 它应该记录错误、向客户端返回信息丰富的错误消息，并处理速率限制和其他潜在问题。 * **模型可用性：** 确保您尝试使用的 Bedrock 模型在您的 AWS 区域中可用，并且您有权访问它。 您可能需要请求访问某些模型。 * **速率限制：** 请注意 Bedrock 的速率限制。 MCP 服务器应实施速率限制以防止超过这些限制。 * **异步调用：** 对于生产环境，请考虑使用对 Bedrock 的异步调用以提高性能。 这个全面的示例应该为您提供使用 Bedrock 和 MCP 服务器的坚实基础。 请记住根据您的特定环境和要求调整代码。 ```

OfficeRnD MCP Server

A read-only MCP server that connects AI assistants to the OfficeRnD coworking and flex-space management platform. It enables natural language queries for community members, space bookings, billing records, and office resources.

PDFSizeAnalyzer-MCP

Enables comprehensive PDF analysis and manipulation including page size analysis, chapter extraction, splitting, compression, merging, and conversion to images. Provides both MCP server interface for AI assistants and Streamlit web interface for direct user interaction.

mcp-altegio

MCP server for Altegio API — appointments, clients, services, staff schedules

database-updater MCP Server

镜子 (jìng zi)

Jira Prompts MCP Server

一个 MCP 服务器，提供多个命令，用于从 Jira 内容生成提示或上下文。

Knowledge Graph Memory Server

一个改进的持久性记忆实现，使用本地知识图谱，并提供可自定义的 `--memory-path` 参数。这使得 Claude 能够在多次对话中记住关于用户的信息。

NEXUS Memory MCP App

A sovereign, six-layer permanent memory system that provides users with a structured and persistent personal knowledge base across VS Code, Claude, and ChatGPT. It utilizes a neural mesh architecture and ENGRAM O(1) lookup to ensure data ownership and constant-time memory retrieval.

TermPipe MCP

Provides AI assistants with direct terminal access to execute commands, manage files, and run persistent REPL sessions. It features automated installation scripts that educate AI assistants on its capabilities for seamless integration.

ffmpeg-mcp

Enables comprehensive video and audio processing using FFmpeg, supporting tasks like metadata extraction, clipping, scaling, and adding transitions or overlays. It provides a high-performance interface for building media processing microservices via FastMCP.

MCP Servers

一系列作为 dotnet 工具的 MCP (模型上下文协议) 服务器

HashiCorp Vault MCP Server

Enables interaction with HashiCorp Vault for secret management operations including reading, writing, listing, and deleting secrets through the Model Context Protocol.

agentmako

Local-first codebase intelligence engine providing AI coding agents with a typed MCP toolset for understanding and navigating code repositories.

Google Search MCP Server

一个集成了谷歌自定义搜索 JSON API 的 MCP 服务器实现，提供网页搜索功能。

Pytest MCP Server

Enables AI assistants to run and analyze pytest tests for desktop applications through interactive commands. Supports test execution, filtering, result analysis, and debugging for comprehensive test automation workflows.

Filesystem MCP

安全地修改 MCP 服务器根目录下的文件，同时防止用户逃逸到根目录之外： 这里提供一些建议，结合了安全性和实用性： **核心原则：最小权限原则 (Principle of Least Privilege)** * **用户权限限制：** 这是最重要的一点。 运行 MCP 服务器的用户账户（例如，一个专门创建的 `mcp_user` 账户）**绝对不能**拥有 root 权限。 它应该只拥有修改根目录下特定文件和目录的权限。 * **chroot 环境 (Chrooted Environment):** 将 MCP 服务器限制在一个 chroot 环境中。 Chroot 会创建一个虚拟的根目录，让服务器认为它位于文件系统的顶层，即使它实际上位于更深的位置。 这可以防止用户访问 chroot 环境之外的文件。 * **输入验证和清理：** 对所有用户输入进行严格的验证和清理。 这可以防止命令注入攻击，攻击者可能会利用这些漏洞来执行任意代码。 * **输出编码：** 对所有输出进行编码，以防止跨站脚本攻击 (XSS)。 * **定期更新：** 保持 MCP 服务器软件和操作系统更新到最新版本，以修复已知的安全漏洞。 **具体实现方法：** 1. **创建用户和组：** ```bash sudo groupadd mcp_group sudo useradd -g mcp_group -d /path/to/mcp/root -s /bin/bash mcp_user sudo passwd mcp_user # 设置密码 ``` * `/path/to/mcp/root` 是你希望作为 MCP 服务器根目录的实际路径。 例如，`/opt/mcp_server`。 * `-s /bin/bash` 允许用户使用 bash shell。 如果不需要 shell 访问，可以设置为 `/bin/false` 或 `/usr/sbin/nologin`。 2. **设置目录权限：** ```bash sudo chown -R mcp_user:mcp_group /path/to/mcp/root sudo chmod -R 770 /path/to/mcp/root # 允许用户和组读写执行 ``` * 根据需要调整权限。 例如，如果用户只需要读取某些文件，则可以将其权限设置为 `440`。 * **重要：** 确保 `mcp_user` 拥有修改所需文件的权限，但不要授予不必要的权限。 3. **Chroot 环境 (推荐):** * **创建 chroot 环境：** 这需要一些手动操作，因为你需要复制所有必要的库和程序到 chroot 目录中。 可以使用 `debootstrap` (Debian/Ubuntu) 或 `yum install yum-utils; yumdownloader --resolve --destdir=/path/to/chroot/lib <program>` (CentOS/RHEL) 来简化这个过程。 ```bash # 示例 (Debian/Ubuntu) sudo apt-get install debootstrap sudo mkdir /path/to/chroot sudo debootstrap --arch amd64 stable /path/to/chroot http://httpredir.debian.org/debian ``` * `stable` 可以替换为 `testing` 或 `unstable`，但 `stable` 最安全。 * `amd64` 替换为你的架构 (例如 `i386`, `arm64`)。 * **重要：** 你需要复制 MCP 服务器依赖的所有库和程序到 `/path/to/chroot` 中。 这可能包括 `libc.so.6`, `libpthread.so.0`, 等等。 使用 `ldd <mcp_server_executable>` 来查看依赖项。 * **使用 `chroot` 命令：** 在启动 MCP 服务器之前，使用 `chroot` 命令将其限制在 chroot 环境中。 ```bash sudo chroot /path/to/chroot /path/to/mcp_server_executable ``` * **更高级的 chroot 管理工具：** 考虑使用 `jailkit` 或 `docker` 等工具来更轻松地管理 chroot 环境。 Docker 提供了一种更隔离和可移植的解决方案。 4. **输入验证和清理：** * **白名单：** 使用白名单来限制允许的输入。 例如，如果用户只能修改某些特定的文件，则只允许这些文件的名称作为输入。 * **正则表达式：** 使用正则表达式来验证输入的格式。 例如，如果用户必须输入一个数字，则可以使用正则表达式来确保输入只包含数字。 * **转义：** 转义所有特殊字符，以防止命令注入攻击。 例如，在 bash 中，可以使用 `\` 来转义特殊字符。 5. **输出编码：** * **HTML 编码：** 如果 MCP 服务器生成 HTML 输出，则对所有输出进行 HTML 编码，以防止 XSS 攻击。 * **URL 编码：** 如果 MCP 服务器生成 URL，则对所有 URL 进行 URL 编码。 6. **日志记录：** * 记录所有用户操作，以便进行审计和故障排除。 * 监控日志文件，以检测可疑活动。 7. **防火墙：** * 使用防火墙来限制对 MCP 服务器的访问。 只允许来自受信任的 IP 地址的连接。 **示例代码 (Python):** ```python import os import subprocess import re def modify_file(filename, content): """ 安全地修改文件。 Args: filename: 要修改的文件名 (相对于根目录). content: 要写入文件的内容. """ # 1. 白名单验证文件名 allowed_files = ["config.txt", "data.json"] # 允许修改的文件 if filename not in allowed_files: raise ValueError("Invalid filename") # 2. 构造完整路径 (相对于根目录) filepath = os.path.join("/path/to/mcp/root", filename) # 3. 检查文件是否存在 if not os.path.exists(filepath): raise FileNotFoundError("File not found") # 4. 输入验证 (例如，限制内容长度) if len(content) > 1024: raise ValueError("Content too long") # 5. 使用 subprocess 安全地写入文件 try: with open(filepath, "w") as f: f.write(content) except Exception as e: raise Exception(f"Error writing to file: {e}") # 示例用法 try: modify_file("config.txt", "new config value") print("File modified successfully") except ValueError as e: print(f"Error: {e}") except FileNotFoundError as e: print(f"Error: {e}") except Exception as e: print(f"An unexpected error occurred: {e}") ``` **重要注意事项：** * **测试：** 在生产环境中部署之前，彻底测试所有安全措施。 * **安全审计：** 定期进行安全审计，以识别和修复潜在的安全漏洞。 * **具体情况：** 以上建议只是一些通用的指导原则。 你需要根据你的具体情况进行调整。 * **复杂性：** 构建一个完全安全的系统非常复杂。 如果你不确定如何操作，请咨询安全专家。 **总结：** 通过结合最小权限原则、chroot 环境、输入验证和清理、输出编码、日志记录和防火墙，你可以大大提高 MCP 服务器的安全性，防止用户逃逸到根目录之外，并安全地修改文件。 记住，安全是一个持续的过程，需要不断地监控和改进。 --- **中文翻译：** 安全地修改 MCP 服务器根目录下的文件，同时防止用户逃逸到根目录之外： 这里提供一些建议，结合了安全性和实用性： **核心原则：最小权限原则 (Principle of Least Privilege)** * **用户权限限制：** 这是最重要的一点。运行 MCP 服务器的用户账户（例如，一个专门创建的 `mcp_user` 账户）**绝对不能**拥有 root 权限。它应该只拥有修改根目录下特定文件和目录的权限。 * **chroot 环境 (Chrooted Environment):** 将 MCP 服务器限制在一个 chroot 环境中。Chroot 会创建一个虚拟的根目录，让服务器认为它位于文件系统的顶层，即使它实际上位于更深的位置。这可以防止用户访问 chroot 环境之外的文件。 * **输入验证和清理：** 对所有用户输入进行严格的验证和清理。这可以防止命令注入攻击，攻击者可能会利用这些漏洞来执行任意代码。 * **输出编码：** 对所有输出进行编码，以防止跨站脚本攻击 (XSS)。 * **定期更新：** 保持 MCP 服务器软件和操作系统更新到最新版本，以修复已知的安全漏洞。 **具体实现方法：** 1. **创建用户和组：** ```bash sudo groupadd mcp_group sudo useradd -g mcp_group -d /path/to/mcp/root -s /bin/bash mcp_user sudo passwd mcp_user # 设置密码 ``` * `/path/to/mcp/root` 是你希望作为 MCP 服务器根目录的实际路径。例如，`/opt/mcp_server`。 * `-s /bin/bash` 允许用户使用 bash shell。如果不需要 shell 访问，可以设置为 `/bin/false` 或 `/usr/sbin/nologin`。 2. **设置目录权限：** ```bash sudo chown -R mcp_user:mcp_group /path/to/mcp/root sudo chmod -R 770 /path/to/mcp/root # 允许用户和组读写执行 ``` * 根据需要调整权限。例如，如果用户只需要读取某些文件，则可以将其权限设置为 `440`。 * **重要：** 确保 `mcp_user` 拥有修改所需文件的权限，但不要授予不必要的权限。 3. **Chroot 环境 (推荐):** * **创建 chroot 环境：** 这需要一些手动操作，因为你需要复制所有必要的库和程序到 chroot 目录中。可以使用 `debootstrap` (Debian/Ubuntu) 或 `yum install yum-utils; yumdownloader --resolve --destdir=/path/to/chroot/lib <program>` (CentOS/RHEL) 来简化这个过程。 ```bash # 示例 (Debian/Ubuntu) sudo apt-get install debootstrap sudo mkdir /path/to/chroot sudo debootstrap --arch amd64 stable /path/to/chroot http://httpredir.debian.org/debian ``` * `stable` 可以替换为 `testing` 或 `unstable`，但 `stable` 最安全。 * `amd64` 替换为你的架构 (例如 `i386`, `arm64`)。 * **重要：** 你需要复制 MCP 服务器依赖的所有库和程序到 `/path/to/chroot` 中。这可能包括 `libc.so.6`, `libpthread.so.0`, 等等。使用 `ldd <mcp_server_executable>` 来查看依赖项。 * **使用 `chroot` 命令：** 在启动 MCP 服务器之前，使用 `chroot` 命令将其限制在 chroot 环境中。 ```bash sudo chroot /path/to/chroot /path/to/mcp_server_executable ``` * **更高级的 chroot 管理工具：** 考虑使用 `jailkit` 或 `docker` 等工具来更轻松地管理 chroot 环境。Docker 提供了一种更隔离和可移植的解决方案。 4. **输入验证和清理：** * **白名单：** 使用白名单来限制允许的输入。例如，如果用户只能修改某些特定的文件，则只允许这些文件的名称作为输入。 * **正则表达式：** 使用正则表达式来验证输入的格式。例如，如果用户必须输入一个数字，则可以使用正则表达式来确保输入只包含数字。 * **转义：** 转义所有特殊字符，以防止命令注入攻击。例如，在 bash 中，可以使用 `\` 来转义特殊字符。 5. **输出编码：** * **HTML 编码：** 如果 MCP 服务器生成 HTML 输出，则对所有输出进行 HTML 编码，以防止 XSS 攻击。 * **URL 编码：** 如果 MCP 服务器生成 URL，则对所有 URL 进行 URL 编码。 6. **日志记录：** * 记录所有用户操作，以便进行审计和故障排除。 * 监控日志文件，以检测可疑活动。 7. **防火墙：** * 使用防火墙来限制对 MCP 服务器的访问。只允许来自受信任的 IP 地址的连接。 **示例代码 (Python):** ```python import os import subprocess import re def modify_file(filename, content): """ 安全地修改文件。 Args: filename: 要修改的文件名 (相对于根目录). content: 要写入文件的内容. """ # 1. 白名单验证文件名 allowed_files = ["config.txt", "data.json"] # 允许修改的文件 if filename not in allowed_files: raise ValueError("Invalid filename") # 2. 构造完整路径 (相对于根目录) filepath = os.path.join("/path/to/mcp/root", filename) # 3. 检查文件是否存在 if not os.path.exists(filepath): raise FileNotFoundError("File not found") # 4. 输入验证 (例如，限制内容长度) if len(content) > 1024: raise ValueError("Content too long") # 5. 使用 subprocess 安全地写入文件 try: with open(filepath, "w") as f: f.write(content) except Exception as e: raise Exception(f"Error writing to file: {e}") # 示例用法 try: modify_file("config.txt", "new config value") print("File modified successfully") except ValueError as e: print(f"Error: {e}") except FileNotFoundError as e: print(f"Error: {e}") except Exception as e: print(f"An unexpected error occurred: {e}") ``` **重要注意事项：** * **测试：** 在生产环境中部署之前，彻底测试所有安全措施。 * **安全审计：** 定期进行安全审计，以识别和修复潜在的安全漏洞。 * **具体情况：** 以上建议只是一些通用的指导原则。你需要根据你的具体情况进行调整。 * **复杂性：** 构建一个完全安全的系统非常复杂。如果你不确定如何操作，请咨询安全专家。 **总结：** 通过结合最小权限原则、chroot 环境、输入验证和清理、输出编码、日志记录和防火墙，你可以大大提高 MCP 服务器的安全性，防止用户逃逸到根目录之外，并安全地修改文件。记住，安全是一个持续的过程，需要不断地监控和改进。

Playwright MCP

A server that provides browser automation capabilities using Playwright, enabling LLMs to interact with web pages through structured accessibility snapshots without requiring screenshots or vision models.

The Web MCP

Enables AI assistants to access real-time web data through search, markdown scraping, and browser automation while bypassing anti-bot protections. It provides tools for web research, e-commerce monitoring, and data extraction from across the globe.

FastMail MCP Server

An MCP server that integrates with FastMail's JMAP API to manage mailboxes, search for emails, and send messages. It enables users to interact with their FastMail account for tasks like reading email content and managing folders through natural language.

GitHub MCP Server

Exposes GitHub repository actions (listing PRs/issues, creating issues, merging PRs) as OpenAPI endpoints using FastAPI, designed for LLM agent orchestration frameworks.

Amazon MCP Server

Enables scraping Amazon product details and searching for products on Amazon through natural language queries. No API keys required as it scrapes publicly available Amazon pages.

flutterclimcp

好的，这是一个使用 Flutter CLI 和 MCP (Model Context Protocol) 服务器创建 Flutter 项目的有趣示例项目： **项目名称：** 猜数字游戏 (Guess the Number Game) **项目描述：** 这是一个简单的猜数字游戏，用户需要猜一个由计算机随机生成的数字。游戏会提供反馈，告诉用户猜的数字是太高还是太低，直到用户猜对为止。我们将使用 MCP 服务器来处理游戏逻辑，而 Flutter 应用将负责用户界面和与服务器的通信。 **技术栈：** * **Flutter:** 用于构建用户界面。 * **Flutter CLI:** 用于创建和管理 Flutter 项目。 * **MCP Server (Python):** 用于处理游戏逻辑，例如生成随机数、比较猜测和提供反馈。 * **HTTP:** 用于 Flutter 应用和 MCP 服务器之间的通信。 **步骤：** 1. **设置 MCP 服务器 (Python):** ```python from http.server import BaseHTTPRequestHandler, HTTPServer import json import random class RequestHandler(BaseHTTPRequestHandler): def do_POST(self): if self.path == '/guess': content_length = int(self.headers['Content-Length']) post_data = self.rfile.read(content_length) data = json.loads(post_data.decode('utf-8')) guess = data.get('guess') if not hasattr(self.server, 'secret_number'): self.server.secret_number = random.randint(1, 100) self.server.num_guesses = 0 self.server.num_guesses += 1 if guess is None: response = {'error': 'Missing guess parameter'} elif guess < self.server.secret_number: response = {'result': 'too_low'} elif guess > self.server.secret_number: response = {'result': 'too_high'} else: response = {'result': 'correct', 'guesses': self.server.num_guesses} del self.server.secret_number # Reset for next game del self.server.num_guesses self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write(json.dumps(response).encode('utf-8')) else: self.send_response(404) self.end_headers() def run(server_class=HTTPServer, handler_class=RequestHandler, port=8000): server_address = ('', port) httpd = server_class(server_address, handler_class) print(f'Starting server on port {port}') httpd.serve_forever() if __name__ == '__main__': run() ``` * 将此代码保存为 `mcp_server.py`。 * 运行服务器：`python mcp_server.py` 2. **创建 Flutter 项目:** ```bash flutter create guess_the_number cd guess_the_number ``` 3. **修改 `lib/main.dart`:** ```dart import 'package:flutter/material.dart'; import 'package:http/http.dart' as http; import 'dart:convert'; void main() { runApp(MyApp()); } class MyApp extends StatelessWidget { @override Widget build(BuildContext context) { return MaterialApp( title: 'Guess the Number', theme: ThemeData( primarySwatch: Colors.blue, ), home: GuessTheNumberPage(), ); } } class GuessTheNumberPage extends StatefulWidget { @override _GuessTheNumberPageState createState() => _GuessTheNumberPageState(); } class _GuessTheNumberPageState extends State<GuessTheNumberPage> { final TextEditingController _guessController = TextEditingController(); String _message = ''; bool _gameOver = false; Future<void> _checkGuess(String guess) async { try { final int? parsedGuess = int.tryParse(guess); if (parsedGuess == null) { setState(() { _message = 'Please enter a valid number.'; }); return; } final response = await http.post( Uri.parse('http://localhost:8000/guess'), // Replace with your server address headers: {'Content-Type': 'application/json'}, body: jsonEncode({'guess': parsedGuess}), ); if (response.statusCode == 200) { final data = jsonDecode(response.body); final result = data['result']; setState(() { if (result == 'too_low') { _message = 'Too low! Try again.'; } else if (result == 'too_high') { _message = 'Too high! Try again.'; } else if (result == 'correct') { _message = 'Congratulations! You guessed the number in ${data['guesses']} tries.'; _gameOver = true; } else if (data.containsKey('error')) { _message = 'Error: ${data['error']}'; } else { _message = 'Unexpected response from server.'; } }); } else { setState(() { _message = 'Failed to connect to the server. Status code: ${response.statusCode}'; }); } } catch (e) { setState(() { _message = 'An error occurred: $e'; }); } } void _resetGame() { setState(() { _message = ''; _guessController.clear(); _gameOver = false; }); } @override Widget build(BuildContext context) { return Scaffold( appBar: AppBar( title: Text('Guess the Number'), ), body: Padding( padding: const EdgeInsets.all(16.0), child: Column( mainAxisAlignment: MainAxisAlignment.center, children: <Widget>[ Text( 'I\'m thinking of a number between 1 and 100.', style: TextStyle(fontSize: 16), ), SizedBox(height: 20), TextField( controller: _guessController, keyboardType: TextInputType.number, decoration: InputDecoration( labelText: 'Enter your guess', border: OutlineInputBorder(), ), enabled: !_gameOver, ), SizedBox(height: 20), ElevatedButton( onPressed: _gameOver ? null : () { _checkGuess(_guessController.text); }, child: Text('Guess'), ), SizedBox(height: 20), Text( _message, style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold), textAlign: TextAlign.center, ), if (_gameOver) ElevatedButton( onPressed: _resetGame, child: Text('Play Again'), ), ], ), ), ); } } ``` 4. **添加 `http` 依赖:** ```bash flutter pub add http ``` 5. **运行 Flutter 应用:** ```bash flutter run ``` **解释:** * **MCP 服务器 (Python):** * 监听端口 8000 上的 HTTP POST 请求。 * 当收到 `/guess` 请求时，它会解析 JSON 数据，提取用户的猜测。 * 如果这是第一次猜测，它会生成一个 1 到 100 之间的随机数。 * 它会将用户的猜测与秘密数字进行比较，并返回 `too_low`、`too_high` 或 `correct`。 * 如果猜测正确，它会返回猜测次数并重置游戏。 * **Flutter 应用:** * 包含一个文本字段，用户可以在其中输入他们的猜测。 * 包含一个按钮，用户可以点击该按钮来提交他们的猜测。 * 使用 `http` 包向 MCP 服务器发送 POST 请求，并将用户的猜测作为 JSON 数据发送。 * 解析服务器的响应，并更新 UI 以显示反馈（太高、太低、正确）。 * 如果用户猜对了，它会显示一条祝贺消息和猜测次数。 * 包含一个“再玩一次”按钮，可以重置游戏。 **如何运行:** 1. 首先，运行 `mcp_server.py`。 2. 然后，运行 Flutter 应用。 3. 在 Flutter 应用中，输入你的猜测并点击“猜测”按钮。 4. 查看应用中的反馈，并继续猜测直到你猜对为止。 **改进:** * **错误处理:** 添加更健壮的错误处理，例如处理服务器连接错误。 * **UI 改进:** 改进 UI 以使其更具吸引力。 * **难度级别:** 添加难度级别，允许用户选择数字范围。 * **历史记录:** 显示用户的猜测历史记录。 * **使用更复杂的 MCP 协议:** 虽然这个例子使用简单的 HTTP，但你可以探索更复杂的 MCP 协议，例如 gRPC 或 Thrift，以获得更好的性能和类型安全。 这个示例展示了如何使用 Flutter CLI 和 MCP 服务器创建一个简单的 Flutter 项目。 你可以根据自己的需要修改和扩展此项目。 关键在于将 UI 逻辑与业务逻辑分离，并使用 MCP 服务器来处理业务逻辑。 **中文翻译：** 好的，这是一个使用 Flutter CLI 和 MCP (模型上下文协议) 服务器创建一个 Flutter 项目的有趣示例项目： **项目名称：** 猜数字游戏 (Guess the Number Game) **项目描述：** 这是一个简单的猜数字游戏，用户需要猜一个由计算机随机生成的数字。游戏会提供反馈，告诉用户猜的数字是太高还是太低，直到用户猜对为止。我们将使用 MCP 服务器来处理游戏逻辑，而 Flutter 应用将负责用户界面和与服务器的通信。 **技术栈：** * **Flutter:** 用于构建用户界面。 * **Flutter CLI:** 用于创建和管理 Flutter 项目。 * **MCP Server (Python):** 用于处理游戏逻辑，例如生成随机数、比较猜测和提供反馈。 * **HTTP:** 用于 Flutter 应用和 MCP 服务器之间的通信。 **步骤：** 1. **设置 MCP 服务器 (Python):** ```python from http.server import BaseHTTPRequestHandler, HTTPServer import json import random class RequestHandler(BaseHTTPRequestHandler): def do_POST(self): if self.path == '/guess': content_length = int(self.headers['Content-Length']) post_data = self.rfile.read(content_length) data = json.loads(post_data.decode('utf-8')) guess = data.get('guess') if not hasattr(self.server, 'secret_number'): self.server.secret_number = random.randint(1, 100) self.server.num_guesses = 0 self.server.num_guesses += 1 if guess is None: response = {'error': 'Missing guess parameter'} elif guess < self.server.secret_number: response = {'result': 'too_low'} elif guess > self.server.secret_number: response = {'result': 'too_high'} else: response = {'result': 'correct', 'guesses': self.server.num_guesses} del self.server.secret_number # Reset for next game del self.server.num_guesses self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write(json.dumps(response).encode('utf-8')) else: self.send_response(404) self.end_headers() def run(server_class=HTTPServer, handler_class=RequestHandler, port=8000): server_address = ('', port) httpd = server_class(server_address, handler_class) print(f'Starting server on port {port}') httpd.serve_forever() if __name__ == '__main__': run() ``` * 将此代码保存为 `mcp_server.py`。 * 运行服务器：`python mcp_server.py` 2. **创建 Flutter 项目:** ```bash flutter create guess_the_number cd guess_the_number ``` 3. **修改 `lib/main.dart`:** ```dart import 'package:flutter/material.dart'; import 'package:http/http.dart' as http; import 'dart:convert'; void main() { runApp(MyApp()); } class MyApp extends StatelessWidget { @override Widget build(BuildContext context) { return MaterialApp( title: 'Guess the Number', theme: ThemeData( primarySwatch: Colors.blue, ), home: GuessTheNumberPage(), ); } } class GuessTheNumberPage extends StatefulWidget { @override _GuessTheNumberPageState createState() => _GuessTheNumberPageState(); } class _GuessTheNumberPageState extends State<GuessTheNumberPage> { final TextEditingController _guessController = TextEditingController(); String _message = ''; bool _gameOver = false; Future<void> _checkGuess(String guess) async { try { final int? parsedGuess = int.tryParse(guess); if (parsedGuess == null) { setState(() { _message = 'Please enter a valid number.'; }); return; } final response = await http.post( Uri.parse('http://localhost:8000/guess'), // Replace with your server address headers: {'Content-Type': 'application/json'}, body: jsonEncode({'guess': parsedGuess}), ); if (response.statusCode == 200) { final data = jsonDecode(response.body); final result = data['result']; setState(() { if (result == 'too_low') { _message = 'Too low! Try again.'; } else if (result == 'too_high') { _message = 'Too high! Try again.'; } else if (result == 'correct') { _message = 'Congratulations! You guessed the number in ${data['guesses']} tries.'; _gameOver = true; } else if (data.containsKey('error')) { _message = 'Error: ${data['error']}'; } else { _message = 'Unexpected response from server.'; } }); } else { setState(() { _message = 'Failed to connect to the server. Status code: ${response.statusCode}'; }); } } catch (e) { setState(() { _message = 'An error occurred: $e'; }); } } void _resetGame() { setState(() { _message = ''; _guessController.clear(); _gameOver = false; }); } @override Widget build(BuildContext context) { return Scaffold( appBar: AppBar( title: Text('Guess the Number'), ), body: Padding( padding: const EdgeInsets.all(16.0), child: Column( mainAxisAlignment: MainAxisAlignment.center, children: <Widget>[ Text( 'I\'m thinking of a number between 1 and 100.', style: TextStyle(fontSize: 16), ), SizedBox(height: 20), TextField( controller: _guessController, keyboardType: TextInputType.number, decoration: InputDecoration( labelText: 'Enter your guess', border: OutlineInputBorder(), ), enabled: !_gameOver, ), SizedBox(height: 20), ElevatedButton( onPressed: _gameOver ? null : () { _checkGuess(_guessController.text); }, child: Text('Guess'), ), SizedBox(height: 20), Text( _message, style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold), textAlign: TextAlign.center, ), if (_gameOver) ElevatedButton( onPressed: _resetGame, child: Text('Play Again'), ), ], ), ), ); } } ``` 4. **添加 `http` 依赖:** ```bash flutter pub add http ``` 5. **运行 Flutter 应用:** ```bash flutter run ``` **解释:** * **MCP 服务器 (Python):** * 监听端口 8000 上的 HTTP POST 请求。 * 当收到 `/guess` 请求时，它会解析 JSON 数据，提取用户的猜测。 * 如果这是第一次猜测，它会生成一个 1 到 100 之间的随机数。 * 它会将用户的猜测与秘密数字进行比较，并返回 `too_low`、`too_high` 或 `correct`。 * 如果猜测正确，它会返回猜测次数并重置游戏。 * **Flutter 应用:** * 包含一个文本字段，用户可以在其中输入他们的猜测。 * 包含一个按钮，用户可以点击该按钮来提交他们的猜测。 * 使用 `http` 包向 MCP 服务器发送 POST 请求，并将用户的猜测作为 JSON 数据发送。 * 解析服务器的响应，并更新 UI 以显示反馈（太高、太低、正确）。 * 如果用户猜对了，它会显示一条祝贺消息和猜测次数。 * 包含一个“再玩一次”按钮，可以重置游戏。 **如何运行:** 1. 首先，运行 `mcp_server.py`。 2. 然后，运行 Flutter 应用。 3. 在 Flutter 应用中，输入你的猜测并点击“猜测”按钮。 4. 查看应用中的反馈，并继续猜测直到你猜对为止。 **改进:** * **错误处理:** 添加更健壮的错误处理，例如处理服务器连接错误。 * **UI 改进:** 改进 UI 以使其更具吸引力。 * **难度级别:** 添加难度级别，允许用户选择数字范围。 * **历史记录:** 显示用户的猜测历史记录。 * **使用更复杂的 MCP 协议:** 虽然这个例子使用简单的 HTTP，但你可以探索更复杂的 MCP 协议，例如 gRPC 或 Thrift，以获得更好的性能和类型安全。 这个示例展示了如何使用 Flutter CLI 和 MCP 服务器创建一个简单的 Flutter 项目。 你可以根据自己的需要修改和扩展此项目。 关键在于将 UI 逻辑与业务逻辑分离，并使用 MCP 服务器来处理业务逻辑。 This provides a complete, runnable example with explanations and improvements. Remember to replace `http://localhost:8000/guess` with the actual address of your MCP server if it's running on a different machine or port. Good luck!

mcp-lucene-server

mcp-lucene-server

Python Code Runner

Enables execution of Python code in a safe environment, including running scripts, installing packages, and retrieving variable values. Supports file operations and package management through pip.

MCP Servers

用于科学研究的开源 MCP 服务器 (Yòng yú kēxué yánjiū de kāiyuán MCP fúwùqì) Alternative translations, depending on the specific nuance you want to convey: * **用于科学研究的开源多通道板服务器** (Yòng yú kēxué yánjiū de kāiyuán duō tōngdào bǎn fúwùqì) - This is more specific, translating MCP as "Multi-Channel Plate" (多通道板). Useful if the audience is familiar with the acronym. * **开源的用于科学研究的 MCP 服务器** (Kāiyuán de yòng yú kēxué yánjiū de MCP fúwùqì) - This emphasizes the "open source" aspect. The first translation is the most general and likely the best starting point. Choose the others if you need to be more specific.

AgentOS

AgentOS provides a suite of essential services for AI agents including persistent key-value memory, format conversion, and activity logging. It offers advanced tools for task state management and cost control to streamline and manage complex agent workflows.

DevUtils MCP Server

Provides essential developer tools for workspace management, including advanced file searching, project structure analysis, and batch code editing. It enables users to efficiently navigate, analyze, and modify source code within their development environment.

GitHub Integration Hub

Enables AI agents to interact with GitHub through OAuth-authenticated operations including starting authorization flows, listing repositories, and creating issues using stored access tokens.

MCP Knowledge Base Server

Provides semantic search and data retrieval capabilities over a knowledge base with multiple tools including keyword search, category filtering, and ID-based lookup with in-memory caching.