Discover Awesome MCP Servers

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

ZenML MCP Server

Un servidor que implementa el Protocolo de Contexto del Modelo (Model Context Protocol) que permite a los LLMs interactuar con la plataforma ZenML, proporcionando acceso a datos de pipelines, información de la pila (stack) y la capacidad de activar nuevas ejecuciones de pipelines.

Aiyogg_tinypng Mcp Server

Espejo de

Airbnb MCP Server

Permite buscar anuncios de Airbnb y obtener información detallada sobre alojamientos con enlaces directos a las páginas de Airbnb.

ROS MCP Server

Facilitates robotic movement control by providing functions that enable precise manipulation of linear and angular velocities through natural language commands, compatible with both ROS and ROS2.

Scansca - MCP Database Connector (under-development)

Servidor MCP para bases de datos principales

MCP-Server

A Flask-based MCP server with web GUI that provides utility tools for mathematical calculations, text analysis, string transformations, timestamps, and Fibonacci sequence generation.

MCP Replicate FLUX

A Model Context Protocol server that generates images using Replicate's FLUX model and stores them in Cloudflare R2, allowing users to create images through simple prompts and retrieve accessible URLs.

Firebase Realtime Database

Firebase Realtime Database

mcp-task

Here are a few options for translating "MCP server demoing task management," depending on the specific context you want to convey: **Option 1 (Most General):** * **Spanish:** Demostración de un servidor MCP que muestra la gestión de tareas. * This is a straightforward translation. **Option 2 (More Technical):** * **Spanish:** Demostración de un servidor MCP que demuestra la administración de tareas. * "Administración" is a more formal and technical term for "management." **Option 3 (Focus on Functionality):** * **Spanish:** Demostración de un servidor MCP para la gestión de tareas. * This emphasizes the server's purpose. **Option 4 (If "demoing" means "demonstrating the capabilities of"):** * **Spanish:** Demostración de las capacidades de gestión de tareas de un servidor MCP. * This focuses on the server's capabilities. **Which option is best depends on the specific context. Consider:** * **Your audience:** Are they technical or non-technical? * **The purpose of the translation:** Are you trying to be precise or just give a general idea? I would lean towards **Option 1** or **Option 2** unless you have a specific reason to choose one of the others.

kbg-viewer

Un componente personalizado de Vue.js para visualizar gráficos de bases de conocimiento generados a partir de servidores de memoria MCP.

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.

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.

Gallabox MCP Server

Implementación de un servidor de Protocolo de Contexto de Modelo (MCP) para las APIs de WhatsApp de Gallabox. Este servidor actúa como un middleware entre los clientes MCP y la API de Gallabox, proporcionando una interfaz estandarizada para enviar mensajes de WhatsApp.

Tushare_MCP

A Model Context Protocol server that provides intelligent stock data assistance through Tushare's financial data API, enabling users to query comprehensive stock information, financial data, and market indices through natural language.

Crawl4AI MCP Wrapper

Enables web scraping, crawling, and content extraction through Crawl4AI Docker API. Supports markdown extraction, screenshots, PDFs, JavaScript execution, and multi-URL crawling with reliable stdio transport.

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.

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.

Hacker News MCP Server

Enables access to Hacker News data including top stories, new stories, specific story details, and search functionality. Integrates with Poke to provide Hacker News content through natural language interactions.

DeepResearch MCP

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

FastMCP Training Course Server

An educational MCP server example built with FastMCP that demonstrates how to expose tools, resources, and prompts to AI clients. Provides a learning foundation for building MCP servers with Python and integrating them with AI applications like IDEs and chatbots.

Opentrons MCP Server

A server that provides both comprehensive API documentation and direct robot control capabilities for Opentrons Flex and OT-2 robots, enabling users to manage protocols, control runs, and monitor robot health through natural language.

Outsource MCP

An MCP server that enables AI applications to access 20+ model providers (including OpenAI, Anthropic, Google) through a unified interface for text and image generation.

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.