Discover Awesome MCP Servers

MCP Scope Consent

Hosted remote MCP server for managing consent scope receipts, enabling checking, issuing, and auditing consent policies and tool calls.

PostgreSQL MCP Server

Enables AI assistants to safely interact with PostgreSQL databases through read-only operations, providing schema discovery, table inspection, and query execution capabilities with structured context awareness.

amocrm-mcp

Enables users to interact with AmoCRM via Claude Desktop using natural language, with 17 tools for accessing CRM entities like leads, contacts, and pipelines.

MCP Server Template

A production-ready Python scaffold for building Model Context Protocol (MCP) servers using FastMCP. It provides a structured framework for developers and AI agents to rapidly develop, test, and manage custom tools and workflows.

nautilus-compass

Enables AI agents to retain memory of past interactions and detect behavioral drift, preventing repeated mistakes without LLM token extraction.

@theyahia/yandex-speechkit-mcp

Enables speech recognition, synthesis, and voice listing via Yandex SpeechKit API through 5 tools.

fallbookspaper-mcp

MCP server for foldkit that exposes 7-prime spine, 7 κ-bands, and 6 fold operations as tools/resources, enabling state folding, κ-band classification, and fold operations in any MCP client.

Playwright MCP Quickstart

Enables AI agents to control a local browser via Playwright's accessibility tree, allowing automated web interactions and testing through natural language commands.

divergent-thinking-mcp

Provides a comprehensive creative thinking tool with methods like structured process, perspective shift, and constraint-based innovation to enhance divergent thinking.

China Festival MCP Server

Provides Chinese holiday information, lunar calendar conversion, traditional festivals, 24 solar terms, and BaZi (Eight Characters) calculations for AI assistants to accurately handle Chinese calendar queries and date conversions.

Cabal-Hunter

On-chain Solana token safety for trading agents — traces coordinated wallet funding, same-block Jito bundles, serial-rug deployers and live coordinated dumps into one Exit-Liquidity Risk verdict before a swap. Free tier, then $0.02 USDC/query via x402.

Paste MCP

Connect Paste to Claude, Codex, Cursor, and other AI tools to access your clipboard.

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!

gamelibs-mcp

An MCP server that exposes your Steam, Epic Games Store, and IGDB game data as tools, enabling game library queries, install status checks, and metadata enrichment.

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.

reclaw-comms-mcp

MCP server enabling permissioned, structured agent-to-agent communications, allowing agents to negotiate availability through schema-validated messages with scoped access and audit logging.

duckdb-mcp

A minimal MCP server that provides a persistent DuckDB SQL engine to AI assistants, enabling natural-language querying of CSVs, Parquet, and cloud data with 12 tools and optional read-only mode.

MCP Quoting System

Intelligently generates cost estimates and lead times for manufacturing RFPs by parsing requests, matching against historical quotes, and calculating activity-based costs with confidence scoring and human approval workflows.

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.

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.

ScrapingDog-MCP

An MCP server that exposes all 77 ScrapingDog API endpoints as AI-ready tools, enabling web scraping, Google search, Amazon product data, LinkedIn profiles, YouTube transcripts, and more through a single API key.

mdn-translation-ja-mcp

Assists MDN Japanese translation tasks by automating file copying from English content, synchronizing source commits, and performing guideline-based reviews.

CalendarBridge

MCP server that connects ChatGPT to Apple Calendar via a local Mac agent, enabling event listing, searching, and creation while keeping data on your machine.

TokenLab Model Explorer

Enables browsing TokenLab models, comparing pricing, and generating cURL examples for various AI endpoints.

MongoDB Atlas MCP Server

A Model Context Protocol server that provides access to the MongoDB Atlas API, enabling management of clusters, users, projects, backups, and more through MCP tools.

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.

sandbook

A multi-tiered memory subsystem for AI agents with markdown, vector, and graph long-term memory, usable as a standalone memory MCP server for Claude.

Notes MCP Server

Enables Claude Desktop to create, read, list, and manage local notes stored on the computer using natural language requests.