Discover Awesome MCP Servers

imail-mcp

MCP server that connects Claude to iCloud Mail, enabling reading, searching, sending, and organizing emails via IMAP/SMTP.

Shell Server

A lightweight MCP server that provides AI assistants with access to a system's terminal through a secure terminal tool. It enables users to execute shell commands and receive stdout, stderr, and exit codes directly within an MCP-compatible client.

musicbrainz-mcp-server

Search artists, releases, recordings, works, and labels; traverse relationships; resolve ISRC/ISWC/barcode; fetch cover art via MCP. STDIO or Streamable HTTP.

Laptop Hardware MCP Server

A Windows-based MCP server that provides real-time hardware telemetry and system stats including CPU, RAM, disk, and battery information to GitHub Copilot. It enables users to monitor performance and retrieve detailed system specifications through natural language commands.

Tentahead MCP

Connects to the Tentahead API to facilitate campsite searching and group trip planning for Illinois state parks. It provides live availability, weather forecasts, safety alerts, and EV charging data to streamline outdoor adventure planning.

mcp-tellus-search

Enables Claude to search for geo entities such as cities, airports, and hotels using Skyscanner's Tellus API. Supports entity lookup, search by type/location, fetching children, and nearby entities.

DeltaSignal ATLAS-7

Real-time financial intelligence MCP server for crypto public companies. Provides covenant stress analysis, alpha signals, peer ranking, risk distribution, SEC XBRL fundamentals, and daily changes. Native x402 micropayments supported. First 5 calls free.

RobotArm MCP P340

Enables natural language control of ElephantRobotics MyCobot series robotic arms (especially ultraArmP340) through MCP protocol, with simulation mode and safety features.

HostProfit

Audit any Airbnb, VRBO, or STR listing URL for dollar-denominated revenue gaps. Free tier shows category grades and monthly losses. Pro tier unlocks ranked action plans.

mcp-instana

Enables seamless interaction with the IBM Instana observability platform, allowing access to real-time observability data directly within development workflows.

maya_mcp

A Model Context Protocol server that enables AI assistants to interact with active Autodesk Maya sessions using the maya.cmds API. It allows users to manage scene objects, control selections, and perform common 3D operations through natural language.

TreasuryOS

An AI-powered treasury management MCP server that enables users to perform commercial banking analysis, including cash flow forecasting, idle cash detection, and debt covenant monitoring. It provides tools to surface financial insights and optimize working capital through automated processing of bank and transaction data.

workday-mcp-reference

A vendor-neutral reference implementation of a Workday MCP server that enables integration with Workday for employee data, compensation, benefits, time off, org info, inbox tasks, admin operations, and headcount management through natural language.

MCP Yandex Voice

MCP server for Cursor that generates text responses via Yandex GPT and converts them to speech using Yandex SpeechKit TTS, enabling voice replies to user messages.

sharp-on-fhir-mcp

A clean-room SHARP-on-MCP compliant FHIR R4 MCP server that enables AI agents to interact with any FHIR R4 endpoint using SHARP context headers, without server-side OAuth. It provides clinical tools, lab results, imaging, and interactive MCP-UI dashboards.

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

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.

Jira MCP Server

Enables AI agents to interact with Jira Cloud, including listing boards and issues, adding comments, and searching users.

bitflyer-mcp

A read-only MCP server that retrieves public market data from bitFlyer, allowing natural language querying of ticker, order book, executions, exchange health, and tradable products.

TradingView MCP Bridge

Connects AI assistants to your local TradingView Desktop app via Chrome DevTools Protocol for chart analysis, Pine Script development, and workflow automation while keeping all data local.

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.

EZTexting MCP Server

Provides MCP tools for SMS messaging, contact management, workflows automation, and account administration through EZTexting's API, supporting both remote Streamable HTTP and local stdio bridge.

Pharaoh

AI reads your codebase like a book - one page at a time. Pharaoh gives it the index and a map of how every chapter connects.

discord-mcp

MCP server for interacting with Discord via REST API, enabling guild, channel, and message operations using a bot token.

Zellij MCP Server

Enables comprehensive management of Zellij terminal workspace sessions, including session, pane, tab, plugin, layout operations, and LLM completion detection.

MCP Auth Example

Demonstrates a FastMCP server with Bearer token authentication via Nginx and fine-grained authorization via Envoy and OPA.

Blender MCP Server

Exposes 50+ Blender tools (object manipulation, materials, animation, etc.) via MCP for AI-driven 3D workflows and automation.

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.

bear-mcp

Enables AI assistants to read and write Bear notes using SQLite for queries and x-callback-url for safe writes.

MCP to LangChain/LangGraph Adapter

Okay, I understand. You want a Python adapter that takes tools designed for an MCP (presumably Minecraft Protocol) server and makes them usable as tools within the Langchain framework. Here's a conceptual outline and a code snippet to get you started. This is a basic example and will need to be adapted to your specific MCP server tools and Langchain setup. **Conceptual Outline** 1. **Understand MCP Server Tools:** You need to know how to interact with your MCP server tools. This likely involves sending commands over a network connection (e.g., TCP socket) and parsing the responses. You'll need to define the specific commands each tool accepts and the format of the data it returns. 2. **Langchain Tool Interface:** Langchain tools have a specific interface. They need a `name`, a `description`, and a `_run` method (or `arun` for asynchronous execution) that takes a string as input and returns a string as output. 3. **Adapter Class:** Create a Python class that inherits from `langchain.tools.BaseTool`. This class will: * Initialize with the necessary connection details for your MCP server. * Implement the `_run` method to: * Connect to the MCP server. * Format the input string into a command suitable for the MCP server tool. * Send the command to the server. * Receive the response from the server. * Parse the response. * Return the parsed response as a string. * Define the `name` and `description` attributes for the tool. **Code Snippet (Basic Example)** ```python from langchain.tools import BaseTool import socket import json # Assuming your MCP server uses JSON for communication class MCPServerTool(BaseTool): """Tool for interacting with an MCP server.""" name: str = "mcp_server_tool" # Replace with a more descriptive name description: str = ( "Useful for interacting with a Minecraft server. " "Input should be a JSON string containing the 'command' and any necessary 'arguments'." ) host: str = "localhost" # Replace with your MCP server's host port: int = 25565 # Replace with your MCP server's port def _run(self, query: str) -> str: """Use the tool.""" try: query_json = json.loads(query) command = query_json.get("command") arguments = query_json.get("arguments", {}) # Default to empty dict if no arguments if not command: return "Error: 'command' key missing in the input JSON." # Format the command for the MCP server (adjust as needed) mcp_command = self._format_mcp_command(command, arguments) # Connect to the MCP server with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((self.host, self.port)) s.sendall(mcp_command.encode()) # Encode to bytes # Receive the response (adjust buffer size as needed) response = s.recv(1024).decode() # Decode from bytes # Parse the response (assuming JSON) try: response_json = json.loads(response) return json.dumps(response_json) # Return as JSON string except json.JSONDecodeError: return f"MCP Server Response: {response}" # Return raw response if not JSON except json.JSONDecodeError: return "Error: Invalid JSON input." except Exception as e: return f"Error: {e}" async def _arun(self, query: str) -> str: """Use the tool asynchronously.""" raise NotImplementedError("This tool does not support asynchronous execution.") def _format_mcp_command(self, command: str, arguments: dict) -> str: """Formats the command for the MCP server. Adjust this based on your server's protocol.""" # Example: Assuming the server expects commands like "command arg1=value1 arg2=value2" command_string = command for key, value in arguments.items(): command_string += f" {key}={value}" return command_string ``` **How to Use** 1. **Replace Placeholders:** Fill in the `host`, `port`, `name`, and `description` attributes with the correct values for your MCP server and tool. 2. **Implement `_format_mcp_command`:** This is crucial. This method *must* format the input `command` and `arguments` into the exact format that your MCP server expects. This will vary depending on your server's protocol. 3. **Adjust Socket Communication:** The `socket` code might need adjustments. Consider: * **Buffering:** The `recv(1024)` call receives up to 1024 bytes. If your server sends larger responses, you'll need to receive in a loop until you have the complete response. * **Encoding:** Make sure you're using the correct encoding (e.g., UTF-8) for both sending and receiving data. * **Error Handling:** Add more robust error handling (e.g., timeouts, connection errors). 4. **Parse Responses:** The code assumes the server returns JSON. If it returns a different format, you'll need to change the parsing logic accordingly. 5. **Add to Langchain:** Instantiate the `MCPServerTool` and add it to your Langchain agent's tools list. ```python # Example of adding the tool to a Langchain agent from langchain.agents import initialize_agent from langchain.llms import OpenAI # Or your preferred LLM # Replace with your OpenAI API key openai_api_key = "YOUR_OPENAI_API_KEY" llm = OpenAI(temperature=0, openai_api_key=openai_api_key) mcp_tool = MCPServerTool() tools = [mcp_tool] agent = initialize_agent(tools, llm, agent="zero-shot-react-description", verbose=True) # Example usage prompt = """ What is the current time on the Minecraft server? The input to this tool should be a json string with the command and arguments. """ # The agent will call the tool with an input like: # '{"command": "get_time", "arguments": {}}' # Assuming your _format_mcp_command formats it correctly. agent.run(prompt) ``` **Important Considerations** * **Security:** Be extremely careful about security. Never expose your MCP server directly to the internet without proper security measures. Sanitize all input to prevent command injection vulnerabilities. Consider using authentication and authorization. * **Error Handling:** Implement robust error handling to catch exceptions and provide informative error messages. * **Asynchronous Execution:** If you need asynchronous execution, you'll need to use `asyncio` and asynchronous socket operations. The `_arun` method in the example raises `NotImplementedError`. * **MCP Server Protocol:** The most important part is understanding and correctly implementing the communication protocol with your MCP server. Consult your server's documentation or source code for details. * **Langchain Agent Type:** The `zero-shot-react-description` agent is a good starting point, but you might need to experiment with different agent types to find one that works best for your use case. This comprehensive response should give you a solid foundation for building your MCP server tool adapter for Langchain. Remember to adapt the code to your specific needs and prioritize security. Good luck!