Discover Awesome MCP Servers

Ping MCP Server

An MCP server that allows users to ping other hosts to check network connectivity and diagnostic information. It enables LLMs to perform network latency tests and host availability checks through a standardized interface.

Fathom MCP Server

Enables AI agents to access Fathom AI meeting data including transcripts, summaries, teams, and team members. Provides tools to list meetings with filters, retrieve detailed transcripts and summaries, and manage team information.

MCP Spec Generator

Generates project specifications and file structures using Claude AI through MCP integration. Enables users to describe project ideas and automatically create corresponding documentation and project files.

Macroforge MCP Server

Enables AI assistants to access Macroforge documentation, validate TypeScript code with @derive decorators, expand macros, and retrieve macro documentation.

OpenFeature MCP Server

Provides OpenFeature SDK installation guidance through MCP tool calls. Enables AI clients to fetch installation prompts and setup instructions for various OpenFeature SDKs across different programming languages and frameworks.

REMnux Documentation MCP Server

Enables AI assistants to search and retrieve information from the REMnux malware analysis toolkit documentation, allowing users to ask questions about reverse-engineering tools and get accurate, up-to-date answers from the live documentation.

Fusion 360 MCP Integration

Enables AI assistants to interact programmatically with Autodesk Fusion 360 for creating parametric 3D models through simple API calls.

zan-mcp-server

Servidor de Protocolo de Contexto de Modelo para o Serviço de Nó ZAN.

MCPServerTransportDemo

A demonstration project for building and testing Model Context Protocol (MCP) servers using the MCP inspector and client tools. It provides a practical implementation for exploring MCP transport mechanisms and server-client interactions.

Zulip MCP Server

A Model Context Protocol server that enables AI assistants to interact with Zulip workspaces by exposing REST API capabilities as tools for message operations, channel management, and user interactions.

Devpipe MCP Server

Enables AI assistants to interact with devpipe, a local pipeline runner, allowing them to list tasks, run pipelines, validate configurations, debug failures, analyze security findings, and generate CI/CD configs through natural language.

SAP Concur MCP Server by CData

This read-only MCP Server allows you to connect to SAP Concur data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

mcp_repo_170d1d13

Este é um repositório de teste criado pelo script de teste do Servidor MCP para o GitHub.

Basic MCP Server

A minimal Model Context Protocol server template demonstrating basic implementation of tools, resources, and prompts. Serves as a starting point for building custom MCP servers with the Smithery SDK.

Movie Database MCP Server

Enables natural language queries against a MongoDB movie database to search films by title, genre, actor, year, or rating, and retrieve detailed movie information from the sample_mflix collection.

Osmosis MCP Server

A comprehensive Model Context Protocol server that provides AI assistants with 158 tools for interacting with the Osmosis blockchain, covering everything from basic queries to direct transaction execution.

XMI MCP Server

An MCP server for querying and exploring SysML XMI models, specifically designed for MTConnect model exports. It allows users to search for packages, classes, and enumerations while providing tools for analyzing documentation and inheritance hierarchies.

MCP iCal Server

Agent-powered calendar management for macOS that transforms natural language into calendar operations through a single MCP tool interface.

Rootly MCP Server for Cloudflare Workers

A remote MCP server that provides AI agents access to the Rootly API for incident management, allowing users to query and manage incidents, alerts, teams, services, and other incident management resources through natural language.

MCP Git Server

A Model Context Protocol server that enables LLMs to interact with Git repositories, providing tools to read, search, and manipulate Git repositories through commands like status, diff, commit, and branch operations.

Cursor Agent Poisoning

A proof-of-concept attack that exploits Model Context Protocol (MCP) tool registration to achieve persistent agent poisoning in AI assistants like Cursor, embedding malicious instructions that persist across chat contexts without requiring tool execution.

MCP to LangChain/LangGraph Adapter

Okay, I understand. You want a way to wrap tools that interact with an MCP (Minecraft Protocol) server into a format that Langchain can use. This would allow you to build Langchain agents that can interact with and control a Minecraft server. Here's a breakdown of how you can approach this, along with code examples and explanations: **1. Understanding the Core Concepts** * **MCP (Minecraft Protocol):** This is the communication protocol used between Minecraft clients and servers. You'll need a library that can handle this protocol. Popular choices include: * **`mcstatus`:** A Python library specifically for querying Minecraft server status. It's good for basic information. * **`python-minecraft-nbt`:** For reading and writing NBT data (the format Minecraft uses for world data, player data, etc.). * **`minecraft-protocol`:** A more comprehensive library for interacting with the full Minecraft protocol. This is more complex but gives you more control. * **Langchain Tools:** Langchain tools are wrappers around functions that allow your Langchain agent to perform specific actions. They have a name, a description, and a function to execute. * **Langchain Agents:** Langchain agents use tools to interact with the environment and achieve goals. **2. General Structure** The basic structure will involve: 1. **MCP Interaction Logic:** Write Python functions that use your chosen MCP library to perform actions on the Minecraft server. Examples: * Get server status (player count, MOTD). * Send commands to the server console. * Read/write NBT data (more advanced). 2. **Tool Wrapping:** Wrap these functions into Langchain `Tool` objects. The `Tool` object will define the name, description, and the function to call. 3. **Agent Integration:** Provide these tools to your Langchain agent. **3. Example Code (using `mcstatus` for simplicity)** ```python from langchain.tools import Tool from mcstatus import JavaServer # --- MCP Interaction Functions --- def get_server_status(server_address): """Gets the status of a Minecraft server.""" try: server = JavaServer.lookup(server_address) status = server.status() return f"Server {server_address} has {status.players.online} players online. MOTD: {status.description}" except Exception as e: return f"Error getting server status: {e}" def send_server_command(server_address, command): """Sends a command to the Minecraft server console (requires RCON setup).""" # **IMPORTANT:** This requires RCON to be enabled and configured on the server. # RCON is a remote console protocol. It's a security risk if not properly secured. try: server = JavaServer.lookup(server_address) query = server.query() # Requires enabling query in server.properties # This is just an example, you'd need to use an RCON library for actual command execution # Example using mcrcon (install with pip install mcrcon): # from mcrcon import MCRcon # with MCRcon(server_address.split(":")[0], "your_rcon_password", int(server_address.split(":")[1])) as mcr: # resp = mcr.command(command) # return resp return f"Command '{command}' sent to server {server_address} (RCON not fully implemented in this example)." except Exception as e: return f"Error sending command: {e}" # --- Langchain Tool Definitions --- status_tool = Tool( name="Minecraft Server Status", func=get_server_status, description="Useful for getting the status of a Minecraft server, including player count and MOTD. Input should be a server address in the format 'host:port'." ) command_tool = Tool( name="Minecraft Server Command", func=send_server_command, description="Useful for sending commands to the Minecraft server console. Requires RCON to be enabled and configured. Input should be a server address in the format 'host:port' followed by the command to execute, separated by a comma. Example: 'localhost:25565,say Hello!'" ) # --- Example Usage (with a dummy agent) --- # In a real application, you'd integrate these tools into a Langchain agent. # This is a simplified example to show how the tools would be used. def dummy_agent(query): """A very simple agent that uses the tools based on keywords.""" if "status" in query.lower(): server_address = query.split("status of ")[-1].strip() # Extract server address return status_tool.run(server_address) elif "command" in query.lower(): parts = query.split("command")[-1].strip().split(",") if len(parts) != 2: return "Invalid command format. Use 'command <server_address>,<command>'." server_address = parts[0].strip() command = parts[1].strip() return command_tool.run(f"{server_address},{command}") else: return "I don't understand. Try asking for the server status or sending a command." # Example interaction print(dummy_agent("What is the status of localhost:25565")) print(dummy_agent("Send command localhost:25565,say Hello from Langchain!")) ``` **Explanation:** 1. **`get_server_status(server_address)`:** * Takes a server address (e.g., "localhost:25565") as input. * Uses `mcstatus` to query the server. * Returns a formatted string with the player count and MOTD. * Includes error handling. 2. **`send_server_command(server_address, command)`:** * Takes a server address and a command as input. * **Important:** This example *does not* fully implement RCON. It shows the basic structure but requires you to add the RCON library and authentication. I've included commented-out code using `mcrcon` as an example. * Returns a message indicating that the command was sent (or an error). 3. **`status_tool` and `command_tool`:** * `Tool` objects that wrap the functions. * `name`: A descriptive name for the tool. * `func`: The function to execute when the tool is called. * `description`: A crucial description for the Langchain agent. This is how the agent decides when to use the tool. Be very specific about the input format and what the tool does. 4. **`dummy_agent(query)`:** * This is a *very* basic example of how you might use the tools. In a real application, you would use a Langchain agent (e.g., `ZeroShotAgent`, `ReActAgent`) to intelligently decide when to use the tools based on the user's input. * The `dummy_agent` simply looks for keywords ("status", "command") in the query and calls the appropriate tool. * It extracts the server address and command from the query string. **Key Improvements and Considerations:** * **RCON Implementation:** The `send_server_command` function *must* be updated to use a proper RCON library (like `mcrcon`) to actually send commands to the server. You'll need to configure RCON on your Minecraft server (in `server.properties`) and provide the correct password. **Security is paramount with RCON.** Don't expose your RCON port to the internet without proper security measures. * **Error Handling:** Add more robust error handling to all functions. Catch exceptions and provide informative error messages to the agent. * **Input Validation:** Validate the input to the tools (e.g., server address format, command syntax) to prevent errors. * **Langchain Agent Integration:** Replace the `dummy_agent` with a real Langchain agent. You'll need to: * Choose an agent type (e.g., `ZeroShotAgent`, `ReActAgent`). * Define the agent's prompt (the instructions that tell the agent how to use the tools). The prompt is *critical* for agent performance. * Create an `AgentExecutor` to run the agent. * **More Advanced Tools:** Consider adding tools for: * Reading and writing NBT data (using `python-minecraft-nbt`). This would allow you to modify world data, player data, etc. * Managing server configuration (e.g., changing game rules). * Interacting with Minecraft plugins (if you have any installed). * **Security:** Be extremely careful about security, especially when dealing with RCON or NBT data. Sanitize inputs to prevent command injection or other vulnerabilities. Never hardcode passwords in your code. Use environment variables or a secure configuration file. * **Asynchronous Operations:** For more complex interactions, consider using asynchronous operations (using `asyncio`) to avoid blocking the main thread. This is especially important if you're running the agent in a web server or other interactive environment. **Example of integrating with a Langchain Agent (Conceptual):** ```python from langchain.agents import initialize_agent, AgentType from langchain.llms import OpenAI # Assuming you have the status_tool and command_tool defined as above llm = OpenAI(temperature=0) # Replace with your LLM tools = [status_tool, command_tool] agent = initialize_agent( tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True # Set to True for debugging ) # Now you can run the agent: response = agent.run("What is the status of localhost:25565? Then, send the command 'say Hello from the agent!' to localhost:25565") print(response) ``` **Important Notes about the Langchain Agent Example:** * **API Key:** You'll need an OpenAI API key to use the `OpenAI` LLM. * **Prompt Engineering:** The success of the agent depends heavily on the prompt used by the `ZERO_SHOT_REACT_DESCRIPTION` agent. You may need to experiment with different prompts to get the agent to behave as desired. The tool descriptions are a key part of the prompt. * **Dependencies:** Make sure you have all the necessary Langchain dependencies installed (`pip install langchain openai`). This comprehensive guide should give you a solid foundation for building Langchain tools that interact with your Minecraft server. Remember to prioritize security and error handling, and to carefully design your agent's prompt for optimal performance. Good luck!

Crash MCP Server

Enables AI assistants to analyze Linux system crash dumps by automatically discovering dump files, matching kernels, and executing interactive crash analysis commands through the MCP protocol.

SAP SuccessFactors MCP Server by CData

SAP SuccessFactors MCP Server by CData

MCPBrowser

Fetches content from authenticated web pages by driving your signed-in Chrome/Edge browser via DevTools Protocol, automatically handling login redirects and reusing sessions across domains.

SEO Audit MCP Server

Provides comprehensive technical SEO auditing tools including page analysis, site crawling, Lighthouse performance testing, and sitemap analysis, with specialized features for job board websites like JobPosting schema validation.

Google AdWords MCP Server by CData

Google AdWords MCP Server by CData

MCP Hello World Example

Um projeto modelo para criar projetos de servidor e cliente MCP.

MCP-Demo: Model Context Protocol Integration with OpenAI

Exemplo inicial de cliente-servidor do SDK MCP em C#