Discover Awesome MCP Servers

GitHub MCP Server

Servidor MCP do Github para integrar com fluxos de CI

7pace Timetracker MCP Server

Enables intelligent time tracking for Azure DevOps work items through natural language commands in AI assistants, integrating directly with 7pace Timetracker API for seamless worklog management and reporting.

Excel MCP Server

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

Implore MCP

Enables AI assistants to request human input through interactive GUI dialogs with quiz-style questions, supporting multiple choice and free-form responses for clarification, decisions, and knowledge extraction.

EntityIdentification

A MCP server that helps determine if two sets of data belong to the same entity by comparing both exact and semantic equality through text normalization and language model integration.

Google Workspace MCP Server

Enables interaction with Google Sheets, Docs, and Drive to manage spreadsheets, documents, and files. It supports operations like reading and updating cell data, extracting text from documents, and searching or sharing files within Google Drive.

Agent Identity Protocol (AIP)

Provides cryptographic identity and signing capabilities for AI agents, enabling them to create persistent identities, sign actions with private keys, and allow external systems to verify the authenticity and provenance of agent-initiated operations.

mcp0

Configurador/inspetor seguro de servidores MCP (Protocolo de Contexto de Modelo) que expõe contextos configurados como servidores MCP. Configure uma vez, reutilize com qualquer cliente MCP.

MCP Test Scratch Server

A Flask-based MCP server designed for testing deployment on Google App Engine. Provides a deeplink checking endpoint that accepts flattened JSON parameters and forwards them as nested objects to external APIs.

Cloud Run MCP Server

A secure MCP server example that demonstrates how to deploy to Google Cloud Run with authentication and identity token protection. Serves as a tutorial template for building production-ready MCP servers in the cloud.

Authless Remote MCP Server

A tool for deploying a remote Model Context Protocol server on Cloudflare Workers without authentication requirements, allowing users to create custom AI tools accessible from Claude Desktop or Cloudflare AI Playground.

MCP Math Server

A Mathematical Computation Protocol server providing 286 mathematical functions across multiple domains with flexible transport options (STDIO/HTTP) and streaming capabilities.

mcp-v8

mcp-v8

Curl MCP Server

A Model Context Protocol server that provides secure curl command execution capabilities, allowing AI assistants to make HTTP requests with configurable parameters and built-in security protections.

Clear Thought MCP Server

Provides systematic thinking tools including mental models, design patterns, debugging approaches, and collaborative reasoning frameworks to enhance problem-solving and decision-making capabilities.

Moonshot MCP Server Gateway

A lightweight gateway server that provides a unified connection entry point for accessing multiple MCP servers, supporting various protocols including Network and Local Transports.

Artur's Model Context Protocol servers

Servidores MCP

Memory MCP Server

Enables agents to maintain persistent memory through three-tiered architecture: short-term session context with TTL, long-term user profiles and preferences, and searchable episodic event history with sentiment analysis. Provides comprehensive memory management for personalized AI interactions.

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.

Twelve Data MCP Server

Provides integration with Twelve Data API to access financial market data including historical time series, real-time quotes, and instrument metadata for stocks, forex pairs, and cryptocurrencies.

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.

vet-mcp

vet-mcp

@mcp/openverse

An MCP server that enables searching and fetching openly-licensed images from Openverse with features like filtering by license type, getting image details, and finding essay-specific illustrations.

Local Services MCP Server

A Multi-Agent Conversation Protocol Server that provides access to Google's Local Services API, enabling interaction with local service businesses information through natural language commands.

OCI Core Services FastMCP Server

A dedicated server for Oracle Cloud Infrastructure (OCI) Core Services that enables management of compute instances and network operations with LLM-friendly structured responses.

mcp-server-email MCP server

I am a language model, and I don't have an email address. I am designed to process and generate text, and I don't have the capability to send or receive emails.

Singapore News MCP Server

Provides real-time news feeds from major Singapore news sources including The Straits Times, Business Times, and Channel News Asia. Delivers live news updates through Server-Sent Events for up-to-date information access.

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.