Discover Awesome MCP Servers

GachaMCP

A Python MCP server that helps AI interact with Gacha games through screenshot capture and click automation, enabling game analysis and automated actions.

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.

mcp-linear

mcp-linear

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.

Youtube Mp310 MCP Server

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

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.

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.

Playwright MCP

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

Cursor Talk to Figma MCP

Implements a Model Context Protocol integration between Cursor AI and Figma, allowing Cursor to programmatically read and modify Figma designs.

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.

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-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.

MCP Server Requests

¿Necesitas un servidor MCP? Solicítalo aquí.

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.

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).

MCP OAuth Gateway

A transparent proxy server that simplifies authentication by chaining its own OAuth layer with an upstream MCP server's credentials. It manages dual token sets behind a single interface, enabling secure and streamlined access to protected MCP resources.

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.

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.

Brain MCP

Enables inter-session communication and coordination for multiple Claude Code instances through a shared SQLite database. Supports real-time messaging, shared state management, and resource locking to facilitate parallel development workflows between AI agents.

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.

CryptoConduit-MCP

An MCP server that gives AI agents direct access to Polymarket Crypto prediction markets, enriched with live spot prices. Discover markets, analyze order books, paper trade strategies, track activity, and execute live trades — all through natural language.

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.

Waybackurls MCP

A bridge that connects Waybackurls with the Model Context Protocol ecosystem, enabling AI assistants to fetch historical URLs from the Wayback Machine to discover forgotten endpoints and potentially vulnerable URLs.

Asana MCP Hybrid Integration

A hybrid MCP server system that enables natural language management of Asana tasks, projects, and portfolios with enhanced security controls. It features a specialized guard server to provide audit logging and two-step confirmation for destructive actions like deletions.

saij-mcp

Connects AI clients to Argentina's official legal database (SAIJ) to search and retrieve court rulings, legislation, summaries, and legal doctrine. It enables users to perform keyword searches and fetch detailed metadata and summaries for Argentinian legal research.