Sistemas de IA multiagente con LangChain: Construyendo uno
Sistemas de IA multiagente con LangChain: qué es un sistema multiagente, cuándo varios agentes superan a un único agente LLM, y cómo crear y conectar los roles.
Fuentes: Multi-Agent AI Systems with LangChain: Building an Orchestrator That Delegates Work
Las notas siguientes reconstruyen un camino práctico para abordar el tema “Sistemas de IA multiagente con LangChain: Creación de un orquestador que delega tareas”. Se da énfasis en los contratos, las verificaciones y los marcadores de posición para código, en lugar de en un enfoque motivacional. Al trabajar en la etapa de descripción general, anote primero el contrato: las entradas requeridas, la señal de éxito y qué ocurre en caso de un fallo parcial. Esa lista de verificación garantiza que los cambios posteriores en el código sean transparentes. Registre los tiempos de ejecución y el costo en tokens o consultas junto con los resultados funcionales. Tener visibilidad del costo desde el principio evita facturas inesperadas cuando se pasa de la demostración a entornos compartidos.
1. ¿Qué es un sistema multiagente?
El punto 1, “¿Qué es una etapa?”, funciona mejor cuando se trata como una superficie medible. Capture una transcripción ejemplar, un caso de fallo y la nota de reversión antes de ampliar el alcance. Mantenga la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de datos secretos y las banderas de funcionalidad deben estar en un lugar donde los operadores puedan auditarlos sin tener que leer todo el grafo. Mantenga el estado del grafo plano y tipado. Los bloques anidados ocultan qué nodo escribió qué campo y causan interrupciones en la continuación del proceso después de las interrupciones.
User
|
v
Single Agent
|
+-- Search
+-- Analyze
+-- Calculate
+-- Generate Report
User
|
v
+--------------+
| Main Agent |
| Orchestrator |
+------+-------+
|
+------------+------------+
| |
v v
+-------------+ +-------------+
| Math Agent | | Search Agent|
+-------------+ +-------------+
| |
square() search()
2. ¿Por qué usar múltiples agentes?
El método 2 Why Use Multiple stage funciona mejor cuando se trata como una superficie medible. Capture una transcripción clave, un caso de fallo y la nota de reversión antes de ampliar el alcance. Documente tanto el camino óptimo como el camino de recuperación juntos. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras posteriores. Mantenga el estado del grafo simple y tipado; los bloques anidados ocultan qué nodo escribió qué campo y provocan interrupciones en la continuación del proceso.
Database queries
Security analysis
Documentation search
Report generation
"I have a database question → call database agent."
"I have a security question → call security agent.""I need documentation → call documentation agent."
Agente único
La etapa de agente único funciona mejor cuando se trata como una superficie medible. Capture un registro ideal, un caso de fallo y la nota de reversión antes de ampliar el alcance. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando falla un paso, el fallo debe apuntar a una sola responsabilidad y no a un proceso complicado. Mantenga el estado del grafo simple y tipado. Los bloques anidados ocultan qué nodo escribió qué campo y provocan interrupciones en la continuación del proceso.
LLM
|
+-------------+-------------+
| | |
Database Search Security
| | |
+-------------+-------------+
La etapa de agente único funciona mejor cuando se trata como una superficie medible. Capture un registro ideal, un caso de fallo y la nota de reversión antes de ampliar el alcance. Registre los tiempos y el costo en tokens o consultas junto con los resultados funcionales. Tener visibilidad del costo desde el principio evita facturas inesperadas al pasar del entorno de demostración a los entornos compartidos.
Múltiples agentes
En la fase de múltiples agentes, defina las entradas, el responsable de cada paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido, sin tener que adivinar el estado oculto. Guarde la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de datos secretos y las banderas de funcionalidad deben encontrarse en un lugar donde los operadores puedan auditarlos sin necesidad de leer todo el sistema. Coloque la aprobación humana en las conexiones que generan gastos o modifican datos de producción. La conexión establecida en tiempo de compilación no equivale a la completitud del proceso empresarial.
Main Agent
/ | \
/ | \
v v v
DB Agent Search Security
Agent Agent
3. Ejemplo: Dos agentes especializados
Para la etapa especial “Ejemplo Dos 3”, defina las entradas, el responsable de la tarea y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la tarea desde un punto de control conocido sin tener que adivinar el estado oculto. Documente tanto la ruta óptima como la ruta de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras posteriores. Incluya la aprobación humana en aquellos casos que impliquen gastos o cambios en los datos de producción. La configuración en tiempo de compilación no equivale a la completitud del proceso empresarial.
Calculate the square of a number
Calculate the square root of a number
@tool
def square_root(x: float) -> float:
"""Calculate the square root of a number"""
return x ** 0.5
@tool
def square(x: float) -> float:
"""Calculate the square of a number"""
return x ** 2
subagent_square_root = create_agent(
model=llm,
tools=[square_root]
)
subagent_square = create_agent(
model=llm,
tools=[square]
)
square_root()
square()
4. La parte importante: Convertir agentes en herramientas
En la fase de “4 The Important Part”, defina las entradas, el responsable del paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido sin tener que adivinar el estado oculto. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando un paso falla, el error debe indicar una única responsabilidad y no un proceso complicado. Autentique en la pasarela de entrada y vuelva a autorizarlo en el plano de datos. Un token portador por sí solo no constituye un límite entre entornos. En la fase de “4 The Important Part”, defina las entradas, el responsable del paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido sin tener que adivinar el estado oculto. Registre los tiempos de ejecución y el costo de los tokens o consultas junto con los resultados funcionales. Tener visibilidad sobre los costos desde el principio evita facturas inesperadas cuando el proceso pasa de entornos de demostración a entornos compartidos.
@tool
def call_subagent_square_root(x: float) -> float:
"""Call subagent 1 in order to calculate
the square root of a number"""
response = subagent_square_root.invoke(
{
"messages": [
HumanMessage(
content=f"Calculate the square root of {x}"
)
]
}
) return response["messages"][-1].content
@tool
def call_subagent_square(x: float) -> float:
"""Call subagent 2 in order to calculate
the square of a number"""
response = subagent_square.invoke(
{
"messages": [
HumanMessage(
content=f"Calculate the square of {x}"
)
]
}
) return response["messages"][-1].content
Main Agent
|
+-- call_subagent_square_root()
|
+-- call_subagent_square()
5. Creación del orquestador
Al trabajar en la etapa 5 de creación del orquestador, anote primero el contrato: las entradas requeridas, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación ayuda a mantener honestas las futuras modificaciones del código. Guarde la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de secretos y las banderas de funcionalidad deben encontrarse en un lugar donde los operadores puedan auditarlos sin tener que leer todo el grafo. Haga un punto de control después de los pasos costosos. La función de reanudación no debe volver a facturar la misma llamada al LLM cuando un operador intente nuevamente un nodo posterior.
main_agent = create_agent(
model=llm,
tools=[
call_subagent_square_root,
call_subagent_square
],
system_prompt=
"You are a helpful assistant who can call "
"subagents to calculate the square root or "
"square of a number."
)
User
|
|
v
+----------------+
| Main Agent |
| Orchestrator |
+-------+--------+
|
Tool selection
/ \
/ \
v v
+----------------+ +----------------+
| Square Root | | Square |
| Subagent | | Subagent |
+-------+--------+ +-------+--------+
| |
v v
square_root() square()
6. ¿Qué ocurre cuando el usuario hace una pregunta?
Al trabajar en la fase 6 “What Happens When”, anote primero el contrato: los datos de entrada requeridos, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación ayuda a mantener la transparencia en los cambios posteriores del código. Documente junto con ella el camino óptimo y el camino de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras realizadas posteriormente. Haga un punto de control después de los pasos costosos. Resume no debe volver a facturar la misma llamada al LLM cuando un operador vuelve a intentar un nodo posterior.
What is the square root of 456?
response = main_agent.invoke(
{
"messages": [
HumanMessage(
content="What is the square root of 456?"
)
]
}
)
call_subagent_square_root(x=456)
Calculate the square root of 456
square_root()
21.3541565
The square root of 456 is approximately 21.35.
User
|
| "What is the square root of 456?"
v
Main Agent
|
| selects call_subagent_square_root
v
Square Root Subagent
|
| invokes square_root(456)
v
21.3541565
|
v
Main Agent
|
v
"The square root of 456 is approximately 21.35."
7. ¿Dónde encaja el LLM?
Al trabajar en la etapa de los 7 “¿Dónde está?”, anote primero el contrato: las entradas requeridas, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando un paso falla, el fallo debe apuntar a una sola responsabilidad y no a un proceso complicado. Almacene en caché las instrucciones del sistema estables y los esquemas de las herramientas. Reenviar un preámbulo idéntico es una causa común de desperdicio. Al trabajar en la etapa de los 7 “¿Dónde está?”, anote primero el contrato: las entradas requeridas, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Registre los tiempos de ejecución y el costo de tokens o consultas junto con los resultados funcionales. Tener visibilidad del costo desde el principio evita facturas inesperadas cuando el proceso pasa de la fase de demostración a entornos compartidos.
llm = ChatOllama(
model="llama3.2:latest",
base_url="http://localhost:11434",
temperature=0,
)
Ollama / Llama
|
+----------+----------+
| |
v v
Main Agent Subagents
Orchestrator Specialized
Main Agent → powerful reasoning model
Security Agent → security-specialized modelCoding Agent → coding modelSimple Agent → smaller/cheaper model
8. Multi-Agent no significa múltiples LLMs
El enfoque 8 Multi-Agent Does Not funciona mejor cuando se trata como una superficie medible. Capture una transcripción exitosa, un caso de fallo y la nota de reversión antes de ampliar el alcance. Guarde la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de secretos y las banderas de funcionalidad deben estar en un lugar donde los operadores puedan auditarlos sin tener que leer todo el sistema. Establezca un límite de tokens por turno y por sesión. Las herramientas agenciales amplían el contexto de manera excesiva; los límites estrictos evitan que las demostraciones se conviertan en facturas inesperadas.
Model A
|
+-- Agent 1
+-- Agent 2
+-- Agent 3
Model A → Agent 1
Model B → Agent 2
Model C → Agent 3
Agent =
Model
+ Instructions
+ Tools
+ State/Context
+ Decision-making
9. ¿Por qué no dar todas las herramientas a un solo agente?
La etapa de “9 Por Qué No Simplemente” funciona mejor cuando se trata como una superficie medible. Capture un registro clave, un caso de fallo y la nota de reversión antes de ampliar el alcance. Documente tanto el camino óptimo como el camino de recuperación juntos. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras posteriores. Exponga herramientas con esquemas limitados y etiquetas explícitas de efectos secundarios. Los administradores necesitan saber qué llamadas modifican el estado antes de aprobarlas automáticamente.
Orchestrator
|
+-------------------+-------------------+
| | |
v v v
Database Agent Security Agent Research Agent
| | |
PostgreSQL SIEM/Security Web/MCP
|
v
Report Generator
10. Flujo de trabajo multiagente vs. secuencial
La etapa 10 Multi-Agent vs Sequential funciona mejor cuando se trata como una superficie medible. Capture un registro ideal, un caso de fallo y la nota de reversión antes de ampliar el alcance. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando un paso falla, el fallo debe apuntar a una sola responsabilidad y no a un proceso complicado. Mantenga el estado del grafo simple y tipado; los bloques anidados ocultan qué nodo escribió qué campo y causan interrupciones en la continuación del proceso. La etapa 10 Multi-Agent vs Sequential funciona mejor cuando se trata como una superficie medible. Capture un registro ideal, un caso de fallo y la nota de reversión antes de ampliar el alcance. Registre los tiempos y el costo en tokens o consultas junto con los resultados funcionales. Tener visibilidad del costo desde el principio evita facturas inesperadas cuando el proceso pasa de una demostración a entornos compartidos.
Flujo de trabajo secuencial
Para la etapa del flujo de trabajo secuencial, defina las entradas, el responsable de la tarea y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la tarea a partir de un punto de control conocido, sin tener que adivinar el estado oculto. Mantenga la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de datos secretos y las banderas de funcionalidad deben estar en un lugar donde los operadores puedan auditarlos sin necesidad de leer todo el sistema. Coloque la aprobación humana en las conexiones que generan gastos o modifican datos de producción. La configuración en tiempo de compilación no equivale a la completitud del proceso empresarial.
Step 1
↓
Step 2
↓
Step 3
↓
Step 4
Retrieve documents
↓
Analyze documents
↓
Generate report
↓
Send email
Sistema orquestado de múltiples agentes
En la fase del sistema multiagente orquestado, defina las entradas, el responsable de cada paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido, sin tener que adivinar el estado oculto. Documente tanto la ruta óptima como la ruta de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras posteriores. Incluya la aprobación humana en aquellos procesos que generen gastos o modifiquen datos de producción. La conexión en tiempo de compilación no equivale a la completitud del sistema empresarial.
Orchestrator
/ | \
/ | \
Agent A Agent B Agent C
Workflow = predefined control flow
Multi-Agent =
LLM-driven delegation between specialized agents
11. Arquitectura de producción
En la etapa 11 de Arquitectura de Producción, defina las entradas, el responsable de cada paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido, sin tener que adivinar el estado oculto. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando un paso falla, el error debe indicar una única responsabilidad y no un proceso complicado.
User
|
v
+-------------------+
| Orchestrator |
| Agent |
+---------+---------+
|
+----------------+----------------+
| | |
v v v
+-----------+ +-----------+ +-----------+
| Research | | Security | | Database |
| Agent | | Agent | | Agent |
+-----+-----+ +-----+-----+ +-----+-----+
| | |
v v v
Web/MCP SIEM/APIs PostgreSQL
| | |
+----------------+----------------+
|
v
+----------------+
| Final Response |
| / Report Agent |
+----------------+
Research Agent
→ web search
→ document retrieval
→ RAG
Security Agent
→ SIEM
→ vulnerability database
→ security APIsDatabase Agent
→ SQL
→ analyticsReport Agent
→ summarize
→ format
→ email
12. Conclusiones clave
1. Especialice los agentes
Agent → one domain / capability
2. Envuelva los subagentes como herramientas
Main Agent
|
+-- Subagent Tool
3. Deje que el orquestador delegue
4. Mantenga las interfaces simples
Tool name
Description
Arguments
Result
5. Comience de forma sencilla
AI Orchestrator
|
+----------------+----------------+
| | |
Research Coding Security
Agent Agent Agent
| | |
MCP GitHub Security APIs
RAG Tools SIEM
Conclusión
User
↓
Main Agent
↓
Tool representing a subagent
↓
Specialized Subagent
↓
Domain-specific Tool
↓
Result
↓
Main Agent
↓
User