Discover Awesome MCP Servers

Coinmarket

Integración de la API de CoinMarketCap para obtener listados y cotizaciones de criptomonedas.

Confluence Communication Server

Permite consultar y recuperar contenido de Confluence a través de búsquedas CQL y la obtención del contenido de las páginas, lo que permite a Claude acceder sin problemas a la información almacenada en los espacios de trabajo de Confluence.

protonmail-mcp

This MCP server provides email sending functionality using Protonmail's SMTP service. It allows both Claude Desktop and Cline VSCode extension to send emails on your behalf using your Protonmail credentials.

Gmail MCP Server

Proporciona una integración completa con Gmail y capacidades de procesamiento de LLM, lo que permite a los usuarios leer, buscar, filtrar correos electrónicos y gestionar archivos adjuntos a través del Protocolo de Contexto del Modelo.

Twitter MCP Server

Un servidor MCP que permite a Claude interactuar con Twitter, permitiéndole publicar tuits y buscar contenido en Twitter.

Steel Puppeteer

Un servidor de Protocolo de Contexto de Modelo que permite a los LLM automatizar navegadores web utilizando Puppeteer, permitiendo la navegación, la toma de capturas de pantalla, el llenado de formularios y la ejecución de JavaScript en un entorno de navegador real.

Crew AI MCP Server

Habilita el agente de IA y la gestión de tareas utilizando el framework CrewAI, permitiendo a los usuarios crear y ejecutar agentes y tareas en un entorno de flujo de trabajo automatizado.

MCP Documentation Server

Un servidor de documentación inteligente que proporciona mejora de código asistida por IA y gestión de documentación a través de la integración con Claude Desktop.

Linear MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite a Claude interactuar con la API de Linear para gestionar equipos, incidencias, proyectos y ciclos.

Geoapify MCP Server

Convierte direcciones a coordenadas GPS y crea visualizaciones de mapas utilizando la API de Geoapify, permitiendo a los usuarios de Claude generar datos GeoJSON e imágenes de mapas a partir de listas de ubicaciones.

Release Notes MCP Server

Generates notas de lanzamiento completas y formateadas desde repositorios de GitHub, organizando eficientemente los commits por tipo e incluyendo estadísticas detalladas utilizando un uso inteligente de la API.

WeCom Bot MCP Server

Un servidor para enviar mensajes a través de bots de WeCom usando FastMCP, que admite comunicación asíncrona y seguimiento de mensajes mediante webhooks.

salesforce-mcp-server

Una implementación de servidor del Protocolo de Contexto de Modelo para interactuar con Salesforce a través de su API REST.

Dataset Viewer MCP Server

Permite la interacción con la API del visor de conjuntos de datos de Hugging Face, lo que permite a los usuarios explorar, buscar, filtrar y analizar los conjuntos de datos alojados en Hugging Face Hub.

MCP Zotero

Permite que la IA interactúe con tu biblioteca de Zotero.

Snyk MCP Server

Un servidor independiente que permite el análisis de seguridad de Snyk a través del Protocolo de Contexto del Modelo, con soporte para análisis de repositorios y proyectos, verificación de tokens e integración con la CLI.

MCP Development Framework

Un potente marco de Protocolo de Contexto de Modelo que extiende Cursor IDE con herramientas para la recuperación de contenido web, el procesamiento de PDF y el análisis de documentos de Word.

DevDocs MCP

Una implementación de Protocolo de Contexto de Modelo que permite el acceso a recursos de documentación impulsado por IA, con navegación basada en URI, coincidencia de plantillas y gestión estructurada de la documentación.

Manifold Markets MCP Server

Proporciona acceso integral a la plataforma de predicciones Manifold Markets a través de una interfaz MCP clara, permitiendo a los usuarios crear mercados, realizar apuestas, gestionar la liquidez y utilizar funciones sociales a través del lenguaje natural.

Google OR-Tools server

MCP-ORTools integra el solucionador de programación de restricciones OR-Tools de Google con Modelos de Lenguaje Grandes a través del MCP, permitiendo que los modelos de IA puedan: Enviar y validar modelos de restricciones Establecer parámetros del modelo Resolver problemas de satisfacción y optimización de restricciones Recuperar y analizar soluciones

Alchemy MCP Plugin

Este plugin permite la interacción con datos de blockchain y NFTs a través del SDK de Alchemy, permitiendo operaciones como recuperar metadatos de NFTs, obtener NFTs para direcciones de billetera y obtener el número de bloque más reciente.

FastAPI MCP SSE

Aquí tienes una implementación de Server-Sent Events (SSE) usando el framework FastAPI que integra el Protocolo de Contexto de Modelo (MCP), permitiendo a los modelos de IA acceder a herramientas externas y fuentes de datos como información meteorológica: ```python from fastapi import FastAPI, Depends, HTTPException, Request from fastapi.responses import StreamingResponse from sse_starlette.sse import EventSourceResponse from typing import AsyncGenerator, Dict, Any import asyncio import aiohttp # Para peticiones asíncronas a la API meteorológica import json app = FastAPI() # --- Definición del Protocolo de Contexto de Modelo (MCP) --- # (Esto es un ejemplo simplificado, en una implementación real sería más robusto) async def get_weather(city: str) -> Dict[str, Any]: """ Obtiene información meteorológica para una ciudad dada. Simulación: En una implementación real, esto llamaría a una API meteorológica. """ # Reemplaza esto con tu clave de API meteorológica real API_KEY = "YOUR_WEATHER_API_KEY" WEATHER_API_URL = f"https://api.weatherapi.com/v1/current.json?key={API_KEY}&q={city}&aqi=no" async with aiohttp.ClientSession() as session: try: async with session.get(WEATHER_API_URL) as response: response.raise_for_status() # Lanza una excepción para errores HTTP data = await response.json() # Extrae la información relevante del JSON de respuesta weather_info = { "city": data["location"]["name"], "temperature_celsius": data["current"]["temp_c"], "condition": data["current"]["condition"]["text"], "humidity": data["current"]["humidity"] } return weather_info except aiohttp.ClientError as e: print(f"Error al obtener información meteorológica: {e}") raise HTTPException(status_code=500, detail=f"Error al obtener información meteorológica: {e}") except KeyError as e: print(f"Error al parsear la respuesta de la API meteorológica: {e}") raise HTTPException(status_code=500, detail=f"Error al parsear la respuesta de la API meteorológica: Error al parsear la respuesta. Asegúrate de que la API devuelve los campos esperados.") async def execute_tool(tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]: """ Ejecuta una herramienta basada en el nombre y los argumentos. """ if tool_name == "get_weather": return await get_weather(arguments["city"]) else: raise ValueError(f"Herramienta desconocida: {tool_name}") async def process_user_query(query: str) -> AsyncGenerator[str, None]: """ Simula el procesamiento de la consulta del usuario por un modelo de IA. Integra el MCP para acceder a herramientas externas. """ yield "Procesando consulta...\n" # Simulación de la detección de la necesidad de usar una herramienta if "tiempo" in query.lower() or "clima" in query.lower(): yield "Detectada necesidad de información meteorológica.\n" try: # Simulación de la extracción de argumentos para la herramienta city = query.lower().split("en")[-1].strip() # Extrae la ciudad de la consulta yield f"Extrayendo ciudad: {city}\n" # Llamada al MCP para ejecutar la herramienta weather_info = await execute_tool("get_weather", {"city": city}) yield "Información meteorológica obtenida.\n" # Formateo de la respuesta para el usuario response = f"El tiempo en {weather_info['city']} es {weather_info['temperature_celsius']}°C y {weather_info['condition']}. Humedad: {weather_info['humidity']}%\n" yield f"Respuesta: {response}\n" yield response # Respuesta final para el usuario except Exception as e: yield f"Error al obtener información meteorológica: {e}\n" yield "Lo siento, no pude obtener la información meteorológica.\n" else: yield "No se requiere ninguna herramienta externa.\n" yield "Respuesta: No estoy seguro de cómo responder a eso.\n" # --- Endpoint SSE --- async def sse_stream(query: str) -> AsyncGenerator[Dict[str, Any], None]: """ Genera eventos SSE a partir del procesamiento de la consulta del usuario. """ async for message in process_user_query(query): yield {"data": message} @app.get("/stream") async def stream(query: str): """ Endpoint para el stream de eventos SSE. """ return EventSourceResponse(sse_stream(query)) # --- Endpoint de prueba --- @app.get("/") async def read_root(): return {"message": "Bienvenido! Usa /stream?query=<tu_consulta> para obtener un stream de eventos SSE."} if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000) ``` **Explicación del código:** 1. **Importaciones:** Importa las bibliotecas necesarias, incluyendo `FastAPI`, `StreamingResponse`, `EventSourceResponse` (de `sse_starlette`), `asyncio`, `aiohttp` (para peticiones asíncronas) y `typing`. 2. **Definición del Protocolo de Contexto de Modelo (MCP):** * `get_weather(city: str)`: Esta función simula la llamada a una API meteorológica. **Debes reemplazar la URL y la clave de API con las tuyas reales.** Utiliza `aiohttp` para realizar la petición asíncrona. Maneja excepciones para errores HTTP y errores al parsear la respuesta JSON. * `execute_tool(tool_name: str, arguments: Dict[str, Any])`: Esta función actúa como un enrutador para diferentes herramientas. Recibe el nombre de la herramienta y sus argumentos, y llama a la función correspondiente. * `process_user_query(query: str)`: Esta función simula el procesamiento de la consulta del usuario por un modelo de IA. **Este es el núcleo de la integración del MCP.** Detecta si la consulta requiere información meteorológica, extrae la ciudad, llama a `execute_tool` para obtener la información, y formatea la respuesta para el usuario. Utiliza `yield` para generar mensajes progresivos que se enviarán como eventos SSE. 3. **Endpoint SSE:** * `sse_stream(query: str)`: Esta función es un generador asíncrono que llama a `process_user_query` y formatea cada mensaje como un evento SSE (un diccionario con la clave "data"). * `@app.get("/stream")`: Este endpoint define la ruta `/stream` que devuelve un `EventSourceResponse`. Recibe la consulta del usuario como un parámetro `query` y la pasa a `sse_stream`. 4. **Endpoint de prueba:** * `@app.get("/")`: Un endpoint simple para verificar que la aplicación está funcionando. 5. **Ejecución:** * El bloque `if __name__ == "__main__":` ejecuta la aplicación usando `uvicorn`. **Cómo ejecutar el código:** 1. **Instala las dependencias:** ```bash pip install fastapi uvicorn sse_starlette aiohttp ``` 2. **Reemplaza `YOUR_WEATHER_API_KEY` con tu clave de API meteorológica real.** Puedes obtener una clave gratuita en sitios como [https://www.weatherapi.com/](https://www.weatherapi.com/). 3. **Guarda el código como un archivo Python (por ejemplo, `main.py`).** 4. **Ejecuta la aplicación:** ```bash python main.py ``` 5. **Abre un navegador y ve a `http://localhost:8000/stream?query=tiempo en Londres`.** Verás un stream de eventos SSE que muestran el procesamiento de la consulta y la respuesta final. **Puntos importantes:** * **MCP Simplificado:** El MCP en este ejemplo es muy simplificado. En una implementación real, necesitarías un mecanismo más robusto para la detección de herramientas, la extracción de argumentos y el manejo de errores. Considera usar una biblioteca como LangChain o LlamaIndex para una implementación más completa del MCP. * **API Meteorológica:** Asegúrate de usar una API meteorológica real y manejar las excepciones correctamente. La API de ejemplo requiere una clave. * **Manejo de Errores:** El manejo de errores es crucial. Asegúrate de capturar excepciones y enviar mensajes de error informativos al cliente. * **Seguridad:** Si vas a usar este código en un entorno de producción, considera implementar medidas de seguridad como la autenticación y la autorización. * **Escalabilidad:** Para una aplicación de producción, considera usar un servidor ASGI más robusto como Gunicorn o Uvicorn con múltiples workers. * **Formato SSE:** El formato de los eventos SSE es `data: <data>\n\n`. La biblioteca `sse_starlette` se encarga de formatear los datos correctamente. * **Cliente SSE:** Para consumir los eventos SSE en el frontend, puedes usar la API `EventSource` de JavaScript. Este ejemplo proporciona una base sólida para construir una aplicación SSE con FastAPI que integra el MCP. Puedes expandir este código para agregar más herramientas, mejorar el manejo de errores y optimizar el rendimiento.

WebSearch

Las herramientas de búsqueda web son una serie de herramientas que le permiten a Claude acceder a internet a través del servidor MCP.

Mozilla Readability Parser MCP Server

Aquí tienes una implementación en Python de un servidor MCP que extrae contenido de páginas web, elimina anuncios y elementos no esenciales, y lo transforma en Markdown limpio optimizado para LLM: ```python import requests from bs4 import BeautifulSoup import markdownify import re from flask import Flask, request, jsonify app = Flask(__name__) def extract_and_clean_content(url): """ Extrae el contenido de una página web, elimina anuncios y elementos no esenciales, y lo transforma en Markdown limpio optimizado para LLM. """ try: response = requests.get(url, timeout=10) response.raise_for_status() # Lanza una excepción para códigos de error HTTP html_content = response.text soup = BeautifulSoup(html_content, 'html.parser') # Eliminar scripts, estilos y otros elementos no esenciales for tag in soup(["script", "style", "meta", "link", "noscript", "iframe", "img", "svg"]): tag.decompose() # Eliminar elementos basados en clases o IDs (ejemplos comunes de anuncios) for tag in soup.find_all(class_=["ad", "advertisement", "adsbygoogle", "sidebar", "related-articles"]): tag.decompose() for tag in soup.find_all(id=["ad-container", "sidebar", "related"]): tag.decompose() # Eliminar comentarios HTML for comment in soup.find_all(string=lambda text: isinstance(text, comment)): comment.extract() # Extraer el contenido principal (ajustar según la estructura del sitio web) # Este es un ejemplo, puede que necesites inspeccionar el HTML de la página # y encontrar el contenedor principal del contenido. main_content = soup.find("div", {"class": "main-content"}) or soup.find("article") or soup.body if not main_content: return "No se pudo encontrar el contenido principal en la página." # Convertir a Markdown markdown = markdownify.markdownify(str(main_content), heading_style="atx") # Limpieza adicional del Markdown (opcional) markdown = re.sub(r'\n{3,}', '\n\n', markdown) # Eliminar líneas en blanco excesivas markdown = re.sub(r' +', ' ', markdown) # Eliminar espacios en blanco excesivos return markdown except requests.exceptions.RequestException as e: return f"Error al acceder a la URL: {e}" except Exception as e: return f"Error durante el procesamiento: {e}" @app.route('/extract', methods=['POST']) def extract_endpoint(): """ Endpoint para recibir una URL y devolver el contenido Markdown limpio. """ data = request.get_json() if not data or 'url' not in data: return jsonify({"error": "Se requiere una URL en el cuerpo de la solicitud JSON."}), 400 url = data['url'] markdown_content = extract_and_clean_content(url) return jsonify({"markdown": markdown_content}) if __name__ == '__main__': app.run(debug=True) ``` **Explicación del código:** 1. **Importaciones:** - `requests`: Para obtener el contenido HTML de la página web. - `BeautifulSoup`: Para analizar el HTML y facilitar la manipulación. - `markdownify`: Para convertir el HTML limpio a Markdown. - `re`: Para realizar limpieza adicional del Markdown con expresiones regulares. - `flask`: Para crear un servidor web simple que exponga un endpoint. 2. **`extract_and_clean_content(url)`:** - **Obtiene el HTML:** Usa `requests.get()` para obtener el contenido HTML de la URL proporcionada. Incluye un `timeout` para evitar que el script se quede colgado si la página no responde. `response.raise_for_status()` lanza una excepción si la solicitud HTTP falla (código de error 4xx o 5xx). - **Analiza el HTML:** Crea un objeto `BeautifulSoup` para analizar el HTML. - **Elimina elementos no esenciales:** - Elimina etiquetas como `<script>`, `<style>`, `<meta>`, `<link>`, `<iframe>`, `<img>`, `<svg>` y `<noscript>` que generalmente no son necesarias para el contenido principal. - Elimina elementos basados en clases e IDs comunes utilizados para anuncios y barras laterales. **Importante:** Esta parte es la que más probablemente necesite ser ajustada para cada sitio web. Inspecciona el HTML de las páginas que quieres procesar y añade o modifica las clases e IDs que se deben eliminar. - Elimina comentarios HTML. - **Extrae el contenido principal:** - Intenta encontrar el contenedor principal del contenido usando `soup.find()`. El código busca un `<div>` con la clase "main-content", un `<article>`, o, si no encuentra ninguno de los anteriores, usa el `<body>` como último recurso. **Esta es la parte más importante que debes adaptar a la estructura de cada sitio web.** Necesitas inspeccionar el HTML de la página y encontrar el elemento que contiene el contenido principal que quieres extraer. - **Convierte a Markdown:** Usa `markdownify.markdownify()` para convertir el HTML limpio a Markdown. `heading_style="atx"` especifica que los encabezados se creen con el estilo "atx" (usando `#` al principio de la línea). - **Limpieza adicional del Markdown (opcional):** - Elimina líneas en blanco excesivas y espacios en blanco redundantes para obtener un Markdown más limpio. - **Manejo de errores:** Incluye bloques `try...except` para capturar excepciones que puedan ocurrir durante la solicitud HTTP o el procesamiento del HTML. Devuelve mensajes de error descriptivos. 3. **`extract_endpoint()`:** - **Endpoint Flask:** Define un endpoint `/extract` que acepta solicitudes `POST`. - **Recibe la URL:** Espera que la URL se envíe en el cuerpo de la solicitud JSON como `{"url": "la_url"}`. - **Llama a `extract_and_clean_content()`:** Llama a la función principal para extraer y limpiar el contenido. - **Devuelve el Markdown:** Devuelve el contenido Markdown limpio en un objeto JSON como `{"markdown": "el_markdown"}`. - **Manejo de errores:** Devuelve un error 400 si la URL no se proporciona en el cuerpo de la solicitud. 4. **`if __name__ == '__main__':`:** - **Ejecuta el servidor:** Inicia el servidor Flask en modo de depuración (`debug=True`). Esto permite que el servidor se reinicie automáticamente cuando se realizan cambios en el código. **Cómo usarlo:** 1. **Instala las dependencias:** ```bash pip install requests beautifulsoup4 markdownify flask ``` 2. **Guarda el código:** Guarda el código como un archivo Python (por ejemplo, `mcp_server.py`). 3. **Ejecuta el servidor:** ```bash python mcp_server.py ``` 4. **Envía una solicitud POST:** Usa `curl`, `Postman` o cualquier otra herramienta para enviar una solicitud POST al endpoint `/extract` con la URL en el cuerpo JSON: ```bash curl -X POST -H "Content-Type: application/json" -d '{"url": "https://es.wikipedia.org/wiki/Inteligencia_artificial"}' http://localhost:5000/extract ``` Reemplaza `"https://es.wikipedia.org/wiki/Inteligencia_artificial"` con la URL que quieras procesar. 5. **Recibe la respuesta:** El servidor devolverá una respuesta JSON con el contenido Markdown limpio: ```json { "markdown": "# Inteligencia artificial\n\nLa **inteligencia artificial** (**IA**), también llamada **inteligencia artificial**, es la inteligencia mostrada por las máquinas. En informática, una máquina «inteligente» ideal es un agente racional que percibe su entorno y lleva a cabo acciones que maximicen sus posibilidades de éxito.\n\nColoquialmente, el término «inteligencia artificial» se aplica cuando una máquina imita las funciones «cognitivas» que los humanos asocian con otras mentes humanas, como por ejemplo: «aprender» y «resolver problemas».\n\n..." } ``` **Puntos importantes a considerar y adaptar:** * **Adaptación a la estructura del sitio web:** La parte más importante es la función `extract_and_clean_content()`. Necesitas inspeccionar el HTML de los sitios web que quieres procesar y ajustar el código para eliminar los elementos no deseados y extraer el contenido principal correctamente. Presta especial atención a las clases e IDs de los elementos que contienen anuncios, barras laterales y otros elementos no esenciales, y al elemento que contiene el contenido principal. * **Manejo de errores:** El código incluye manejo de errores básico, pero puedes mejorarlo para que sea más robusto. Por ejemplo, puedes agregar registro de errores o implementar estrategias de reintento. * **Configuración:** Considera agregar opciones de configuración para personalizar el comportamiento del servidor, como la lista de clases e IDs a eliminar, el estilo de encabezado Markdown, etc. Puedes usar variables de entorno o un archivo de configuración para esto. * **Escalabilidad:** Si planeas procesar muchas páginas web, considera usar un framework asíncrono como `asyncio` y `aiohttp` para mejorar el rendimiento. También puedes usar una cola de mensajes como RabbitMQ o Kafka para distribuir el trabajo entre varios servidores. * **Seguridad:** Si vas a exponer este servidor a Internet, asegúrate de implementar medidas de seguridad adecuadas, como la validación de la entrada del usuario y la protección contra ataques de denegación de servicio. * **Optimización para LLMs:** La limpieza del Markdown es importante para los LLMs. Asegúrate de eliminar cualquier ruido innecesario y de estructurar el contenido de manera clara y concisa. Considera agregar metadatos relevantes al Markdown, como el título de la página, la URL y la fecha de extracción. También puedes experimentar con diferentes estilos de Markdown para ver cuál funciona mejor con tu LLM. * **Robots.txt:** Respeta el archivo `robots.txt` del sitio web para evitar rastrear páginas que no están permitidas. Puedes usar la biblioteca `robotparser` para verificar si una URL está permitida antes de extraerla. Este es un punto de partida. La clave para que funcione bien es la adaptación a los sitios web específicos que quieres procesar. ¡Buena suerte!

image-tools-mcp

Image Tools MCP es un servicio de Protocolo de Contexto de Modelo (MCP) que recupera las dimensiones de imágenes y comprime imágenes desde URLs y archivos locales utilizando la API de TinyPNG. Admite la conversión de imágenes a formatos como webp, jpeg/jpg y png, proporcionando información detallada sobre el ancho, la altura, el tipo y la compresión.

MCP Human Loop Server

Un middleware inteligente que determina cuándo es necesaria la intervención humana en las operaciones de agentes de IA, utilizando un sistema de puntuación secuencial que evalúa múltiples dimensiones de una solicitud.

MCP Server Memos

Un paquete de Python que permite a los modelos LLM interactuar con el servidor Memos a través de la interfaz del Protocolo de Contexto del Modelo, permitiendo la búsqueda, creación, recuperación y gestión de memos.

Hex API MCP Server

Un servidor que permite a los asistentes de IA acceder, ver, ejecutar y administrar proyectos de Hex a través de una interfaz estandarizada.

LumbreTravel MCP Server

Facilita el acceso a la API de LumbreTravel para gestionar programas de viaje, actividades y entidades relacionadas a través de clientes MCP.

mcp-timeplus

Integración con Timeplus, una base de datos para datos en streaming, como Apache Kafka/Pulsar.