Mi flujo de trabajo con mi agente de IA: Lo que realmente estoy usando

Hola a todos, Sarah aquí de agnthq.com. Han sido unas semanas locas, ¿no? Cada vez que parpadeo, aparece un nuevo agente de IA prometiendo cambiar mi vida, mi flujo de trabajo, o al menos mi pedido de café. Y, sinceramente, muchos de ellos simplemente… no lo hacen. O son demasiado complejos, demasiado especializados, o simplemente no cumplen con las expectativas.

Pero, de vez en cuando, algo genuinamente interesante aparece. Algo que realmente me hace sentar y pensar, “Está bien, esto podría ser útil.” Hoy quiero hablar sobre uno de esos. No es algo completamente nuevo y brillante, sino una plataforma que ha ido evolucionando de manera constante y, en mi opinión, ha alcanzado un punto ideal para uso práctico y cotidiano: el nuevo marco de Agentes de LangChain con su salida estructurada mejorada y capacidades para llamar herramientas.

Ahora, antes de que frunzas el ceño y pienses, “Oh genial, otro artículo sobre LangChain,” escúchame. He estado jugueteando con LangChain casi desde el primer día. Recuerdo los primeros días, uniendo LLMs y herramientas, sintiéndome como un Frankenstein digital. Era poderoso, claro, pero a menudo torpe, difícil de depurar, y me sentía un poco como si estuviera escribiendo código de Python 2 en 2024. Las salidas podían ser… creativas, por decir lo menos, y lograr que un agente hiciera de manera fiable lo que querías, especialmente con múltiples pasos, se sentía más como una oración que como programación.

Las actualizaciones recientes, particularmente en cómo los agentes interactúan con las herramientas y producen salidas estructuradas, realmente han cambiado el juego para mí. Ha pasado de ser un “parque de juegos experimental” a “realmente útil para mi trabajo como freelance.” Y eso es algo importante.

Mi frustración con los agentes no fiables (y cómo esto ayuda)

Déjame pintar un cuadro. Hace unos meses, estaba tratando de construir un agente simple para una amiga que tiene una pequeña tienda de comercio electrónico. Su problema: los clientes a menudo hacen preguntas muy similares sobre productos, envíos y devoluciones, y ella pasaba demasiado tiempo copiando y pegando respuestas. Mi idea era un agente que pudiera:

• Buscar detalles del producto (precio, disponibilidad) en una base de datos ficticia.
• Verificar zonas y tiempos de envío.
• Formular una respuesta educada y precisa.

Suena sencillo, ¿verdad? No realmente. Mis primeros intentos con LangChain fueron un desastre. A veces, el agente alucinaba ID de productos, o se olvidaba de llamar a la herramienta de envío, o simplemente producía un discurso conversacional en lugar de una respuesta concisa. Hacer que produjera de manera constante un formato específico, como un objeto JSON que contenga la respuesta y las herramientas que utilizó, era una pesadilla. Pasaba horas tratando de coaxionarlo con indicaciones elaboradas, solo para que fallara en un caso límite.

Aquí es donde brilla el nuevo marco de agentes. LangChain ha perfeccionado cómo los agentes deciden qué herramientas usar y, crucialmente, cómo informan sobre sus hallazgos. Se trata menos de esperar que el LLM “lo descubra” y más de darle un camino claro y estructurado.

La idea principal: mejor llamada de herramientas y salida estructurada

La mayor mejora, en mi opinión, proviene de una combinación de cosas:

1. Mejora en la definición de herramientas: Ahora las herramientas se definen con esquemas de Pydantic, lo que hace mucho más claro para el LLM qué entradas espera.
2. API de llamadas a funciones (por ejemplo, las de OpenAI): LangChain aprovecha estas API de fondo para hacer que la selección de herramientas sea mucho más fiable. El LLM no solo “adivina” qué herramienta usar; se le informa explícitamente sobre las funciones disponibles y sus parámetros.
3. Parseadores de salida estructurada: Este es el santo grial para mí. Ya no es necesario intentar obtener una respuesta mediante regex de un bloque de texto libre. Ahora podemos definir exactamente qué estructura esperamos que tenga la respuesta final del agente.

Veamos un ejemplo simple para ilustrar esto. Imagina que tenemos una herramienta para obtener el nivel de stock actual de un producto.

Ejemplo: una herramienta simple para comprobar el stock

Primero, definamos nuestra herramienta usando un modelo de Pydantic para su entrada:

from langchain_core.tools import tool
from pydantic import BaseModel, Field

class ProductStockInput(BaseModel):
 product_id: str = Field(description="El identificador único para el producto.")

@tool("get_product_stock", args_schema=ProductStockInput)
def get_product_stock(product_id: str) -> dict:
 """
 Busca el nivel actual de stock para un ID de producto dado.
 Devuelve un diccionario con product_id y stock_level.
 """
 # Esto normalmente consultaría una base de datos
 stock_data = {
 "P101": 50,
 "P102": 0, # Sin stock
 "P103": 15
 }
 stock_level = stock_data.get(product_id, -1) # -1 para no encontrado
 if stock_level == -1:
 return {"product_id": product_id, "stock_level": "Producto no encontrado"}
 return {"product_id": product_id, "stock_level": stock_level}

tools = [get_product_stock]

Nota el `args_schema` aquí. Esto es crucial. Informa al LLM exactamente qué argumentos espera `get_product_stock` y cuáles son sus tipos. No más ambigüedad.

Construyendo el agente con salida estructurada

Ahora, vamos a construir un agente que use esta herramienta y, lo más importante, proporcione su respuesta final de manera estructurada. Para mi amiga del comercio electrónico, quería que el agente produjera la consulta del cliente, la respuesta del agente, y cualquier herramienta que utilizara, todo en un formato JSON agradable.

from langchain_openai import ChatOpenAI
from langchain import hub
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_core.messages import BaseMessage
from typing import List, Union, Dict, Any

# Define el formato de salida estructurada para la respuesta final del agente
class AgentResponse(BaseModel):
 original_query: str = Field(description="La consulta original del cliente.")
 agent_answer: str = Field(description="La respuesta formulada del agente a la consulta.")
 tools_used: List[str] = Field(description="Una lista de nombres de las herramientas que utilizó el agente.")
 metadata: Dict[str, Any] = Field(description="Cualquier metadato adicional o hallazgos de las herramientas.")

# Cargar el prompt base para el agente de herramientas de OpenAI
prompt = hub.pull("hwchase17/openai-tools-agent")

llm = ChatOpenAI(model="gpt-4-0125-preview", temperature=0) # Usando un GPT-4 reciente por fiabilidad

# Crear el agente
agent = create_openai_tools_agent(llm, tools, prompt)

# Crear el ejecutor del agente
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Ahora, definimos cómo debe responder el agente usando with_structured_output
# ¡Aquí es donde ocurre la magia para una salida estructurada fiable!
structured_agent_executor = agent_executor.with_structured_output(AgentResponse)

# ¡Probémoslo!
query1 = "¿Cuál es el nivel de stock para el producto P101?"
response1 = structured_agent_executor.invoke({"input": query1})
print("\n--- Respuesta 1 ---")
print(response1.json(indent=2))

query2 = "¿Está disponible el producto P102?"
response2 = structured_agent_executor.invoke({"input": query2})
print("\n--- Respuesta 2 ---")
print(response2.json(indent=2))

query3 = "¿Cuál es la capital de Francia?" # El agente no debería usar nuestra herramienta para esto
response3 = structured_agent_executor.invoke({"input": query3})
print("\n--- Respuesta 3 ---")
print(response3.json(indent=2))

Cuando ejecutes esto, verás en la salida detallada cómo el LLM primero identifica la necesidad de `get_product_stock`, lo llama con el `product_id` correcto, y luego usa el resultado para formar su `agent_answer`. Más importante aún, la *salida final* es un objeto `AgentResponse`, no solo una cadena. Esto es increíblemente poderoso para el procesamiento posterior, el registro, o incluso para mostrar información consistente a un usuario.

Lo que me encanta de `with_structured_output`

Este método `with_structured_output` es un cambio significativo. Significa que puedo integrar de manera fiable las respuestas del agente en otras partes de mi aplicación. No tengo que escribir lógicas de análisis frágiles. Si el agente se desvía de alguna manera, Pydantic a menudo lo detectará, dándome un error claro en lugar de fallar silenciosamente o devolver basura.

Para mi amiga del comercio electrónico, esto significa que su portal de servicio al cliente puede ahora mostrar la respuesta del agente con confianza, sabiendo que está en el formato correcto. Incluso podemos registrar los campos `tools_used` y `metadata` para entender con qué frecuencia el agente utiliza herramientas específicas o si hay preguntas comunes que no puede responder.

Más allá de herramientas simples: razonamiento en múltiples pasos con fiabilidad

La verdadera prueba para un agente suele ser el razonamiento en múltiples pasos. Vamos a añadir otra herramienta: una para obtener tiempos estimados de envío basados en un ID de producto y una zona de destino.

from langchain_core.tools import tool
from pydantic import BaseModel, Field

# ... (ProductStockInput y get_product_stock permanecen igual) ...

class ShippingInfoInput(BaseModel):
 product_id: str = Field(description="El identificador único del producto.")
 destination_zone: str = Field(description="La zona de envío (por ejemplo, 'Zona A', 'Zona B').")

@tool("get_shipping_info", args_schema=ShippingInfoInput)
def get_shipping_info(product_id: str, destination_zone: str) -> dict:
 """
 Proporciona tiempos de envío estimados para un producto a una zona específica.
 Devuelve un diccionario con product_id, zone y estimated_days.
 """
 # Datos de envío ficticios
 shipping_times = {
 ("P101", "Zone A"): "3-5 días hábiles",
 ("P101", "Zone B"): "5-7 días hábiles",
 ("P103", "Zone A"): "2-4 días hábiles",
 ("P103", "Zone B"): "4-6 días hábiles",
 }
 key = (product_id, destination_zone)
 estimated_days = shipping_times.get(key, "Varía, por favor contacta al soporte")
 return {"product_id": product_id, "destination_zone": destination_zone, "estimated_days": estimated_days}

tools_multi = [get_product_stock, get_shipping_info]

# Recrear agente y ejecutor con las nuevas herramientas
agent_multi = create_openai_tools_agent(llm, tools_multi, prompt)
agent_executor_multi = AgentExecutor(agent=agent_multi, tools=tools_multi, verbose=True)
structured_agent_executor_multi = agent_executor_multi.with_structured_output(AgentResponse)

# Probar una consulta de múltiples pasos
multi_step_query = "¿Cuál es el stock de P101 y cuánto tardaría en enviarse a la Zona A?"
response_multi = structured_agent_executor_multi.invoke({"input": multi_step_query})
print("\n--- Respuesta de múltiples pasos ---")
print(response_multi.json(indent=2))

Notarás en la salida detallada que el agente ahora llama inteligentemente a `get_product_stock` primero, luego a `get_shipping_info`, y combina la información en una respuesta coherente, todo mientras respeta la estructura de `AgentResponse`. Este es un gran avance respecto a los días en que tenías que encadenar explícitamente estas llamadas a herramientas o esperar que el LLM inferiría la secuencia correcta.

Mis Conclusiones & Por qué Esto Importa Ahora

Entonces, ¿por qué estoy haciendo tanto alboroto sobre esto ahora? Porque parece que los agentes de LangChain, específicamente con la combinación de `create_openai_tools_agent` y `with_structured_output`, finalmente han madurado a un punto donde son realmente prácticos para los desarrolladores que construyen aplicaciones del mundo real. No más interminables ingenierías de prompt para forzar una salida JSON, no más análisis frágil de regex, y significativamente menos “llamadas a herramientas alucinadas”.

Conclusiones Accionables para Ti:

1. Revisa los Agentes de LangChain: Si probaste los agentes de LangChain hace un año y te frustraste, ahora es el momento de echarles otro vistazo. Las mejoras en la llamada a herramientas y la salida estructurada son sustanciales.
2. Define Herramientas con Pydantic: Siempre define las entradas de tus herramientas usando modelos de Pydantic con descripciones claras. Esto le da al LLM la mejor oportunidad de entender cuándo y cómo usar tus herramientas.
3. Adopta `with_structured_output`: Este es tu mejor amigo para una integración de agente confiable. Define un modelo de Pydantic para la salida final de tu agente y usa `agent_executor.with_structured_output(YourOutputModel)`. Te ahorrará innumerables horas de depuración y análisis.
4. Comienza Simple, luego Expande: No trates de construir un super-agente de inmediato. Comienza con una o dos herramientas simples y una estructura de salida clara. Una vez que eso funcione de manera confiable, agrega gradualmente más complejidad.
5. Usa Descripciones Detalladas de Herramientas: El campo `description` en tu decorador `@tool` es lo que el LLM lee para decidir si usar o no una herramienta. Hazlo claro, conciso, y explica lo que la herramienta *hace* y lo que *devuelve*.
6. Utiliza la Llamada a Funciones de OpenAI: Mientras este artículo se centra en LangChain, la confiabilidad subyacente a menudo proviene de modelos LLM como los de OpenAI que tienen capacidades sólidas de llamada a funciones. Asegúrate de estar usando modelos que soporten esto para obtener los mejores resultados.

Creo firmemente que estos avances hacen que la construcción de agentes inteligentes sea mucho más accesible y, lo que es más importante, mucho más confiable. Para cualquiera que esté construyendo características impulsadas por IA, ya sea un bot de atención al cliente, un asistente de análisis de datos, o simplemente automatizando tareas tediosas, la capacidad de interactuar de manera predecible con un agente y recibir datos estructurados a cambio es un cambio significativo. Ha llevado a los agentes de ser una demostración interesante a un elemento genuinamente útil en la caja de herramientas del desarrollador.

Eso es todo por hoy. ¡Pruébalo y déjame saber qué construyes! Comparte tus pensamientos y experiencias en los comentarios a continuación. ¡Feliz construcción de agentes!

🕒 Published: March 25, 2026