Discover Awesome MCP Servers

Redfish MCP Server

Enables interaction with Redfish-compliant BMC devices for server management, firmware updates, and hardware monitoring through session-based authentication and standardized API endpoints.

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.

Constellation

Code Intelligence Platform for AI Coding Assistants

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.

Strudel MCP Server

Enables AI assistants to work with Strudel live coding patterns for music creation, including parsing mini notation, generating rhythmic patterns, accessing music theory (scales/chords), and applying pattern transformations.

Aiyogg_tinypng Mcp Server

Espejo de

Bash MCP Server

An MCP server that enables the execution of arbitrary bash commands and returns detailed output including stdout, stderr, and exit codes. It supports customizable working directories, execution timeouts, and environment variable configurations.

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.

ChurnFlow MCP Server

An ADHD-friendly productivity system that uses AI to provide frictionless capture of tasks and ideas through natural language input, with automatic context detection and intelligent routing to appropriate project trackers. Eliminates cognitive overhead by working with ADHD thinking patterns rather than against them.

Scansca - MCP Database Connector (under-development)

Servidor MCP para bases de datos principales

MCP Weather Server

Provides weather information using the US National Weather Service API, including active weather alerts for US states and location-specific forecasts based on latitude and longitude coordinates.

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.

Linux MCP Server

An MCP server for read-only Linux system administration and diagnostics on RHEL-based systems via SSH. It enables users to troubleshoot remote hosts by accessing system information, services, logs, and network configurations through natural language.

Firebase Realtime Database

Firebase Realtime Database

GitLab MCP Server

Enables monitoring of GitLab CI/CD pipelines and job statuses through automatic project detection and intelligent polling. It provides reliable API integration for checking build progress directly within AI-powered development environments.

GoPlus Security MCP Server

Enables blockchain security analysis using GoPlus Security API, providing rug pull detection, phishing site detection, NFT security analysis, and token security assessment across 14+ blockchain networks. Supports comprehensive security analysis for addresses, tokens, and smart contracts through natural language queries.

Anomaly Detection MCP Server

A server that enables LLMs to detect anomalies in sensor data by providing tools for data retrieval, analysis, visualization, and corrective action execution.

AI Memory MCP Server

A cross-platform MCP server providing persistent storage for AI assistants to store, retrieve, and manage memories across conversations. It features keyword and tag-based search capabilities using a local JSON file for data persistence.

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.

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.

Google Search Console MCP Server

Provides comprehensive access to Google Search Console data with enhanced analytics capabilities, supporting up to 25,000 rows of performance data, advanced filtering with regex patterns, and automatic detection of SEO optimization opportunities.

Lunch Flow MCP Server

Enables AI assistants to access financial data from 20,000+ banks across 40+ countries, allowing users to query account balances, transactions, and spending patterns through natural language.