Inicio / Artículos

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.

Editor: REACTAPP.TOP11 min de lectura2636 palabras

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

Lista de verificación operativa