Discover Awesome MCP Servers

Parallel Task MCP

Deep Research and Batch Tasks

SearchAPI MCP Server

Connects AI assistants to external data sources (Google, Bing, etc.) via SearchAPI.site, implementing the Model Context Protocol (MCP) for secure and contextual access to web information.

PDF Reader MCP Server

An MCP server that provides comprehensive PDF processing capabilities including text extraction, image extraction, table detection, annotation extraction, metadata retrieval, page rendering, and document structure analysis.

MCP PDF Server

Enables conversion of Markdown content into PDF documents with customizable paper formats and orientations. Supports both inline Markdown text and file path inputs, automatically generating PDFs using Playwright and Chromium.

MCP Utils

A comprehensive utilities library for building Model Context Protocol servers, providing standardized tools for response formatting, caching, rate limiting, logging, and WebSocket management.

Vault Java MCP Server

PayPal-Java-MCP Server

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.

MCP Server for Dust Agent Integration

Conectarse a un agente de Dust a través de una llamada HTTP.

Xiaohongshu MCP Server

An automation server that enables interaction with Xiaohongshu platform through browser automation, supporting functions like article search, content viewing, reading comments, and posting comments.

santa-mcp

Un servidor MCP PoC para Santa (or Papá Noel)

@demoway/mcp-server

Servicio independiente Demoway MCP

SolMail MCP

Enables AI agents to send physical letters and postcards to over 200 countries using Solana cryptocurrency for payment. It provides tools for generating mail quotes, managing wallet balances, and automating physical correspondence directly through the Model Context Protocol.

Act CRM MCP Server by CData

This read-only MCP Server allows you to connect to Act CRM data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

Work Memory MCP Server

Manages persistent work memories and context across AI tools, enabling structured storage, search, and retrieval of work content, tasks, and knowledge with session-based project organization.

Jopmcp

A MCP server for Joplin note-taking application that enables interaction with Joplin notes through the web clipper API, supporting notebook hierarchy and running in Docker.

JSON Logs MCP Server

JSON Logs MCP Server

Python MCP Server Template

A template repository for creating custom Model Context Protocol (MCP) servers in Python that can be integrated with applications like Claude Desktop or Cursor.

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.