Kuuli Technologies
English
Backend/API11 de junio de 2026 · 6 min de lectura

¿MCP o tool codificada en LangChain? Cuándo usar cada enfoque

No hay razón arquitectural para preferir una tool codificada sobre MCP dentro de un agente LangChain. El @tool es la interfaz; lo que hay dentro — MCP, REST, GraphQL — es un detalle de implementación.

La pregunta que confunde

"¿Tiene sentido usar MCP en un agente LangChain si ya puedo definir herramientas con @tool?" Esta pregunta asume que hay una elección arquitectural exclusiva entre los dos enfoques. No la hay. Son capas distintas que operan en niveles distintos y que pueden coexistir perfectamente — y en muchos casos, deberían.

El @tool de LangChain define la interfaz que el LLM ve: el nombre de la herramienta, su docstring y sus parámetros. Lo que ocurre dentro de esa función es completamente libre — puede llamar a una API REST, a GraphQL, a un cliente MCP, a una base de datos directamente, o a cualquier combinación de las anteriores.

La distinción clave: el @tool es la frontera entre el agente LangChain y el mundo exterior — la interfaz que el LLM usa para razonar. MCP (o cualquier otra tecnología) es el mecanismo de comunicación dentro de esa frontera.

Cómo funciona @tool por dentro

Cuando el LLM decide invocar una herramienta, LangChain ejecuta la función Python decorada con @tool. Esa función puede hacer cualquier cosa que Python permita. En el ejemplo siguiente, la misma interfaz de herramienta funciona con una llamada REST directa o con un cliente MCP:

Opción A: tool con llamada REST directa
@tool
def search_jira(query: str) -> str:
    """
    Busca tickets existentes en Jira.
    Invoca SIEMPRE antes de crear un ticket nuevo.
    """
    response = requests.get(
        f"{JIRA_BASE}/rest/api/2/search",
        params={"jql": f"text ~ '{query}'"},
        auth=(JIRA_USER, JIRA_TOKEN)
    )
    return format_results(response.json())
Opción B: misma tool, implementación con MCP
@tool
def search_jira(query: str) -> str:
    """
    Busca tickets existentes en Jira.
    Invoca SIEMPRE antes de crear un ticket nuevo.
    """
    # El cliente MCP encapsula auth, rate-limiting y retry
    client = MCPClient(server="jira-mcp-server")
    result = client.call("search_issues", {"query": query})
    return format_results(result)

El LLM ve exactamente la misma herramienta en ambos casos — mismo nombre, mismo docstring, mismos parámetros. La diferencia es completamente interna a la función Python. Cambiar de REST a MCP no requiere tocar nada del agente ni del chain de LangChain.

Cuándo usar MCP (y cuándo no)

Usa MCP cuando…

El servidor MCP ya existe y está mantenido (Jira MCP, GitHub MCP, etc.)
Quieres reutilizar el mismo servidor desde varios agentes distintos
El servidor MCP ya gestiona autenticación, rate-limiting o caché
Quieres desacoplar la lógica de integración del código del agente

Usa tool codificada cuando…

El MCP no existe o no está disponible para tu sistema objetivo
Necesitas lógica personalizada de transformación o manejo de errores
Quieres control fino sobre reintentos, timeouts y formatos de respuesta
La herramienta es específica de este agente y no necesitas reutilizarla

La decisión no es sobre pureza arquitectural — es sobre pragmatismo. ¿Ya existe un servidor MCP bien mantenido para la integración que necesitas? Úsalo. ¿Necesitas control fino que el MCP no proporciona? Codifica la tool directamente. Los dos enfoques son perfectamente válidos y pueden convivir en el mismo agente.

La capa de abstracción correcta

El patrón correcto es: el @tooles el contrato entre el agente y el mundo externo. Lo que hay dentro del @tool es un detalle de implementación que puede cambiar sin afectar al agente. Esta separación permite:

Migrar de REST a MCP (o viceversa) sin cambiar el agente ni sus tests
Probar el agente con mocks de las herramientas independientemente de las integraciones reales
Reutilizar el mismo servidor MCP desde múltiples tools de múltiples agentes
Añadir lógica de transformación, caché o manejo de errores sin cambiar la interfaz del agente

Anti-patrón: exponer el servidor MCP directamente al agente sin pasar por un @toolpersonalizado pierde la capacidad de añadir transformaciones, control de errores y docstrings precisos. El @tool es el lugar donde defines el comportamiento visible para el LLM — no lo saltes.

El takeaway

No hay razón arquitectural para preferir una tool codificada sobre MCP — son capas distintas.
El @tool es la interfaz que el LLM ve. La implementación dentro es un detalle libre.
MCP es la implementación correcta cuando el servidor ya existe, está mantenido y necesitas reutilizarlo.
Tool codificada es la correcta cuando necesitas control fino, lógica personalizada o el MCP no existe.
Los dos enfoques pueden coexistir en el mismo agente sin ningún problema arquitectural.

¿Quieres aplicar esto en tu equipo?

En Kuuli Technologies llevamos estas metodologías a equipos reales. Escríbenos si quieres una sesión de trabajo o una consultoría sobre agentes IA y SDD.