Introducción a LangChain

Qué es LangChain

LangChain es un framework orientado a construir aplicaciones completas con modelos de lenguaje, tomando como pieza central el concepto de agente. En lugar de limitarse a enviar peticiones sueltas a una API, LangChain proporciona una arquitectura para definir qué objetivo tiene el agente, qué herramientas puede usar y cómo debe razonar paso a paso hasta conseguir un resultado útil.

Una aplicación de IA moderna rara vez es solo “un prompt y una respuesta”, sino una combinación de razonamiento, llamadas a distintos servicios, lectura de documentos y validaciones. LangChain organiza todo esto en componentes bien definidos para que puedas evolucionar tu aplicación sin ir acumulando código difícil de mantener.

Agentes como unidad central

En la versión actual de LangChain, los agents son el punto de entrada habitual para muchas aplicaciones. Un agente recibe una tarea en lenguaje natural, acceso a uno o varios modelos de lenguaje y una colección de herramientas (por ejemplo, una búsqueda en base de datos, una calculadora o una API interna), y decide de forma autónoma qué pasos seguir.

El agente utiliza el modelo de lenguaje no solo para generar texto, sino para planificar, elegir qué herramientas invocar, interpretar los resultados y combinar todo ello en una respuesta final. Esto permite pasar de un simple chat a un asistente que puede consultar sistemas internos, ejecutar operaciones y justificar sus decisiones.

De forma conceptual, un agente en LangChain se apoya en:

• 1. Un modelo de chat estandarizado: una interfaz común para proveedores como OpenAI o Anthropic, que expone operaciones como invoke o stream.
• 2. Un conjunto de herramientas: funciones o servicios externos descritos de forma estructurada para que el modelo pueda llamarlos de manera segura.
• 3. Un bucle de razonamiento: lógica que combina la salida del modelo y de las herramientas para avanzar hacia el objetivo.

Gracias a esta estructura, puedes centrarte en diseñar qué debe poder hacer tu agente en lugar de ocuparte de detalles de bajo nivel de cada API.

Relación con otros componentes del ecosistema

Aunque el foco está en los agentes, LangChain se apoya en otros bloques importantes del ecosistema. Los modelos proporcionan la capacidad de lenguaje, los retrievers y almacenes vectoriales permiten buscar información relevante en documentos, y las herramientas conectan el agente con el mundo externo.

Para orquestar flujos complejos y persistentes, LangChain se apoya en LangGraph, que permite describir grafos de estados y transiciones entre nodos. Para observar lo que ocurre en producción y evaluar la calidad de las respuestas, se integra con LangSmith, que ofrece trazas detalladas y experimentos controlados.

En conjunto, LangChain actúa como la capa de aplicación sobre los modelos de lenguaje: por debajo sigues usando los proveedores habituales, pero por encima dispones de una estructura coherente para construir productos reales.

LangChain vs no usar SDK

Cuando hablamos de “no usar SDK” nos referimos a comunicarse con los proveedores de IA directamente vía peticiones HTTP (por ejemplo, con la librería requests en Python) contra los endpoints de OpenAI, Anthropic u otros. Este enfoque da control total sobre el formato de la petición, pero también te obliga a gestionar manualmente muchos detalles que se repiten en todos los proyectos.

Llamar a la API a mano con requests

Supongamos que quieres hacer una llamada básica al endpoint de chat de un proveedor usando solo requests. Podrías escribir algo como esto:

import os
import requests

API_KEY = os.environ["OPENAI_API_KEY"]

def responder_pregunta(pregunta: str) -> str:
    url = "https://api.openai.com/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
    }
    payload = {
        "model": "gpt-4.1-mini",
        "messages": [
            {"role": "system", "content": "Responde de forma clara y breve"},
            {"role": "user", "content": pregunta},
        ],
    }
    response = requests.post(url, headers=headers, json=payload, timeout=30)
    response.raise_for_status()
    data = response.json()
    return data["choices"][0]["message"]["content"]

Este enfoque funciona, pero tú eres responsable de toda la infraestructura alrededor de la llamada: gestionar errores, reintentos, límites de uso, cambios de versión de la API, formatos de mensajes y cualquier variación entre proveedores. En cuanto necesitas streaming, herramientas, recuperación de contexto o trazas, el código crece y se distribuye por distintas partes de tu proyecto.

Además, si decides probar otro proveedor, como Anthropic, tendrás que reescribir buena parte de la lógica de peticiones: endpoints diferentes, estructura JSON distinta, campos de seguridad propios y nuevas formas de representar los mensajes.

Qué aporta LangChain por encima de requests

LangChain se sitúa por encima de estas llamadas HTTP y las encapsula detrás de interfaces estandarizadas. Internamente seguirá utilizando los SDK o las APIs HTTP de cada proveedor, pero desde tu código trabajarás siempre con las mismas operaciones y tipos de objetos.

Algunas ventajas clave de usar LangChain en lugar de peticiones manuales son:

• 1. Interfaz de modelo unificada: en lugar de construir y parsear JSON para cada proveedor, trabajas con una interfaz común de modelo de chat. Cambiar de OpenAI a Anthropic o a otro proveedor compatible suele implicar solo cambiar la inicialización del modelo.

• 2. Agentes como capa de orquestación: LangChain ofrece un patrón claro para definir agents que pueden llamar a herramientas, consultar documentos y razonar en varios pasos, sin que tengas que implementar tú mismo el bucle de planificación y ejecución.

• 3. Integración con herramientas y RAG: la conexión con bases de datos, buscadores o almacenes vectoriales se hace mediante integraciones ya preparadas que implementan las mismas interfaces. No necesitas reinventar cómo se describen ni cómo se conectan al modelo.

• 4. Observabilidad y evaluación: con la integración con LangSmith, cada ejecución queda registrada con sus inputs, outputs, prompts, errores y tiempos, lo que facilita depurar y mejorar la aplicación sin añadir código de logging a mano en todos los puntos.

• 5. Aislamiento frente a cambios de API: al apoyarte en las abstracciones de langchain-core, los cambios de bajo nivel en las APIs HTTP de cada proveedor impactan menos en tu código de aplicación, ya que se mantienen en la capa de integración.

Un ejemplo simplificado usando LangChain para el mismo caso anterior podría ser:

from langchain_openai import ChatOpenAI

modelo = ChatOpenAI(model="gpt-4.1-mini")

def responder_pregunta(pregunta: str) -> str:
    return modelo.invoke(pregunta)

Aquí no te ocupas de cabeceras HTTP, endpoints, serialización ni parsing de respuestas. Estás trabajando con un objeto de modelo que se integra directamente con agentes, herramientas y trazas, y que podrías sustituir por otro proveedor compatible cambiando solo su construcción.

De una llamada aislada a un agente completo

La diferencia se hace más evidente cuando pasas de una llamada aislada a un agente que puede usar herramientas. Aunque en esta introducción no entraremos en detalle, a alto nivel el patrón en LangChain sería algo como:

from langchain_openai import ChatOpenAI
from langchain.agents import create_agent

modelo = ChatOpenAI(model="gpt-4.1-mini")
tools = [...]  # Lista de herramientas definidas en tu aplicación

agent = create_agent(modelo, tools)

resultado = agent.invoke("Analiza las ventas del último mes y dime si hay anomalías")

En este esquema, LangChain se encarga de coordinar las llamadas al modelo y a las herramientas, de mantener el contexto de la conversación y de devolver un resultado coherente. Con peticiones HTTP manuales tendrías que implementar tú todo este flujo de razonamiento, gestión de estado y manejo de errores.

En resumen, trabajar a bajo nivel con requests puede ser útil para comprender cómo funcionan las APIs de los proveedores, pero a la hora de construir aplicaciones mantenibles y extensibles, LangChain ofrece una capa de abstracción orientada a agentes que reduce complejidad, mejora la portabilidad y facilita la observabilidad desde el primer día.