LangChain para Principiantes: Construye Tu Primer Agente de IA

LangChain es el framework más popular para construir aplicaciones de inteligencia artificial en producción. Si ya usas la API de OpenAI directamente, LangChain te llevará al siguiente nivel: agentes que buscan en internet, leen tus documentos y ejecutan tareas complejas.

¿Qué es LangChain?

LangChain es un framework open-source en Python (y JavaScript) que simplifica la construcción de aplicaciones con LLMs. En lugar de manejar manualmente prompts, memoria y herramientas, LangChain lo abstrae todo con componentes reutilizables.

Problemas que resuelve:

• Dar memoria a la IA entre conversaciones
• Conectar la IA a tus documentos y bases de datos
• Construir agentes que usan herramientas (búsqueda web, calculadora, APIs)
• Encadenar múltiples llamadas a IA en pipelines

Instalación

pip install langchain langchain-openai langchain-community chromadb python-dotenv

Crea un archivo .env:

OPENAI_API_KEY=tu-api-key-aqui

Conceptos Fundamentales

Models (Modelos)

LangChain envuelve cualquier LLM con la misma interfaz:

from langchain_openai import ChatOpenAI

model = ChatOpenAI(model="gpt-4o-mini", temperature=0)

Prompt Templates

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un experto en {tema}."),
    ("user", "{pregunta}")
])

Chains (Cadenas)

LangChain Expression Language (LCEL) conecta componentes con |:

from langchain_core.output_parsers import StrOutputParser

chain = prompt | model | StrOutputParser()
resultado = chain.invoke({"tema": "Python", "pregunta": "¿Qué son los decoradores?"})

Añadir Memoria a Tu Chatbot

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import HumanMessage, AIMessage

model = ChatOpenAI(model="gpt-4o-mini")

prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente útil."),
    MessagesPlaceholder(variable_name="historial"),
    ("user", "{input}")
])

chain = prompt | model
historial = []

def chat(mensaje: str) -> str:
    respuesta = chain.invoke({
        "historial": historial,
        "input": mensaje
    })
    historial.append(HumanMessage(content=mensaje))
    historial.append(AIMessage(content=respuesta.content))
    return respuesta.content

print(chat("Hola, me llamo Carlos"))
print(chat("¿Cómo me llamo?"))  # ¡Recuerda!

Sistema RAG: IA que Responde desde Tus Documentos

RAG (Retrieval-Augmented Generation) conecta la IA a tu propio conocimiento:

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_core.documents import Document
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough

# Tus documentos
documentos = [
    Document(page_content="LearnGeni ofrece 30 guías de IA por $5 cada una."),
    Document(page_content="Los usuarios tienen acceso de por vida tras la compra."),
]

# Base de datos vectorial
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(documentos, embeddings)
retriever = vectorstore.as_retriever()

# Chain RAG
prompt = ChatPromptTemplate.from_template("""
Responde usando el contexto:

Contexto: {contexto}
Pregunta: {pregunta}
""")

model = ChatOpenAI(model="gpt-4o-mini")

chain = (
    {"contexto": retriever, "pregunta": RunnablePassthrough()}
    | prompt
    | model
)

resultado = chain.invoke("¿Cuánto cuestan las guías de LearnGeni?")
print(resultado.content)

Tu Primer Agente con Herramientas

Un agente puede decidir qué herramientas usar y en qué orden:

from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.tools import tool

@tool
def obtener_clima(ciudad: str) -> str:
    """Obtiene el clima de una ciudad."""
    return f"El clima en {ciudad}: 22°C, soleado"

@tool
def calcular(expresion: str) -> str:
    """Calcula una expresión matemática."""
    try:
        return str(eval(expresion))
    except:
        return "Error en el cálculo"

herramientas = [obtener_clima, calcular]
model = ChatOpenAI(model="gpt-4o", temperature=0)

prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente que puede usar herramientas."),
    ("user", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

agente = create_tool_calling_agent(model, herramientas, prompt)
executor = AgentExecutor(agent=agente, tools=herramientas, verbose=True)

resultado = executor.invoke({"input": "¿Qué clima hace en Madrid? ¿Y cuánto es 15 × 23?"})
print(resultado["output"])

LangGraph: Para Flujos Complejos

Para workflows con múltiples pasos y lógica condicional:

from langgraph.graph import StateGraph, END
from typing import TypedDict

class Estado(TypedDict):
    mensajes: list
    siguiente: str

def investigar(estado):
    return {**estado, "siguiente": "escribir"}

def escribir(estado):
    return {**estado, "siguiente": END}

flujo = StateGraph(Estado)
flujo.add_node("investigar", investigar)
flujo.add_node("escribir", escribir)
flujo.set_entry_point("investigar")
flujo.add_edge("investigar", "escribir")
flujo.add_edge("escribir", END)

app = flujo.compile()

Próximos Pasos

Después de dominar LangChain, estudia:

1. LangSmith — monitoreo y debugging
2. RAG avanzado — reranking, HyDE, parent-child chunks
3. Agentes multi-paso — planificación y ejecución autónoma

---

¿Quieres aprender LangChain desde cero hasta nivel avanzado? La guía completa de LearnGeni incluye proyectos reales, código ejecutable y los mejores patrones de 2026. Ver todas las guías.