Tutorial de agentes profundos: LangGraph para una IA más inteligente

Imagine una IA que no solo responda sus preguntas, sino que piense en el futuro, desglose las tareas, cree sus propios TODO e incluso genere subagentes para realizar el trabajo. Esa es la promesa de Deep Agents. Los agentes de IA ya aprovechan las capacidades de LLM un nivel más stop, y hoy veremos a Deep Agents para ver cómo pueden arrostrar ese nivel aún más remotamente. Deep Agents está construido sobre LangGraphuna biblioteca diseñada específicamente para crear agentes capaces de manejar tareas complejas. Echemos un vistazo más profundo a los agentes profundos, comprendamos sus capacidades principales y luego usemos la biblioteca para crear nuestros propios agentes de IA.

Agentes profundos

LangGraph le ofrece un tiempo de ejecución basado en gráficos para flujos de trabajo con estado, pero aún necesita crear su propia deducción de planificación, administración de contexto o descomposición de tareas desde cero. DeepAgents (creado sobre LangGraph) incluye herramientas de planificación, memoria basada en un sistema de archivos supuesto y orquestación de subagentes listas para usar.

Puede utilizar DeepAgents de forma independiente deepagents biblioteca. Incluye capacidades de planificación, puede difundir subagentes y utiliza un sistema de archivos para la administración del contexto. Además se puede combinar con LangSmith para su implementación y monitoreo. Los agentes creados aquí utilizan el maniquí “claude-sonnet-4-5-20250929” de forma predeterminada, pero se puede personalizar. Ayer de comenzar a crear los agentes, comprendamos los componentes principales.

Componentes principales

• Indicaciones detalladas del sistema – El agente Deep utiliza un indicador del sistema con instrucciones detalladas y ejemplos.
• Herramientas de planificación – Los agentes profundos tienen una útil incorporada para la planificación, los agentes utilizan la útil de administración de listas TODO para la misma. Esto les ayuda a mantenerse concentrados incluso mientras realizan una tarea compleja.
• Subagentes – El subagente se genera para las tareas delegadas y se ejecutan en contexto separado.
• Sistema de archivos – Sistema de archivos supuesto para la administración del contexto y la administración de la memoria. Los agentes de IA aquí utilizan archivos como útil para descargar el contexto a la memoria cuando la ventana de contexto está llena.

Construyendo un agente profundo

Ahora construyamos un agente de investigación usando la biblioteca ‘deepagents’ que usará tavily para la búsqueda web y tendrá todos los componentes de un agente profundo.

Nota: Haremos el tutorial en Google Colab.

Requisitos previos

Necesitará una esencia OpenAI para este agente que crearemos; igualmente puede optar por utilizar un proveedor de maniquí diferente como Gemini/Claude. Obtenga su esencia OpenAI desde la plataforma: https://platform.openai.com/api-keys

Obtenga igualmente una esencia API de Tavily para búsqueda web desde aquí: https://app.tavily.com/home

Ensenada una nueva cuaderno en Google Colab y agregue las claves secretas:

Guarde las claves como OPENAI_API_KEY, TAVILY_API_KEY para la demostración y no olvide activar el golpe a la computadora portátil.

Lea igualmente: Búsqueda de archivos API de Gemini: la forma más sencilla de crear RAG

Requisitos

!pip install deepagents tavily-python langchain-openai 

Instalaremos estas bibliotecas necesarias para ejecutar el código.

Importaciones y configuración de API

import os 
from deepagents import create_deep_agent 
from tavily import TavilyClient 
from langchain.chat_models import init_chat_model 
from google.colab import userdata 
 

# Set API keys 
TAVILY_API_KEY=userdata.get("TAVILY_API_KEY") 
os.environ("OPENAI_API_KEY")=userdata.get("OPENAI_API_KEY") 

Estamos almacenando la API de Tavily en una variable y la API de OpenAI en el entorno.

Definición de las herramientas, el subagente y el agente

# Initialize Tavily client 
tavily_client = TavilyClient(api_key=TAVILY_API_KEY) 
 
# Define web search tool 
def internet_search(query: str, max_results: int = 5) -> str: 
   """Run a web search to find current information""" 
   results = tavily_client.search(query, max_results=max_results) 
   return results  

# Define a specialized research sub-agent 
research_subagent = { 
   "name": "data-analyzer", 
   "description": "Specialized agent for analyzing data and creating detailed reports", 
   "system_prompt": """You are an expert data analyst and report writer. 
   Analyze information thoroughly and create well-structured, detailed reports.""", 
   "tools": (internet_search), 
   "model": "openai:gpt-4o", 
}  

# Initialize GPT-4o-mini model 
model = init_chat_model("openai:gpt-4o-mini") 
# Create the deep agent 
# The agent automatically has access to: write_todos, read_todos, ls, read_file, 
# write_file, edit_file, glob, grep, and task (for subagents) 
agent = create_deep_agent( 
   model=model, 
   tools=(internet_search),  # Passing the tool 
   system_prompt="""You are a thorough research assistant. For this task: 
   1. Use write_todos to create a task list breaking down the research 
   2. Use internet_search to gather current information 
   3. Use write_file to save your findings to /research_findings.md 
   4. You can delegate detailed analysis to the data-analyzer subagent using the task tool 
   5. Create a final comprehensive report and save it to /final_report.md 
   6. Use read_todos to check your progress 

   Be systematic and thorough in your research.""", 
   subagents=(research_subagent), 
) 

Hemos definido una útil para la búsqueda web y se la hemos pasado a nuestro agente. Estamos utilizando ‘gpt-4o-mini’ de OpenAI para esta demostración. Puedes cambiar esto a cualquier maniquí.

Además tenga en cuenta que no creamos ningún archivo ni definimos nadie para el sistema de archivos necesario para descargar el contexto y la tira de tareas pendientes. Estos ya están prediseñados en ‘create_deep_agent()’ y tiene golpe a ellos.

Ejecución de inferencia

# Research query 
research_topic = "What are the latest developments in AI agents and LangGraph in 2025?"  

print(f"Starting research on: {research_topic}n") 
print("=" * 70)  

# Execute the agent 
result = agent.invoke({ 
   "messages": ({"role": "user", "content": research_topic}) 
}) 

print("n" + "=" * 70) 
print("Research completed.n") 

Nota: La ejecución del agente puede tardar un poco.

Ver la salida

# Agent execution trace 
print("AGENT EXECUTION TRACE:") 
print("-" * 70) 
for i, msg in enumerate(result("messages")): 
   if hasattr(msg, 'type'): 
       print(f"n({i}) Type: {msg.type}") 
       if msg.type == "human": 
           print(f"Human: {msg.content}") 
       elif msg.type == "ai": 
           if hasattr(msg, 'tool_calls') and msg.tool_calls: 
               print(f"AI tool calls: {(tc('name') for tc in msg.tool_calls)}") 
           if msg.content: 
               print(f"AI: {msg.content(:200)}...") 
       elif msg.type == "tool": 
           print(f"Tool '{msg.name}' result: {str(msg.content)(:200)}...") 

# Final AI response 
print("n" + "=" * 70) 
final_message = result("messages")(-1) 
print("FINAL RESPONSE:") 
print("-" * 70) 
print(final_message.content) 

# Files created 
print("n" + "=" * 70) 
print("FILES CREATED:") 
print("-" * 70) 
if "files" in result and result("files"): 
   for filepath in sorted(result("files").keys()): 
       content = result("files")(filepath) 
       print(f"n{'=' * 70}") 
       print(f"{filepath}") 
       print(f"{'=' * 70}") 
       print(content) 
else: 
   print("No files found.") 

print("n" + "=" * 70) 
print("Analysis complete.") 

Como podemos ver, el agente hizo un buen trabajo, mantuvo un sistema de archivos supuesto, dio una respuesta luego de múltiples iteraciones y pensó que debería ser un «agente profundo». Pero hay ganancia de alivio en nuestro sistema; veámoslo en el venidero sistema.

Mejoras potenciales en nuestro agente

Creamos un agente profundo simple, pero puedes desafiarte a ti mismo y crear poco mucho mejor. Aquí hay algunas cosas que puede hacer para mejorar este agente:

1. Utilice la memoria a grande plazo – El agente profundo puede conservar las preferencias del becario y los comentarios en archivos (/memories/). Esto ayudará al agente a dar mejores respuestas y a construir una cojín de conocimientos a partir de las conversaciones.
2. Controlar el sistema de archivos – De forma predeterminada, los archivos se almacenan en un estado supuesto; puede hacerlo en un backend o disco almacén diferente utilizando el ‘FilesystemBackend’ de deepagents.backends
3. Refinando las indicaciones del sistema – Puede probar varias indicaciones para ver cuál funciona mejor para usted.

Conclusión

Hemos construido con éxito nuestros Agentes Profundos y ahora podemos ver cómo Agentes de IA puede impulsar las capacidades de LLM a un nivel superior, utilizando LangGraph para manejar las tareas. Con planificación integrada, subagentes y un sistema de archivos supuesto, gestionan los TODO, el contexto y los flujos de trabajo de investigación sin problemas. Los agentes profundos son geniales, pero igualmente recuerde que si una tarea es más simple y puede ser realizada por un agente simple o un LLM, entonces no se recomienda usarlos.

Preguntas frecuentes