Discover Awesome MCP Servers

Whoop MCP Server

Exposes Whoop fitness data (recovery, sleep, strain, workouts) to Claude for use as a daily training coach, enabling natural language queries about your health metrics and training readiness.

Qobrix CRM MCP Server

A read-only MCP server providing 56 tools to query Qobrix real-estate CRM data, covering listings, leads, viewings, offers, contracts, analytics, and more, with RESO Data Dictionary alignment and caching support.

Cirvoy-Kiro MCP Integration

Enables seamless task synchronization between Kiro IDE and the Cirvoy project management platform. It provides tools to create, list, and update tasks directly within the IDE using the Model Context Protocol.

phren

A persistent memory server for AI agents that stores findings, tasks, and patterns in Markdown files within a git repository, enabling context injection across multiple AI tools.

GitHub MCP Server

Enables users to interact with GitHub via natural language requests, executing API calls and returning structured responses.

mark-coach-mcp

Local MCP server that turns Mark Builds Brands' YouTube knowledge into an AI coaching assistant for ecommerce and Facebook Ads.

mcp-coinbase

Browser-automated MCP server for Coinbase crypto exchange, enabling live prices, portfolio management, transaction history, and trading.

TickTick MCP

A remote MCP server that enables Claude to create and manage TickTick to-dos using the TickTick Open API. It supports nine tools for projects, tasks, and sections, and works across all Claude platforms (web, mobile, desktop, Cowork).

Hono MCP Sample Server

A sample Model Context Protocol server built with Hono framework that provides weather and news resources, calculator and string reversal tools, and code review prompt templates.

PostgreSQL MCP Server

Enables LLMs to interact deeply with PostgreSQL databases—query data, manage schema, analyze performance, and administer the database.

Enterprise Template Generator

Enables generation of enterprise-grade software templates with built-in GDPR/Swedish compliance validation, workflow automation for platform migrations, and comprehensive template management through domain-driven design principles.

oaid-mcp

Enables AI agents to securely use Open Agent ID credentials for signing requests, looking up agent data, and exchanging encrypted messages. It performs all cryptographic operations within the server process to ensure private keys are never exposed to the AI agent.

SEOforGPT MCP Server

Enables AI-driven brand visibility monitoring and SEO project management via the SEOforGPT API. Users can execute brand visibility checks, list projects, and retrieve detailed visibility reports through natural language interactions.

mcp-arcgis-dc

Enables searching and querying Washington DC's open geospatial datasets (parcels, zoning, addresses, transport) via ArcGIS feature services, with tools for dataset discovery, attribute/geometry queries, and schema inspection.

StarUML MCP Server

Enables creating diagrams or generating code from diagrams in StarUML via prompts.

Comedy MCP Server

Okay, here's a breakdown of how you could approach building an MCP (presumably Minecraft Protocol) server using the C# SDK, enhanced with jokes from JokeAPI to add humor to comments or messages: **Conceptual Overview** 1. **Minecraft Protocol (MCP) Server:** You'll need a C# library that handles the Minecraft protocol. Popular options include: * **Minecraft.Net:** The official Minecraft.Net library (often used for authentication and related services, but might not be a full server implementation). * **A custom implementation:** This is a lot of work, but gives you full control. 2. **JokeAPI Integration:** You'll use an HTTP client in C# to make requests to the JokeAPI. You'll parse the JSON response to extract the joke. 3. **Comment/Message Handling:** Your server will need to intercept or process chat messages or comments. This is where you'll inject the jokes. 4. **C# SDK:** This refers to the .NET SDK, which provides the tools and libraries you'll use to build the server. **Code Structure (Illustrative - Requires Adaptation to Your Chosen MCP Library)** ```csharp using System; using System.Net.Http; using System.Text.Json; using System.Threading.Tasks; // Assuming you have a Minecraft server library (replace with your actual library) // using MinecraftServerLibrary; namespace MinecraftJokeServer { public class JokeHandler { private static readonly HttpClient client = new HttpClient(); private const string JokeApiUrl = "https://v2.jokeapi.dev/joke/Programming,Christmas?blacklistFlags=nsfw,racist,sexist,explicit&safe-mode"; // Example JokeAPI endpoint public static async Task<string> GetJokeAsync() { try { HttpResponseMessage response = await client.GetAsync(JokeApiUrl); response.EnsureSuccessStatusCode(); // Throw exception if not successful string responseBody = await response.Content.ReadAsStringAsync(); // Parse the JSON response using (JsonDocument document = JsonDocument.Parse(responseBody)) { JsonElement root = document.RootElement; if (root.TryGetProperty("type", out JsonElement typeElement)) { string type = typeElement.GetString(); if (type == "single") { if (root.TryGetProperty("joke", out JsonElement jokeElement)) { return jokeElement.GetString(); } } else if (type == "twopart") { if (root.TryGetProperty("setup", out JsonElement setupElement) && root.TryGetProperty("delivery", out JsonElement deliveryElement)) { return $"{setupElement.GetString()} {deliveryElement.GetString()}"; } } } return "No joke found."; // Handle cases where the joke structure is unexpected } } catch (HttpRequestException e) { Console.WriteLine($"Exception calling JokeAPI: {e.Message}"); return "Failed to retrieve joke."; } catch (JsonException e) { Console.WriteLine($"Exception parsing JSON: {e.Message}"); return "Failed to parse joke."; } } } public class MinecraftServer { // Replace with your actual server initialization and event handling public async Task StartServer() { Console.WriteLine("Starting Minecraft server..."); // Example: Simulate receiving a chat message string message = "Player1: Hello, world!"; Console.WriteLine($"Received message: {message}"); // Add a joke to the message string joke = await JokeHandler.GetJokeAsync(); string enhancedMessage = $"{message} (Joke: {joke})"; Console.WriteLine($"Enhanced message: {enhancedMessage}"); // Simulate sending the enhanced message to other players Console.WriteLine($"Sending enhanced message to all players."); // Keep the server running (replace with your actual server loop) Console.ReadKey(); } } public class Program { public static async Task Main(string[] args) { MinecraftServer server = new MinecraftServer(); await server.StartServer(); } } } ``` **Explanation and Key Considerations** * **`JokeHandler` Class:** * `HttpClient`: A static `HttpClient` is used for making HTTP requests to the JokeAPI. It's good practice to reuse `HttpClient` instances for performance. * `JokeApiUrl`: The URL of the JokeAPI endpoint. You can customize this to select different joke categories or flags. See the JokeAPI documentation for options. * `GetJokeAsync()`: This asynchronous method fetches a joke from the JokeAPI. * It uses `HttpClient.GetAsync()` to make the request. * `response.EnsureSuccessStatusCode()`: Throws an exception if the HTTP response is not successful (e.g., 404 Not Found, 500 Internal Server Error). * `response.Content.ReadAsStringAsync()`: Reads the JSON response body as a string. * `JsonDocument.Parse()`: Parses the JSON string into a `JsonDocument` for easy access to the data. * The code then checks the `type` property of the JSON response. JokeAPI can return jokes in two formats: "single" (a single joke string) or "twopart" (a setup and a delivery). The code handles both cases. * Error handling: Includes `try-catch` blocks to handle potential exceptions during the HTTP request or JSON parsing. * **`MinecraftServer` Class:** * This class *simulates* a Minecraft server. **You will need to replace the placeholder code with your actual Minecraft server implementation using your chosen MCP library.** * `StartServer()`: This method is where you would initialize your Minecraft server, listen for client connections, and handle events. * The example code simulates receiving a chat message. In a real server, you would get chat messages from the Minecraft protocol. * It calls `JokeHandler.GetJokeAsync()` to get a joke. * It then constructs an "enhanced" message by adding the joke to the original message. * The example code simulates sending the enhanced message to other players. In a real server, you would use the Minecraft protocol to send the message to connected clients. * **`Program` Class:** * The `Main` method is the entry point of the application. It creates an instance of the `MinecraftServer` class and calls the `StartServer()` method. * **Asynchronous Operations:** The code uses `async` and `await` to perform asynchronous operations (e.g., making HTTP requests). This prevents the server from blocking while waiting for the JokeAPI to respond. **Steps to Build and Run** 1. **Create a New C# Project:** Create a new console application project in Visual Studio or your preferred IDE. 2. **Install NuGet Packages:** * `System.Text.Json`: For parsing JSON. (This is usually included by default in newer .NET versions.) 3. **Replace Placeholder Code:** The most important step is to replace the placeholder code in the `MinecraftServer` class with your actual Minecraft server implementation. This will depend on the MCP library you choose. 4. **Implement Minecraft Protocol Handling:** Use your chosen MCP library to handle client connections, authentication, chat messages, and other Minecraft protocol events. 5. **Integrate Joke Handling:** In your chat message handling code, call `JokeHandler.GetJokeAsync()` to get a joke and add it to the message before sending it to other players. 6. **Error Handling:** Add robust error handling to your server to handle potential exceptions, such as network errors, JSON parsing errors, and errors from the Minecraft protocol. 7. **Configuration:** Consider adding configuration options to allow users to customize the JokeAPI endpoint, the frequency of jokes, and other settings. 8. **Build and Run:** Build the project and run the executable. **Important Considerations** * **MCP Library:** Choosing the right MCP library is crucial. Research the available options and choose one that meets your needs in terms of features, performance, and ease of use. Be prepared for a significant learning curve if you're implementing the protocol yourself. * **JokeAPI Rate Limiting:** The JokeAPI may have rate limits. Be sure to respect these limits to avoid being blocked. You might want to implement caching to reduce the number of requests you make to the API. * **Joke Appropriateness:** The JokeAPI allows you to filter jokes based on flags (e.g., `nsfw`, `racist`, `sexist`). Be sure to configure the API to return jokes that are appropriate for your server's audience. Consider adding your own filtering logic to further refine the jokes. * **Performance:** Fetching jokes from the JokeAPI can add latency to your server. Consider caching jokes or using a background thread to fetch jokes so that it doesn't block the main server thread. * **Security:** If your server handles sensitive data (e.g., player authentication), be sure to implement appropriate security measures to protect against attacks. * **User Experience:** Consider how the jokes will be presented to players. You might want to add a command that players can use to request a joke, or you might want to add jokes automatically to certain messages. Make sure the jokes are not too disruptive or annoying. **Example using a hypothetical Minecraft Server Library** ```csharp // Hypothetical Minecraft Server Library // (This is just an example - replace with your actual library) namespace MinecraftServerLibrary { public class MinecraftServer { public event EventHandler<ChatMessageEventArgs> ChatMessageReceived; public void Start() { // ... Server startup logic ... } public void SendMessage(string message, MinecraftPlayer player) { // ... Send message to a player ... } protected virtual void OnChatMessageReceived(ChatMessageEventArgs e) { ChatMessageReceived?.Invoke(this, e); } // Simulate receiving a chat message public void SimulateChatMessage(string message, MinecraftPlayer player) { OnChatMessageReceived(new ChatMessageEventArgs(message, player)); } } public class MinecraftPlayer { public string Name { get; set; } // ... Other player properties ... } public class ChatMessageEventArgs : EventArgs { public string Message { get; set; } public MinecraftPlayer Player { get; set; } public ChatMessageEventArgs(string message, MinecraftPlayer player) { Message = message; Player = player; } } } // Modified MinecraftServer class in your main project using MinecraftServerLibrary; // Assuming you've added the library as a reference namespace MinecraftJokeServer { public class MinecraftServer { private readonly MinecraftServerLibrary.MinecraftServer _server; public MinecraftServer() { _server = new MinecraftServerLibrary.MinecraftServer(); _server.ChatMessageReceived += OnChatMessageReceived; } public async Task StartServer() { Console.WriteLine("Starting Minecraft server..."); _server.Start(); // Simulate a player joining and sending a message MinecraftPlayer player1 = new MinecraftPlayer { Name = "Player1" }; _server.SimulateChatMessage("Hello, world!", player1); Console.ReadKey(); } private async void OnChatMessageReceived(object sender, ChatMessageEventArgs e) { string joke = await JokeHandler.GetJokeAsync(); string enhancedMessage = $"{e.Player.Name}: {e.Message} (Joke: {joke})"; Console.WriteLine($"Enhanced message: {enhancedMessage}"); // Send the enhanced message to all players (replace with actual logic) // _server.SendMessage(enhancedMessage, e.Player); // Example: Send back to the original sender } } } ``` This revised example shows how you might integrate the `JokeHandler` into a more realistic Minecraft server scenario, using a hypothetical `MinecraftServerLibrary`. Remember to replace the hypothetical library with your actual MCP library. The key is to hook into the chat message events provided by your library and then use the `JokeHandler` to enhance the messages. This is a complex project, but by breaking it down into smaller steps and using the right tools, you can create a fun and engaging Minecraft server experience. Good luck!

mcp-maritime

Provides real-time maritime weather data, tropical cyclone warnings, and route calculations for AI agents.

WuWa MCP Server

Enables querying detailed information about characters, echoes, and character profiles from the Wuthering Waves game, returning results in LLM-optimized Markdown format.

scopa-mcp-server

An MCP server for playing the Italian card game Scopa, supporting 2-4 players, Redis-backed event logging, real-time synchronization, and an optional LLM opponent.

figma-developer-docs-mcp

Provides AI assistants with structured access to complete Figma developer documentation, including Plugin, Widget, and REST APIs. It enables users to search and read over 600 documentation pages to facilitate Figma-related development tasks.

Spotinst MCP Server

An MCP server for the Spot.io API that enables management of AWS and Azure Ocean clusters across multiple accounts. It provides tools for cluster inventory, node management, cost analysis, and scaling operations through natural language.

MCP Prompt Optimizer

This MCP server provides research-backed prompt optimization tools and professional domain templates designed to improve AI performance through strategies like Tree of Thoughts and Medprompt. It enables users to analyze, auto-optimize, and refine prompts using advanced reasoning patterns and safety-critical alignment techniques.

MegaMem

Syncs Obsidian notes into a temporal knowledge graph and exposes 23 MCP tools for AI assistants to read, search, and write to your vault, enabling persistent memory across conversations.

mechanic-mcp

Enables searching, fetching, and customizing Mechanic tasks and documentation for Shopify automation. Provides offline access to bundled task library and docs with tools for task code, docs content, and similar task suggestions.

Amazon Business Integrations MCP Server

Provides AI-enabled access to Amazon Business API documentation, sample code, and troubleshooting resources. Enables developers to search and retrieve API documentation, generate integration code, and get guided solutions for common errors during the API integration process.

사주 MCP 대시보드

Korean traditional saju (four pillars) fortune analysis MCP server with a premium web GUI dashboard for local data persistence, 100-point scoring, and history management.

safe-ssh-mcp

A secure SSH MCP server that enables execution of read-only diagnostic commands over SSH, preventing modifications to remote systems.

icloud-mcp

MCP server for iCloud integration, providing tools for managing calendars, contacts, and email.

MCP with Langchain Sample Setup

Okay, here's a sample setup for an MCP (presumably referring to a **Multi-Client Processing** or **Message Communication Protocol**) server and client, designed to be compatible with LangChain. This example focuses on a basic request-response pattern, suitable for offloading LangChain tasks to a separate process or machine. **Important Considerations:** * **Serialization:** LangChain objects can be complex. You'll need a robust serialization/deserialization method (e.g., `pickle`, `json`, `cloudpickle`) to send data between the client and server. `cloudpickle` is often preferred for its ability to handle more complex Python objects, including functions and classes. * **Security:** If you're running this over a network, consider security implications. Use encryption (e.g., TLS/SSL) and authentication to protect your data. This example omits security for simplicity. * **Error Handling:** Implement comprehensive error handling on both the client and server to gracefully handle exceptions and network issues. * **Asynchronous Operations:** For better performance, especially with LangChain's potentially long-running tasks, consider using asynchronous communication (e.g., `asyncio` in Python). This example uses synchronous communication for clarity. * **Message Format:** Define a clear message format (e.g., JSON with specific keys) for requests and responses. * **LangChain Integration:** The core idea is to send LangChain-related data (prompts, documents, chains, etc.) to the server, have the server process it, and return the result. **Example Implementation (Python):** **1. Server (server.py):** ```python import socket import pickle # Or json, cloudpickle import langchain # Import LangChain on the server from langchain.llms import OpenAI from langchain.chains import LLMChain from langchain.prompts import PromptTemplate # Server configuration HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) def process_langchain_request(data): """ Processes a LangChain request. This is where the LangChain logic resides. """ try: # Assuming 'data' is a dictionary containing necessary information # (e.g., prompt, model parameters, etc.) prompt_text = data.get("prompt") if not prompt_text: return {"error": "Missing prompt in request"} # Example: Using OpenAI (replace with your desired LangChain setup) llm = OpenAI(temperature=0.7) # Replace with your API key or other LLM prompt = PromptTemplate.from_template(prompt_text) chain = LLMChain(llm=llm, prompt=prompt) # Execute the chain result = chain.run(data) # Pass the entire data dictionary as input return {"result": result} except Exception as e: return {"error": str(e)} with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Server listening on {HOST}:{PORT}") while True: conn, addr = s.accept() with conn: print(f"Connected by {addr}") try: # Receive data (serialized LangChain request) received_data = conn.recv(4096) # Adjust buffer size as needed if not received_data: continue # No data received, continue listening # Deserialize the data data = pickle.loads(received_data) # Or json.loads, cloudpickle.loads # Process the LangChain request response = process_langchain_request(data) # Serialize the response serialized_response = pickle.dumps(response) # Or json.dumps, cloudpickle.dumps # Send the response back to the client conn.sendall(serialized_response) except Exception as e: print(f"Error processing request: {e}") error_response = pickle.dumps({"error": str(e)}) conn.sendall(error_response) ``` **2. Client (client.py):** ```python import socket import pickle # Or json, cloudpickle # Client configuration HOST = '127.0.0.1' # The server's hostname or IP address PORT = 65432 # The port used by the server def send_langchain_request(prompt, input_data): """ Sends a LangChain request to the server and receives the response. """ with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: try: s.connect((HOST, PORT)) # Create the request data (e.g., a dictionary) request_data = { "prompt": prompt, **input_data # Include any other input data for the prompt } # Serialize the request data serialized_data = pickle.dumps(request_data) # Or json.dumps, cloudpickle.dumps # Send the data to the server s.sendall(serialized_data) # Receive the response from the server received_data = s.recv(4096) # Adjust buffer size as needed # Deserialize the response response = pickle.loads(received_data) # Or json.loads, cloudpickle.loads return response except Exception as e: return {"error": str(e)} if __name__ == "__main__": # Example usage prompt = "Tell me a short story about {topic}." input_data = {"topic": "a friendly dragon"} response = send_langchain_request(prompt, input_data) if "error" in response: print(f"Error: {response['error']}") else: print(f"Result: {response['result']}") ``` **Explanation:** * **Server (server.py):** * Creates a socket and listens for incoming connections. * When a client connects, it receives serialized data (assumed to be a LangChain request). * Deserializes the data using `pickle` (or `json`, `cloudpickle`). * Calls `process_langchain_request()` to handle the LangChain logic. This function: * Extracts the prompt and any other necessary data from the received data. * Initializes a LangChain LLM (e.g., OpenAI). **Replace this with your actual LangChain setup.** * Creates a `PromptTemplate` and `LLMChain`. * Runs the chain and returns the result. * Serializes the response and sends it back to the client. * Includes error handling. * **Client (client.py):** * Creates a socket and connects to the server. * Constructs a dictionary containing the prompt and any other input data needed for the LangChain chain. * Serializes the data using `pickle` (or `json`, `cloudpickle`). * Sends the serialized data to the server. * Receives the serialized response from the server. * Deserializes the response. * Prints the result or any error message. **How to Run:** 1. **Install Dependencies:** ```bash pip install langchain openai cloudpickle # Or json, if you prefer ``` 2. **Set your OpenAI API Key (if using OpenAI):** ```python import os os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY" ``` 3. **Run the server:** ```bash python server.py ``` 4. **Run the client:** ```bash python client.py ``` **Indonesian Translation of Key Concepts:** * **Server:** Peladen * **Client:** Klien * **Socket:** Soket * **Serialization:** Serialisasi (mengubah objek menjadi format yang dapat dikirim) * **Deserialization:** Deserialisasi (mengubah format yang dikirim kembali menjadi objek) * **LangChain:** Rantai Bahasa (nama pustaka) * **Prompt:** Perintah * **LLM (Large Language Model):** Model Bahasa Besar * **Request:** Permintaan * **Response:** Tanggapan * **Error Handling:** Penanganan Kesalahan **Important Notes for Indonesian Speakers:** * The code comments are in English for broader understanding, but you can translate them to Indonesian for your own use. * The core logic of LangChain remains the same regardless of the language. The key is to ensure that the data being sent between the client and server is correctly serialized and deserialized. * Consider using Indonesian language models within LangChain if you are primarily working with Indonesian text. This example provides a basic framework. You'll need to adapt it to your specific LangChain use case, including: * Choosing the appropriate serialization method. * Defining a clear message format. * Implementing robust error handling. * Adding security measures if necessary. * Using asynchronous communication for better performance. * Customizing the `process_langchain_request()` function to handle your specific LangChain chains and tasks.

Maiga API MCP Server

Provides comprehensive integration with the Maiga API for cryptocurrency analysis, including token technicals, social sentiment tracking, and KOL insights. It enables AI assistants to retrieve market reports, trending token data, and detailed on-chain information.