Servidores MCP: extender la IA con herramientas reales

Los grandes modelos de lenguaje son inteligentes. Pueden razonar, escribir, analizar y crear. Pero también están aislados. Por defecto, un LLM no puede mirar el clima de hoy, revisar tu base de datos, buscar en la web o leer un archivo de tu computadora. Solo sabe lo que estaba en sus datos de entrenamiento y lo que pegas en el prompt.

MCP — el Model Context Protocol — cambia eso. Es un estándar para conectar modelos de IA con herramientas externas. Piensa en ello como USB para IA: un enchufe universal que deja a cualquier modelo usar cualquier herramienta, siempre que ambos hablen el protocolo.

Cómo funciona MCP

El flujo es simple:

La idea clave: el LLM decide cuándo usar una herramienta. No escribes código que diga “si el usuario pregunta sobre GitHub, llama a la API de GitHub.” El modelo entiende la intención del usuario, reconoce que necesita datos externos, llama al servidor MCP apropiado, obtiene el resultado y lo incorpora en su respuesta.

Esto es lo que hace a MCP poderoso — y lo que lo hace diferente de las integraciones tradicionales de API donde un desarrollador tiene que anticipar cada posible flujo de trabajo.

Qué servidores MCP existen

Hay 117 servidores MCP disponibles en Zubnet. Aquí están las categorías y algunos destacados:

Herramientas de desarrollo

• GitHub — buscar repos, crear/leer/cerrar issues, listar PRs, leer contenido de archivos, crear ramas
• GitLab — similar a GitHub, para proyectos alojados en GitLab
• Linear — crear y gestionar issues, leer estado de proyectos
• Sentry — buscar errores, leer stack traces, resolver issues

Bases de datos

• PostgreSQL — ejecutar queries de lectura contra tu BD Postgres
• MySQL — igual para MySQL/MariaDB
• SQLite — consultar archivos SQLite locales
• Redis — leer claves, escanear patrones

Búsqueda e investigación

• Brave Search — búsqueda web sin tracking
• Exa — búsqueda semántica a través de la web
• ArXiv — buscar papers académicos
• Wikipedia — consultar conocimiento enciclopédico

Sistemas de archivos y almacenamiento

• Filesystem — leer, escribir, listar y buscar archivos en un directorio especificado
• Google Drive — buscar y leer documentos desde Drive
• S3 — listar y leer objetos desde buckets AWS S3

Comunicación

• Slack — leer canales, enviar mensajes, buscar historial
• Discord — leer y enviar mensajes en servidores
• Email — leer y redactar correos vía IMAP/SMTP

Datos y APIs

• Fetch — hacer peticiones HTTP a cualquier URL
• Puppeteer — navegar páginas web, tomar capturas, extraer contenido
• Google Maps — geocodificación, direcciones, búsqueda de lugares

Navega la lista completa en nuestra MCP Store.

Configuración para Claude Desktop

Claude Desktop soporta MCP nativamente. Para conectar un servidor, agregas su configuración al archivo de config de Claude. En la MCP Store de Zubnet, cada servidor tiene un botón de copiar de un clic para esta config exacta.

El archivo de config vive en:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Así se ve una config con dos servidores MCP:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "your_brave_key_here"
      }
    }
  }
}

Guarda el archivo, reinicia Claude Desktop, y las herramientas aparecen automáticamente. Claude las usará cuando sean relevantes a tu conversación.

Configuración para Cursor

Cursor (el editor de código IA) también soporta MCP. La config va en el archivo .cursor/mcp.json de tu proyecto:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y", "@modelcontextprotocol/server-filesystem",
        "/path/to/your/project"
      ]
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_CONNECTION_STRING": "postgresql://user:pass@localhost/mydb"
      }
    }
  }
}

Esto le da a la IA de Cursor la capacidad de leer tus archivos de proyecto y consultar tu base de datos — haciéndola dramáticamente mejor entendiendo tu codebase y respondiendo preguntas sobre tus datos.

Configuración en Zubnet

Para agentes corriendo en la plataforma Zubnet, la configuración de servidores MCP es aún más simple:

1. Ve al MCP Store

2. Encuentra el servidor que quieres (ej., GitHub)

3. Clic en “Activar”

4. Ingresa la configuración requerida (claves API, URLs, etc.)

5. Conéctalo a tu agente

El servidor corre en nuestra infraestructura. Sin instalación local, sin npx, sin Node.js requerido. Solo funciona.

Esquemas de config: lo que cada servidor necesita

Cada servidor MCP necesita alguna configuración. Los patrones más comunes:

Cómo la IA decide usar herramientas

Esta es la parte que se siente como magia. No escribes reglas. El LLM lo averigua.

Cuando preguntas “¿qué issues abiertos tenemos en GitHub?”, el modelo reconoce que:

1. Esto requiere datos que no tiene (tus issues específicos de GitHub)
2. Una herramienta de GitHub está disponible
3. La función list_issues con state=open es la llamada correcta

Construye la llamada a herramienta, la envía al servidor MCP, obtiene la respuesta JSON y luego la resume en lenguaje natural.

Para tareas multi-paso, el modelo encadena llamadas a herramientas. “Encuentra el issue abierto más comentado y publica un resumen en #dev-chat de Slack” podría involucrar:

1. github.list_issues(state=open, sort=comments)
2. github.get_issue(number=142) (para detalles completos)
3. slack.post_message(channel=#dev-chat, text=...)

Tres llamadas a herramientas, orquestadas automáticamente. Sin código escrito.

Consideraciones de seguridad

Construyendo tu propio servidor MCP

La especificación MCP es abierta. Si la herramienta que necesitas no existe aún, puedes construirla. Un servidor MCP es un programa que:

1. Declara sus herramientas disponibles (nombre, descripción, esquema de parámetros)
2. Maneja peticiones de llamadas a herramientas
3. Devuelve resultados estructurados

El SDK oficial está disponible en TypeScript y Python. Un servidor mínimo en TypeScript son unas 50 líneas de código. La especificación y los SDKs están en modelcontextprotocol.io.

Si construyes un servidor que otros podrían encontrar útil, considera publicarlo al ecosistema MCP. La comunidad crece cada semana.

Cuándo usar MCP vs. llamadas API regulares

MCP no siempre es la respuesta correcta. Úsalo cuando:

• Quieres que la IA decida cuándo llamar servicios externos (flujos dinámicos, guiados por el usuario)
• Estás construyendo agentes que necesitan acceso a herramientas
• Quieres una interfaz estándar a través de muchas herramientas (un protocolo, 117 servidores)

Usa llamadas API regulares cuando:

• El flujo es determinista (siempre llamar esta API, luego esa)
• Necesitas control preciso sobre cada petición
• El rendimiento es crítico y no puedes permitirte el bucle de decisión del LLM

---

Navega los 117 servidores MCP en nuestra MCP Store. Configuraciones de un clic para Claude Desktop y Cursor. O actívalos directamente para tus agentes de Zubnet.