LangGraph: Creación de agentes de IA escalables y autónomos.

En el ámbito de la arquitectura de software moderna, el paradigma está cambiando de las cadenas lineales de ejecución a gráficos dinámicos y cíclicos. Para los directores de tecnología y ingenieros senior, esta distinción es fundamental. Si bien las "cadenas" tradicionales (como las que se encuentran en las primeras versiones de LangChain) son suficientes para tareas simples de entrada-salida, el desarrollo de agentes Desarrollo de agentes de IA personalizadosde IA personalizados de nivel empresarial

Este artículo proporciona un análisis técnico en profundidad sobre la creación de un marco para agentes autónomos utilizando LangGraphLangGraphAgentExecutor, LangGraph permite la creación de aplicaciones estáticas y con múltiples actores, donde los agentes pueden razonar, iterar y corregir errores.

En4Geeks<s3>desarrollo de agentes de IA personalizadosDesarrollo de agentes de IA personalizados

Equipo de Ingeniería de Software Compartido Bajo Demanda, Por Suscripción.

Acceda a un equipo flexible y compartido de ingeniería de software bajo demanda a través de una suscripción mensual predecible. Desarrolladores expertos, diseñadores, ingenieros de QA y un gestor de proyectos gratuito le ayudan a crear MVPs, escalar productos e innovar con tecnologías modernas como React, Node.js y más.

Try 4Geeks Teams

La Arquitectura: ¿Por qué los gráficos?

Los agentes autónomos difieren de los simples chatbots porque poseen "capacidad de decisión"—la habilidad de decidir qué hacer a continuación en función del estado actual.

Una arquitectura basada en grafos modela esto a la perfección:

• Nodos: Representan unidades de trabajo (por ejemplo, una llamada a un LLM, la ejecución de una herramienta o un paso de revisión humana).
• Aristas: Representan el flujo de control.
• Estado: Una estructura de datos compartida que se pasa entre los nodos, manteniendo el contexto a lo largo del ciclo de vida del grafo.

Esta estructura permite flujos de trabajo cíclicosSi la salida de una herramienta del agente es insuficiente, el gráfico puede redirigir la ejecución de nuevo al nodo de razonamiento para intentar nuevamente, en lugar de fallar linealmente.

Implementación paso a paso

Construiremos un agente de investigación capaz de buscar en la web de forma iterativa y refinar su respuesta hasta que se cumpla una condición.

1. Requisitos y configuración del entorno

Asegúrese de tener las bibliotecas necesarias instaladas. Utilizaremos <s1>langgraphlanggraphlangchaintavily-python, ytavily-pythonpara mejorar las capacidades de búsqueda.

pip install langgraph langchain langchain-openai tavily-python

2. Definir el estado del Agente

El Estado es la base de tu grafo. Es un TypedDict (o modelo de Pydantic) que contiene las claves disponibles para todos los nodos.es la estructura fundamental de tu grafo. Es un TypedDict (o modelo de Pydantic) que contiene las claves disponibles para todos los nodos.

from typing import TypedDict, Annotated, List, Union
from langchain_core.messages import BaseMessage
import operator

class AgentState(TypedDict):
    # 'messages' tracks the conversation history. 
    # operator.add ensures new messages are appended, not overwritten.
    messages: Annotated[List[BaseMessage], operator.add]
    # We can add custom keys for tracking specific logic
    next_step: str

3. Creando los nodos

Necesitamos dos nodos principales: uno para el Agente(Razonamiento basado en modelos de lenguaje grandes) y uno paraHerramientas(ejecución).

from langchain_openai import ChatOpenAI
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_core.messages import ToolMessage
from langgraph.prebuilt import ToolNode

# Initialize Tools and LLM
tools = [TavilySearchResults(max_results=1)]
tool_node = ToolNode(tools)

# Bind tools to the model so it knows it can call them
model = ChatOpenAI(model="gpt-4o", temperature=0).bind_tools(tools)

# Define the Agent Node
def agent_node(state: AgentState):
    messages = state['messages']
    response = model.invoke(messages)
    # The response is returned as a dict to update the 'messages' key in State
    return {"messages": [response]}

4. Definición de la lógica condicional (Condiciones)

Aquí es donde reside la "autonomía". Definimos una función para inspeccionar el último mensaje. Si el modelo de lenguaje decidió llamar a una herramienta, se dirige a herramientas.FIN.

from typing import Literal
from langgraph.graph import END

def should_continue(state: AgentState) -> Literal["tools", END]:
    messages = state['messages']
    last_message = messages[-1]
    
    # If the LLM generated tool calls, route to the tool node
    if last_message.tool_calls:
        return "tools"
    
    # Otherwise, end the workflow
    return END

Equipo de Ingeniería de Software Compartido Bajo Demanda, Por Suscripción.

Acceda a un equipo flexible y compartido de ingeniería de software bajo demanda a través de una suscripción mensual predecible. Desarrolladores expertos, diseñadores, ingenieros de control de calidad y un gerente de proyecto gratuito le ayudan a construir MVPs, escalar productos e innovar con tecnologías modernas como React, Node.js y más.

Try 4Geeks Teams

5. Compilar el grafo

Finalmente, ensamblamos el gráfico. Este paso de compilación valida la estructura y prepara el archivo ejecutable.

from langgraph.graph import StateGraph, START

# Initialize the Graph
workflow = StateGraph(AgentState)

# Add Nodes
workflow.add_node("agent", agent_node)
workflow.add_node("tools", tool_node)

# Set Entry Point
workflow.add_edge(START, "agent")

# Add Conditional Edge
workflow.add_conditional_edges(
    "agent",
    should_continue,
    {
        "tools": "tools",
        END: END
    }
)

# Add Edge from Tools back to Agent (The Loop)
workflow.add_edge("tools", "agent")

# Compile
app = workflow.compile()

Funcionalidades Avanzadas: Persistencia y Memoria

Para el desarrollo de agentes de IA personalizados para producción, la memoria temporal rara vez es suficiente. Necesitará hilos que funcionen durante largos períodos y que persistan a través de las sesiones del usuario. LangGraph lo gestiona mediante , la memoria volátil rara vez es suficiente. Necesitas hilos que se ejecutan durante un período prolongado y que persisten a lo largo de las sesiones del usuario. LangGraph gestiona esto mediante:puntos de control.

Al añadir un punto de control, el estado del grafo se guarda después de la ejecución de cada nodo. Esto permite "viajar en el tiempo" (reanudar desde un estado anterior) o implementar flujos de trabajo con "Human-in-the-Loop" donde un agente se detiene para obtener aprobación antes de ejecutar acciones sensibles.Human-in-the-Loop workflows where an agent pauses for approval before executing sensitive actions.

from langgraph.checkpoint.memory import MemorySaver

# Initialize checkpointer
memory = MemorySaver()

# Compile with checkpointer
app = workflow.compile(checkpointer=memory)

# Execute with a thread_id to maintain session state
thread = {"configurable": {"thread_id": "1"}}
inputs = {"messages": [("user", "What is the current stock price of Apple?")]}

for event in app.stream(inputs, thread):
    for key, value in event.items():
        print(f"Node '{key}' output: {value}")

Conclusión

Pasar de estructuras basadas en cadenas simples a arquitecturas basadas en grafos permite a los ingenieros construir agentes que sean resilientes, introspectivos y capaces de resolver problemas complejos. Tanto si está automatizando flujos de trabajo empresariales como si está creando productos de IA generativa, controlar el ciclo de estado es fundamental.

Para organizaciones que buscan acelerar este proceso, 4Geeks ofrece el desarrollo de agentes de IA personalizados y especializados, . Asistimos a las empresas en el diseño e implementación de estas sofisticadas arquitecturas de IA, garantizando que su transición hacia sistemas autónomos sea tanto estratégica como técnicamente sólida.. Ayudamos a las empresas a diseñar e implementar estas sofisticadas arquitecturas de IA, asegurando que su transición hacia sistemas autónomos sea tanto estratégica como técnicamente sólida.

Equipo de Ingeniería de Software Compartido Bajo Demanda, Por Suscripción.

Acceda a un equipo flexible y compartido de ingeniería de software bajo demanda mediante una suscripción mensual predecible. Desarrolladores, diseñadores, ingenieros de control de calidad y un gerente de proyectos gratuito le ayudan a crear MVPs, escalar productos e innovar con tecnologías modernas como React, Node.js y más.

Try 4Geeks Teams

Preguntas frecuentes