发现优秀的 MCP 服务器

LINE Bot MCP Server

MCP server for LINE Messaging API — send messages, manage groups, rich menus, webhooks, and more through 25 tools.

Fast Context MCP

Enables AI-driven semantic code search using Windsurf's reverse-engineered SWE-grep protocol to query local codebases with natural language. It executes local search tools like ripgrep and tree-node-cli to return relevant file paths and line ranges to MCP-compatible clients.

Weather MCP Server

Enables Claude to query real-time weather information for specified regions using the OpenWeatherMap API.

mcp-trivia

Wraps the Open Trivia Database to provide trivia categories and questions via MCP tools.

docker

sapne dekha ache baat hai sapna ke so jaana wo sahi nahi hai

MCP Platform

High-performance Model Context Protocol server supporting multiple LLM providers (OpenRouter, OpenAI, Groq) with WebSocket API and conversation history persistence.

hko_mcp

使用 MCP 从香港天文台获取数据

octane-mcp

A local MCP server that lets Hermes Agent use Octane X as a shared visual canvas for geometry, data, math, and concept visualization.

VectorClaw

Enables AI assistants to control Anki Vector robots locally via natural language, providing tools for speech, motion, perception, and interaction without cloud dependency.

MongoDB Memory MCP

Provides persistent memory for AI assistants using MongoDB Vector Search, enabling content storage, semantic search, and knowledge retrieval through MCP tools.

Archery MCP Server

Enables AI agents to interact with the Archery SQL audit and query platform for submitting and managing SQL tickets, executing queries, and administering instances.

linux-computer-use

Enables AI agents to control Linux/X11 desktops by providing tools for taking screenshots, clicking, typing, and managing windows via AT-SPI and xdotool.

LacyLights MCP Server

Provides AI-powered theatrical lighting design capabilities for the LacyLights system, allowing users to generate lighting scenes, analyze scripts, manage cues, and optimize lighting effects based on artistic intent.

Fluent MCP

There isn't a single, pre-built Python package specifically designed to create Minecraft (MCP) servers with embedded Large Language Model (LLM) reasoning. You'll need to combine several existing packages and build the integration logic yourself. Here's a breakdown of the components you'll need and how you might approach it, along with potential package recommendations: **1. Minecraft Server Management:** * **Purpose:** This handles the core Minecraft server functionality: starting, stopping, managing players, executing commands, and receiving server events. * **Options:** * **`mcstatus`:** (Relatively simple) Primarily for querying server status (player count, MOTD, etc.). Less suitable for full server control. * **`minecraft-launcher-lib`:** (More complex, but powerful) Allows you to launch and manage Minecraft server instances programmatically. You can control the server process, read its output, and send commands. This is likely the best option for more advanced control. * **`pyminecraft`:** (Less actively maintained) Provides some server interaction capabilities, but might be outdated. * **Directly interacting with the server process:** You can use Python's `subprocess` module to launch the Minecraft server JAR file and communicate with it via standard input/output. This gives you the most control but requires more manual handling of server processes and command parsing. **2. Minecraft Protocol Handling:** * **Purpose:** This allows your Python code to understand and interact with the Minecraft network protocol. You'll need this to send commands to the server and receive information about the game world. * **Options:** * **`python-minecraft-protocol` (or `mcproto`):** A popular library for handling the Minecraft protocol. It allows you to connect to a Minecraft server as a client, send and receive packets, and interact with the game world. This is crucial for sending commands and receiving information from the server. * **`nbt`:** For reading and writing NBT (Named Binary Tag) data, which is used to store Minecraft world data, player data, and other information. You'll likely need this if you want to analyze or modify the game world. **3. LLM Integration:** * **Purpose:** This provides the interface to your chosen Large Language Model. * **Options:** * **`openai`:** For interacting with OpenAI's models (GPT-3, GPT-4, etc.). Requires an OpenAI API key. * **`transformers` (Hugging Face):** A very versatile library for working with a wide range of LLMs, including open-source models. You can use it to load pre-trained models or fine-tune your own. * **`cohere`:** For interacting with Cohere's LLMs. * **`llama-cpp-python`:** For running Llama 2 and other LLMs locally. This is useful if you want to avoid API costs and have more control over the model. * **LangChain:** A framework that simplifies the process of building applications with LLMs. It provides tools for chaining together different LLM calls, managing prompts, and integrating with external data sources. It can be very helpful for complex reasoning tasks. **4. Text Processing and Natural Language Understanding (NLU):** * **Purpose:** To parse player commands, extract relevant information, and format responses from the LLM. * **Options:** * **`spaCy`:** A powerful library for natural language processing. It can be used for tokenization, part-of-speech tagging, named entity recognition, and more. * **`NLTK` (Natural Language Toolkit):** Another popular NLP library with a wide range of features. * **Regular expressions (`re` module):** Useful for simple pattern matching and text extraction. **5. Asynchronous Programming (Optional but Recommended):** * **Purpose:** To handle multiple tasks concurrently (e.g., listening for server events, processing player commands, interacting with the LLM) without blocking the main thread. * **Options:** * **`asyncio`:** Python's built-in asynchronous programming library. * **`aiohttp`:** An asynchronous HTTP client/server library (useful if you're interacting with an LLM API over the network). **Conceptual Architecture:** 1. **Minecraft Server Management:** Use `minecraft-launcher-lib` (or `subprocess`) to start and manage the Minecraft server. 2. **Protocol Connection:** Use `python-minecraft-protocol` to connect to the server as a client. 3. **Command Handling:** * Listen for chat messages from players using `python-minecraft-protocol`. * Parse the chat messages using `spaCy` or regular expressions to identify commands and arguments. 4. **LLM Reasoning:** * Formulate a prompt for the LLM based on the player's command and any relevant game state information. * Send the prompt to the LLM using the `openai`, `transformers`, `cohere`, or `llama-cpp-python` library. * Receive the LLM's response. 5. **Action Execution:** * Parse the LLM's response to determine the appropriate action to take in the game world. * Use `python-minecraft-protocol` to send commands to the server to execute the action (e.g., `/give`, `/tp`, `/say`). * Send a response back to the player in the chat. **Example (Illustrative - Requires Significant Implementation):** ```python import asyncio import minecraft_launcher_lib from mcproto import MinecraftProtocol import openai import re # Configuration (replace with your actual values) SERVER_JAR = "server.jar" # Path to your Minecraft server JAR SERVER_PORT = 25565 OPENAI_API_KEY = "YOUR_OPENAI_API_KEY" async def main(): # 1. Start the Minecraft server # (Using minecraft-launcher-lib or subprocess) # ... (Implementation details omitted for brevity) # 2. Connect to the server using mcproto protocol = MinecraftProtocol("localhost", SERVER_PORT) await protocol.connect() await protocol.handshake() await protocol.login("LLMBot") # Bot's username # 3. Listen for chat messages async def handle_chat_message(packet): message = packet.data['content'] print(f"Received chat message: {message}") # Extract player name and command (very basic example) match = re.match(r"^<(\w+)> !(\w+)\s*(.*)$", message) if match: player_name = match.group(1) command = match.group(2) arguments = match.group(3) # 4. LLM Reasoning prompt = f"Player {player_name} issued command: {command} {arguments}. What should I do in Minecraft?" openai.api_key = OPENAI_API_KEY response = openai.Completion.create( engine="text-davinci-003", # Choose an appropriate model prompt=prompt, max_tokens=50, n=1, stop=None, temperature=0.7, ) llm_response = response.choices[0].text.strip() print(f"LLM Response: {llm_response}") # 5. Action Execution (very basic example) server_command = f"/say {llm_response}" await protocol.send_chat_message(server_command) # Assuming you have a send_chat_message function protocol.register_packet_listener("chat.message", handle_chat_message) # Keep the connection alive try: while True: await asyncio.sleep(1) except asyncio.CancelledError: pass finally: await protocol.disconnect() if __name__ == "__main__": asyncio.run(main()) ``` **Important Considerations:** * **Security:** Be extremely careful about executing commands based on LLM output. Implement robust validation and sanitization to prevent malicious commands from being executed. Consider using a whitelist of allowed commands. * **Rate Limiting:** LLM APIs often have rate limits. Implement appropriate rate limiting in your code to avoid exceeding these limits. * **Prompt Engineering:** The quality of the LLM's responses depends heavily on the prompts you provide. Experiment with different prompts to find what works best for your application. * **Error Handling:** Implement robust error handling to gracefully handle unexpected errors, such as network errors, API errors, and invalid LLM responses. * **Minecraft Server Configuration:** You may need to configure your Minecraft server to allow connections from your Python script. * **Performance:** LLM inference can be computationally expensive. Consider using techniques such as caching and batching to improve performance. Running the LLM locally (e.g., with `llama-cpp-python`) can reduce latency but requires significant computational resources. * **Ethical Considerations:** Be mindful of the potential ethical implications of using LLMs in a game environment. Consider how the LLM's behavior might affect players and ensure that it is used responsibly. This is a complex project, but by breaking it down into smaller components and using the appropriate libraries, you can create a powerful and engaging Minecraft server with embedded LLM reasoning. Good luck!

D&D MCP Server

A comprehensive Model Context Protocol server for managing Dungeons & Dragons campaigns with tools for characters, NPCs, locations, quests, combat encounters, and session tracking.

Quant2Ptrader-MCP

Automatically converts JoinQuant quantitative trading strategies to Ptrade platform format, supporting direct code input or file paths, with automatic API mapping and detailed conversion reports.

mcp-server-template

A Python MCP server template with environment-driven configuration, key authentication with rotation, JSON logging, and a golden-set eval harness for building production-ready MCP servers.

LibreOffice MCP Tools

Enables AI agents to read, write, and edit Office documents via LibreOffice with token-efficient design. Supports multiple formats including DOCX, XLSX, PPTX, and legacy formats through LibreOffice bridge.

Brewman MCP Server

Wraps the Brewman Web (V7) API to read and write Brewman data (orders, outlets, stock, config) via tools, with the API token stored securely as an environment variable.

LSP-MCP

Minimal MCP server bridging a Roslyn C# language server to AI agents, exposing tools for diagnostics, call hierarchy, and type hierarchy.

Lightroom Classic MCP Server

Enables local automation of Adobe Lightroom Classic via the Model Context Protocol, supporting import, export, and non-destructive develop adjustments through an async job queue.

Widget MCP

Adds interactive widgets to LLM chats for common tasks like timers, stopwatches, unit conversions, and displaying facts. Breaks away from text-only interfaces by providing visual, interactive components similar to Google's search result widgets.

isocast-mcp

MCP server providing Polymarket weather-market bucket-transition signals for AI agents, with free city/signal inspection tools and paid signal bundles via USDC on Base using x402.

Peekaboo MCP

A macOS utility that captures screenshots and analyzes them with AI vision, enabling AI assistants to see and interpret what's on your screen.

state-trace

Graph-native bounded working memory for coding agents with typed memories, causal retrieval, current-vs-stale state queries, and compact small-model briefs.

todo-list-mcp

Manages a persistent todo list with SQLite storage, reminder notifications, and cross-platform sound alerts.

Tripwire

A local MCP server that auto-injects relevant context into file reads when an agent accesses specified paths, ensuring agents have necessary knowledge before interacting with code.

Databricks MCP Server

Enables AI assistants like Claude to interact with Databricks workspaces through secure OAuth authentication. Supports custom prompts, tools for cluster management, SQL execution, and job operations via the Databricks SDK.

atlassian-mcp

MCP server for Atlassian Confluence and Jira Cloud with 51 tools to manage pages, issues, sprints, boards, and backlogs.

Ebay MCP server

镜子 (jìng zi)