Discover Awesome MCP Servers

ChEMBL-MCP-Server

🔍 通过简单的 MCP 接口，使 AI 助手能够搜索、访问和分析 ChEMBL。

duckduckgo-web-search MCP Server

DuckDuckGo Web Search MCP Server - 一个简单的网页搜索实现，用于 Claude Desktop，使用 DuckDuckGo API。

graphexpert2025

Okay, here are comprehensive notes on Graph Databases and MCP (presumably Minecraft Protocol) Servers, designed to provide enough context for a Language Model (LM) to quickly understand and contribute to Graph Database projects related to MCP Servers. **I. Graph Databases: Core Concepts** * **What are Graph Databases?** * A type of NoSQL database that uses graph structures with nodes, edges, and properties to store and represent data. Focus is on *relationships* between data points. * **Nodes (Vertices):** Represent entities (e.g., players, items, locations, events in a Minecraft server). * **Edges (Relationships):** Represent connections between entities (e.g., "player A *owns* item B", "player A *is_friend_with* player C", "player A *visited* location X"). Edges have direction (directed graph) or no direction (undirected graph). * **Properties:** Key-value pairs that store attributes of nodes and edges (e.g., a player node might have properties like "username", "level", "last_login"; an edge might have a property like "timestamp"). * **Why Use Graph Databases?** * **Relationship-Centric Data:** Excellent for data where relationships are as important as the data itself. Ideal for social networks, recommendation engines, knowledge graphs, fraud detection, and, as we'll see, Minecraft server analysis. * **Performance on Complex Relationships:** Graph databases excel at traversing relationships (finding all friends of a friend, finding the shortest path between two players). Relational databases often struggle with deep, complex joins. * **Flexibility:** Easier to evolve the data model than with relational databases. Adding new node types, edge types, and properties is generally straightforward. * **Intuitive Data Modeling:** The graph model often closely mirrors the real-world domain, making it easier to understand and design. * **Key Graph Database Concepts:** * **Graph Traversal:** The process of navigating the graph by following edges from node to node. This is the core operation in graph databases. * **Graph Algorithms:** Algorithms designed to analyze graph structures (e.g., shortest path, community detection, centrality measures). * **Query Languages:** Specialized languages for querying graph databases. The most common is **Cypher** (used by Neo4j). Gremlin is another popular option. * **ACID Properties:** Like relational databases, graph databases often provide ACID (Atomicity, Consistency, Isolation, Durability) properties to ensure data integrity. * **Popular Graph Database Systems:** * **Neo4j:** The most popular graph database. Mature, well-documented, and has a large community. Uses Cypher. * **Amazon Neptune:** A fully managed graph database service from AWS. Supports both Gremlin and SPARQL. * **JanusGraph:** A distributed, scalable graph database. Supports Gremlin. * **TigerGraph:** A high-performance graph database designed for complex analytics. Uses its own GSQL language. * **Example Cypher Query (Neo4j):** ```cypher // Find all friends of a player named "Alice" MATCH (alice:Player {username: "Alice"})-[:FRIENDS_WITH]->(friend:Player) RETURN friend.username; // Find all items owned by a player named "Bob" MATCH (bob:Player {username: "Bob"})-[:OWNS]->(item:Item) RETURN item.name; // Find the shortest path between two players MATCH (start:Player {username: "PlayerA"}), (end:Player {username: "PlayerB"}), p = shortestPath((start)-[*]-(end)) RETURN p ``` **II. Minecraft Protocol (MCP) Servers** * **What is the Minecraft Protocol?** * The communication protocol used between Minecraft clients and servers. It's a binary protocol that defines how clients send requests (e.g., player movement, chat messages, block placement) and how servers respond (e.g., world updates, player positions, chat messages). * **Not Officially Documented by Mojang:** The protocol is reverse-engineered and maintained by the community. This means it's subject to change with each Minecraft version update. * **Packets:** The fundamental unit of communication. Each packet has an ID and a data payload. The structure of the payload depends on the packet ID. * **Why is MCP Relevant to Graph Databases?** * **Data Source:** MCP provides a rich stream of data about player actions, world state, and server events. This data can be ingested into a graph database to build a comprehensive model of the Minecraft server. * **Real-time Analysis:** By processing MCP packets in real-time, you can update the graph database and perform real-time analysis of player behavior, server performance, and other metrics. * **Key MCP Concepts:** * **Packet IDs:** Unique identifiers for each type of packet (e.g., `0x00` for Handshake, `0x0F` for Player Position). These IDs change between Minecraft versions. * **Packet Payloads:** The data contained within a packet. The structure of the payload is defined by the packet ID and the Minecraft version. Data types include integers, strings, booleans, and arrays. * **Handshaking:** The initial process where the client and server establish a connection and negotiate the protocol version. * **State:** The connection goes through different states (Handshaking, Status, Login, Play) as the client authenticates and joins the game. * **Data Serialization/Deserialization:** Converting data between the binary format of the MCP and the data structures used in your programming language. * **Common MCP Packets of Interest (for Graph DB projects):** * **Player Position:** Tracks player movement. Useful for building player location graphs, identifying travel patterns, and detecting anomalies. * **Chat Message:** Captures player chat. Useful for sentiment analysis, identifying social connections, and detecting rule violations. * **Block Change:** Tracks block placement and destruction. Useful for analyzing building activity, identifying griefing, and tracking resource usage. * **Entity Spawn:** Tracks the creation of entities (players, mobs, items). Useful for analyzing population dynamics and tracking item flow. * **Entity Destroy:** Tracks the removal of entities. * **Join/Leave Game:** Tracks when players join and leave the server. Useful for analyzing player activity and server load. * **Tools and Libraries for Working with MCP:** * **PrismarineJS:** A JavaScript library for interacting with the Minecraft protocol. Well-maintained and supports many Minecraft versions. * **Python-Minecraft:** A Python library for interacting with the Minecraft protocol. * **Packet Libraries (Various Languages):** Many libraries exist in different languages that provide pre-built packet definitions and serialization/deserialization logic. Search for "[language] minecraft protocol library". * **Wireshark:** A network protocol analyzer that can be used to capture and inspect MCP packets. Useful for debugging and understanding the protocol. **III. Combining Graph Databases and MCP Servers: Project Ideas & Considerations** * **Example Project: Social Network Analysis** * **Nodes:** Players * **Edges:** `FRIENDS_WITH` (inferred from chat messages, party systems, etc.), `PLAYED_WITH` (inferred from being in the same location at the same time) * **Analysis:** Identify influential players, detect communities, recommend friends. * **Example Project: Griefing Detection** * **Nodes:** Players, Blocks, Locations * **Edges:** `PLACED`, `DESTROYED`, `NEAR` * **Analysis:** Identify patterns of block destruction that are indicative of griefing. Track the movement of players who are suspected of griefing. * **Example Project: Resource Tracking** * **Nodes:** Players, Items, Locations * **Edges:** `OWNS`, `MINED_FROM`, `PLACED_AT` * **Analysis:** Track the flow of resources through the server. Identify bottlenecks and potential exploits. * **Example Project: Dynamic World Map** * **Nodes:** Locations, Chunks * **Edges:** `ADJACENT_TO`, `CONTAINS` * **Analysis:** Visualize the world, track changes over time, identify areas of high activity. * **Key Considerations:** * **Minecraft Version Compatibility:** The MCP changes with each Minecraft version. Ensure your code and libraries are compatible with the target version. * **Data Volume:** Minecraft servers can generate a large amount of data. Choose a graph database that can handle the scale. * **Real-time vs. Batch Processing:** Decide whether you need to process MCP packets in real-time or whether batch processing is sufficient. Real-time processing requires more complex infrastructure. * **Data Cleaning and Transformation:** MCP data can be noisy and inconsistent. Implement data cleaning and transformation pipelines to ensure data quality. * **Privacy:** Be mindful of player privacy when collecting and storing data. Obtain consent where necessary and anonymize data where possible. * **Performance:** Graph database queries can be expensive. Optimize your queries and data model to ensure performance. Consider using indexes. * **Graph Database Schema Design:** Careful planning of your node and edge types, and their properties, is crucial for efficient querying and analysis. **IV. LM-Specific Considerations** * **Prompt Engineering:** When using an LM to work with this data, provide clear and specific prompts. For example: * "Write a Cypher query to find all players who have placed more than 100 diamond blocks in the last hour." * "Explain the purpose of the `Player Position` packet in the Minecraft protocol." * "Suggest a graph database schema for tracking player interactions on a Minecraft server." * **Contextual Information:** Provide the LM with relevant context about the Minecraft version, the graph database schema, and the specific project goals. * **Code Generation:** Use the LM to generate code snippets for interacting with the graph database and the MCP. Be sure to review and test the generated code carefully. * **Data Analysis:** Use the LM to analyze the data stored in the graph database. For example, you could ask the LM to identify trends in player behavior or to detect anomalies in the data. * **Fine-tuning:** Consider fine-tuning the LM on a dataset of Minecraft-related text and code to improve its performance on these tasks. **In summary, a successful Graph Database project for MCP Servers requires a solid understanding of both Graph Database principles and the intricacies of the Minecraft Protocol. By carefully designing your data model, choosing the right tools, and paying attention to performance and privacy, you can build powerful applications that unlock valuable insights from your Minecraft server data.** This comprehensive overview should provide a strong foundation for an LM to quickly grasp the key concepts and contribute effectively to Graph Database projects related to MCP Servers. Remember to tailor the information to the specific project requirements and to provide the LM with clear and specific instructions.

mcp-server-collector MCP server

镜子 (jìng zi)

Laravel Artisan MCP Server

一个模型上下文协议 (MCP) 服务器，它允许通过 Claude 和其他 MCP 客户端安全地执行 Laravel Artisan 命令。

Setup

适用于 Ableton Live 的 MCP 服务器

Awesome-Medical-MCP-Servers

医疗 Minecraft 服务端合集。

CLI MCP Server

镜子 (jìng zi)

Model Context Protocol Server

使用 FastAPI 实现的模型上下文协议服务器： ```python from fastapi import FastAPI, Request, HTTPException from pydantic import BaseModel from typing import Dict, Any, Optional app = FastAPI() # 定义请求和响应模型 class ContextRequest(BaseModel): model_id: str context: Dict[str, Any] request_id: Optional[str] = None # 可选的请求 ID，用于跟踪 class ContextResponse(BaseModel): model_id: str context: Dict[str, Any] request_id: Optional[str] = None # 响应中返回请求 ID # 模拟的模型上下文存储 model_contexts: Dict[str, Dict[str, Any]] = {} @app.post("/context") async def update_context(request: ContextRequest) -> ContextResponse: """ 更新指定模型的上下文。 Args: request: 包含模型 ID 和上下文数据的 ContextRequest 对象。 Returns: 包含更新后的模型 ID 和上下文数据的 ContextResponse 对象。 """ model_id = request.model_id context = request.context request_id = request.request_id # 检查模型 ID 是否存在 if model_id not in model_contexts: model_contexts[model_id] = {} # 更新上下文 model_contexts[model_id].update(context) # 构建响应 response = ContextResponse(model_id=model_id, context=model_contexts[model_id], request_id=request_id) return response @app.get("/context/{model_id}") async def get_context(model_id: str) -> Dict[str, Any]: """ 获取指定模型的上下文。 Args: model_id: 要获取上下文的模型 ID。 Returns: 指定模型的上下文数据。 Raises: HTTPException: 如果模型 ID 不存在。 """ if model_id not in model_contexts: raise HTTPException(status_code=404, detail=f"Model ID '{model_id}' not found") return model_contexts[model_id] @app.delete("/context/{model_id}") async def delete_context(model_id: str) -> Dict[str, str]: """ 删除指定模型的上下文。 Args: model_id: 要删除上下文的模型 ID。 Returns: 一个包含删除结果的消息。 Raises: HTTPException: 如果模型 ID 不存在。 """ if model_id not in model_contexts: raise HTTPException(status_code=404, detail=f"Model ID '{model_id}' not found") del model_contexts[model_id] return {"message": f"Context for model ID '{model_id}' deleted successfully."} if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000) ``` **代码解释:** * **`from fastapi import FastAPI, Request, HTTPException`**: 导入 FastAPI 及其相关模块。 * **`from pydantic import BaseModel`**: 导入 Pydantic 的 `BaseModel` 用于定义数据模型。 * **`from typing import Dict, Any, Optional`**: 导入类型提示，提高代码可读性。 * **`app = FastAPI()`**: 创建 FastAPI 应用实例。 * **`ContextRequest` 和 `ContextResponse`**: 使用 Pydantic 定义请求和响应的数据模型。 `ContextRequest` 包含 `model_id` (模型 ID), `context` (上下文数据，一个字典), 和可选的 `request_id`。 `ContextResponse` 包含相同的信息，用于返回更新后的上下文。 * **`model_contexts: Dict[str, Dict[str, Any]] = {}`**: 一个字典，用于存储模型上下文。 键是 `model_id` (字符串)，值是另一个字典，表示该模型的上下文数据。 这只是一个内存中的存储，在实际应用中，你可能需要使用数据库或其他持久化存储。 * **`@app.post("/context")`**: 定义一个 POST 路由，用于更新模型的上下文。 * `async def update_context(request: ContextRequest) -> ContextResponse:`: 定义异步函数 `update_context`，它接收一个 `ContextRequest` 对象作为参数，并返回一个 `ContextResponse` 对象。 * 函数首先从请求中提取 `model_id` 和 `context`。 * 然后，它检查 `model_id` 是否已经存在于 `model_contexts` 中。如果不存在，则创建一个新的条目。 * 接下来，它使用 `update()` 方法将请求中的 `context` 合并到现有的模型上下文中。 * 最后，它创建一个 `ContextResponse` 对象并返回。 * **`@app.get("/context/{model_id}")`**: 定义一个 GET 路由，用于获取指定模型的上下文。 * `async def get_context(model_id: str) -> Dict[str, Any]:`: 定义异步函数 `get_context`，它接收一个 `model_id` 作为参数，并返回一个字典，表示该模型的上下文数据。 * 函数首先检查 `model_id` 是否存在于 `model_contexts` 中。如果不存在，则抛出一个 `HTTPException`，状态码为 404 (Not Found)。 * 如果 `model_id` 存在，则返回 `model_contexts[model_id]`。 * **`@app.delete("/context/{model_id}")`**: 定义一个 DELETE 路由，用于删除指定模型的上下文。 * `async def delete_context(model_id: str) -> Dict[str, str]:`: 定义异步函数 `delete_context`，它接收一个 `model_id` 作为参数，并返回一个字典，包含删除结果的消息。 * 函数首先检查 `model_id` 是否存在于 `model_contexts` 中。如果不存在，则抛出一个 `HTTPException`，状态码为 404 (Not Found)。 * 如果 `model_id` 存在，则使用 `del model_contexts[model_id]` 删除该模型的上下文。 * 最后，返回一个包含成功消息的字典。 * **`if __name__ == "__main__":`**: 确保代码只在直接运行脚本时执行，而不是作为模块导入时执行。 * **`uvicorn.run(app, host="0.0.0.0", port=8000)`**: 使用 Uvicorn 启动 FastAPI 应用。 `host="0.0.0.0"` 表示监听所有网络接口，`port=8000` 表示监听 8000 端口。 **如何运行:** 1. **安装 FastAPI 和 Uvicorn:** ```bash pip install fastapi uvicorn ``` 2. **保存代码:** 将代码保存为 `main.py` (或其他你喜欢的名字)。 3. **运行应用:** ```bash python main.py ``` 或者，如果你安装了 `uvicorn` 作为全局命令： ```bash uvicorn main:app --reload ``` `--reload` 标志会在代码更改时自动重新加载服务器，方便开发。 **如何使用:** 你可以使用 `curl` 或任何 HTTP 客户端来与服务器交互。 * **更新上下文 (POST):** ```bash curl -X POST -H "Content-Type: application/json" -d '{"model_id": "my_model", "context": {"key1": "value1", "key2": 123}, "request_id": "req123"}' http://localhost:8000/context ``` * **获取上下文 (GET):** ```bash curl http://localhost:8000/context/my_model ``` * **删除上下文 (DELETE):** ```bash curl -X DELETE http://localhost:8000/context/my_model ``` **重要注意事项:** * **错误处理:** 代码包含基本的错误处理 (例如，检查模型 ID 是否存在)。 在实际应用中，你需要更完善的错误处理机制，例如记录错误日志、返回更详细的错误信息等。 * **安全性:** 此代码没有包含任何安全措施。 在生产环境中，你需要添加身份验证、授权、输入验证等安全措施。 * **持久化存储:** 此代码使用内存中的字典来存储模型上下文。 这意味着，当服务器重启时，所有上下文数据都会丢失。 在实际应用中，你需要使用数据库或其他持久化存储来保存上下文数据。 常见的选择包括 Redis、PostgreSQL、MongoDB 等。 * **并发:** FastAPI 是一个异步框架，可以处理并发请求。 但是，如果你的模型上下文存储是线程不安全的，你需要采取措施来保护它，例如使用锁。 * **模型集成:** 此代码只是一个模型上下文协议服务器的框架。 你需要将其与你的实际模型集成。 这可能涉及到加载模型、调用模型进行推理、以及将模型的结果存储到上下文中。 * **数据验证:** 你可以使用 Pydantic 的验证功能来确保上下文数据符合预期的格式和类型。 This provides a basic implementation of a Model Context Protocol server using FastAPI. Remember to adapt it to your specific needs and consider the important notes above for production deployments.

mcp-servers-client-langgraph-react-agent

多重 MCP 服务器和客户端，带有 LangGraph 预构建的 ReAct 代理。 (Duōchóng MCP fúwùqì hé kèhùduān, dài yǒu LangGraph yù gòujiàn de ReAct dàilǐ.)

say-mcp-server

镜子 (jìng zi)

Luke Desktop

一个现代化的 Claude AI 桌面客户端，支持 MCP 服务器，使用 Tauri、React 和 TypeScript 构建。

local-command-server MCP Server

镜子 (jìng zi)

sek-fx-mcp

一个模型上下文协议服务器 (MCP)，将大型语言模型 (LLM) 连接到瑞典国家银行 (Riksbanken) 的克朗汇率 API。

MCP Server

一个中间件服务器，充当 Cursor IDE 和 AI 模型之间的桥梁，使用项目上下文和 Gemini 验证 AI 响应。 (Alternatively, a slightly more formal translation:) 一个中间件服务器，作为 Cursor IDE 与人工智能模型之间的桥梁，利用项目上下文和 Gemini 来验证人工智能的响应。

Air-Pollution

这个项目是一个模型上下文协议（MCP）服务器，使用 Node.js + Express.js 构建，并与 OpenWeather API 交互。它允许用户根据经纬度或城市和国家/地区获取空气污染数据。后端使用 dotenv 确保安全的 API 密钥管理，并高效地处理 API 请求。

@f4ww4z/mcp-mysql-server

镜子 (jìng zi)

Naver Maps MCP Server

使用模型上下文协议 (MCP) 服务器实现 Naver 地图 API

IBKR MCP Server

IBKR Client 的 MCP 服务器

mcp-server-curio

MCP 服务器用于 Filecoin 生态系统的 Curio 项目。

Alper Hoca ile MCP Server

使用 Next.js 构建的 MCP 服务器项目

Go Delve Debugger MCP Server

将暴露 Golang 的 Delve 调试器的 MCP 服务器，使 AI 能够进行自我调试。

Financial Analysis MCP Server

一个 Anthropic 模型上下文协议 (MCP) 服务器，用于金融分析，集成了 alphavantage.com 和 financialmodellingprep.com API。

MCP File Finder

用 Python 编写的 MCP 服务器 (Yòng Python biānxiě de MCP fúwùqì) This translates to: "MCP server written in Python" or "MCP server on Python" (more literally).

Claude MCP (Master Control Program)

使用不同工具扩展 Claude 代码功能的 MCP 服务器。

mcp-servers

MCP服务器搭建示例 (This is a general translation. Depending on the specific context of "MCP Server," the translation might need to be adjusted. For example, if "MCP" refers to a specific software or game, the translation might include the name of that software/game in Chinese.)