Componentes principales de LangChain

Antes de trabajar con pipelines avanzados o LCEL, necesitas dominar los bloques fundamentales de LangChain. Aquí entiendes qué componentes existen y cómo encajan entre sí.

Componentes principales de LangChain

LangChain no es una sola cosa, es un ecosistema de componentes. Los principales son:

• Documents
• Chains
• Agents
• Language model (LLMs)
  • Chat Model
  • Embedding Models
• Chat Message
• Prompt Templates
• Output Parsers

Modelos de Lenguaje

Son la base de los LLMs, reciben y generan texto. Sirven para generar contenido, resumir documentos y completar tareas. LangChain utiliza OpenAI, Google, Meta e IBM como lenguajes primarios.

Los modelos se pueden personalizar ajustando parámetros que modifican su forma de responder, algunos son:

• temperature: Aleatoriedad del modelo, más temperura = más creatividad.
• max_tokens: Longitud máxima de la respuesta en tokens
• top_p: Diversidad de palabras considerando la probabilidad acumulada.
• top_k: Diversidad de palabras considerando la frecuencia
• frequency_penalty: Penalización de frecuencia
• presence_penalty: Penalización de presencia

Modelos de Chat

Son una evolución de los LLM tradicionales. Convierten texto plano en conversaciones estructuradas, entienden contexto y mantienen coherencia entre mensajes.

Embedding Models

Estos modelos no generan texto. Su única función es transformar contenido en vectores (listas de números) que representan el significado semántico.

Se utilizan exclusivamente para RAG (Retrieval Augmented Generation). Sirven para buscar información en bases de datos vectoriales comparando qué tan “cerca” está la pregunta del usuario de tus documentos.

Cargar un modelo:

from langchain_openai import ChatOpenAI

# Cargar variables de entorno
load_dotenv()

# Crear modelo directamente
llm = ChatOpenAI(
    model="deepseek-chat",
    openai_api_key=os.getenv("DEEPSEEK_API_KEY"),
    openai_api_base="https://api.deepseek.com",

    # Parámetros de generación
    temperature=0.3,
    max_tokens=100,
    top_p=0.9,
    frequency_penalty=0.2,
    presence_penalty=0.1
)

from langchain_openai import ChatOpenAI

# Cargar variables de entorno
load_dotenv()

# Crear modelo directamente
llm = ChatOpenAI(
    model="deepseek-chat",
    openai_api_key=os.getenv("DEEPSEEK_API_KEY"),
    openai_api_base="https://api.deepseek.com",

    # Parámetros de generación
    temperature=0.3,
    max_tokens=100,
    top_p=0.9,
    frequency_penalty=0.2,
    presence_penalty=0.1
)

En la variable llm se carga el modelo que después se llama con el método .invoke()

response = llm.invoke(messages)
print(response.content)

response = llm.invoke(messages)
print(response.content)

Mensajes de chat

Un modelo de chat no trabaja con texto plano, sino con mensajes estructurados. Cada tipo de mensaje tiene un rol (quién habla) y un contenido (qué dice).

Tipos de mensajes

• "system"→ define comportamiento y contexto del modelo
• "human"→ entrada del usuario
• "ai"→ respuesta del modelo
• “tool”→ interacción con sistemas externos

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres experto en análisis de datos."),

    # Usuario
    ("human", "{question}"),

    # Respuesta previa del modelo (contexto conversacional)
    ("ai", "La varianza mide la dispersión de los datos."),

    # Resultado de una herramienta (tool calling)
    ("tool", '{"mean": 10, "std": 2}', {"tool_name": "stats_calculator"})
])

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres experto en análisis de datos."),

    # Usuario
    ("human", "{question}"),

    # Respuesta previa del modelo (contexto conversacional)
    ("ai", "La varianza mide la dispersión de los datos."),

    # Resultado de una herramienta (tool calling)
    ("tool", '{"mean": 10, "std": 2}', {"tool_name": "stats_calculator"})
])

No todos se usan siempre:

• En el 90% de los casos → solo "system" + "human"
• "ai" → cuando hay memoria conversacional
• "tool" → solo en flujos con herramientas (agents / tool calling)

Plantillas de prompts

Las plantillas convierten entradas en instrucciones claras:

• Estandarizan prompts
• Permiten reutilización
• Introducen variables dinámicas

prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un experto en {domain}. Responde en tono {tone}."),
    ("human", "Pregunta: {question}\nContexto: {context}")
])

chain = prompt | llm

response = chain.invoke({
    "domain": "machine learning",
    "tone": "conciso",
    "question": "¿Qué es overfitting?",
    "context": "Modelo entrenado con pocos datos"
})

print(response.content)

prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un experto en {domain}. Responde en tono {tone}."),
    ("human", "Pregunta: {question}\nContexto: {context}")
])

chain = prompt | llm

response = chain.invoke({
    "domain": "machine learning",
    "tone": "conciso",
    "question": "¿Qué es overfitting?",
    "context": "Modelo entrenado con pocos datos"
})

print(response.content)

Tipos principales

• Plantillas de cadena (string): para texto simple.
• Plantillas de chat: para estructuras conversacionales.
  • Mensajes del sistema
  • Mensajes humanos
  • Mensajes de IA
• Plantillas de pocos ejemplos (few-shot): incluyen ejemplos para guiar al modelo.

Output Parsers

Los Output Parsers en LangChain son el mecanismo para convertir la salida del LLM (texto libre) en estructuras controladas y utilizables (JSON, objetos tipados, listas, etc.).

Son críticos cuando necesitas fiabilidad, integración con código y postprocesado determinista. Se guardan en una variable que se añade al final de la cadena.

parser = JsonOutputParser()

parser = JsonOutputParser()

Chains (Cadenas)

En LangChain, las Chains son la forma de encadenar los componentes (prompts, modelos, parsers, funciones) para construir un flujo completo desde entrada → transformación → salida. En el enfoque moderno (LCEL), una chain no es una clase rígida, sino una composición declarativa de “runnables”.

prompt = ChatPromptTemplate.from_messages([
    ("system", "Responde como experto en estadística."),
    ("human", "{question}")
])

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

parser = StrOutputParser()

chain = prompt | llm | parser

response = chain.invoke({"question": "¿Qué es la media?"})

print(response)

prompt = ChatPromptTemplate.from_messages([
    ("system", "Responde como experto en estadística."),
    ("human", "{question}")
])

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

parser = StrOutputParser()

chain = prompt | llm | parser

response = chain.invoke({"question": "¿Qué es la media?"})

print(response)

Documents

En LangChain, un Document es la unidad estándar de datos que encapsula contenido (page_content) y metadatos (metadata), y actúa como formato común para que todos los módulos sean interoperables.

• Se crea al ingerir información externa.
• Se fragmenta para optimizar el procesamiento.
• Mantiene siempre su metadata para permitir filtrado, ranking y trazabilidad.
• Se transforma en vectores sin perder contexto.
• Finalmente se recupera para inyectarse en prompts dentro de arquitecturas RAG.

Agentes

En LangChain, los Agentes (Agents) son el componente que permite a un LLM tomar decisiones iterativas y usar herramientas para resolver tareas complejas. A diferencia de una chain (pipeline fija), un agente decide dinámicamente qué hacer en cada paso.

Un Agente es un orquestador basado en LLM que:

1. razona sobre el problema
2. elige acciones (tools)
3. ejecuta
4. observa resultados
5. repite hasta llegar a una respuesta

Diferencia agente vs Chains