Discover Awesome MCP Servers

Base Implementation Framework

Un marco de Protocolo de Contexto de Modelo genérico para construir aplicaciones impulsadas por IA que proporciona formas estandarizadas de crear servidores y clientes MCP para integrar LLMs con soporte para Ollama y Supabase.

Looking-Glass-MCP

A Model Context Protocol server that provides network probing capabilities through Looking Glass vantage points, allowing users to perform global network diagnostics like ping, BGP route lookups, and traceroute operations from multiple locations worldwide.

MCP Starter for Puch AI

Provides job search capabilities including analyzing job descriptions, fetching job postings from URLs, and searching opportunities, plus basic image processing tools like converting images to black and white.

OKX MCP Server

Enables AI assistants to interact with OKX trading accounts through read-only access to retrieve portfolio information, trading positions, order history, and account analytics. Provides secure, local processing of trading data without storing sensitive information or enabling trade execution.

tmap_mcp

tmap rest api 기반 mcp server 구축

Figma Server

Permite una interacción fluida con Figma a través del Protocolo de Contexto de Modelo, permitiendo que las aplicaciones LLM accedan, manipulen y rastreen archivos, componentes y variables de Figma.

PostGIS MCP Server

A server application that provides PostGIS database connection using Model Context Protocol (MCP), enabling spatial database functionality through natural language interactions.

MCP Server TypeScript Template

Aquí tienes una plantilla de TypeScript para crear servidores del Protocolo de Contexto de Modelos que permiten a los modelos de IA utilizar herramientas externas, incluyendo operaciones de ejemplo y una funcionalidad simple de suma de números: ```typescript // Importa las bibliotecas necesarias import express, { Request, Response } from 'express'; import bodyParser from 'body-parser'; // Define la interfaz para una operación interface Operation { name: string; description: string; parameters: { [key: string]: { type: string; description: string } }; execute: (params: { [key: string]: any }) => Promise<any>; } // Define la interfaz para la respuesta del protocolo de contexto del modelo interface ModelContextResponse { result: any; error?: string; } // Define las operaciones disponibles const operations: Operation[] = [ { name: 'add_numbers', description: 'Suma dos números.', parameters: { num1: { type: 'number', description: 'El primer número.' }, num2: { type: 'number', description: 'El segundo número.' }, }, execute: async (params: { num1: number; num2: number }) => { const { num1, num2 } = params; return num1 + num2; }, }, // Agrega más operaciones aquí ]; // Crea la aplicación Express const app = express(); const port = 3000; // Usa middleware para analizar el cuerpo de la solicitud como JSON app.use(bodyParser.json()); // Define el endpoint para el protocolo de contexto del modelo app.post('/execute', async (req: Request, res: Response) => { const { operationName, parameters } = req.body; try { // Encuentra la operación solicitada const operation = operations.find((op) => op.name === operationName); if (!operation) { return res.status(400).json({ error: `Operación no encontrada: ${operationName}` }); } // Valida los parámetros for (const paramName in operation.parameters) { if (!parameters.hasOwnProperty(paramName)) { return res.status(400).json({ error: `Parámetro faltante: ${paramName}` }); } // Puedes agregar validación de tipo aquí si es necesario } // Ejecuta la operación const result = await operation.execute(parameters); // Envía la respuesta const response: ModelContextResponse = { result }; res.json(response); } catch (error: any) { console.error("Error al ejecutar la operación:", error); const response: ModelContextResponse = { result: null, error: error.message || "Error desconocido" }; res.status(500).json(response); } }); // Define el endpoint para obtener la lista de operaciones disponibles app.get('/operations', (req: Request, res: Response) => { const operationList = operations.map(op => ({ name: op.name, description: op.description, parameters: op.parameters })); res.json(operationList); }); // Inicia el servidor app.listen(port, () => { console.log(`Servidor escuchando en el puerto ${port}`); }); ``` **Explicación del código:** * **Importaciones:** Importa las bibliotecas `express` para crear el servidor web, `body-parser` para analizar el cuerpo de las solicitudes JSON. * **Interfaces:** Define las interfaces `Operation` y `ModelContextResponse` para estructurar los datos. `Operation` define la estructura de cada operación que el servidor puede realizar, incluyendo su nombre, descripción, parámetros esperados y la función `execute` que realiza la operación. `ModelContextResponse` define la estructura de la respuesta que el servidor envía al modelo de IA. * **Operaciones:** Define un array `operations` que contiene las operaciones disponibles. En este ejemplo, solo hay una operación: `add_numbers`. Puedes agregar más operaciones a este array. * **Aplicación Express:** Crea una instancia de la aplicación Express y configura el middleware `body-parser` para analizar las solicitudes JSON. * **Endpoint `/execute`:** Define el endpoint principal para ejecutar las operaciones. * Recibe el `operationName` y los `parameters` en el cuerpo de la solicitud. * Busca la operación correspondiente en el array `operations`. * Valida que todos los parámetros requeridos estén presentes. * Ejecuta la operación utilizando los parámetros proporcionados. * Envía una respuesta JSON con el resultado o un error. * **Endpoint `/operations`:** Define un endpoint para obtener la lista de operaciones disponibles. Esto permite al modelo de IA descubrir las capacidades del servidor. * **Inicio del servidor:** Inicia el servidor Express en el puerto especificado. **Cómo usar esta plantilla:** 1. **Instala las dependencias:** ```bash npm install express body-parser @types/express @types/body-parser ``` 2. **Guarda el código:** Guarda el código como un archivo TypeScript (por ejemplo, `server.ts`). 3. **Compila el código:** ```bash tsc server.ts ``` 4. **Ejecuta el servidor:** ```bash node server.js ``` 5. **Envía una solicitud POST a `/execute`:** Puedes usar `curl`, `Postman` o cualquier otra herramienta para enviar una solicitud POST a `http://localhost:3000/execute` con el siguiente cuerpo JSON: ```json { "operationName": "add_numbers", "parameters": { "num1": 5, "num2": 10 } } ``` La respuesta será: ```json { "result": 15 } ``` 6. **Obtén la lista de operaciones:** Envía una solicitud GET a `http://localhost:3000/operations` para obtener la lista de operaciones disponibles. **Consideraciones adicionales:** * **Validación de tipos:** Agrega validación de tipos más robusta para los parámetros de las operaciones. Puedes usar bibliotecas como `zod` o `yup` para definir esquemas de validación. * **Manejo de errores:** Implementa un manejo de errores más detallado y registra los errores para facilitar la depuración. * **Autenticación y autorización:** Si el servidor necesita acceder a recursos protegidos, implementa autenticación y autorización para controlar el acceso a las operaciones. * **Escalabilidad:** Considera la escalabilidad del servidor si esperas un alto volumen de solicitudes. Puedes usar un balanceador de carga y múltiples instancias del servidor. * **Seguridad:** Implementa medidas de seguridad para proteger el servidor contra ataques, como la validación de entrada y la protección contra ataques de inyección. * **Documentación:** Documenta las operaciones disponibles y sus parámetros para que los modelos de IA puedan utilizarlas correctamente. Puedes usar herramientas como Swagger/OpenAPI para generar documentación automáticamente. Esta plantilla proporciona un punto de partida sólido para crear servidores del Protocolo de Contexto de Modelos en TypeScript. Puedes adaptarla y ampliarla para satisfacer las necesidades específicas de tu aplicación.

Custom MCP Server

Un servidor MCP personalizado que integra la búsqueda de Brave, el sistema de archivos, GitHub y el pensamiento secuencial.

Twitter MCP Server

Model Context Protocol server that enables programmatic interaction with Twitter API, allowing users to post tweets, search for content, and retrieve user timelines through standardized MCP tools.

Flight MCP Server

A real-time flight tracking interface for LLMs that connects AI assistants to live aircraft data from ADS-B Exchange, enabling searches by location, specific flight tracking, military aircraft monitoring, and aviation pattern discovery.

MCP Obsidian Docker

Versión Dockerizada del servidor MCP Obsidian para la integración de la API REST Local de Obsidian.

tl;dv MCP for Zoom, Google Meet and MS Teams

lets you interact with your meeting data (to list, ask, summarize, extract - virtually anything about your meeting) through Claude’s desktop client across Zoom, Google Meet and MS Teams via tl;dv.

Baidu Digital Human MCP Server

Provides programmatic access to Baidu's Xiling Digital Human platform, enabling AI assistants to generate digital human videos, clone voices, and create synthesized speech through 13 standardized MCP protocol interfaces.

Pinboard MCP Server

Provides LLMs with read-only access to search, filter, and retrieve bookmark metadata from Pinboard.in at inference time via Model Context Protocol.

🛠️ dbt MCP Server

dbt-mcp-server

MCP Python Interpreter

Un servidor de Protocolo de Contexto de Modelo que permite a los LLM interactuar con entornos de Python, ejecutar código y administrar archivos dentro de un directorio de trabajo especificado.

DocGen MCP Server

Automatiza la creación de documentación estandarizada extrayendo información de archivos fuente y aplicando plantillas, con capacidades de integración para GitHub, Google Drive y Perplexity AI.

Day 5 Remote MCP Server

Enables Claude Web to interact with Google Docs through a remote HTTP-based MCP server. Provides scalable document operations including creation, editing, and management with service account authentication.

MCP Server Template 🚀

Aquí tienes una plantilla para construir servidores MCP (Protocolo de Contexto del Modelo) para Claude y otros asistentes de IA: **Título: Plantilla para Servidor MCP (Protocolo de Contexto del Modelo)** **Introducción:** Esta plantilla proporciona una estructura básica para construir un servidor MCP que permita a Claude (u otros asistentes de IA) acceder y utilizar información contextual externa. El Protocolo de Contexto del Modelo (MCP) define una interfaz estandarizada para que los modelos de lenguaje interactúen con fuentes de datos externas, mejorando su capacidad para responder preguntas, generar contenido y realizar tareas con mayor precisión y relevancia. **Componentes Clave:** 1. **API del Servidor MCP:** * **Punto Final Principal:** `/mcp/query` (o similar) * **Método:** `POST` * **Formato de Solicitud (JSON):** ```json { "query": "Pregunta o solicitud del modelo de lenguaje", "context_keys": ["lista", "de", "claves", "opcionales", "para", "filtrar", "el", "contexto"], "model_id": "identificador_del_modelo_de_lenguaje" // Opcional: para manejar diferentes modelos } ``` * **Formato de Respuesta (JSON):** ```json { "context": [ { "key": "clave_identificadora_del_contexto", "content": "Contenido relevante para la consulta", "source": "Fuente del contexto (e.g., base de datos, archivo)", "relevance_score": 0.85 // Opcional: puntuación de relevancia }, { "key": "otra_clave", "content": "Más contenido contextual", "source": "Otra fuente", "relevance_score": 0.92 } ], "metadata": { "processing_time": 0.123, // Opcional: tiempo de procesamiento en segundos "num_results": 2 // Opcional: número de resultados devueltos } } ``` 2. **Gestión de Datos de Contexto:** * **Almacenamiento:** Decide dónde almacenar los datos de contexto. Opciones comunes incluyen: * Bases de datos (SQL, NoSQL) * Almacenamiento de archivos (JSON, CSV, texto) * Bases de datos vectoriales (para búsqueda semántica) * **Indexación:** Implementa un sistema de indexación eficiente para buscar rápidamente el contexto relevante. * **Actualización:** Define un proceso para actualizar y mantener los datos de contexto al día. 3. **Lógica de Búsqueda de Contexto:** * **Algoritmos de Búsqueda:** Implementa algoritmos para encontrar el contexto más relevante para la consulta. Considera: * Búsqueda de palabras clave * Búsqueda semántica (usando incrustaciones de palabras o frases) * Filtrado basado en `context_keys` * **Puntuación de Relevancia:** Asigna una puntuación de relevancia a cada pieza de contexto para ayudar al modelo de lenguaje a priorizar la información más importante. 4. **Autenticación y Autorización (Opcional):** * Implementa mecanismos de autenticación y autorización para controlar el acceso al servidor MCP y a los datos de contexto. 5. **Registro y Monitorización:** * Registra las solicitudes, las respuestas y los errores para monitorizar el rendimiento del servidor MCP y diagnosticar problemas. **Implementación (Ejemplo en Python con Flask):** ```python from flask import Flask, request, jsonify import json app = Flask(__name__) # Simulación de una base de datos de contexto context_data = { "empresa_descripcion": { "content": "Somos una empresa líder en tecnología...", "source": "Base de datos interna" }, "producto_caracteristicas": { "content": "Nuestro producto ofrece características innovadoras...", "source": "Documentación del producto" } } @app.route('/mcp/query', methods=['POST']) def handle_query(): data = request.get_json() query = data.get('query', '') context_keys = data.get('context_keys', []) model_id = data.get('model_id', 'default') # Ejemplo de uso de model_id print(f"Consulta recibida del modelo {model_id}: {query}") # Lógica de búsqueda de contexto (simplificada) relevant_context = [] for key, value in context_data.items(): if not context_keys or key in context_keys: # Filtra por context_keys si se proporcionan relevant_context.append({ "key": key, "content": value["content"], "source": value["source"], "relevance_score": 0.9 # Puntuación fija para este ejemplo }) response = { "context": relevant_context, "metadata": { "processing_time": 0.05, "num_results": len(relevant_context) } } return jsonify(response) if __name__ == '__main__': app.run(debug=True) ``` **Consideraciones Adicionales:** * **Escalabilidad:** Diseña el servidor MCP para que pueda escalar horizontalmente para manejar un gran volumen de solicitudes. * **Seguridad:** Implementa medidas de seguridad para proteger los datos de contexto y el servidor MCP de accesos no autorizados. * **Pruebas:** Escribe pruebas unitarias y de integración para garantizar la calidad y la fiabilidad del servidor MCP. * **Documentación:** Documenta la API del servidor MCP y su configuración para facilitar su uso y mantenimiento. * **Integración con Claude (u otros modelos):** Asegúrate de que el formato de la solicitud y la respuesta del servidor MCP sean compatibles con la API del modelo de lenguaje que estás utilizando. En el caso de Claude, consulta la documentación oficial de Anthropic para conocer los detalles de la integración. **Ejemplo de Uso con Claude (Conceptual):** 1. Claude recibe una pregunta del usuario: "¿Cuál es la descripción de la empresa?" 2. Claude formatea la pregunta y la envía al servidor MCP como una solicitud POST a `/mcp/query`. 3. El servidor MCP busca en su base de datos de contexto y encuentra la descripción de la empresa. 4. El servidor MCP devuelve la descripción de la empresa a Claude en formato JSON. 5. Claude utiliza la descripción de la empresa para generar una respuesta para el usuario. **Conclusión:** Esta plantilla proporciona un punto de partida para construir un servidor MCP robusto y escalable para Claude y otros asistentes de IA. Recuerda adaptar la plantilla a tus necesidades específicas y seguir las mejores prácticas de desarrollo de software. La clave es diseñar un sistema que proporcione información contextual relevante de manera eficiente y segura para mejorar el rendimiento de los modelos de lenguaje.

Puppeteer MCP Server

Un servidor de Protocolo de Contexto de Modelo que proporciona capacidades de automatización del navegador utilizando Puppeteer, permitiendo que los LLM interactúen con páginas web, tomen capturas de pantalla y ejecuten JavaScript en un entorno de navegador real.

React + TypeScript + Vite

Una prueba para crear un editor de texto simple utilizando el servidor Figma MCP con Cursor. Esta prueba ha consistido en guiar a Cursor paso a paso a través de todos los componentes.

MySQL Database Server

Un servidor de Protocolo de Contexto de Modelo que permite a los modelos de IA interactuar con bases de datos MySQL, proporcionando herramientas para consultar, ejecutar sentencias, listar tablas y describir estructuras de tablas.

MCP Server UniFi

Una implementación de servidor que permite interacciones en lenguaje natural con dispositivos de red UniFi al encapsular la API de red UniFi para agentes de IA como Goose y Claude.

Memory Bank MCP

A Model Context Protocol plugin that helps AI assistants maintain persistent project context through structured markdown files, providing a systematic approach to tracking project goals, decisions, progress, and patterns.

Model Context Protocol (MCP) Server for Home Assistant

Enables seamless integration between Home Assistant and Language Learning Models (LLMs), allowing natural language interaction for smart home control and automation management.

Crawlab MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite a las aplicaciones de IA interactuar con la funcionalidad de Crawlab a través del lenguaje natural, habilitando la gestión de spiders, la ejecución de tareas y las operaciones de archivos.