Discover Awesome MCP Servers

CCXT MCP Server

Espejo de

Binary Ninja MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite a los Modelos de Lenguaje Extensos interactuar con Binary Ninja para tareas de ingeniería inversa como ver código ensamblador, código descompilado, renombrar funciones y añadir comentarios.

BetterMCPFileServer

Un servidor de Protocolo de Contexto de Modelo rediseñado que permite a los modelos de IA acceder a sistemas de archivos a través de alias de ruta que preservan la privacidad, con una interfaz API optimizada de 6 funciones.

Vibe Worldbuilding MCP

Un Protocolo de Contexto de Modelo para crear mundos ficticios detallados con Claude, que incluye indicaciones estructuradas para la construcción del mundo y la generación automática de imágenes a través de la API Imagen de Google.

mcp_repob7b7df37-94c2-48e4-8721-6cc695c23d4c

Este es un repositorio de prueba creado por un script de prueba del Servidor MCP para GitHub.

Caiyun Weather MCP Server

Servidor de Protocolo de Contexto del Modelo (MCP) para la API del Clima de Caiyun

Spreadsheet MCP Server

Proporciona un servidor de Protocolo de Contexto de Modelo (MCP) que permite a los LLM acceder e interactuar directamente con datos de Hojas de Cálculo de Google.

MCP - Model Context Protocol TypeScript SDK

A TypeScript wrapper library for the Model Context Protocol SDK that provides a simplified interface for creating MCP servers with tools, resources, and prompts without needing to work directly with the protocol.

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!

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.

Speckle MCP Server

Un puente entre la API de Speckle y las aplicaciones cliente que permite a los usuarios listar/buscar proyectos, acceder a versiones de modelos y recuperar/consultar objetos y sus propiedades desde el centro de datos colaborativo de Speckle para herramientas AEC (Arquitectura, Ingeniería y Construcción).

MCPollinations Multimodal MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite a los asistentes de IA generar imágenes, texto y audio a través de las APIs de Pollinations sin necesidad de autenticación.

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

MCP Installer

Servidor MCP oficial para Smithery CLI

MCPKit

Una biblioteca sencilla de TypeScript para crear servidores de Protocolo de Contexto de Modelo (MCP) con características como seguridad de tipos, validación de parámetros y una API de código mínima.

SingleStore MCP Server

Un servidor para interactuar con bases de datos SingleStore, que permite la consulta de tablas, la descripción de esquemas y la generación de diagramas ER con soporte SSL seguro y seguridad de tipos en TypeScript.

Remote MCP Server

A Cloudflare Workers-based Model Context Protocol server that enables AI assistants like Claude to access external tools via OAuth authentication.

Audio Player MCP Server

Un servidor que le permite a Claude controlar la reproducción de audio en tu computadora, compatible con archivos MP3, WAV y OGG con funciones como reproducir, listar y detener.

hny-mcp

Servidor para interactuar con los datos de observabilidad de Honeycomb. Este servidor permite que los LLM (modelos de lenguaje grandes) como Claude analicen y consulten directamente sus conjuntos de datos de Honeycomb.

Toolhouse

Servidor MCP para toolhouse.ai. Este no depende de un LLM externo, a diferencia del servidor oficial.

UNO-MCP

Operador Narrativo Unificado, enriquece y expande el texto de manera fluida, diseño agentivo 5 en 1.

Weather MCP Server

Un servidor MCP que se conecta a la API de OpenWeatherMap para proporcionar datos meteorológicos actuales y pronósticos de varios días para ubicaciones de todo el mundo en diferentes unidades de medida.

Cloudflare API MCP

A lightweight MCP server that enables agents to interface with Cloudflare's REST API, allowing management of DNS records and other Cloudflare services.

AutoCAD LT AutoLISP MCP Server

Enables natural language control of AutoCAD LT through AutoLISP code generation and execution, allowing users to create engineering drawings with conversational prompts.