Caso: llamar a un LLM con LangChain

Cuando uno empieza a construir algo real con un modelo de lenguaje, enseguida aparece la misma necesidad repetida: armar un prompt con plantillas, llamar al modelo, parsear la salida, encadenar un paso con el siguiente. Podrías escribir todo eso a mano cada vez… o usar LangChain, la librería que se volvió estándar precisamente para no reinventar esa fontanería una y otra vez.

En este caso conectaremos LangChain con Claude, el modelo de Anthropic. La gracia es que LangChain es agnóstico: aprendes el patrón una vez y cambiar de proveedor es cambiar una línea.

Preparar el terreno

pip install langchain langchain-anthropic

Necesitas una clave de API de Anthropic en la variable de entorno ANTHROPIC_API_KEY (nunca la escribas dentro del código):

export ANTHROPIC_API_KEY="tu-clave-aqui"

La llamada más simple

Antes de encadenar nada, hagamos hablar al modelo. LangChain envuelve a Claude en una clase, ChatAnthropic:

from langchain_anthropic import ChatAnthropic

# claude-opus-4-8 es un modelo potente; para tareas simples y de bajo costo
# existen modelos más rápidos como Claude Haiku.
modelo = ChatAnthropic(model="claude-opus-4-8", max_tokens=1024)

respuesta = modelo.invoke("Explica qué es un vector en una sola frase.")
print(respuesta.content)

invoke es el verbo universal de LangChain: le das una entrada, te devuelve una salida. La respuesta es un objeto; el texto está en .content.

El verdadero valor: encadenar (LCEL)

Lo interesante de LangChain no es envolver una llamada, sino componer pasos con el operador |, como una tubería de Unix. A esto se le llama LCEL (LangChain Expression Language). Armemos una cadena que tome un tema, lo meta en una plantilla de prompt, llame al modelo y devuelva texto limpio:

from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

modelo = ChatAnthropic(model="claude-opus-4-8", max_tokens=512)

# La plantilla deja huecos ({tema}) que rellenaremos en cada llamada.
prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un profesor claro y directo. Respondes en 3 viñetas."),
    ("human", "Explícame: {tema}"),
])

parser = StrOutputParser()  # extrae el texto plano de la respuesta

# La tubería: prompt → modelo → parser. Se lee de izquierda a derecha.
cadena = prompt | modelo | parser

print(cadena.invoke({"tema": "el sobreajuste en machine learning"}))
print(cadena.invoke({"tema": "qué es un embedding"}))

Fíjate en lo que ganamos: la misma cadena sirve para cualquier tema, la plantilla separa la instrucción fija de lo variable, y el parser nos ahorra andar sacando .content a mano. Cambiar el comportamiento —otro tono, otro formato— es tocar la plantilla, no el código que la rodea.

Salidas estructuradas

Muchas veces no queremos texto libre, sino datos: un JSON con campos concretos para guardar en una base o pasar a otro sistema. LangChain se apoya en las mismas herramientas de Claude para forzar una estructura:

from pydantic import BaseModel, Field

class Analisis(BaseModel):
    sentimiento: str = Field(description="positivo, negativo o neutro")
    resumen: str = Field(description="resumen en una frase")

# with_structured_output ata la salida del modelo al esquema de Pydantic.
modelo_estructurado = modelo.with_structured_output(Analisis)

r = modelo_estructurado.invoke("El envío llegó tarde y el producto venía dañado.")
print(r.sentimiento)  # negativo
print(r.resumen)      # p. ej. "Retraso en la entrega y producto en mal estado."

En vez de recibir un párrafo y rezar por poder parsearlo, recibes un objeto con sentimiento y resumen garantizados. Este truco —pasar de texto suelto a datos fiables— es de lo que más se usa en producción.

¿Cuándo LangChain, cuándo no?

LangChain brilla cuando tu aplicación tiene muchos pasos: recuperar documentos, encadenar prompts, conectar varias fuentes, mantener memoria de conversación. Para eso trae piezas listas (incluido casi todo lo que necesitas para montar un sistema RAG). Si tu caso es una única llamada simple, quizás te sobre la librería y baste el SDK de Anthropic directo. La regla: usa la herramienta a la altura del problema.

Para llevar

LangChain estandariza la fontanería de trabajar con LLM: plantillas de prompt, llamadas al modelo, parseo y —sobre todo— encadenar pasos con el operador | (LCEL). Con ChatAnthropic conectas Claude en una línea, y con with_structured_output conviertes texto libre en datos tipados y fiables. Es la caja de herramientas para aplicaciones de varios pasos como RAG y los agentes; para una sola llamada, puede ser más de lo que necesitas.