Discover Awesome MCP Servers

Voice to Text MCP Server

A powerful speech-to-text MCP server that supports multiple audio formats and recognition engines including remote APIs (Bailian, OpenAI Whisper, iFLYTEK), Google Speech Recognition, and CMU Sphinx.

Exa Websets MCP Server

A Model Context Protocol server that enables interaction with Exa's Websets API for AI-powered web search and data collection, allowing users to create and manage customized websets through natural language queries.

substack-mcp

MCP server for Substack — read posts, manage drafts, and upload images. Safe by design: cannot publish or delete.

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.

vmware-storage

AI-powered VMware storage management for vSphere. Manage datastores, iSCSI targets, and vSAN via natural language with 11 MCP tools.

DeepResearch MCP

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

spring-ai-playground

Spring AI Playground is a self-hosted web UI platform for building low-code tools and dynamically exposing them via built-in MCP server for AI agents.

MCP Obsidian Docker

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

systerd-lite

An AI-Native OS Core that enables LLMs to autonomously monitor, control, and optimize Linux systems with 200+ system control tools covering process management, security, containers, and self-editing capabilities.

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.

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.

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.

Slack MCP Server

Enables AI-powered Slack workspace management with 18+ tools for messaging, channel management, conversation analysis, and real-time bot responses. Features an autonomous AI agent that can plan and execute complex multi-step tasks combining Slack operations with web research.

Apollo MCP Server

Enables sales intelligence and outreach automation through Apollo.io's 275M+ contact database. Supports prospecting, contact enrichment, email sequences, workflow automation, and pipeline management.

MCP Streamable HTTP Server Template

A dual-runtime template for building Model Context Protocol servers compatible with Node.js and Cloudflare Workers. It features integrated OAuth, encrypted token storage, and multi-tenant session management to simplify the creation of secure tool, resource, and prompt interfaces.

mcp-server-for-powershell

Unofficial Powershell MCP server

MCP Server Deepdive Deployment

An example Model Context Protocol (MCP) server that provides basic mathematical operations such as adding two numbers together. It serves as a demonstration for deploying and configuring MCP servers using Python and the uv package manager.

Tibero MCP Server

Enables AI applications to securely connect to and interact with Tibero databases, supporting SQL queries, schema inspection, and data retrieval through the Model Context Protocol.

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.

MCP Chat

A command-line interface application that enables interactive chat with AI models through the Anthropic API, supporting document retrieval, command-based prompts, and extensible tool integrations.

Splitwise MCP Server

Enables AI assistants to manage Splitwise expenses with atomic duplicate prevention, smart fuzzy matching, and support for flexible split ratios between two people.

GitHub MCP Server

A Model Context Protocol server that provides comprehensive GitHub integration for Claude Desktop, allowing users to manage repositories, issues, and pull requests. It supports file operations, branch management, and repository searches through natural language commands.

Cloudflare MCP

Enables interaction with the complete Cloudflare API using a codemode pattern that allows agents to search the OpenAPI spec and execute API calls via JavaScript. This approach minimizes token usage by keeping the massive specification on the server and only returning relevant results.

tmap_mcp

tmap rest api 기반 mcp server 구축

DeepL MCP Server

Provides translation capabilities using the DeepL API, supporting text translation between numerous languages, rephrasing, batch translation, document translation, and language detection with formality control.

Decide Test MCP

Enables Claude to generate executable test cases from decision tables in CSV, JSON, or Markdown formats. Provides intelligent test planning guidance and generates Playwright/API test code with TypeScript support.

Jimeng MCP Server

Integrates Jimeng AI image and video generation services through MCP protocol, enabling users to generate high-quality images and videos from text prompts with support for image mixing, reference images, and multiple AI models.