Discover Awesome MCP Servers

PostgreSQL MCP Server

Provides read-only access to PostgreSQL databases, allowing LLMs to inspect table schemas and execute SQL queries. It ensures data safety by running all operations within read-only transactions.

API Aggregator MCP Server

A Model Context Protocol (MCP) Server that provides unified access to multiple external APIs (weather, news, financial data) through a single, consistent interface for AI agents and LLMs.

MCP Server for apple calendar

A simple mcp-server to add calendar events

ABAQUS MCP Server for GUI Scripting

A server that enables programmatic interaction with an already running Abaqus/CAE GUI application, allowing users to execute Python scripts and retrieve message logs through the Model Context Protocol (MCP).

DDG MCP Server

A basic MCP server template built with FastMCP framework that provides example tools for echoing messages and retrieving server information. Serves as a starting point for building custom MCP servers with support for both stdio and HTTP transports.

Model Context Protocol (MCP) Tips and Best Practices

Aquí tienes una colección de consejos y buenas prácticas para trabajar con servidores del Protocolo de Contexto del Modelo (MCP):

SharkMCP

A Model Context Protocol server that provides network packet capture and analysis capabilities through Wireshark/tshark integration, enabling AI assistants to perform network security analysis and troubleshooting.

MCP Executor Server

A secure server that enables code execution in isolated Docker environments, supporting Python with strict security constraints including network isolation, limited filesystem access, and resource limitations.

MCP (Model Context Protocol) Server

Aquí tienes una implementación en TypeScript de un servidor y cliente del Protocolo de Contexto de Modelo que permite la interacción con modelos de lenguaje (específicamente Mistral ejecutándose en Ollama): **Título:** Implementación en TypeScript de un Servidor y Cliente del Protocolo de Contexto de Modelo para Interactuar con Mistral en Ollama **Descripción:** Este proyecto proporciona una implementación en TypeScript de un servidor y cliente para el Protocolo de Contexto de Modelo (Model Context Protocol - MCP). Permite la comunicación con modelos de lenguaje, con un enfoque específico en Mistral ejecutándose a través de Ollama. El servidor MCP expone una interfaz para recibir solicitudes y enviar respuestas al modelo, mientras que el cliente MCP facilita la interacción con el servidor. **Componentes:** * **Servidor MCP (TypeScript):** * Escucha en un puerto específico para las solicitudes entrantes. * Recibe solicitudes en formato MCP (definido por el protocolo). * Envía las solicitudes a Ollama (que ejecuta Mistral). * Recibe las respuestas de Ollama. * Formatea las respuestas en formato MCP. * Envía las respuestas al cliente. * **Cliente MCP (TypeScript):** * Se conecta al servidor MCP. * Envía solicitudes formateadas en MCP. * Recibe respuestas formateadas en MCP. * Procesa las respuestas para su uso. * **Integración con Ollama:** * Utiliza la API de Ollama para interactuar con el modelo Mistral. * Maneja la comunicación con Ollama (ejecución del modelo, envío de prompts, recepción de resultados). **Consideraciones Clave:** * **Formato del Protocolo de Contexto de Modelo (MCP):** Es crucial definir y adherirse a un formato MCP claro y consistente para la comunicación entre el cliente y el servidor. Esto incluye la estructura de las solicitudes (por ejemplo, el prompt, parámetros del modelo) y las respuestas (por ejemplo, el texto generado, información de uso). * **Manejo de Errores:** Implementar un manejo robusto de errores tanto en el servidor como en el cliente es esencial. Esto incluye el manejo de errores de red, errores de Ollama, y errores de formato MCP. * **Asincronía:** La comunicación con Ollama y la red es inherentemente asíncrona. Utilizar `async/await` o Promesas para manejar la asincronía de manera efectiva. * **Tipado Fuerte (TypeScript):** Aprovechar el tipado estático de TypeScript para garantizar la corrección y la mantenibilidad del código. Definir interfaces para las solicitudes, las respuestas y los datos del modelo. * **Configuración:** Permitir la configuración del puerto del servidor, la dirección de Ollama, y otros parámetros relevantes a través de variables de entorno o archivos de configuración. * **Streaming (Opcional):** Considerar la implementación de streaming de respuestas desde Ollama al cliente para mejorar la experiencia del usuario, especialmente para respuestas largas. * **Seguridad:** Si el servidor MCP se expone a una red, implementar medidas de seguridad adecuadas para protegerlo contra accesos no autorizados. **Ejemplo de Estructura de Proyecto (Simplificado):** ``` mcp-ollama-ts/ ├── src/ │ ├── server.ts # Servidor MCP │ ├── client.ts # Cliente MCP │ ├── ollama.ts # Interacción con Ollama │ ├── mcp.ts # Definiciones del protocolo MCP (interfaces, tipos) │ ├── config.ts # Configuración │ └── index.ts # Punto de entrada principal ├── package.json ├── tsconfig.json └── README.md ``` **Ejemplo de Código (Fragmento - Servidor):** ```typescript // src/server.ts import * as net from 'net'; import { handleOllamaRequest } from './ollama'; import { parseMCPRequest, formatMCPResponse } from './mcp'; import { config } from './config'; const server = net.createServer(socket => { console.log('Cliente conectado.'); socket.on('data', async data => { try { const request = parseMCPRequest(data.toString()); console.log('Solicitud MCP recibida:', request); const ollamaResponse = await handleOllamaRequest(request.prompt, request.options); // Asume que 'request' tiene 'prompt' y 'options' console.log('Respuesta de Ollama:', ollamaResponse); const mcpResponse = formatMCPResponse(ollamaResponse); console.log('Respuesta MCP enviada:', mcpResponse); socket.write(mcpResponse); } catch (error) { console.error('Error al procesar la solicitud:', error); socket.write(formatMCPResponse({ error: error.message })); // Enviar un error MCP } }); socket.on('end', () => { console.log('Cliente desconectado.'); }); socket.on('error', err => { console.error('Error de socket:', err); }); }); server.listen(config.port, () => { console.log(`Servidor MCP escuchando en el puerto ${config.port}`); }); ``` **Ejemplo de Código (Fragmento - Cliente):** ```typescript // src/client.ts import * as net from 'net'; import { formatMCPRequest, parseMCPResponse } from './mcp'; import { config } from './config'; async function sendRequest(prompt: string, options: any): Promise<any> { return new Promise((resolve, reject) => { const client = net.createConnection({ port: config.port }, () => { console.log('Conectado al servidor.'); const mcpRequest = formatMCPRequest({ prompt, options }); console.log('Solicitud MCP enviada:', mcpRequest); client.write(mcpRequest); }); client.on('data', data => { try { const mcpResponse = parseMCPResponse(data.toString()); console.log('Respuesta MCP recibida:', mcpResponse); resolve(mcpResponse); } catch (error) { reject(error); } client.end(); }); client.on('end', () => { console.log('Desconectado del servidor.'); }); client.on('error', err => { console.error('Error de conexión:', err); reject(err); }); }); } // Ejemplo de uso async function main() { try { const response = await sendRequest("Cuéntame un chiste.", { temperature: 0.7 }); console.log("Respuesta del modelo:", response); } catch (error) { console.error("Error:", error); } } main(); ``` **Ejemplo de Código (Fragmento - Interacción con Ollama):** ```typescript // src/ollama.ts import { exec } from 'child_process'; import { promisify } from 'util'; const execAsync = promisify(exec); export async function handleOllamaRequest(prompt: string, options: any): Promise<string> { try { // Construir el comando de Ollama (ajustar según la API de Ollama) const command = `ollama run mistral "${prompt}"`; // Ejemplo básico console.log(`Ejecutando comando Ollama: ${command}`); const { stdout, stderr } = await execAsync(command); if (stderr) { console.error(`Error de Ollama: ${stderr}`); throw new Error(`Error de Ollama: ${stderr}`); } console.log(`Salida de Ollama: ${stdout}`); return stdout; } catch (error) { console.error(`Error al ejecutar Ollama: ${error}`); throw error; } } ``` **Ejemplo de Código (Fragmento - Definiciones MCP):** ```typescript // src/mcp.ts interface MCPRequest { prompt: string; options: any; // Opciones del modelo (temperatura, etc.) } interface MCPResponse { text?: string; // Texto generado por el modelo error?: string; // Mensaje de error (si ocurre) } function formatMCPRequest(request: MCPRequest): string { return JSON.stringify(request); } function parseMCPRequest(data: string): MCPRequest { return JSON.parse(data); } function formatMCPResponse(response: MCPResponse): string { return JSON.stringify(response); } function parseMCPResponse(data: string): MCPResponse { return JSON.parse(data); } export { MCPRequest, MCPResponse, formatMCPRequest, parseMCPRequest, formatMCPResponse, parseMCPResponse }; ``` **Pasos para la Implementación:** 1. **Configurar Ollama:** Asegurarse de que Ollama esté instalado y configurado correctamente, y que el modelo Mistral esté disponible. 2. **Crear el Proyecto TypeScript:** Inicializar un nuevo proyecto TypeScript con `npm init -y` y configurar `tsconfig.json`. 3. **Instalar Dependencias:** Instalar las dependencias necesarias, como `net` (viene con Node.js), y posiblemente `dotenv` para la configuración. 4. **Implementar los Componentes:** Implementar el servidor MCP, el cliente MCP y la integración con Ollama, siguiendo las consideraciones clave mencionadas anteriormente. 5. **Probar y Depurar:** Probar exhaustivamente la implementación para garantizar que funcione correctamente y manejar los errores de manera adecuada. 6. **Documentar:** Documentar el código y el protocolo MCP para facilitar su uso y mantenimiento. **Consideraciones Adicionales:** * **Autenticación y Autorización:** Si el servidor MCP se expone a una red, considerar la implementación de mecanismos de autenticación y autorización para controlar el acceso. * **Monitorización:** Implementar la monitorización del servidor MCP para detectar y solucionar problemas de rendimiento o errores. * **Escalabilidad:** Si se espera un alto volumen de tráfico, considerar la implementación de técnicas de escalabilidad para garantizar que el servidor MCP pueda manejar la carga. Este es un esquema general. La implementación real requerirá más detalles y código específico para adaptarse a tus necesidades. Recuerda que este código es un punto de partida y necesita ser adaptado y completado para que funcione correctamente en tu entorno. Es importante entender la API de Ollama y el protocolo MCP para poder implementar la comunicación correctamente.

Playwright MCP

Enables browser automation and web page interaction using Playwright's accessibility tree for fast, structured automation without requiring vision models or screenshots.

Image Generation MCP Server

An integration server that connects to gpt-image-1 and Gemini imagen4 models, allowing users to generate high-quality images from text descriptions via simple API endpoints.

Vitally MCP Server

Provides access to Vitally customer success platform data, enabling users to search accounts and users, view health scores, manage conversations and tasks, and create notes through natural language interactions.

EVE-NG MCP Server

A Model Context Protocol server that enables LLMs to manage network topologies, labs, nodes, and configurations in the EVE-NG network emulation platform through a standardized interface.

WOL MCP Server

Provides read-only access to the Watchtower Online Library (WOL) with advanced search capabilities, document retrieval, and multilingual support. Enables users to search and browse Jehovah's Witnesses publications through natural language interactions.

GibsonAI

AI-Powered Cloud databases: Empower your LLMs to build, migrate, and deploy database instances with AI

Zillow Working API MCP Server

Enables access to Zillow real estate data through the Zillow Working API, allowing users to query property information and listings.

Lunar Calendar MCP Server

Provides traditional Chinese lunar calendar information including auspicious date checking, BaZi (八字) Four Pillars analysis, festival data, moon phases, zodiac compatibility, and calendar conversions based on Chinese cultural traditions.

WinAutoWx

Enables automated WeChat operations on Windows through pywinauto, allowing users to send messages to multiple friends or groups programmatically. Provides tools for searching contacts, sending bulk messages, and controlling WeChat interface elements via MCP protocol.

Crypto-Signal MCP

Provides cryptocurrency trading signals, market analysis, and portfolio management capabilities across 15+ exchanges with AI-enhanced technical analysis, arbitrage detection, and risk assessment tools.

DB-Mcp

MCP Database Server is a service that provides secure database access for AI assistants and LLM-based tools, supporting SQLite, PostgreSQL, MySQL and MariaDB, and featuring query verification, audit logs and security control functions.

MindsDB MySQL MCP Server

Connects AI clients to MindsDB via the MySQL protocol to execute SQL queries, manage databases, and perform semantic searches within knowledge bases. It enables automated workflows through job scheduling and provides seamless integration with external data sources.

Youtube Mp310 MCP Server

Enables downloading MP3 audio files from YouTube videos by providing a YouTube URL through the Youtube Mp310 API.

DLI Power Switch MCP Server

Enables AI agents to control Digital Loggers (DLI) Web Power Switches for hardware discovery, status querying, and power operations. It features a safety-first architecture with configurable access levels to protect critical infrastructure from unauthorized or accidental power loss.

Qontinui Web MCP Server

Enables AI assistants to create and manage visual automation configurations, workflows, and UI states through the Qontinui API. It supports project management, workflow execution, and configuration handling for automated web interactions.

GitLab MCP Server

Connects AI assistants to GitLab projects, enabling users to query merge requests, review discussions, view test results and pipelines, search by branch, and respond to comments through natural language commands.

Spotify MCP Server

Enables control of Spotify playback through OAuth authentication, including play/pause, track navigation, volume control, device management, and searching/playing songs by artist or track name.

comet-mcp

An MCP server that connects Claude to Perplexity Comet for agentic web browsing and deep research via an isolated browser instance. It enables Claude to delegate complex navigation, login flows, and real-time task monitoring to Perplexity's specialized research intelligence.

Trello Desktop MCP

Enables comprehensive Trello integration through Claude Desktop, allowing users to search, create, update, and manage Trello boards, cards, lists, comments, and collaborate with team members through natural language.

Everything MCP Server

A test MCP server implementing all protocol features including tools, resources, prompts, and sampling to help developers build and test MCP clients.

MCP YFinance Stock Server

Enables AI agents to retrieve real-time stock data, manage watchlists, and perform comprehensive technical analysis using Yahoo Finance API. Provides 18+ tools for stock price tracking, trend analysis, volatility assessment, and financial indicators through MCP integration.