Usas Claude o ChatGPT todos los días. Ya le agarraste la onda — prompts, seguimientos, toda la coreografía. Pero cada vez que necesitas datos del CRM de tu empresa, del project tracker o de la base de datos interna, te conviertes en un cable USB humano: copiar de la pestaña A del navegador, pegar en la pestaña B del chatbot, repetir hasta que el alma te abandone el cuerpo.

Lo que la mayoría de los tutoriales no te dicen de frente: la brecha entre "IA que conoce internet" e "IA que conoce tu negocio" es exactamente un archivo de Python. No una migración de plataforma. No un contrato millonario con un vendor. Un solo archivo con un decorador y un docstring. El protocolo ya existe, todas las empresas grandes de IA ya lo adoptaron, y lo puedes conectar en una tarde. Te muestro cómo.

Por qué las respuestas obvias no funcionan

"Solo usa la API" — excelente consejo, excepto que tu IA no tiene manos. No puede llamar la API REST de tu empresa (una URL que devuelve datos cuando le pides amablemente) por su cuenta. Podrías pegar la documentación de la API en el chat, pero eso devora tu ventana de contexto — cuánto texto puede "ver" la IA a la vez, su memoria de trabajo — y sigues siendo tú el que copia y pega. Las integraciones estilo Zapier existen, pero son rígidas: triggers predefinidos, acciones predefinidas, y una página de precios que hace llorar a tu director de finanzas.

Lo que realmente necesitas es una forma de dejar que tu IA descubra y llame tus herramientas internas directamente — sin que tú seas el intermediario.

MCP: el estándar que resolvió esto

MCP (Model Context Protocol) es un estándar universal de conexión para herramientas de IA — piensa en USB-C, pero para conectar IA con tus datos. Anthropic lo liberó como open source en noviembre de 2024. Para marzo de 2026, alcanzó 97 millones de descargas mensuales del SDK. OpenAI, Google y Microsoft lo adoptaron. Al 26 de abril de 2026, más de 17,000 servidores MCP están indexados en los registros.

El SDK de Python te permite construir un servidor funcional en un solo archivo. Así es como.

Paso 1: Instala el SDK

Necesitas Python 3.10+ y ya sea uv (el gestor de paquetes recomendado por Anthropic) o el clásico pip.

# Opción A: uv (recomendado)
uv init my-mcp-server && cd my-mcp-server
uv add "mcp[cli]" httpx

# Opción B: pip
pip install "mcp[cli]" httpx

httpx es una librería HTTP de Python — es lo que tu servidor usa para obtener datos de APIs externas. Si tus datos viven en una base de datos, cámbiala por el driver de tu base de datos.

Paso 2: Escribe el servidor

Crea server.py. Aquí tienes un servidor MCP completo que obtiene alertas meteorológicas del Servicio Nacional de Meteorología de EE.UU. — una API real, sin clave de autenticación, perfecta para aprender:

from typing import Any
import httpx
from mcp.server.fastmcp import FastMCP

# FastMCP — un wrapper de alto nivel que convierte
# funciones Python normales en herramientas MCP
mcp = FastMCP("weather")

NWS_API_BASE = "https://api.weather.gov"

async def make_request(url: str) -> dict[str, Any] | None:
    headers = {
        "User-Agent": "mcp-weather-demo/1.0",
        "Accept": "application/geo+json",
    }
    async with httpx.AsyncClient() as client:
        try:
            response = await client.get(
                url, headers=headers, timeout=30.0
            )
            response.raise_for_status()
            return response.json()
        except Exception:
            return None

@mcp.tool()
async def get_alerts(state: str) -> str:
    """Get active weather alerts for a US state.

    Args:
        state: Two-letter US state code (e.g. CA, NY)
    """
    data = await make_request(
        f"{NWS_API_BASE}/alerts/active/area/{state}"
    )
    if not data or "features" not in data:
        return "No alerts found."

    alerts = []
    for feature in data["features"][:5]:
        props = feature["properties"]
        alerts.append(
            f"Event: {props.get('event', 'Unknown')}\n"
            f"Area: {props.get('areaDesc', 'Unknown')}\n"
            f"Severity: {props.get('severity', 'Unknown')}"
        )
    return "\n---\n".join(alerts) or "No active alerts."

if __name__ == "__main__":
    mcp.run(transport="stdio")

Unas 40 líneas de código real. El decorador @mcp.tool() — un atajo de Python que registra tu función como una herramienta que la IA puede llamar — hace el trabajo pesado. FastMCP lee tus type hints (state: str) y el docstring (la descripción entre comillas triples) para generar automáticamente las definiciones de herramientas que la IA entiende.

Este es el patrón central. Cada servidor MCP que hayas visto — Slack, GitHub, Figma, los más de 17,000 — es este mismo esqueleto con más endpoints.

Paso 3: Conéctalo a Claude Desktop

Claude Desktop lee un archivo de configuración JSON (un archivo de ajustes en un formato específico) para saber qué servidores MCP lanzar. Encuéntralo en:

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

Créalo o edítalo:

{
  "mcpServers": {
    "weather": {
      "command": "uv",
      "args": [
        "--directory",
        "/ruta/absoluta/a/my-mcp-server",
        "run",
        "server.py"
      ]
    }
  }
}

Reemplaza /ruta/absoluta/a/my-mcp-server con la ruta completa real. Las rutas relativas no funcionan — esto es lo primero que hace tropezar a todo el mundo.

Reinicia Claude Desktop. Busca el ícono del martillo en la esquina inferior derecha del campo de texto del chat. Haz clic — deberías ver get_alerts en la lista. Si no aparece, revisa ~/Library/Logs/Claude/mcp*.log en macOS para ver los errores.

Paso 4: Pregúntale algo a Claude

Escribe: "¿Hay alertas meteorológicas en California ahorita?"

Claude reconoce que tiene una herramienta get_alerts, te pide permiso para llamarla, consulta tu servidor y responde con datos en vivo del NWS que no podía acceder hace cinco minutos.

Ese es el momento "ajá". Tu chatbot dejó de ser genérico.

Paso 5: Reemplaza la API del clima con la tuya

Ahora cambia make_request por cualquier API que tu equipo use — Jira, Linear, tu dashboard interno. Si tiene un endpoint que devuelve datos, está a una función de convertirse en una herramienta de IA. El patrón siempre es:

  1. Escribe una función async que obtenga datos
  2. Decórala con @mcp.tool()
  3. Escribe un docstring claro (más adelante te explico por qué esto importa tanto)
  4. Agrégala a tu configuración, reinicia

Algunos principios de diseño que separan las herramientas MCP útiles de las frustrantes: nombra tus herramientas con pares verbo-sustantivo (get_alerts, search_tickets, create_issue) para que el modelo pueda inferir la intención solo por el nombre. Mantén cada herramienta enfocada en una sola acción — una función que busca, filtra y escribe de vuelta son tres herramientas disfrazadas de una. Y para el diseño de parámetros, prefiere argumentos tipados y explícitos sobre strings genéricos; state: str con un docstring que dice "Código de estado de EE.UU. de dos letras" le da al modelo suficiente información para validar su propia entrada.

Trampas que te van a morder

1. La descripción de tu herramienta ES el producto

Un estudio de la Queen's University de febrero de 2026 analizó 856 herramientas MCP en 103 servidores. Resultado: el 97.1% de las descripciones de herramientas tenía al menos un defecto de calidad. El 56% ni siquiera lograba articular su propósito. Cuando los investigadores mejoraron las descripciones, las tasas de éxito de las tareas subieron +5.85 puntos porcentuales. Tu docstring no es documentación — es la interfaz de usuario que tu IA lee. Escríbelo como una especificación de producto: propósito, explicación de parámetros, limitaciones, ejemplos.

2. Nunca uses print() a stdout

Para servidores basados en stdio (lo que usa Claude Desktop), escribir a stdout corrompe los mensajes JSON-RPC — el protocolo que tu IA y servidor usan para comunicarse. Tu servidor se rompe silenciosamente y pasas 45 minutos mirando la nada. Usa print("debug", file=sys.stderr) o el módulo logging de Python.

3. La seguridad es TU responsabilidad

MCP no tiene autenticación integrada para servidores locales. Eso está bien cuando corre en tu laptop vía stdio — es solo un proceso local. Pero en el momento en que consideres exponerlo por HTTP: detente. El OWASP MCP Top 10, publicado a principios de 2026, existe porque la gente se saltó este paso. Más de treinta CVEs cayeron contra herramientas MCP solo en enero-febrero de 2026. FastMCP mismo tuvo una vulnerabilidad de inyección de comandos (CVE-2025-64340, divulgada a finales de 2025) en todas las versiones anteriores a la 3.2.0.

Si tu servidor toca APIs internas, trátalo como cualquier servicio backend: valida cada input que el modelo envíe (va a alucinar valores de parámetros — dalo por hecho), aplica el principio de menor privilegio para que cada herramienta solo pueda acceder a los datos que necesita, y fija las versiones de tus dependencias. Stdio local es el único default seguro hasta que hayas resuelto la autenticación como se debe.

4. La ruta en la config debe ser absoluta

Las rutas relativas en claude_desktop_config.json fallan silenciosamente. Sin error, sin log, solo un ícono de martillo ausente y un desarrollador perdiendo la fe poco a poco. Usa /Users/tunombre/... en macOS — la expansión del tilde no es confiable aquí.

Lo que puedes hacer ahora

Ya tienes un patrón replicable. Cualquier API que tu equipo ya use — project tracker, CRM, dashboard interno, base de datos — está a un archivo de Python de convertirse en algo que tu IA puede consultar directamente. Sin lista de espera de integración con vendors. Sin impuesto de Zapier. Sin más copy-paste entre pestañas como si estuviéramos en 2019.

El muro entre "IA que conoce internet" e "IA que conoce tu negocio" ahora tiene una puerta. La construiste en menos líneas que un archivo de configuración típico.