Discover Awesome MCP Servers

envbouncer

A tiny local MCP server and CLI that lets AI agents read only allowlisted environment variables, redacts known secrets from text, and logs every access.

AICre8 MCP Server

Enables AI agents to create, modify, and deploy web projects through the AICre8 platform's sandbox environment. It supports project management, code generation, and direct shell command execution for streamlined web development.

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.

bricks-use

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

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.

ai-summarizer

AI text and URL summarizer that extracts key points, reduces word count, and estimates reading time, with pay-per-call via x402 micropayments.

erddap-mcp-demo

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

Microsoft Graph MCP Server

A comprehensive server that enables AI applications to interact with Microsoft 365 and Azure AD services through standardized Model Context Protocol interfaces.

fallanno-mcp

MCP server for the Fallanno platform, enabling identity management, annotation signing and verification, payout routing, pricing, peer scoring, audit chains, and portfolio building through Claude Code/Desktop.

diffsorted

Splits messy, multi-concern git diffs into focused groups and generates a clear, accurate commit message for each, exposed as an MCP server for use with MCP-compatible clients.

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.

prowlarr-mcp

MCP server exposing Prowlarr's API v1 as tools for managing indexers, applications, download clients, and more, including cross-indexer searches and system commands.

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.

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.

GuardRail MCP v2.0 (Enterprise)

GuardRail MCP is an enterprise agent security server that provides multi-language code analysis, dependency scanning, and container security checks, with RBAC, policy packs, and audit logging.

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.

flutter-stripe-mcp

An MCP server that diagnoses Flutter + Stripe (flutter_stripe) setup issues — so Claude can check your project automatically.

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.

rybbit-super-mcp

Enables querying and managing Rybbit Analytics directly from Claude Code, with 48 tools for full CRUD on funnels, goals, and sites, plus real-time statistics, performance metrics, and user journey analysis.

mcp-arcgis-pima

Enables searching and querying Pima County, Arizona open geospatial data (parcels, addresses, zoning, public works) through ArcGIS Feature Services.

pqc-migration-mcp

Provides six MCP tools for AI agents to compute post-quantum cryptography migration facts, such as credential sizes, fragment counts, and failure taxonomy, enabling accurate migration decisions without estimation.

Youtube Mp310 MCP Server

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

ClickUp MCP Server

Integrates with ClickUp API to manage tasks, workspaces, spaces, folders, and lists, enabling AI assistants to perform discovery, read, and write operations across ClickUp hierarchy.

Freshsales MCP Server

Connects AI assistants to Freshsales CRM, enabling natural language queries and CRUD operations on contacts, deals, accounts, and more.

KriteriusMX

Enables Claude to search and retrieve legal sources from Mexican and inter-American courts (SCJN, TFJA, DOF, Corte IDH) with complete citations and official links.

Google Ads Gateway MCP

A Codex MCP server that wraps the Google Ads Gateway Worker to provide list_accounts and run_gaql tools, enabling natural language querying of Google Ads accounts and running GAQL queries without storing credentials.

AIAgentMCP

Enables browser automation and testing using Playwright through the Model Context Protocol.