MCP (Model Context Protocol): conecta Claude con tus herramientas en menos de 30 minutos

El problema que nadie te cuenta sobre los asistentes de IA

Tienes Claude abierto en una pestaña, tu base de datos en otra, tu gestor de tareas en una tercera y tu repositorio de código en una cuarta. Copias y pegas contexto manualmente entre ellos. Eso no es productividad asistida por IA; eso es trabajo manual con pasos extra.

El Model Context Protocol (MCP) es la solución a ese problema. Es un estándar abierto desarrollado por Anthropic que permite a Claude conectarse directamente con tus herramientas externas: bases de datos, APIs, sistemas de archivos, servicios web y prácticamente cualquier fuente de datos que puedas imaginar. En lugar de que tú lleves el contexto al modelo, el modelo va a buscar el contexto donde vive.

Por qué MCP cambia la forma en que trabajas con LLMs

Antes de MCP, integrar un LLM con herramientas externas requería construir cadenas complejas con frameworks como LangChain o LlamaIndex: parsers, adaptadores, gestión de estado, manejo de errores. El tiempo de setup para una integración básica podía superar fácilmente las 8-10 horas.

MCP estandariza esa capa de integración. Define un protocolo cliente-servidor donde:

• El host es la aplicación que ejecuta el LLM (Claude Desktop, por ejemplo).
• El cliente MCP gestiona la comunicación entre el host y los servidores.
• Los servidores MCP exponen recursos, herramientas y prompts a través de una interfaz unificada.

El resultado: Claude puede leer archivos de tu sistema, consultar tu base de datos PostgreSQL o ejecutar búsquedas en tiempo real sin que tú copies ni una línea de texto manualmente.

Guía paso a paso: tu primer servidor MCP en 30 minutos

Vamos a construir un servidor MCP que permite a Claude leer y escribir en archivos locales. Usaremos Python y el SDK oficial de Anthropic.

Paso 1: Instala las dependencias

pip install mcp anthropic

Paso 2: Crea el servidor MCP

Crea un archivo llamado file_server.py con el siguiente contenido:

from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp import types
import asyncio
import os

app = Server("file-manager")

@app.list_tools()
async def list_tools() -> list[types.Tool]:
    return [
        types.Tool(
            name="read_file",
            description="Lee el contenido de un archivo local",
            inputSchema={
                "type": "object",
                "properties": {
                    "path": {"type": "string", "description": "Ruta del archivo"}
                },
                "required": ["path"]
            }
        ),
        types.Tool(
            name="write_file",
            description="Escribe contenido en un archivo local",
            inputSchema={
                "type": "object",
                "properties": {
                    "path": {"type": "string"},
                    "content": {"type": "string"}
                },
                "required": ["path", "content"]
            }
        )
    ]

@app.call_tool()
async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
    if name == "read_file":
        with open(arguments["path"], "r", encoding="utf-8") as f:
            return [types.TextContent(type="text", text=f.read())]
    elif name == "write_file":
        with open(arguments["path"], "w", encoding="utf-8") as f:
            f.write(arguments["content"])
        return [types.TextContent(type="text", text=f"Archivo guardado en {arguments['path']}")]

async def main():
    async with stdio_server() as (read_stream, write_stream):
        await app.run(read_stream, write_stream, app.create_initialization_options())

if __name__ == "__main__":
    asyncio.run(main())

Paso 3: Registra el servidor en Claude Desktop

Abre el archivo de configuración de Claude Desktop. En macOS está en:

~/Library/Application Support/Claude/claude_desktop_config.json

Añade tu servidor al objeto mcpServers:

{
  "mcpServers": {
    "file-manager": {
      "command": "python",
      "args": ["/ruta/absoluta/a/file_server.py"]
    }
  }
}

Reinicia Claude Desktop. Verás un icono de herramientas en la interfaz que confirma que el servidor MCP está activo.

Paso 4: Prueba la integración con prompts reales

Una vez conectado, puedes pedirle a Claude directamente:

• "Lee el archivo /Users/tu_usuario/notas.txt y resúmelo en 5 puntos"
• "Analiza el código en /proyectos/app/main.py y sugiere mejoras de rendimiento"
• "Crea un archivo informe.md en mi escritorio con un análisis de las métricas que te voy a pasar"

Claude invocará las herramientas automáticamente sin que tengas que indicarle cómo hacerlo. Esa es la potencia del protocolo: el modelo decide cuándo y cómo usar cada herramienta según el contexto de la conversación.

Qué más puedes conectar con MCP

El ecosistema de servidores MCP ya incluye integraciones mantenidas por la comunidad para:

• Bases de datos: PostgreSQL, SQLite, MongoDB
• Productividad: GitHub, Notion, Linear, Jira
• Búsqueda: Brave Search, DuckDuckGo
• Cloud: AWS, Google Drive, Slack

Puedes encontrar el repositorio oficial de servidores en github.com/modelcontextprotocol/servers. La mayoría se instalan con un único comando npm o uvx y se configuran en menos de 5 minutos.

El siguiente paso: construye servidores MCP específicos para tu flujo de trabajo

El servidor de archivos que acabas de construir es el punto de entrada. La verdadera productividad llega cuando diseñas servidores MCP alrededor de los datos y procesos propios de tu organización: conectar Claude con tu CRM, con los logs de producción, con tu pipeline de datos o con tu documentación interna.

La pregunta que debes hacerte no es "¿para qué sirve MCP?", sino "¿cuántas horas a la semana pierdo copiando contexto entre herramientas?". Esa cifra es exactamente lo que MCP puede devolverte.