Construir agentes inteligentes que procesen datos de forma rápida y organizada requiere dominar cómo encadenar tareas, estructurar respuestas y mostrar resultados en tiempo real. Tres componentes de LangChain hacen esto posible: Runnable, Output Parser y Streaming. Comprender su integración te permitirá crear chatbots avanzados y escalables que manejan grandes volúmenes de información.
¿Qué es Runnable y cómo encadena tareas en LangChain?
Un Runnable es una unidad de trabajo que puede invocarse, transformarse y ejecutarse en secuencia o en paralelo [00:08]. En la práctica, funciona como una pieza de una cadena donde la salida de un paso se convierte en la entrada del siguiente.
Para comenzar, se instala el paquete principal con pip install langchain y se importan los módulos necesarios desde langchain_core:
python
from langchain_core.runnables import RunnableLambda
El componente RunnableLambda permite envolver funciones lambda dentro de la cadena [01:12]. En LangChain Expression Language (LCEL), el símbolo pipe (|) conecta cada paso de la secuencia:
python
sequence = RunnableLambda(lambda x: x + 1) | RunnableLambda(lambda x: x * 2)
sequence.invoke(10)
Resultado: 22
- El primer lambda recibe
10, suma 1 y produce 11.
- El segundo lambda toma
11, multiplica por 2 y devuelve 22.
¿Cómo guardar resultados intermedios con diccionarios?
Cuando necesitas conservar valores de pasos anteriores, puedes usar diccionarios dentro de la cadena [02:42]. Cada clave almacena el resultado de un proceso distinto:
python
sequence = RunnableLambda(lambda x: x + 1) | {
"index_1": RunnableLambda(lambda x: x),
"index_2": RunnableLambda(lambda x: x * 5)
}
sequence.invoke(10)
{'index_1': 11, 'index_2': 55}
De esta forma, cada resultado queda accesible por su clave, lo que facilita la reutilización de datos dentro de flujos más complejos.
¿Cómo obtener respuestas en formato JSON con Output Parser?
Hasta ahora los resultados han sido strings o números simples. Sin embargo, en aplicaciones reales se necesitan formatos estructurados como JSON [03:31]. El JsonOutputParser transforma la salida del modelo en un objeto JSON válido.
Primero se importan los componentes necesarios:
python
from langchain_core.output_parsers import JsonOutputParser
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
Después se crea el modelo, el parser y el PromptTemplate [04:10]. Este último define el rol del modelo, cómo recibe la entrada del usuario y el formato de salida esperado:
python
modelo = ChatOpenAI()
parser = JsonOutputParser()
prompt = PromptTemplate(
template="Answer the user query.\n{format_instructions}\n{query}",
input_variables=["query"],
partial_variables={"format_instructions": parser.get_format_instructions()}
)
¿Cómo se construye la cadena completa?
Se encadenan los tres elementos con el operador pipe: prompt, modelo y parser [06:08].
python
chain = prompt | modelo | parser
response = chain.invoke({"query": joke_query})
El resultado es un diccionario con estructura JSON, no un texto plano. Esto es fundamental para integrar las respuestas en APIs o bases de datos.
¿Qué es Streaming y por qué mejora la experiencia del usuario?
Los modelos tardan en generar respuestas completas. La técnica de Streaming permite visualizar la construcción de la respuesta token por token, similar a como funciona ChatGPT [07:05].
Para implementarlo de forma síncrona se usa el método .stream() junto con la librería time:
python
import time
s = chain.stream({"query": joke_query})
for chunk in s:
print(chunk, end="", flush=True)
time.sleep(0.3)
También existe la versión asíncrona con .astream() [08:00], que genera chunks progresivamente:
python
chunks = []
async for chunk in chain.astream({"query": joke_query}):
chunks.append(chunk)
print(chunk, end="", flush=True)
await asyncio.sleep(0.3)
- Cada chunk representa un fragmento parcial de la respuesta.
- El parámetro
flush=True fuerza la impresión inmediata en pantalla.
- El intervalo de
0.3 segundos simula la generación progresiva.
Esta combinación de Runnable para orquestar flujos, Output Parser para estructurar datos y Streaming para entregar resultados en tiempo real forma la base para construir agentes conversacionales robustos. Ahora es tu turno: integra estos tres componentes para generar una conversación completa con un usuario y comparte tu solución en los comentarios.
