Crea sistemas multiagente con el ADK

1. Introducción

Descripción general

En este lab, aprenderás a organizar sistemas multiagente complejos con el Kit de desarrollo de agentes (ADK de Google) de Google. Pasarás de jerarquías de agentes simples a la creación de flujos de trabajo automatizados y colaborativos.

Qué compilarás

Crearás dos sistemas multiagente distintos:

  • Un agente de planificación de viajes simple que aprende a transferir conversaciones entre un agente de "lluvia de ideas" y un agente de "planificación de atracciones".
  • Un generador de presentaciones de películas más avanzado que usa una "sala de escritores" de agentes automatizados (como un investigador, un guionista y un crítico) para trabajar juntos en un bucle y crear una trama completa de la película.

Qué aprenderás

  • Cómo crear relaciones de agente principal y secundario
  • Cómo escribir datos en la sesión state desde una herramienta
  • Cómo leer desde state con plantillas de claves (p.ej., {my_key?}).
  • Cómo usar un SequentialAgent para flujos de trabajo paso a paso
  • Cómo usar un LoopAgent para crear ciclos de perfeccionamiento iterativos
  • Cómo usar un ParallelAgent para ejecutar tareas independientes de forma simultánea

2. Sistemas de múltiples agentes

El Kit de desarrollo de agentes (ADK) permite a los desarrolladores obtener comportamientos más confiables, sofisticados y de varios pasos de los modelos generativos. En lugar de una instrucción compleja, el ADK te permite crear un flujo de varios agentes más simples que colaboran en un problema dividiendo el trabajo.

Este enfoque tiene varias ventajas en comparación con el uso de una sola instrucción monolítica:

  • Diseño más simple: Es más sencillo diseñar y organizar un flujo de agentes pequeños y especializados que diseñar una instrucción grande y compleja.
  • Confiabilidad: Los agentes especializados son más confiables en sus tareas específicas que un agente grande y complejo.
  • Mantenimiento: Es más fácil corregir o mejorar un agente pequeño y especializado sin dañar otras partes del sistema.
  • Modularidad: Los agentes creados para un flujo de trabajo se pueden reutilizar fácilmente en otros.

El árbol de agentes jerárquico

Estructura de árbol que muestra agentes jerárquicos

En el ADK, organizas los agentes en una estructura de árbol. Esta jerarquía es clave para controlar el flujo de la conversación, ya que limita a qué agente puede "pasar" la conversación a qué otro agente. Esto hace que el comportamiento del sistema sea más predecible y fácil de depurar. Estos son algunos de los beneficios:

  • Diseño intuitivo: La estructura se inspira en equipos del mundo real, lo que facilita el razonamiento.
  • Flujo controlado: La jerarquía te brinda un control preciso sobre la delegación de tareas, lo que ayuda a depurar. Por ejemplo, la estructura de árbol garantiza que se llame al agente de redacción de informes correcto, incluso si tienes dos con descripciones similares.

Toda la estructura comienza con root_agent. Este agente actúa como principal y puede tener uno o más agentes secundarios, que, a su vez, también pueden ser principales de sus propios agentes secundarios, lo que forma el árbol.

3. Configura el proyecto

Cuenta de Google

Si aún no tienes una Cuenta de Google personal, debes crear una.

Usa una cuenta personal en lugar de una cuenta de trabajo o institución educativa.

Accede a la consola de Google Cloud

Accede a la consola de Google Cloud con una Cuenta de Google personal.

Habilitar facturación

Canjea USD 5 en créditos de Google Cloud (opcional)

Para realizar este taller, necesitas una cuenta de facturación con algo de crédito. Si planeas usar tu propia facturación, puedes omitir este paso.

  1. Haz clic en este vínculo y accede con una Cuenta de Google personal.Verás algo como lo siguiente:Haz clic aquí para ir a la página de créditos
  2. Haz clic en el botón HAZ CLIC AQUÍ PARA ACCEDER A TUS CRÉDITOS.Se te dirigirá a una página para configurar tu perfil de facturaciónPágina de configuración del perfil de facturación
  3. Haz clic en Confirmar.

Ahora estás conectado a una cuenta de facturación de prueba de Google Cloud Platform.

Captura de pantalla de la descripción general de la facturación

Configura una cuenta de facturación personal

Si configuraste la facturación con créditos de Google Cloud, puedes omitir este paso.

Para configurar una cuenta de facturación personal, ve aquí para habilitar la facturación en la consola de Cloud.

Algunas notas:

  • Completar este lab debería costar menos de USD 1 en recursos de Cloud.
  • Puedes seguir los pasos al final de este lab para borrar recursos y evitar cargos adicionales.
  • Los usuarios nuevos pueden acceder a la prueba gratuita de USD 300.

Crear un proyecto (opcional)

Si no tienes un proyecto actual que quieras usar para este lab, crea uno nuevo aquí.

4. Abre el editor de Cloud Shell

  1. Haz clic en este vínculo para navegar directamente al editor de Cloud Shell.
  2. Si se te solicita autorización en algún momento, haz clic en Autorizar para continuar.Haz clic para autorizar Cloud Shell
  3. Si la terminal no aparece en la parte inferior de la pantalla, ábrela:
    • Haz clic en Ver.
    • Haz clic en Terminal.Abre una terminal nueva en el editor de Cloud Shell
  4. En la terminal, configura tu proyecto con este comando:
    gcloud config set project [PROJECT_ID]
    • Ejemplo:
      gcloud config set project lab-project-id-example
    • Si no recuerdas el ID de tu proyecto, puedes enumerar todos tus IDs de proyecto con el siguiente comando:
      gcloud projects list
      Establece el ID del proyecto en la terminal del editor de Cloud Shell
  5. Deberías ver el siguiente mensaje:
    Updated property [core/project].

5. Habilita las APIs

Para usar la API de Vertex AI y, así, interactuar con el modelo de Gemini, debes habilitar la API de Vertex AI en tu proyecto de Google Cloud.

  1. En la terminal, habilita la API:
    gcloud services enable aiplatform.googleapis.com

A continuación, se muestran las secciones actualizadas, en las que se reemplaza la creación manual de archivos por instrucciones para clonar el repositorio de GitHub y, luego, instalar las dependencias.

Introducción al SDK de Vertex AI para Python

Para interactuar con los modelos alojados en Vertex AI desde tu aplicación en Python, usarás el SDK de Vertex AI para Python. Este SDK simplifica el proceso de envío de instrucciones, especificación de parámetros del modelo y recepción de respuestas sin necesidad de controlar directamente las complejidades de las llamadas a la API subyacentes.

Puedes encontrar documentación completa para el SDK de Vertex AI para Python aquí: Introducción al SDK de Vertex AI para Python | Google Cloud.

6. Configurar el entorno del proyecto

Clone el repositorio

  1. En la terminal, clona el repositorio que contiene los archivos de inicio.
    git clone --depth 1 https://github.com/GoogleCloudPlatform/devrel-demos.git
    La marca --depth 1 solo clona la versión más reciente, lo que es más rápido.
  2. En la terminal, navega al directorio de trabajo correcto para este lab.
    cd devrel-demos/ai-ml/build-multiagent-systems-with-adk/adk_multiagent_systems

Activa un entorno virtual

  1. En la terminal, crea y activa un entorno virtual con uv:
    uv venv
source .venv/bin/activate
  2. En la terminal, instala google-adk y las demás dependencias del archivo requirements.txt:
    uv pip install -r requirements.txt

Revisa la estructura de tu archivo

Ahora que creaste todos los archivos, abre la carpeta adk_multiagent_systems en el explorador para ver la estructura completa.

  1. En el menú del editor de Cloud Shell, selecciona Archivo > Abrir carpeta….
    Menú Archivo del editor de Cloud Shell con la opción Abrir carpeta seleccionada
  2. En el cuadro emergente, agrega la siguiente información de la carpeta después de tu nombre de usuario: devrel-demos/ai-ml/build-multiagent-systems-with-adk/adk_multiagent_systems/. Haz clic en OK.
    Debería verse algo similar a esto:
    Cuadro de diálogo Abrir carpeta con la ruta del proyecto
  3. Se actualizará el panel del explorador de la izquierda. Ahora deberías ver la estructura completa del proyecto, con los subdirectorios parent_and_subagents y workflow_agents, listos para los próximos pasos.
    Panel del Explorador que muestra la carpeta abierta adk_multiagent_systems

Configura variables de entorno

  1. Ya estás en el directorio adk_multiagent_systems. En la terminal, crea un archivo .env para almacenar tus variables de entorno:
    cloudshell edit .env
  2. Pega lo siguiente en el archivo .env que se abre en el editor:
    GOOGLE_GENAI_USE_VERTEXAI=TRUE
GOOGLE_CLOUD_PROJECT="[YOUR-PROJECT-ID]"
GOOGLE_CLOUD_LOCATION=global
MODEL="gemini-2.5-flash"
  3. Reemplaza [YOUR-PROJECT-ID] por el ID de tu proyecto de Google Cloud. (p.ej., PROJECT_ID = "google-cloud-labs")
    Si no recuerdas el ID de tu proyecto, ejecuta el siguiente comando en tu terminal. Se mostrará una lista de todos tus proyectos y sus IDs.
    gcloud projects list
  4. En la terminal, copia este archivo .env en los directorios de los subagentes para que también puedan acceder a las variables:
    cp .env parent_and_subagents/.env
cp .env workflow_agents/.env
    La estructura del archivo ahora debería verse así:
    Panel del Explorador que muestra la carpeta abierta adk_multiagent_systems

7. Explora las transferencias entre agentes principales, secundarios y pares

La conversación siempre comienza con root_agent. De forma predeterminada, un agente principal usa el description de sus subagentes para decidir cuándo transferir la conversación. También puedes guiar estas transferencias de forma explícita en el instruction del agente principal con el name de los agentes secundarios.

Probemos esto.

  1. En el Editor de Cloud Shell, abre adk_multiagent_systems/parent_and_subagents/agent.py. Observa los tres agentes en el archivo agent.py:
    • root_agent (llamado steering): Le hace una pregunta al usuario para decidir a qué subagente transferir la conversación. Inicialmente, solo se basa en el description de sus subagentes.
    • travel_brainstormer: Ayuda al usuario a generar ideas sobre destinos.
    • attractions_planner: Ayuda al usuario a enumerar las cosas que puede hacer en un país específico.
  2. Haz que travel_brainstormer y attractions_planner sean agentes secundarios de root_agent agregando la siguiente línea a la creación de root_agent:
        sub_agents=[travel_brainstormer, attractions_planner]
  3. En la terminal, chatea con tu agente:
    cd ~/devrel-demos/ai-ml/build-multiagent-systems-with-adk/adk_multiagent_systems
adk run parent_and_subagents
  4. En el mensaje [user]: del terminal, escribe lo siguiente:
    hello
    Resultado de ejemplo (el tuyo puede ser un poco diferente):
    [steering]: Hi there! Do you already have a country in mind for your trip, or would you like some help deciding where to go?
  5. Ahora, dile al agente en la terminal:
    I could use some help deciding.
    Resultado de ejemplo (el tuyo puede ser un poco diferente):
    [travel_brainstormer]: Okay! To give you the best recommendations, I need to understand what you're looking for in a trip.
...
    Observa la etiqueta [travel_brainstormer]. El control transferido de root_agent se basa únicamente en el description del agente secundario.
  6. En el mensaje user: en la terminal, escribe exit y presiona INTRO para finalizar la conversación.
  7. Ahora seamos más explícitos. En agent.py, agrega lo siguiente al instruction de root_agent:
            If they need help deciding, send them to 'travel_brainstormer'.
        If they know what country they'd like to visit, send them to the 'attractions_planner'.
  8. En la terminal, vuelve a ejecutar el agente:
    adk run parent_and_subagents
  9. En el mensaje [user]: del terminal, escribe lo siguiente:
    hello
  10. Responde con lo siguiente:
    I would like to go to Japan.
    Resultado de ejemplo (el tuyo puede ser un poco diferente):
    [attractions_planner]: Okay, I can help you with that! Here are some popular attractions in Japan:
...
    Observa la transferencia a attractions_planner, según las nuevas instrucciones.
  11. Ahora responde con lo siguiente:
    Actually I don't know what country to visit.
    Resultado de ejemplo (el tuyo puede ser un poco diferente):
    [travel_brainstormer]: Okay! I can help you brainstorm some countries for travel...
    Observa que se te transfirió a travel_brainstormer, un par de attractions_planner. Esta opción está habilitada de forma predeterminada.
  12. En el mensaje de usuario, escribe exit para finalizar la sesión.

Resumen

En esta sección, aprendiste los conceptos básicos de la jerarquía de agentes y el flujo de conversación:

  • La conversación siempre comienza con root_agent.
  • Un agente principal puede transferir automáticamente la conversación a un agente secundario según su description.
  • Puedes controlar este flujo de forma explícita si le das al agente principal el instruction para transferir a un agente secundario por su name.
  • De forma predeterminada, los agentes pueden transferir la conversación a sus agentes peer (hermanos en la jerarquía).

8. Usa el estado de la sesión para almacenar y recuperar información

Cada conversación del ADK tiene un Session, que incluye un diccionario de estados de sesión. Todos los agentes pueden acceder a este estado, lo que lo convierte en la forma perfecta de pasar información entre ellos o mantener datos (como una lista) a lo largo de la conversación.

Para explorar cómo agregar datos al estado y leerlos:

  1. Regresa al archivo adk_multiagent_systems/parent_and_subagents/agent.py
  2. Pega la siguiente definición de función después del encabezado # Tools:
    def save_attractions_to_state(
tool_context: ToolContext,
attractions: List[str]
) -> dict[str, str]:
    """Saves the list of attractions to state["attractions"].

    Args:
        attractions [str]: a list of strings to add to the list of attractions

    Returns:
        None
    """
    # Load existing attractions from state. If none exist, start an empty list
    existing_attractions = tool_context.state.get("attractions", [])

    # Update the 'attractions' key with a combo of old and new lists.
    # When the tool is run, ADK will create an event and make
    # corresponding updates in the session's state.
    tool_context.state["attractions"] = existing_attractions + attractions

    # A best practice for tools is to return a status message in a return dict
    return {"status": "success"}
    En este código, observa lo siguiente:
    • La función recibe tool_context: ToolContext. Este objeto es tu puerta de entrada a la sesión.
    • La línea tool_context.state["attractions"] = ... lee y escribe directamente en el diccionario de estado de la sesión. El ADK se encarga del resto.
  3. Agrega la herramienta al agente attractions_planner agregando el parámetro tools:
        tools=[save_attractions_to_state]
  4. Agrega las siguientes viñetas a la instruction existente del agente attractions_planner:
            - When they reply, use your tool to save their selected attraction and then provide more possible attractions.
        - If they ask to view the list, provide a bulleted list of { attractions? } and then suggest some more.
  5. Inicia la IU web del Kit de desarrollo de agentes con el siguiente comando en la terminal:
    adk web
    Salida
    INFO:     Started server process [2434]
INFO:     Waiting for application startup.
+-------------------------------------------------------+
| ADK Web Server started                                |
|                                                       |
| For local testing, access at http://localhost:8000.   |
+-------------------------------------------------------+

INFO:     Application startup complete.
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
  6. En la terminal de Cloud Shell, haz clic en el botón Vista previa en la Web y selecciona Cambiar puerto para ver la interfaz web en una pestaña nueva.
    Menú de vista previa en la Web
  7. Ingresa el número de puerto 8000 y haz clic en Cambiar y obtener vista previa. Se abrirá una nueva pestaña del navegador con la IU de desarrollo del ADK.
    Ventana emergente para cambiar el puerto con 8000 ingresado en el cuadro de texto
  8. En el menú desplegable Select an agent de la izquierda, elige parent_and_subagents.
  9. Comienza la conversación con: hello
  10. Después de que el agente te salude, responde con lo siguiente:
    I'd like to go to Egypt.
    Deberías ser transferido a attractions_planner y recibir una lista de atracciones.
  11. Elige una atracción, por ejemplo:
    I'll go to the Sphinx
  12. Deberías obtener una respuesta como la siguiente: De acuerdo, guardé The Sphinx en tu lista…
  13. Haz clic en el cuadro de herramientas de respuesta (marcado con una marca de verificación) para ver el evento creado a partir de la respuesta de la herramienta.
    Observa que incluye un campo actions que incluye stateDelta, que describe los cambios en el estado.
  14. Responde con otra atracción de la lista del agente.
  15. En el menú de navegación de la izquierda, haz clic en la "X" para salir del enfoque en el evento que inspeccionaste antes.
  16. En la barra lateral izquierda, haz clic en la pestaña Estado. Ahora puedes ver el array attractions en el estado de la sesión, que debería contener los dos elementos seleccionados.Vista previa del estado de la sesión en la IU web
  17. Envía este mensaje al agente:
    What is on my list?
    El agente ahora debería leer el estado y devolver tu lista.
  18. Cuando termines de experimentar con el agente, cierra la pestaña del navegador web y presiona CTRL + C en la terminal de Cloud Shell para detener el servidor.

Resumen de la sección

En esta sección, aprendiste a usar el estado Session para compartir datos:

  • Para escribir el estado: Escribes en el diccionario de estado desde una herramienta, con el objeto tool_context.state (p.ej., tool_context.state["my_list"] = [...]).
  • Para leer el estado: Insertas datos de estado directamente en el instruction de un agente con plantillas de claves (p.ej., Here is your list: {my_list?}).
  • Para inspeccionar el estado: Puedes supervisar el estado de la sesión en vivo en la IU de desarrollo del ADK con la pestaña Estado.

9. Agentes de flujo de trabajo

Hasta ahora, viste cómo un agente principal transfiere a un agente secundario y, luego, espera al usuario. Los agentes de flujo de trabajo son diferentes: ejecutan sus agentes secundarios uno tras otro en un flujo automatizado, sin esperar la entrada del usuario.

Esto es ideal para tareas automatizadas de varios pasos, como una canalización de "Planificar y ejecutar" o "Redactar y revisar". El ADK proporciona tres agentes de flujo de trabajo integrados para administrar esto:

  • SequentialAgent
  • LoopAgent
  • ParallelAgent

El resto de este lab se enfocará en compilar un sistema multiagente con estos tres agentes de flujo de trabajo.

Crearás un agente que desarrollará un documento de presentación para una nueva película sobre un personaje histórico. Tus agentes se encargarán de la investigación, la escritura iterativa y la generación de informes.

Al final, tu sistema se verá de la siguiente manera:

Diagrama de un sistema multiagente film_concept_team

Crearás este sistema paso a paso, comenzando con el flujo de trabajo más simple.

10. Crea un sistema multiagente con un SequentialAgent

Un SequentialAgent es un agente de flujo de trabajo que ejecuta sus agentes secundarios en una secuencia lineal simple. Cada agente de su lista sub_agents se ejecuta uno tras otro, en orden. Esto es perfecto para las canalizaciones en las que las tareas deben realizarse en un orden específico, como el agente de sugerencias de películas que compilarás ahora.

Esta primera versión se estructurará de la siguiente manera:

Film_concept_team multi-agent system step 1

  • Un root_agent (greeter) le dará la bienvenida al usuario y obtendrá el tema de la película.
  • Luego, se transferirá a un SequentialAgent llamado film_concept_team, que hará lo siguiente:
    1. Ejecuta un agente researcher para obtener datos de Wikipedia.
    2. Ejecuta un agente screenwriter para usar esos datos y escribir una trama.
    3. Ejecuta un agente file_writer para guardar el gráfico final en un archivo.

Ejecutémoslo.

  1. En el Editor de Cloud Shell, abre adk_multiagent_systems/workflow_agents/agent.py.
    Lee este archivo de definición de agente. Como los agentes secundarios deben definirse antes de que se les pueda asignar uno principal, para leer el archivo en el orden del flujo conversacional, puedes leer los agentes desde la parte inferior del archivo hasta la parte superior.
  2. Observa la herramienta append_to_state. Esta función auxiliar permite que los agentes agreguen datos a una lista en el estado de la sesión, que es la forma en que researcher y screenwriter pasarán su trabajo.
  3. Prueba el agente. En la terminal, inicia la interfaz web con la recarga en vivo habilitada:
    cd ~/devrel-demos/ai-ml/build-multiagent-systems-with-adk/adk_multiagent_systems
adk web --reload_agents
  4. En la terminal de Cloud Shell, haz clic en el botón Vista previa en la Web y selecciona Cambiar puerto para ver la interfaz web en una pestaña nueva.
    Menú de vista previa en la Web
  5. Ingresa el número de puerto 8000 y haz clic en Cambiar y obtener vista previa. Se abrirá una nueva pestaña del navegador con la IU de desarrollo del ADK.
    Ventana emergente para cambiar el puerto con 8000 ingresado en el cuadro de texto
  6. En el menú desplegable Select an agent, selecciona workflow_agents.
  7. Comienza la conversación con hello. El agente de greeter responderá.
  8. Cuando se te solicite, ingresa una figura histórica. Puedes usar una de estas o tu propia opción:
    • Zhang Zhongjing
    • Ada Lovelace
    • Marco Aurelio
  9. Ahora, se hará cargo el SequentialAgent. No verás ningún mensaje intermedio. researcher, screenwriter y file_writer se ejecutarán uno después del otro. El agente solo responderá cuando se complete toda la secuencia.
    Si falla, puedes hacer clic en + Nueva sesión en la parte superior derecha y volver a intentarlo.
  10. Una vez que el agente confirme que se escribió el archivo, busca y abre el nuevo archivo .txt en el directorio movie_pitches en el editor de Cloud Shell para ver el resultado.
  11. En la IU de desarrollo del ADK, haz clic en el último ícono de agente del historial de chat para abrir la vista de eventos.
  12. La vista de eventos muestra un gráfico visual del árbol de agentes. Puedes ver cómo greeter llamó a film_concept_team, que luego llamó a cada uno de sus subagentes en orden.gráfico web de adk
  13. Puedes hacer clic en las pestañas Solicitud y Respuesta de cualquier agente del gráfico para inspeccionar los datos exactos que se pasaron, incluido el estado de la sesión.

Resumen de la sección

En esta sección, aprendiste a usar un agente de flujo de trabajo:

  • Un SequentialAgent ejecuta sus agentes secundarios uno por uno, en orden, sin esperar la entrada del usuario entre los pasos.
  • Se trata de un "flujo de trabajo" porque el usuario habla con root_agent, que luego le entrega el trabajo a SequentialAgent para que lo complete.
  • Los subagentes de la secuencia usan el estado de la sesión (p.ej., { PLOT_OUTLINE? }) para acceder al trabajo de agentes anteriores.
  • Puedes usar el gráfico de eventos en la IU de desarrollo para visualizar y depurar todo el flujo de trabajo de agente a agente.

11. Agrega un LoopAgent para el trabajo iterativo

El LoopAgent es un agente de flujo de trabajo que ejecuta sus agentes secundarios en una secuencia y, luego, se repite, comenzando desde el principio. Este "bucle" continúa hasta que se cumple una condición, como alcanzar un recuento de max_iterations o que un subagente llame a la herramienta integrada exit_loop.

Es útil para tareas que requieren un perfeccionamiento iterativo. Agregarás este LoopAgent para crear una "sala de escritores" para tu agente de presentación de películas. Esto permite que un researcher, un screenwriter y un nuevo agente critic trabajen en un bucle, lo que mejora la trama con cada pasada hasta que el critic decide que está lista. Esto también ayuda al agente a controlar las entradas de usuario más vagas (como "un médico antiguo") permitiéndole investigar y definir una idea.

Film_concept_team multi-agent system step 2

Para hacer estos cambios, sigue estos pasos:

  1. En adk_multiagent_systems/workflow_agents/agent.py, agrega la importación para exit_loop (cerca de las otras importaciones de google.adk):
    from google.adk.tools import exit_loop
  2. Agrega el nuevo agente critic. Este agente revisará la trama. Si es bueno, llama a exit_loop. De lo contrario, agrega comentarios al estado para el siguiente bucle.
    Pega la siguiente definición del agente en la sección # Agents:
    critic = Agent(
    name="critic",
    model=model_name,
    description="Reviews the outline so that it can be improved.",
    instruction="""
    INSTRUCTIONS:
    Consider these questions about the PLOT_OUTLINE:
    - Does it meet a satisfying three-act cinematic structure?
    - Do the characters' struggles seem engaging?
    - Does it feel grounded in a real time period in history?
    - Does it sufficiently incorporate historical details from the RESEARCH?

    If the PLOT_OUTLINE does a good job with these questions, exit the writing loop with your 'exit_loop' tool.
    If significant improvements can be made, use the 'append_to_state' tool to add your feedback to the field 'CRITICAL_FEEDBACK'.
    Explain your decision and briefly summarize the feedback you have provided.

    PLOT_OUTLINE:
    { PLOT_OUTLINE? }

    RESEARCH:
    { research? }
    """,
    before_model_callback=log_query_to_model,
    after_model_callback=log_model_response,
    tools=[append_to_state, exit_loop]
)
  3. Crea el LoopAgent de writers_room. Contendrá los tres agentes que trabajarán en el bucle.
    Pega el siguiente código arriba de la definición del agente film_concept_team:
    writers_room = LoopAgent(
    name="writers_room",
    description="Iterates through research and writing to improve a movie plot outline.",
    sub_agents=[
        researcher,
        screenwriter,
        critic
    ],
    max_iterations=5,
)
  4. Actualiza el SequentialAgent de film_concept_team para usar el nuevo bucle writers_room. Reemplaza researcher y screenwriter por el único agente writers_room.Reemplaza tu definición de film_concept_team existente por esta:
    film_concept_team = SequentialAgent(
    name="film_concept_team",
    description="Write a film plot outline and save it as a text file.",
    sub_agents=[
        writers_room,
        file_writer
    ],
)
  5. Vuelve a la pestaña de la IU de desarrollo del ADK y haz clic en + New Session en la parte superior derecha.
  6. Comienza una nueva conversación con: hello
  7. Cuando se te solicite, indícale al agente un tema más amplio esta vez. Estas son algunas ideas:
    • que diseñó productos para las masas
    • un cartógrafo (un creador de mapas)
    • que hizo que los cultivos produjeran más alimentos
    El agente ahora trabajará en el bucle. En la IU de desarrollo del ADK, verás los registros a medida que los agentes se ejecuten varias veces (p.ej., "[investigador]", "[guionista]", "[crítico]", "[investigador]", "[guionista]", "[crítico]…").
  8. Cuando se complete el bucle, el agente escribirá el archivo. Revisa el archivo generado en el directorio adk_multiagent_systems/movie_pitches.
  9. Inspecciona el gráfico de eventos en la IU para desarrolladores y observa la estructura del bucle.

Resumen de la sección

En esta sección, aprendiste a usar LoopAgent de la siguiente manera:

  • Un LoopAgent es un agente de flujo de trabajo que repite su secuencia de agentes secundarios, lo que crea un "bucle interno" para las tareas iterativas.
  • Los agentes dentro del bucle usan el estado de la sesión para pasar el trabajo (p.ej., PLOT_OUTLINE) y comentarios (p.ej., CRITICAL_FEEDBACK) entre sí en pases posteriores.
  • El bucle se puede detener cuando se alcanza un límite de max_iterations o cuando un agente llama a la herramienta exit_loop.

12. Usa un ParallelAgent para "distribuir y recopilar"

El ParallelAgent es un agente de flujo de trabajo que ejecuta todos sus agentes secundarios al mismo tiempo (de forma simultánea). Esto es valioso para tareas que se pueden dividir en subtareas independientes, como ejecutar dos trabajos de investigación diferentes.

Usarás un ParallelAgent para crear un "equipo de preproducción" que trabaje en paralelo. Un agente investigará el potencial de taquilla, mientras que otro generará ideas de casting de forma simultánea. Esto suele llamarse patrón de "distribución y recopilación": ParallelAgent "distribuye" el trabajo, y un agente posterior (nuestro file_writer) "recopila" los resultados.

Film_concept_team multi-agent system step 3

El flujo final del agente será el siguiente:

  1. El greeter (raíz) inicia el chat.
  2. Se transfiere al film_concept_team (SequentialAgent), que ejecuta lo siguiente:
    • Es el writers_room (LoopAgent) para crear el gráfico.
    • El nuevo preproduction_team (ParallelAgent) para investigar la taquilla y el elenco al mismo tiempo.
    • El file_writer para recopilar todos los resultados y guardar el archivo.

Para hacer estos cambios, sigue estos pasos:

  1. En adk_multiagent_systems/workflow_agents/agent.py, pega el nuevo ParallelAgent y sus subagentes en el encabezado # Agents.
    box_office_researcher = Agent(
    name="box_office_researcher",
    model=model_name,
    description="Considers the box office potential of this film",
    instruction="""
    PLOT_OUTLINE:
    { PLOT_OUTLINE? }

    INSTRUCTIONS:
    Write a report on the box office potential of a movie like that described in PLOT_OUTLINE based on the reported box office performance of other recent films.
    """,
    output_key="box_office_report"
)

casting_agent = Agent(
    name="casting_agent",
    model=model_name,
    description="Generates casting ideas for this film",
    instruction="""
    PLOT_OUTLINE:
    { PLOT_OUTLINE? }

    INSTRUCTIONS:
    Generate ideas for casting for the characters described in PLOT_OUTLINE
    by suggesting actors who have received positive feedback from critics and/or
    fans when they have played similar roles.
    """,
    output_key="casting_report"
)

preproduction_team = ParallelAgent(
    name="preproduction_team",
    sub_agents=[
        box_office_researcher,
        casting_agent
    ]
)
  2. Actualiza la lista sub_agents de SequentialAgent del film_concept_team para incluir el nuevo preproduction_team (entre writers_room y file_writer).Reemplaza la definición de film_concept_team existente por esta:
    film_concept_team = SequentialAgent(
    name="film_concept_team",
    description="Write a film plot outline and save it as a text file.",
    sub_agents=[
        writers_room,
        preproduction_team,
        file_writer
    ],
)
  3. Actualiza el instruction del agente file_writer para que "recopile" los informes nuevos del estado y los agregue al archivo.
    Reemplaza la cadena instruction por file_writer con lo siguiente:
        instruction="""
    INSTRUCTIONS:
    - Create a marketable, contemporary movie title suggestion for the movie described in the PLOT_OUTLINE.
    If a title has been suggested in PLOT_OUTLINE, you can use it, or replace it with a better one.
    - Use your 'write_file' tool to create a new txt file with the following arguments:
    - for a filename, use the movie title
    - Write to the 'movie_pitches' directory.
    - For the 'content' to write, include:
    - The PLOT_OUTLINE
    - The BOX_OFFICE_REPORT
    - The CASTING_REPORT

    PLOT_OUTLINE:
    { PLOT_OUTLINE? }

    BOX_OFFICE_REPORT:
    { box_office_report? }

    CASTING_REPORT:
    { casting_report? }
    """,
  4. Vuelve a la pestaña de la IU de desarrollo del ADK y haz clic en + New Session.
  5. Ingresa hello para iniciar la conversación.
  6. Cuando se te solicite, ingresa una nueva idea de personaje. Estas son algunas ideas:
    • la actriz que inventó la tecnología wifi
    • un chef emocionante
    • en las exposiciones de las ferias mundiales
  7. Cuando el agente complete su trabajo, inspecciona el archivo final en el directorio adk_multiagent_systems/movie_pitches. Ahora debería contener el argumento, el informe de taquilla y el informe de casting, todo en un solo documento.

Resumen de la sección

En esta sección, aprendiste a usar ParallelAgent de la siguiente manera:

  • Un trabajo de ParallelAgent se "expande" y ejecuta todos sus agentes secundarios al mismo tiempo, en lugar de hacerlo en secuencia.
  • Esto es muy eficiente para las tareas que no dependen entre sí (como investigar dos temas diferentes).
  • Un agente posterior "recopila" los resultados de los agentes paralelos. Para ello, los agentes paralelos guardan su trabajo en el estado de la sesión (con output_key), y un agente final (como file_writer) lee esas claves.

13. Agentes de flujo de trabajo personalizados

Cuando los agentes de flujo de trabajo predefinidos de SequentialAgent, LoopAgent y ParallelAgent no son suficientes para tus necesidades, CustomAgent proporciona la flexibilidad para implementar una nueva lógica de flujo de trabajo.

Puedes definir patrones para el control de flujo, la ejecución condicional o la administración de estados entre agentes secundarios. Esto es útil para flujos de trabajo complejos, orquestaciones con estado o la integración de lógica empresarial personalizada en la capa de orquestación del framework.

La creación de un CustomAgent no se aborda en este lab, pero es bueno saber que existe si lo necesitas.

14. ¡Felicitaciones!

Creaste con éxito un sistema multiagente sofisticado con el Kit de desarrollo de agentes (ADK) de Google. Pasaste de una simple relación de agente principal y secundario a la organización de flujos de trabajo complejos y automatizados que pueden investigar, escribir y perfeccionar un proyecto creativo.

Resumen

En este lab, realizaste las siguientes tareas:

  • Agentes organizados en un árbol jerárquico con relaciones de agente principal y secundario
  • Transferencias controladas de agente a agente, tanto de forma automática (con description) como explícita (con instruction).
  • Se usó una herramienta para escribir datos en el diccionario tool_context.state.
  • Se usó la plantilla de claves (p.ej., { PLOT_OUTLINE? }) para leer el estado de la sesión y guiar la instrucción de un agente.
  • Se implementó un SequentialAgent para crear un flujo de trabajo simple paso a paso (investigación -> escritura -> guardar).
  • Se usó un LoopAgent con un agente critic y la herramienta exit_loop para crear un ciclo de perfeccionamiento iterativo.
  • Se usó un ParallelAgent para "expandir" tareas independientes (como la investigación de casting y de taquilla) para que se ejecuten de forma simultánea.

Experimentación continua

Hay muchas formas de aprovechar lo que aprendiste. A continuación, le proponemos algunas ideas:

  • Agrega más agentes: Intenta agregar un agente nuevo a tu preproduction_team ParallelAgent. Por ejemplo, podrías crear un marketing_agent que escriba un eslogan para la película en función del PLOT_OUTLINE.
  • Agregar más herramientas: Dale más herramientas a tu agente de researcher. Podrías crear una herramienta que use una API de la Búsqueda de Google para encontrar información que no esté en Wikipedia.
  • Explorar CustomAgent: En el lab, se mencionó el CustomAgent para los flujos de trabajo que no se ajustan a las plantillas estándares. Intenta compilar uno que, por ejemplo, ejecute un agente de forma condicional solo si existe una clave específica en el estado de la sesión.