MCP Servers

Discover Awesome MCP Servers

Extend your agent with 27,542 capabilities via MCP servers.

All27,542

At-Work API MCP Server

An MCP (Multi-Agent Conversation Protocol) Server that enables interaction with the At-Work API (api.at-work.biz), allowing agents to communicate with this service through various transport modes like stdio, SSE, and HTTP.

Mock Store MCP Server

Enables AI agents to explore and query a mock e-commerce store's data including customers, products, inventory, and orders through conversational interactions backed by PostgreSQL.

crawl4ai-mcp

Okay, here's a Python outline and conceptual structure for wrapping the Crawl4AI library within an MCP (Model Context Protocol) server. This is a complex task, so I'll break it down into key components and provide code snippets to illustrate the core ideas. **Conceptual Overview** 1. **Crawl4AI Library:** Assume you have the Crawl4AI library installed and accessible in your Python environment. This library provides functions for web crawling, data extraction, and AI-related tasks. Let's say it has functions like: * `crawl_website(url, max_depth)`: Crawls a website up to a specified depth. * `extract_text(html_content)`: Extracts text from HTML content. * `analyze_content(text)`: Analyzes the extracted text using AI models (e.g., sentiment analysis, topic extraction). 2. **MCP Server:** The MCP server will act as a central point for receiving requests to use the Crawl4AI functions. It will expose these functions as services that can be called remotely. We'll use a framework like Flask or FastAPI to create the server. 3. **MCP Protocol:** MCP defines a standard way for clients to communicate with the server. Requests are typically sent as JSON payloads, and responses are also in JSON format. The requests will specify which Crawl4AI function to call and the parameters to pass to it. 4. **Python Implementation:** We'll use Python to: * Wrap the Crawl4AI functions. * Create the MCP server using Flask or FastAPI. * Handle incoming MCP requests. * Call the Crawl4AI functions. * Format the results as JSON responses. **Code Structure (Illustrative)** ```python # Import necessary libraries from flask import Flask, request, jsonify import json # Assume Crawl4AI is installed and accessible # import Crawl4AI # Replace with the actual import app = Flask(__name__) # Mock Crawl4AI functions (replace with actual Crawl4AI calls) def crawl_website(url, max_depth): """Mocks crawling a website.""" print(f"Crawling {url} with max depth {max_depth}") # Simulate crawling and getting HTML content html_content = f"<html><body><h1>Crawled Content from {url}</h1><p>Some text.</p></body></html>" return html_content def extract_text(html_content): """Mocks extracting text from HTML.""" print("Extracting text from HTML") text = "Crawled Content from a website. Some text." return text def analyze_content(text): """Mocks analyzing content.""" print("Analyzing content") analysis_result = {"sentiment": "neutral", "topic": "general"} return analysis_result @app.route('/mcp', methods=['POST']) def mcp_handler(): """Handles MCP requests.""" try: data = request.get_json() print(f"Received MCP request: {data}") # Extract function name and parameters from the MCP request function_name = data.get('function') params = data.get('params', {}) # Default to empty dictionary if no params # Call the appropriate Crawl4AI function based on the function name if function_name == 'crawl_website': url = params.get('url') max_depth = params.get('max_depth', 1) # Default max_depth result = crawl_website(url, max_depth) # Call the Crawl4AI function response_data = {"result": result} # Wrap the result elif function_name == 'extract_text': html_content = params.get('html_content') result = extract_text(html_content) response_data = {"result": result} elif function_name == 'analyze_content': text = params.get('text') result = analyze_content(text) response_data = {"result": result} else: return jsonify({"error": "Invalid function name"}), 400 # Return the result as a JSON response return jsonify(response_data), 200 except Exception as e: print(f"Error processing request: {e}") return jsonify({"error": str(e)}), 500 if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=5000) ``` **Explanation:** 1. **Imports:** Imports Flask for creating the web server and `json` for handling JSON data. 2. **Mock Crawl4AI Functions:** These are placeholder functions. **You must replace these with actual calls to your Crawl4AI library.** They simulate the behavior of the Crawl4AI functions for demonstration purposes. 3. **`mcp_handler` Function:** * This function is the endpoint that receives MCP requests (at the `/mcp` route). * It parses the JSON request body using `request.get_json()`. * It extracts the `function` name and `params` from the request. * It uses an `if/elif/else` block to determine which Crawl4AI function to call based on the `function_name`. * It calls the appropriate Crawl4AI function with the provided parameters. * It formats the result as a JSON response using `jsonify()`. * It handles potential errors using a `try...except` block and returns an error response if something goes wrong. 4. **`if __name__ == '__main__':`:** This ensures that the Flask app is only run when the script is executed directly (not when it's imported as a module). It starts the Flask development server. **How to Run:** 1. **Install Flask:** `pip install flask` 2. **Replace Mock Functions:** Replace the mock Crawl4AI functions with actual calls to your Crawl4AI library. 3. **Run the Script:** `python your_script_name.py` **Example MCP Request (sent to the server):** ```json { "function": "crawl_website", "params": { "url": "https://www.example.com", "max_depth": 2 } } ``` **Example MCP Response (from the server):** ```json { "result": "<html><body><h1>Crawled Content from https://www.example.com</h1><p>Some text.</p></body></html>" } ``` **Key Improvements and Considerations:** * **Error Handling:** The `try...except` block provides basic error handling. You should add more robust error handling, including logging and more specific exception handling. * **Input Validation:** Validate the input parameters in the `mcp_handler` function to prevent errors and security vulnerabilities. For example, check if the `url` is a valid URL. * **Security:** If this server will be exposed to the internet, implement proper security measures, such as authentication and authorization. Consider using HTTPS. * **Asynchronous Operations:** Web crawling can be time-consuming. Consider using asynchronous tasks (e.g., with `asyncio` or Celery) to prevent the server from blocking while crawling. This will improve the server's responsiveness. * **Configuration:** Use a configuration file (e.g., a `.ini` or `.yaml` file) to store settings such as the server port, logging level, and API keys. * **Logging:** Implement comprehensive logging to track requests, errors, and other important events. * **Documentation:** Document the API endpoints and the expected request/response formats. Consider using a tool like Swagger/OpenAPI to generate API documentation. * **Rate Limiting:** Implement rate limiting to prevent abuse of the API. * **Framework Choice:** While Flask is a good starting point, FastAPI is often preferred for modern APIs due to its performance and automatic data validation. The code structure would be similar, but you'd use FastAPI's decorators and data validation features. **Example using FastAPI:** ```python from fastapi import FastAPI, HTTPException from pydantic import BaseModel from typing import Optional app = FastAPI() # Define data models for request parameters (using Pydantic) class CrawlWebsiteParams(BaseModel): url: str max_depth: Optional[int] = 1 class ExtractTextParams(BaseModel): html_content: str class AnalyzeContentParams(BaseModel): text: str # Mock Crawl4AI functions (replace with actual Crawl4AI calls) def crawl_website(url: str, max_depth: int): """Mocks crawling a website.""" print(f"Crawling {url} with max depth {max_depth}") # Simulate crawling and getting HTML content html_content = f"<html><body><h1>Crawled Content from {url}</h1><p>Some text.</p></body></html>" return html_content def extract_text(html_content: str): """Mocks extracting text from HTML.""" print("Extracting text from HTML") text = "Crawled Content from a website. Some text." return text def analyze_content(text: str): """Mocks analyzing content.""" print("Analyzing content") analysis_result = {"sentiment": "neutral", "topic": "general"} return analysis_result @app.post("/crawl_website") async def crawl_website_endpoint(params: CrawlWebsiteParams): try: result = crawl_website(params.url, params.max_depth) return {"result": result} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @app.post("/extract_text") async def extract_text_endpoint(params: ExtractTextParams): try: result = extract_text(params.html_content) return {"result": result} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @app.post("/analyze_content") async def analyze_content_endpoint(params: AnalyzeContentParams): try: result = analyze_content(params.text) return {"result": result} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) ``` In the FastAPI example: * **Pydantic:** Pydantic is used to define data models (`CrawlWebsiteParams`, `ExtractTextParams`, `AnalyzeContentParams`). This provides automatic data validation and serialization. * **Type Hints:** Type hints are used extensively to improve code readability and help with static analysis. * **FastAPI Decorators:** FastAPI's decorators (`@app.post`) are used to define the API endpoints and the HTTP methods they handle. * **HTTPException:** `HTTPException` is used to raise HTTP errors with appropriate status codes and error messages. * **Separate Endpoints:** Each Crawl4AI function has its own dedicated endpoint (e.g., `/crawl_website`, `/extract_text`). This is generally a cleaner and more RESTful approach than a single `/mcp` endpoint. Remember to replace the mock functions with your actual Crawl4AI library calls. This comprehensive outline should give you a solid foundation for building your MCP server. Good luck!

UniProt MCP Server

mcp-voice-hooks

Voice Mode for Claude Code

Jira MCP Server

Un servidor MCP para consultar tareas de Jira.

Gemini-Imagen4

Generate high-quality images from text descriptions using Google's Imagen 4.0 models with multiple quality variants, flexible aspect ratios, and local file storage.

USPTO Final Petition Decisions MCP Server

Enables high-performance access to USPTO Final Petition Decisions API with intelligent context reduction (80-99%), customizable fields, hybrid document extraction (free PyPDF2 + Mistral OCR fallback), and seamless cross-MCP integration for complete patent lifecycle analysis including prosecution history, PTAB challenges, and citation intelligence.

Model Context Protocol (MCP) Tutorial

Aquí tienes una guía completa sobre los servidores del Protocolo de Contexto del Modelo (MCP), su instalación y uso con Cursor y Smithery: **Guía Completa de Servidores del Protocolo de Contexto del Modelo (MCP)** El Protocolo de Contexto del Modelo (MCP) es un protocolo que permite a los editores de código y otras herramientas de desarrollo acceder a información contextual sobre el código que están editando. Esto puede incluir información sobre definiciones de símbolos, referencias, tipos y otra información relevante. Los servidores MCP proporcionan esta información contextual a los clientes MCP, como los editores de código. **¿Qué es un Servidor MCP?** Un servidor MCP es una aplicación que implementa el protocolo MCP. Escucha las solicitudes de los clientes MCP y responde con información contextual sobre el código. Piensa en él como un intermediario que entiende tu código y puede responder preguntas sobre él. **Beneficios de Usar un Servidor MCP:** * **Mejor Autocompletado:** Obtén sugerencias de código más precisas y relevantes. * **Navegación de Código Mejorada:** Salta rápidamente a definiciones y referencias de símbolos. * **Información de Código Más Rica:** Visualiza información sobre tipos, documentación y otros detalles directamente en tu editor. * **Análisis de Código Más Inteligente:** Permite a las herramientas de análisis de código comprender mejor tu código. **Instalación de un Servidor MCP:** La instalación de un servidor MCP depende del lenguaje de programación y las herramientas que estés utilizando. Aquí hay algunos ejemplos comunes: * **Para Python:** Muchos servidores MCP para Python están disponibles como paquetes de Python. Puedes instalarlos usando `pip`: ```bash pip install <nombre-del-paquete-del-servidor-mcp> ``` Ejemplos de servidores MCP para Python incluyen `pyright` (para TypeScript/JavaScript también) y `jedi-language-server`. * **Para JavaScript/TypeScript:** `typescript-language-server` es una opción popular. Se instala típicamente con `npm`: ```bash npm install -g typescript-language-server ``` * **Para otros lenguajes:** Busca en la documentación de tu lenguaje de programación o IDE para encontrar un servidor MCP adecuado. A menudo, la documentación del lenguaje o del IDE te guiará a través del proceso de instalación. **Configuración de Cursor y Smithery para Usar un Servidor MCP:** Tanto Cursor como Smithery son editores de código que pueden aprovechar los servidores MCP para proporcionar una mejor experiencia de desarrollo. Aquí te mostramos cómo configurarlos: **Cursor:** 1. **Instala el Servidor MCP:** Sigue las instrucciones de instalación para el servidor MCP que deseas usar (por ejemplo, `pyright` para Python). 2. **Configura Cursor:** Cursor generalmente detecta automáticamente los servidores MCP instalados. Si no lo hace, puedes configurarlo manualmente: * Ve a la configuración de Cursor (generalmente a través de `File` -> `Preferences` -> `Settings`). * Busca la configuración relacionada con "Language Server" o "LSP" (Language Server Protocol, que es similar a MCP). * Especifica la ruta al ejecutable del servidor MCP. Por ejemplo, si instalaste `pyright` globalmente, podría ser algo como `/usr/local/bin/pyright-langserver`. Si lo instalaste localmente en un proyecto, podría ser algo como `./node_modules/.bin/pyright-langserver`. **Smithery (si te refieres a un editor de código llamado Smithery, ya que no es un editor ampliamente conocido):** Si "Smithery" es un editor de código menos común, los pasos generales serían similares a Cursor: 1. **Instala el Servidor MCP:** Sigue las instrucciones de instalación para el servidor MCP que deseas usar. 2. **Configura Smithery:** * Busca la configuración del editor. * Busca opciones relacionadas con "Language Server," "LSP," o "MCP." * Especifica la ruta al ejecutable del servidor MCP. **Ejemplo de Configuración (Python con `pyright` en Cursor):** 1. **Instala `pyright`:** ```bash pip install pyright ``` 2. **Configura Cursor:** * Abre la configuración de Cursor. * Busca "Python Language Server." * Si Cursor no detecta `pyright` automáticamente, especifica la ruta al ejecutable. Puedes encontrar la ruta usando: ```bash which pyright-langserver ``` En la configuración de Cursor, ingresa la ruta que `which` te devolvió. **Solución de Problemas:** * **El servidor MCP no se inicia:** Verifica que el servidor MCP esté instalado correctamente y que la ruta al ejecutable sea correcta en la configuración de tu editor. Revisa los logs del servidor MCP (si los hay) para obtener más información. * **El autocompletado no funciona:** Asegúrate de que el servidor MCP sea compatible con el lenguaje de programación que estás utilizando. Verifica que el servidor MCP esté configurado correctamente en tu editor. * **Errores en el servidor MCP:** Revisa la documentación del servidor MCP para obtener información sobre cómo solucionar problemas específicos. **Conclusión:** Los servidores MCP son herramientas valiosas que pueden mejorar significativamente tu experiencia de desarrollo. Al instalar y configurar un servidor MCP para tu lenguaje de programación y editor de código, puedes disfrutar de un autocompletado más inteligente, una navegación de código mejorada y una información de código más rica. Recuerda consultar la documentación específica de tu lenguaje, servidor MCP y editor para obtener instrucciones más detalladas.

memex

Zettelkasten-based persistent memory for AI coding agents. Auto-saves atomic knowledge cards with \[\[bidirectional links]] after tasks and auto-recalls before new ones. No vector DB — plain markdown files with git sync. Works as Claude Code plugin or MCP server for Cursor, VS Code Copilot, Codex, and Windsurf.

MCP Data Analyzer

Enables loading and statistical analysis of .xlsx and .csv files with visualization capabilities using matplotlib and plotly to generate various graphs and charts.

HR Assistant Agent

An MCP-powered HR management system that automates employee onboarding, leave tracking, meeting scheduling, and IT ticketing. It allows users to manage organizational workflows and administrative tasks through natural language interactions with Claude.

Plex Assistant MCP

Enables users to manage and control their Plex media library through natural language commands in MCP-compatible AI clients. It supports searching content, managing playlists, tracking library statistics, and monitoring live viewing sessions.

YAPI MCP Server

Ultra MCP

A Model Context Protocol server that exposes OpenAI and Gemini AI models through a single interface, allowing tools like Claude Code and Cursor to access multiple AI providers with built-in usage analytics.

ExcelForge

A Windows-based MCP server that enables AI assistants to manage Excel files through the desktop application, supporting workbook operations, data manipulation, and formula validation. It features robust safety tools including snapshot-based rollbacks, path restrictions, and comprehensive audit logging.

MCP Gateway

La puerta de enlace MCP es un servidor proxy inverso que reenvía las solicitudes de los clientes al servidor MCP o utiliza todos los servidores MCP bajo la puerta de enlace a través de un portal unificado.

Sunsama MCP Server

Enables AI assistants to manage tasks in Sunsama, including creating tasks, reading daily and backlog tasks, marking tasks complete, and organizing projects through streams.

Framelink Figma MCP Server Extension for Zed

Weather MCP Server

Enables secure retrieval of real-time weather data for any location via Open-Meteo using AWS Cognito OAuth 2.1 Bearer token authentication. Implements full MCP Authorization Specification with dynamic client registration and protected resource metadata discovery.

mcp-k8s

Here are a few possible translations, depending on the context: * **MCP Kubernetes server:** This is the most direct translation and works if you're referring to a specific server named "MCP" within a Kubernetes environment. * **Servidor MCP de Kubernetes:** This is a more natural-sounding translation, placing "servidor" (server) first. * **Servidor MCP para Kubernetes:** This emphasizes that the MCP server is *for* Kubernetes. Without more context, it's difficult to choose the absolute best translation. However, **Servidor MCP de Kubernetes** is likely the most common and generally applicable.

RPG Maker MZ MCP Server

Enables AI agents to directly manipulate RPG Maker MZ projects through natural language commands, allowing creation and modification of game assets like items, weapons, enemies, maps, and plugins without manually editing game files.

Multi-Tool Control Platform (MCP) Server

A Python framework for developing and managing tool instances through a registry system, where developers can easily create new tools by inheriting from the BaseHandler class and implementing required methods.

Gmail MCP Server

Enables AI assistants to interact with Gmail through OAuth2 authentication, allowing users to list, search, read emails, and create drafts with a safety-first design that prevents accidental sends by default.

Apple Deep Docs MCP

Provides comprehensive access to Apple's development documentation ecosystem including hidden Xcode docs, Swift Evolution proposals, GitHub repositories, and WWDC session notes. Enables developers to search and retrieve advanced Apple development resources not available through public channels.

token-rugcheck

MCP server for real-time Solana token risk analysis. Cross-references RugCheck.xyz, DexScreener, and GoPlus Security to generate three-layer reports: machine verdict → LLM analysis → raw on-chain evidence. Live on Solana mainnet with USDC micropayments ($0.02/audit). Give any AI agent the ability to check if a token is safe before trading.

Marvel MCP Server using Azure Functions

Un servidor MCP basado en Azure Functions que permite la interacción con datos de personajes y cómics de Marvel a través de la API oficial de desarrolladores de Marvel.

mcp-gomamayo

There is no direct translation for "ゴママヨ" into English or Spanish that would make sense in the context of an MCP (Minecraft Coder Pack) server. "ゴママヨ" (Gomamayo) is a Japanese word that refers to a sauce made with sesame and mayonnaise. Therefore, I will translate the *purpose* of having an MCP server for something named "Gomamayo". Here are a few options, depending on the intended meaning: **Option 1 (If "Gomamayo" is the name of a Minecraft mod):** * **English:** MCP server for the "Gomamayo" mod. * **Spanish:** Servidor MCP para el mod "Gomamayo". **Option 2 (If "Gomamayo" is the name of a Minecraft server or community):** * **English:** MCP server for the "Gomamayo" community. * **Spanish:** Servidor MCP para la comunidad "Gomamayo". **Option 3 (If you want to create a mod that adds Gomamayo to Minecraft):** * **English:** MCP server for developing a "Gomamayo" mod (e.g., a mod that adds sesame mayonnaise to Minecraft). * **Spanish:** Servidor MCP para desarrollar un mod de "Gomamayo" (por ejemplo, un mod que añada mayonesa de sésamo a Minecraft). **In summary, the best translation depends on what "ゴママヨ" represents in your context. Please provide more context if none of these options are suitable.**

munich-mensa-mcp

Remote MCP Server for listing and getting the menus of the official mensas in munich

Clawslist MCP Server

Enables AI agents to interact with the Clawslist marketplace to browse, create, and manage listings using the Model Context Protocol. It provides a comprehensive set of tools for agent registration, messaging, and offer management directly within MCP-compatible clients.