Discover Awesome MCP Servers

Homelab MCP Server

Extensible MCP server for managing a homelab from Claude AI, enabling control of VMs, snapshots, services, and files via natural language.

Angular Component Inspector

Enables dynamic exploration of Angular library components by reading and analyzing the public API exports. Provides tools to list available components and retrieve detailed component information.

IBAMA: Certidão de Embargos (Nada Consta)

MCP server for consulting IBAMA's official embargo certificate (Certidão de Embargos/Nada Consta), providing read-only queries through a single tool.

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.

basic-react

Provides a get-time tool with a linked React UI for displaying the current time.

Weather MCP Server

Provides real-time weather updates and city geocoding by integrating the Nominatim and Open-Meteo APIs. It enables users to retrieve current weather conditions for any location through natural language queries in MCP-compatible clients.

team-protocol

Enables structured role-to-role handoffs and merge gating for multi-agent collaboration. It persists evidence and computes approval gates without invoking LLMs.

Hermes GLPI Wave Hub

Enables interaction with GLPI (ITSM) through 71 tools covering tickets, assets, problems, changes, knowledge base, projects, users, and more, using SSE or stdio transport.

social-connect-mcp-poc

Enables MCP-driven testing and verification of Facebook and TikTok connections, including OAuth flows and connection status checks.

ArXiv Research Assistant

Enables researchers to search ArXiv papers, extract key insights (problems, methods, results) from abstracts, and perform ML-powered analysis including topic modeling, trend visualization, and author collaboration networks.

HWCA MCP Server

Enables AI assistants to automate context-management tasks for the Horizon Worlds editor by executing system commands, reading/writing files, and managing processes.

log-collector

MCP server for collecting and analyzing CLI/web server error logs. Enables watching log files/directories, parsing common error patterns, and querying/analyzing logs through natural language.

Tekla MCP Server

Enables AI-driven interaction with Tekla Structures through natural language commands, allowing users to select elements, insert components, and automate modeling workflows.

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.

ssh-mcp

An MCP server enabling Claude to execute commands on multiple remote servers via SSH and transfer large files (40GB+) with resume support via SFTP.

vibealive MCP Server

Provides code analysis for Next.js projects through the Model Context Protocol, enabling IDE and LLM integration to identify unused files, dead code, and redundant API endpoints.

Rabobank MCP Training Demo

A training MCP server that demonstrates how GitHub Copilot can securely access internal banking APIs, documentation, and architecture review prompts.

stockfish-mcp

Analyzes chess positions via Stockfish, returning best moves and evaluations from FEN or PGN input.

gov-transparency-mcp

MCP server for US government transparency data (congressional trades, federal contracts, campaign finance, lobbying, regulations) with per-call paid access via x402 USDC.

secure-mcp-database-crud

Enables secure task CRUD operations on SQLite or MySQL databases with input validation, parameterized queries, audit events, transactions, and signed delete confirmation.

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.

stackchan-relay

MCP server that enables controlling a StackChan robot via tools like speak, emote, and move head, with a relay service for ESP32 long polling.

Debeka MCP Server

Automates Debeka insurance claim submissions by filling forms, uploading PDF documents, and submitting via Playwright.

Rabobank Demo MCP Server

Demonstrates how to expose approved internal banking tools to AI assistants via MCP, enabling secure lookups of account balances, customer names, branch details, and live exchange rate conversions.

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.

RAG MCP Server with Streamable HTTP

Enables hybrid search (BM25 + semantic with RRF) over documentation, with Thai language support. It exposes MCP tools for adding documents and searching via Qdrant and Ollama/OpenAI, using a stateless Streamable HTTP transport.

code-intel

Provides semantic code search and code insights via a knowledge graph, enabling AI to understand, navigate, and modify complex projects with deep dependency and architecture analysis.

heor-agent-mcp

AI-powered HEOR (Health Economics and Outcomes Research) MCP server with 7 tools for literature search across 41 medical data sources, cost-effectiveness modeling (Markov/PartSA/PSA), and HTA dossier preparation for NICE, EMA, FDA, IQWiG, HAS, and EU JCA submissions.

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.

Ryft MCP

A Model Context Protocol server that enables interaction with the Ryft API to manage financial resources such as payment sessions, customers, and subscriptions. It supports comprehensive operations including payouts, disputes, and account-scoped requests through a secure stdio interface.