Discover Awesome MCP Servers

Local MCP Server

Provides 18 tools including calculator operations (add, subtract, multiply, divide, power, sqrt, log, trigonometric functions) and secure sandboxed file operations (read, write, append, delete, list) for LangGraph agents and MCP clients. Features async support, YAML configuration, comprehensive logging, and path traversal protection.

Knowledge Retrieval Server

A BM25-based MCP server that enables document search and retrieval across structured domains of knowledge content, allowing Claude to search and reference documentation when answering questions.

MCP Server Template for Cursor IDE

Okay, here's a template and explanation for creating and connecting custom tools to Cursor IDE using the Model Context Protocol, with a focus on cheerful server responses. This template provides a good starting point and emphasizes clear communication between your tool and the IDE. **Conceptual Overview** * **Model Context Protocol (MCP):** This is the communication standard Cursor uses to interact with external tools. It's based on JSON-RPC. Your tool acts as a server, and Cursor (the client) sends requests to it. * **JSON-RPC:** A simple remote procedure call protocol using JSON for data encoding. Cursor sends JSON requests to your tool, and your tool sends back JSON responses. * **Cheerful Responses:** Instead of just returning data, your tool should provide informative and positive messages to the user through Cursor. This enhances the user experience. **Template Structure (Python - Flask Example)** This example uses Python and Flask for simplicity. You can adapt it to other languages and frameworks. ```python from flask import Flask, request, jsonify import json import os import subprocess # For running external commands import logging app = Flask(__name__) # Configure logging (optional, but highly recommended) logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') # --- Configuration --- TOOL_NAME = "MyAwesomeTool" # Replace with your tool's name TOOL_DESCRIPTION = "A tool that does amazing things!" # Replace with a description # Example: TOOL_COMMAND = ["python", "/path/to/my_script.py"] TOOL_COMMAND = ["echo", "Hello from MyAwesomeTool!"] # Replace with your tool's command # --- End Configuration --- def run_command(command, input_str=None): """ Executes a command and returns the output. Handles potential errors. """ try: process = subprocess.Popen( command, stdin=subprocess.PIPE if input_str else None, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True # Important for handling text data ) stdout, stderr = process.communicate(input=input_str) return_code = process.returncode if return_code != 0: logging.error(f"Command failed with code {return_code}: {stderr}") return None, stderr # Indicate failure return stdout, None # Indicate success except FileNotFoundError: logging.error(f"Command not found: {command[0]}") return None, f"Error: Command not found: {command[0]}" except Exception as e: logging.exception("An unexpected error occurred:") return None, f"An unexpected error occurred: {str(e)}" @app.route('/', methods=['POST']) def handle_request(): """ Handles incoming requests from Cursor. """ try: data = request.get_json() logging.info(f"Received request: {data}") method = data.get('method') params = data.get('params', {}) # Default to empty dictionary if no params if method == 'initialize': return handle_initialize() elif method == 'execute': return handle_execute(params) else: return create_error_response(f"Method not supported: {method}", code=-32601) # Method not found except json.JSONDecodeError: logging.error("Invalid JSON received.") return create_error_response("Invalid JSON received.", code=-32700) # Parse error except Exception as e: logging.exception("An unexpected error occurred:") return create_error_response(f"An unexpected error occurred: {str(e)}", code=-32000) # Server error def handle_initialize(): """ Handles the 'initialize' request. Returns tool information. """ response = { "jsonrpc": "2.0", "result": { "name": TOOL_NAME, "description": TOOL_DESCRIPTION, "version": "1.0.0", # Replace with your tool's version "capabilities": { "execute": True # Indicates that the tool can execute commands } }, "id": 0 # Important: Use the ID from the request if available. This is a placeholder. } logging.info(f"Sending initialize response: {response}") return jsonify(response) def handle_execute(params): """ Handles the 'execute' request. Executes the tool's command. """ query = params.get('query', '') # Get the query from the parameters context = params.get('context', {}) # Get the context from the parameters (e.g., selected text) selected_text = context.get('selectedText', '') logging.info(f"Executing with query: {query}, selected_text: {selected_text}") # --- Example: Pass the query and selected text as input to the command --- input_data = f"{query}\n{selected_text}" stdout, stderr = run_command(TOOL_COMMAND, input_data) if stdout: # --- Cheerful Success Response --- result = stdout.strip() # Remove leading/trailing whitespace response = { "jsonrpc": "2.0", "result": { "response": f"Great job! {TOOL_NAME} successfully processed your request. Here's the result:\n\n{result}", "success": True, }, "id": 1 # Important: Use the ID from the request if available. This is a placeholder. } logging.info(f"Sending execute success response: {response}") return jsonify(response) else: # --- Cheerful Error Response (even in error, be polite!) --- error_message = stderr or "Something went wrong, but I couldn't get the details. Please check the server logs." response = { "jsonrpc": "2.0", "result": { "response": f"Oops! {TOOL_NAME} encountered a problem. Don't worry, we'll get it sorted out. Here's what happened:\n\n{error_message}", "success": False, }, "id": 1 # Important: Use the ID from the request if available. This is a placeholder. } logging.error(f"Sending execute error response: {response}") return jsonify(response) def create_error_response(message, code): """ Creates a JSON-RPC error response. """ response = { "jsonrpc": "2.0", "error": { "code": code, "message": message }, "id": None # Or the ID from the request, if available } return jsonify(response), 500 # Return a 500 status code for errors if __name__ == '__main__': # Determine the port from the environment variable, default to 5000 port = int(os.environ.get('PORT', 5000)) app.run(debug=True, host='0.0.0.0', port=port) # Make sure to set debug=False in production ``` **Explanation and Key Points** 1. **Imports:** Import necessary libraries (Flask, JSON, `subprocess` for running external commands, `logging` for debugging). 2. **Configuration:** * `TOOL_NAME`: The name of your tool (displayed in Cursor). * `TOOL_DESCRIPTION`: A brief description of what your tool does. * `TOOL_COMMAND`: The command to execute. This is a list of strings (like `subprocess.Popen` expects). **Important:** Use absolute paths to your scripts or executables to avoid path issues. The example uses `echo` for demonstration purposes. Replace this with your actual tool's command. 3. **`run_command(command, input_str=None)`:** * This function executes the command using `subprocess.Popen`. * It captures both standard output (`stdout`) and standard error (`stderr`). * It handles potential errors like `FileNotFoundError` (if the command doesn't exist) and other exceptions. * **Important:** The `text=True` argument in `subprocess.Popen` ensures that the output is treated as text, which is crucial for handling strings correctly. * It returns the `stdout` and `stderr`. If there's an error, `stdout` will be `None`, and `stderr` will contain the error message. 4. **`@app.route('/', methods=['POST'])`:** * This Flask route handles all incoming POST requests to the root URL (`/`). Cursor will send requests here. 5. **`handle_request()`:** * This function is the main entry point for handling requests from Cursor. * It parses the JSON request body. * It extracts the `method` and `params` from the request. * It calls the appropriate handler function based on the `method` (e.g., `handle_initialize`, `handle_execute`). * It includes comprehensive error handling using `try...except` blocks to catch JSON parsing errors, method not found errors, and other exceptions. It then calls `create_error_response` to return a proper JSON-RPC error response to Cursor. 6. **`handle_initialize()`:** * Handles the `initialize` request. * Returns a JSON response containing the tool's name, description, version, and capabilities. * The `capabilities` section indicates what the tool can do (in this case, `execute`). * **Important:** The `id` field in the response should match the `id` from the request. This is how Cursor correlates requests and responses. The example uses `0` as a placeholder; you'll need to get the `id` from the incoming request. 7. **`handle_execute(params)`:** * Handles the `execute` request. * Extracts the `query` and `context` from the `params`. The `context` often contains information like the selected text in the editor. * Calls `run_command` to execute the tool's command. * **Cheerful Responses:** * If the command is successful, it creates a positive and informative response message that includes the result. The `"success": True` field indicates success. * If the command fails, it creates a polite error message that explains what went wrong. The `"success": False` field indicates failure. It also includes the error message from `stderr`. * **Important:** The `id` field in the response should match the `id` from the request. This is how Cursor correlates requests and responses. The example uses `1` as a placeholder; you'll need to get the `id` from the incoming request. 8. **`create_error_response(message, code)`:** * Creates a standard JSON-RPC error response. * Includes an error `code` and a `message`. See the JSON-RPC specification for standard error codes. * Returns a 500 HTTP status code to indicate an error. 9. **`if __name__ == '__main__':`:** * This block runs the Flask app when the script is executed directly. * It gets the port number from the environment variable `PORT` (this is important for deployment). If the `PORT` environment variable is not set, it defaults to port 5000. * It starts the Flask development server. **Important:** Set `debug=False` in production to disable the debugger. Also, use a proper WSGI server (like Gunicorn or uWSGI) for production deployments. * `host='0.0.0.0'` makes the server accessible from outside the local machine. **How to Use This Template** 1. **Install Flask:** ```bash pip install Flask ``` 2. **Customize:** * Replace `TOOL_NAME`, `TOOL_DESCRIPTION`, and `TOOL_COMMAND` with your tool's information. * Modify the `handle_execute` function to handle the `query` and `context` parameters appropriately for your tool. This is where you'll integrate your tool's logic. * Adjust the cheerful response messages to be more specific and engaging for your tool. 3. **Run the Server:** ```bash python your_script_name.py ``` 4. **Configure Cursor:** * In Cursor, go to Settings -> Tools. * Click "Add Tool". * Enter the URL of your server (e.g., `http://localhost:5000`). * Enter the name and description (these should match `TOOL_NAME` and `TOOL_DESCRIPTION`). * Click "Save". 5. **Test Your Tool:** * In Cursor, type `/` to bring up the command palette. * You should see your tool listed. * Select your tool and enter a query. * Observe the cheerful response from your tool. **Important Considerations** * **Error Handling:** Robust error handling is crucial. Provide informative error messages to the user. Log errors on the server-side for debugging. * **Security:** If your tool handles sensitive data, take appropriate security measures (e.g., authentication, authorization, input validation). * **Asynchronous Operations:** If your tool's command takes a long time to execute, consider using asynchronous operations (e.g., Celery, asyncio) to avoid blocking the server. You can send a "processing" message to Cursor and then send the final result when the command is finished. * **Input Validation:** Validate the input from Cursor to prevent security vulnerabilities and unexpected behavior. * **JSON-RPC Specification:** Refer to the JSON-RPC 2.0 specification for details on the protocol: [https://www.jsonrpc.org/specification](https://www.jsonrpc.org/specification) * **Cursor Documentation:** Check the Cursor documentation for the latest information on the Model Context Protocol. * **IDs:** Always echo the `id` from the incoming request in your response. This is essential for Cursor to match requests and responses correctly. If the request doesn't have an `id`, you can omit it from the response or use `null`. * **Logging:** Use logging extensively to track requests, responses, and errors. This will help you debug your tool. * **Deployment:** When deploying your tool to a production environment, use a proper WSGI server (like Gunicorn or uWSGI) and configure it correctly. Also, set `debug=False` in Flask. **Example with Selected Text** Let's say your tool is a code formatter. You could use the selected text as input to the formatter: ```python def handle_execute(params): query = params.get('query', '') context = params.get('context', {}) selected_text = context.get('selectedText', '') if selected_text: # Format the selected text stdout, stderr = run_command(["clang-format"], selected_text) # Example: Use clang-format if stdout: response = { "jsonrpc": "2.0", "result": { "response": f"Formatted code:\n\n{stdout}", "success": True, }, "id": 1 } return jsonify(response) else: response = { "jsonrpc": "2.0", "result": { "response": f"Error formatting code:\n\n{stderr}", "success": False, }, "id": 1 } return jsonify(response) else: response = { "jsonrpc": "2.0", "result": { "response": "No code selected to format.", "success": False, }, "id": 1 } return jsonify(response) ``` This example uses `clang-format` (you'll need to have it installed). It passes the `selected_text` as input to `clang-format` and returns the formatted code in the response. This comprehensive template and explanation should give you a solid foundation for building custom tools for Cursor IDE. Remember to adapt the code to your specific tool's requirements and focus on providing a positive and informative user experience. Good luck!

Workers + Stytch TODO App MCP Server

A Cloudflare Workers server that extends a traditional full-stack TODO application with Model Context Protocol support, enabling AI agents to interact with the app through Stytch authentication.

claude-whatsapp-mcp

Enables Claude Code to interact with WhatsApp for reading messages, sending replies, and searching contacts through the Model Context Protocol. It uses whatsapp-web.js to facilitate local connection management with QR code authentication and session persistence.

Emoji Storyteller MCP Server

Generates entertaining stories told entirely through emojis with adjustable chaos levels, themed narratives, and a maximum chaos mode. Perfect for creating delightful emoji-based tales across adventure, romance, horror, space, food, and party themes.

Aiven MCP Server

Un servidor de Protocolo de Contexto de Modelo que proporciona acceso a los servicios de Aiven (PostgreSQL, Kafka, ClickHouse, Valkey, OpenSearch), permitiendo a los LLM construir soluciones de pila completa al interactuar con estos servicios.

godoc-mcp

godoc-mcp is a Model Context Protocol (MCP) server that provides efficient access to Go documentation. It helps LLMs understand Go projects by providing direct access to package documentation without needing to read entire source files.

Salesforce CLI Connect MCP

Provides a user-friendly setup wizard that guides users through connecting Claude Desktop to Salesforce via secure OAuth authentication using the Salesforce CLI, requiring no technical knowledge or manual credential management.

IMDB MCP Server

Provides access to IMDB movie and person data, including searches, cast details, and top-rated lists through the Model Context Protocol. It enables LLMs to fetch structured cinematic metadata and filmographies using the Cinemagoer backend.

Claude Web Scraper MCP

Un servidor MCP sencillo que integra el raspador web eGet con Claude para Escritorio. Este conector permite a Claude extraer contenido web a través de tu API local de eGet, habilitando la búsqueda, el resumen y el análisis de sitios web directamente en las conversaciones.

OpenF1 MCP Server

Enables access to Formula 1 data from the openF1.org API, including driver information, race results, lap times, telemetry, pit stops, weather conditions, and live position data across multiple seasons.

lorcana-oracle

Disney Lorcana TCG MCP server -- card search, deck analysis, and franchise browsing powered by LorcanaJSON.

MCP Kubernetes

Enables advanced management of Kubernetes clusters through natural language interactions. Supports querying, managing, and monitoring pods, deployments, nodes, and logs across multiple contexts and namespaces.

Boxtalk Data MCP Server

An MCP server for interacting with SQL Server databases that enables schema inspection, record counting, and paginated data retrieval. It provides tools to explore table structures and fetch specific records while enforcing safety limits on data volume.

Beep Boop MCP

A Model Context Protocol (MCP) server for coordinating work between multiple AI agents in monorepos and shared codebases using a simple file-based signaling system or Discord thread chat.

MCP Tavily Search Server

Integra la API de búsqueda de Tavily con LLMs para proporcionar capacidades avanzadas de búsqueda web, incluyendo resúmenes inteligentes de resultados, filtrado de dominio para control de calidad y parámetros de búsqueda configurables.

astronomy-oracle

Accurate astronomical catalog data and observing session planner for LLM assistants. Stops hallucinated magnitudes, coordinates, and visibility.

Terraform Cloud MCP Server

Enables AI assistants to interact with Terraform Cloud workspaces and runs, including checking run status, listing workspaces, and retrieving detailed information about workspaces and runs.

Recast MCP

Enables AI assistants to fetch clean text from any URL and repurpose it into platform-ready social media content for LinkedIn, Twitter, Reddit, and newsletters. It provides specialized tools for content extraction and structured prompt templates for various formats and tones.

MkDocs MCP Search Server

Enables Claude and other LLMs to search through any published MkDocs documentation site using the Lunr.js search engine, allowing the AI to find and summarize relevant documentation for users.

MCP Tekmetric

A Model Context Protocol server that allows AI assistants to interact with Tekmetric data, enabling users to query appointment details, vehicle information, repair order status, and parts inventory through natural language.

Cloud PC Management MCP Server

Permite la administración de Cloud PC de Azure mediante la API de Microsoft Graph, lo que permite a los usuarios enumerar los Cloud PC disponibles en su inquilino a través de Claude Desktop.

Tasks MCP Server

A task management MCP server that provides tools to create, list, complete, and delete tasks using pluggable storage backends. It enables users to interact with their task lists through natural language using MCP-compatible clients like Claude Desktop.

Edgar MCP Service

Enables deep analysis of SEC EDGAR filings through universal company search, document content extraction, and advanced filing search capabilities. Provides AI-ready access to business descriptions, risk factors, financial statements, and full-text search across any public company's SEC documents.

the402-mcp-server

MCP server for the402.ai — an open marketplace where AI agents discover and purchase services from third-party providers via x402 micropayments (USDC on Base). Browse the catalog, purchase services, manage conversation threads, and list services as a provider.

Searchfox MCP Server

Provides access to Mozilla's Searchfox code search service, enabling AI assistants to search through Mozilla's codebases and retrieve file contents from repositories like mozilla-central, autoland, and ESR branches.

systemprompt-mcp-server

A production-ready Model Context Protocol server that integrates with Reddit, demonstrating complete MCP specification with OAuth 2.1, sampling, elicitation, structured data validation, and real-time notifications.

Basecamp MCP Server by CData

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