Discover Awesome MCP Servers

Texas Holdem MCP Server

Un servidor de Protocolo de Contexto de Modelo (MCP) que permite a agentes de IA jugar partidas de póquer Texas Hold'em a través de una interfaz de cliente MCP.

Remote MCP Server Authless

A tool that deploys an authentication-free Model Context Protocol server on Cloudflare Workers, allowing you to create and access custom AI tools from the Cloudflare AI Playground or Claude Desktop.

Redis MCP Server

Permite a los usuarios realizar operaciones en la base de datos Redis utilizando las herramientas del Protocolo de Contexto de Modelo (MCP), lo que permite una gestión eficiente de los datos a través de comandos como establecer, obtener y escanear campos hash.

MCP Vector Sync

A multi-tenant service that automatically monitors Supabase database changes, generates OpenAI embeddings, and maintains synchronized vector search capabilities for each tenant's projects.

LPS MCP

Un servidor mínimo que proporciona a Claude AI acceso seguro al sistema de archivos y capacidades de pensamiento secuencial, permitiendo a Claude navegar por directorios, leer archivos y descomponer problemas complejos en pasos de pensamiento estructurados.

JFrog MCP Server

Servidor experimental del protocolo de contexto del modelo que permite el acceso a las capacidades de la API de la plataforma JFrog, incluyendo la gestión de repositorios, el seguimiento de compilaciones, la búsqueda de artefactos y el análisis de seguridad de paquetes.

DeepResearch MCP

A powerful research assistant that conducts intelligent, iterative research through web searches, analysis, and comprehensive report generation on any topic.

Figma MCP Tool

Enables interaction with Figma designs through the Figma API, allowing users to export images in multiple formats, extract style data and CSS, analyze design elements, and retrieve SVG code from Figma files. Supports batch operations and comprehensive design element analysis including images, vectors, and components.

General MCP Server

A comprehensive Model Context Protocol server that enables AI assistants to search and retrieve content from Reddit, YouTube, and Twitter through simple API calls.

ethereum-tools

Un conjunto de herramientas integral para el análisis de la cadena de bloques de Ethereum dentro de Claude AI, que permite la auditoría de contratos, el análisis de billeteras, el seguimiento de la rentabilidad y la recuperación de datos en la cadena.

MCP Security Analyst

Un servidor MCP (Protocolo de Contexto de Modelo) para permitir revisiones de seguridad del código utilizando

Query MCP

Permite el acceso al IDE a las bases de datos de Supabase con ejecución de consultas SQL, gestión de esquemas, operaciones de administración de Auth y controles de seguridad integrados para evitar acciones destructivas accidentales.

Coreflux MCP Server

Conecta a Claude y otros asistentes de IA compatibles con MCP a un broker MQTT de Coreflux, permitiéndoles descubrir y ejecutar comandos de Coreflux para gestionar modelos, acciones, reglas y rutas a través del lenguaje natural.

Cal Server

Un calculador de expresiones matemáticas que procesa expresiones ingresadas por el usuario y devuelve los resultados calculados, admitiendo operaciones básicas y constantes integradas como PI y E.

TaxJar MCP Server by CData

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for TaxJar (beta): https://www.cdata.com/download/download.aspx?sku=JTZK-V&type=beta

Understanding MCP Architecture: Single-Server vs Multi-Server Clients

Demostración de la arquitectura MCP con clientes de un solo servidor y de múltiples servidores utilizando LangGraph, llamadas de herramientas impulsadas por IA y comunicación asíncrona.

FrontendLeap MCP Server

A Model Context Protocol server that enables Claude and other AI assistants to generate personalized, contextually-relevant coding challenges in JavaScript, TypeScript, HTML, and CSS.

MCP LEDAPI Intent Controller

A Model Context Protocol server that translates high-level intents into commands for controlling an Arduino-based LED system via a RESTful interface.

Gmail MCP Server

Un servidor de Protocolo de Contexto de Modelo de Gmail para una integración fluida con asistentes de IA.

toyMCP To-Do List Server

Este es un servidor de ejemplo sencillo que implementa una API CRUD de lista de tareas pendientes utilizando los conceptos del Protocolo de Contexto del Modelo (MCP), específicamente utilizando JSON-RPC 2.0 sobre HTTP. Utiliza Node.js, Express y PostgreSQL (a través de Docker) para la persistencia.

Multichat MCP Server

Un servidor que permite la comunicación simultánea con múltiples servidores MCP basados en unichat, permitiendo a los usuarios consultar diferentes modelos de lenguaje y combinar sus respuestas para obtener resultados más completos.

Context Manager MCP Server

Una implementación de servidor del Protocolo de Contexto del Modelo (MCP) para gestionar el flujo de trabajo de desarrollo con funciones como gestión de proyectos, seguimiento de tareas y soporte para la revisión de control de calidad.

Hi-AI

A simple AI development tool that helps users interact with AI through natural language commands, offering 29 tools across thinking, memory, browser, code quality, planning, and time management capabilities.

WebSearch

Construido como un servidor de Protocolo de Contexto de Modelo (MCP) que proporciona capacidades avanzadas de búsqueda web, extracción de contenido, rastreo web y "scraping" utilizando la API de Firecrawl.

MCP Server for Slack

Una implementación de servidor del Protocolo de Contexto de Modelo que permite a los asistentes de IA interactuar con espacios de trabajo de Slack, permitiéndoles explorar canales, enviar mensajes, responder a hilos, añadir reacciones y recuperar información de usuarios.

MCP Server TypeScript Starter

Aquí tienes una plantilla inicial para crear un servidor de Protocolo de Contexto de Modelo (MCP) usando TypeScript: ```typescript // Importa las bibliotecas necesarias import { Server, ServerCredentials } from '@grpc/grpc-js'; import { ModelContextService } from './generated/model_context_grpc_pb'; // Reemplaza con la ruta correcta import { IModelContextServer } from './generated/model_context_grpc_pb'; // Reemplaza con la ruta correcta import { ModelRequest, ModelResponse } from './generated/model_context_pb'; // Reemplaza con la ruta correcta // Implementa la interfaz del servidor MCP class ModelContextServer implements IModelContextServer { // Implementa el método de inferencia async infer(call: any, callback: any): Promise<void> { const request: ModelRequest = call.request; // Lógica de inferencia del modelo aquí // ... const response: ModelResponse = new ModelResponse(); // Configura la respuesta // response.setResult(...); callback(null, response); // null indica que no hay error } // Implementa el método de información del modelo (opcional) async getModelInfo(call: any, callback: any): Promise<void> { // Lógica para obtener información del modelo aquí // ... // Ejemplo de respuesta (ajusta según tus necesidades) const response = { name: "MiModelo", version: "1.0", inputs: [], // Define las entradas del modelo outputs: [] // Define las salidas del modelo }; callback(null, response); } } // Función principal para iniciar el servidor function main() { const server = new Server(); server.addService(ModelContextService, new ModelContextServer()); const port = 50051; // Elige un puerto server.bindAsync(`0.0.0.0:${port}`, ServerCredentials.createInsecure(), (err, port) => { if (err) { console.error(`Error al iniciar el servidor: ${err.message}`); return; } server.start(); console.log(`Servidor MCP escuchando en el puerto ${port}`); }); } // Inicia el servidor main(); ``` **Explicación:** 1. **Importaciones:** - `@grpc/grpc-js`: La biblioteca gRPC para JavaScript/TypeScript. - `model_context_grpc_pb.ts`: Este archivo (y `model_context_pb.ts`) se genera a partir de tu definición de protocolo (archivo `.proto`). **Debes generar estos archivos usando el compilador `protoc` y el plugin `grpc_tools_node_protoc_ts`.** Consulta la sección "Generación de Código" más abajo. - `ModelRequest`, `ModelResponse`: Clases generadas a partir de tu definición de protocolo que representan las solicitudes y respuestas. 2. **`ModelContextServer` Class:** - Implementa la interfaz `IModelContextServer` (generada a partir del archivo `.proto`). - **`infer(call, callback)`:** Este es el método principal donde se realiza la inferencia del modelo. - `call.request`: Contiene la solicitud `ModelRequest` enviada por el cliente. - `callback(error, response)`: Se utiliza para enviar la respuesta `ModelResponse` al cliente. El primer argumento es `null` si no hay error, o un objeto `Error` si ocurre un error. - **`getModelInfo(call, callback)` (Opcional):** Este método proporciona información sobre el modelo (nombre, versión, entradas, salidas, etc.). Es útil para que los clientes descubran las capacidades del modelo. 3. **`main()` Function:** - Crea una instancia de `Server`. - `server.addService()`: Registra el servicio `ModelContextService` con la implementación del servidor `ModelContextServer`. - `server.bindAsync()`: Enlaza el servidor a un puerto específico. `0.0.0.0` significa que el servidor escuchará en todas las interfaces de red. `ServerCredentials.createInsecure()` crea credenciales inseguras (sin TLS). **Para producción, debes usar credenciales seguras (TLS).** - `server.start()`: Inicia el servidor. **Pasos para usar esta plantilla:** 1. **Instala las dependencias:** ```bash npm install @grpc/grpc-js @grpc/proto-loader google-protobuf npm install -D typescript ts-node @types/node ``` 2. **Define tu protocolo (archivo `.proto`):** Crea un archivo llamado `model_context.proto` (o el nombre que prefieras) con la definición de tu servicio y mensajes. Aquí tienes un ejemplo básico: ```protobuf syntax = "proto3"; package model_context; service ModelContext { rpc Infer (ModelRequest) returns (ModelResponse); rpc GetModelInfo (Empty) returns (ModelInfo); // Opcional } message ModelRequest { bytes input_data = 1; // Datos de entrada del modelo } message ModelResponse { bytes result = 1; // Resultado de la inferencia } message ModelInfo { string name = 1; string version = 2; repeated InputInfo inputs = 3; repeated OutputInfo outputs = 4; } message InputInfo { string name = 1; string type = 2; repeated int32 shape = 3; } message OutputInfo { string name = 1; string type = 2; repeated int32 shape = 3; } message Empty {} // Mensaje vacío para GetModelInfo ``` 3. **Generación de Código:** Usa el compilador `protoc` y el plugin `grpc_tools_node_protoc_ts` para generar los archivos TypeScript a partir del archivo `.proto`. Necesitarás instalar `grpc-tools`: ```bash npm install -g grpc-tools ``` Luego, ejecuta el siguiente comando (ajusta las rutas según tu configuración): ```bash protoc --plugin=protoc-gen-ts=./node_modules/.bin/protoc-gen-ts --js_out=import_style=commonjs,binary:. --grpc_out=grpc_js:. --ts_out=. model_context.proto ``` Esto generará los archivos `model_context_pb.js`, `model_context_grpc_pb.js`, `model_context_pb.d.ts`, y `model_context_grpc_pb.d.ts`. Puedes renombrar los archivos `.js` a `.ts` si prefieres usar módulos ES. **Importante:** Asegúrate de que la ruta a `protoc-gen-ts` sea correcta. Si tienes problemas, puedes intentar usar la ruta absoluta. 4. **Crea el archivo `index.ts` (o el nombre que prefieras) y pega el código de la plantilla.** 5. **Implementa la lógica de inferencia:** Reemplaza el comentario `// Lógica de inferencia del modelo aquí` en el método `infer()` con el código que carga tu modelo y realiza la inferencia. Esto dependerá del tipo de modelo que estés utilizando (TensorFlow, PyTorch, etc.). 6. **Configura la respuesta:** Configura el objeto `ModelResponse` con el resultado de la inferencia. Asegúrate de que el tipo de datos del resultado coincida con la definición en tu archivo `.proto`. 7. **Implementa `getModelInfo()` (opcional):** Si deseas proporcionar información sobre el modelo, implementa el método `getModelInfo()`. 8. **Compila y ejecuta el servidor:** ```bash npx tsc node index.js ``` **Consideraciones adicionales:** * **Manejo de errores:** Implementa un manejo de errores adecuado en los métodos `infer()` y `getModelInfo()`. Envía un error al cliente usando `callback(error, null)` si ocurre un error. * **Credenciales seguras (TLS):** Para producción, usa credenciales seguras (TLS) para proteger la comunicación entre el cliente y el servidor. Consulta la documentación de gRPC para obtener más información. * **Logging:** Implementa logging para registrar eventos importantes, como solicitudes, errores y el inicio/detención del servidor. * **Validación de entrada:** Valida los datos de entrada en el método `infer()` para asegurarte de que sean válidos y seguros. * **Escalabilidad:** Si necesitas manejar un gran volumen de solicitudes, considera usar un balanceador de carga y ejecutar múltiples instancias del servidor. * **Tipos de datos:** Asegúrate de que los tipos de datos en tu archivo `.proto` coincidan con los tipos de datos que utiliza tu modelo. * **Streaming:** gRPC también admite streaming, lo que puede ser útil para modelos que procesan grandes cantidades de datos. Este es un punto de partida. Necesitarás adaptar esta plantilla a tus necesidades específicas. Recuerda consultar la documentación de gRPC y el compilador `protoc` para obtener más información.

ADLS2 MCP Server 🚀

Servidor MCP de Microsoft Azure Data Lake Storage

MCP PJe Server

Enables interaction with Brazil's Electronic Judicial Process (PJe) system to search for legal processes, view case details, and download court documents. Supports secure JWT authentication and process lookup by CPF/CNPJ or party name.