Discover Awesome MCP Servers

DingTalk Robot MCP

Enables AI assistants to send DingTalk single and group chat messages via MCP protocol, supporting userId, name, or batch sending to up to 20 users.

migratoor

Database migration safety checker MCP server that analyzes SQL for dangerous patterns and provides safe alternatives.

𓂀𓁢𓋹𝔸ℕ𝕌𝔹𝕀𝕊𓋹𓁢𓂀 - Intelligent Guidance for

Hey @roocode community! I'm thrilled to share a project born from my work with Roocode and the vision of an AI-powered development team: the Anubis MCP Server! This system is heavily inspired by Roocode and designed to orchestrate an AI development workflow based on agile methodology. It simulates

federal-compass-mcp

An MCP server that connects Claude to the USAJobs API, enabling natural language search for federal jobs, translation of government jargon, CV qualification analysis, and explanation of federal concepts like GS grades and clearances.

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.

Ollama MCP Server

A universal MCP server that integrates with local Ollama instances, enabling AI-powered chat, model management, and text generation from any MCP-compatible IDE or application.

Onplana MCP server

Open-source TypeScript MCP server template with Streamable HTTP transport, Bearer auth, and prompt-injection containment, plus a client SDK for Onplana's hosted MCP endpoint.

mcp-gitlab-jira

A Model Context Protocol (MCP) server for GitLab and Jira integration. This server allows AI agents like gemini-cli to interact with your GitLab and Jira instances.

healow-mcp-server

An MCP server that wraps the eClinicalWorks / healow FHIR R4 API so an MCP client (e.g. Claude Desktop) can read patient clinical data from one or more practices.

mcp-tw-invoice

A server that queries Taiwan uniform invoice winning numbers and performs automatic prize matching.

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 WordPress Server

Comprehensive MCP server to manage WordPress sites via natural language, enabling content creation, SEO, and multi-site administration through AI tools like Claude Desktop.

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.

kaspi-merchant-mcp

Enables managing Kaspi Marketplace orders through AI assistants, including listing, accepting, completing, and canceling orders, with real-time operations directly on production data (no sandbox).

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.

Kinsta MCP Server

MCP server for the Kinsta WordPress hosting platform, enabling AI assistants to interact with Kinsta sites and infrastructure via the Kinsta API.

bricks-use

MCP server for executing Databricks SQL queries and comparing table data, supporting CLI and VS Code integration.

Parallel Task MCP

Deep Research and Batch Tasks

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.

scb-mcp

Enables querying Statistics Sweden's statistical database via tools like navigate, get_table_metadata, query_table, etc.

erddap-mcp-demo

Enables LLMs to interact with ERDDAP search, metadata, and tabledap services for oceanographic data.

Pixel Art MCP

An MCP server that generates pixel-art PNGs from text prompts, using a free image backend, and saves them directly to your project directory.

Sequential Thinking MCP Server

Enables dynamic and reflective problem-solving through a structured thinking process with tools for sequential analysis, tree of thoughts, self-critique, and integration with external knowledge and codebase analysis.

npu-vision-fallback

Provides an MCP server for local low-power screen vision, enabling AI agents to perform OCR and UI detection on inaccessible screens (games, remote desktops) using NPU acceleration and system OCR.

APAC Compliance MCP

MCP server for AI agents selling into APAC. 7 tools: country briefs (Japan/Singapore/Korea/India/Australia/Hong Kong/Indonesia), outreach templates, etiquette guides, follow-up cadences, stakeholder maps. PDPA/APP/APPI-aware.

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.

Sui MCP SHIT Minter

MCP server for minting SHIT tokens on Sui blockchain, supporting self-sponsored and sponsored transaction flows.

image-recognition-mcp

Gives vision-less LLMs the ability to recognize clipboard screenshots and images by proxying to an OpenAI-compatible vision model.