GENAI106

Descripción general

En este lab, se explica cómo organizar sistemas multiagente con el Kit de desarrollo de agentes de Google (ADK de Google).

En este lab, se supone que conoces los conceptos básicos del ADK y el uso de herramientas, como se explica en los siguientes labs:

• Comienza a usar el Kit de desarrollo de agentes (ADK) de Google
• Potencia los agentes del ADK con herramientas

Objetivos

En este lab, aprenderás a hacer lo siguiente:

• Definir varios agentes y conectarlos entre sí con relaciones de agente superior a agente secundario
• Crear contenido en varios turnos de conversación y varios agentes escribiendo en el diccionario de estado de una sesión
• Instruir a los agentes para que lean valores del estado de la sesión y los usen como contexto para sus respuestas
• Usar agentes de flujo de trabajo para pasar la conversación entre agentes directamente

Configuración y requisitos

Antes de hacer clic en el botón Comenzar lab

Lee estas instrucciones. Los labs son cronometrados y no se pueden pausar. El temporizador, que comienza a funcionar cuando haces clic en Comenzar lab, indica por cuánto tiempo tendrás a tu disposición los recursos de Google Cloud.

Este lab práctico te permitirá realizar las actividades correspondientes en un entorno de nube real, no en uno de simulación o demostración. Para ello, se te proporcionan credenciales temporales nuevas que utilizarás para acceder a Google Cloud durante todo el lab.

Para completar este lab, necesitarás lo siguiente:

• Acceso a un navegador web estándar. Se recomienda el navegador Chrome.

• Tiempo para completar el lab (recuerda que, una vez que comienzas un lab, no puedes pausarlo).

Cómo iniciar tu lab y acceder a la consola de Google Cloud

1. Haz clic en el botón Comenzar lab. Si debes pagar por el lab, se abrirá un diálogo para que selecciones la forma de pago. A la izquierda, se encuentra el panel Detalles del lab, que tiene estos elementos:

   • El botón para abrir la consola de Google Cloud
   • El tiempo restante
   • Las credenciales temporales que debes usar para el lab
   • Otra información para completar el lab, si es necesaria

2. Haz clic en Abrir la consola de Google Cloud (o haz clic con el botón derecho y selecciona Abrir el vínculo en una ventana de incógnito si ejecutas el navegador Chrome).

   El lab inicia recursos y abre otra pestaña en la que se muestra la página de acceso.

   Sugerencia: Ordena las pestañas en ventanas separadas, una junto a la otra.

   Nota: Si ves el diálogo Elige una cuenta, haz clic en Usar otra cuenta.

3. De ser necesario, copia el nombre de usuario a continuación y pégalo en el diálogo Acceder.

   {{{user_0.username | "Username"}}}

   También puedes encontrar el nombre de usuario en el panel Detalles del lab.

4. Haz clic en Siguiente.

5. Copia la contraseña que aparece a continuación y pégala en el diálogo Te damos la bienvenida.

   {{{user_0.password | "Password"}}}

   También puedes encontrar la contraseña en el panel Detalles del lab.

6. Haz clic en Siguiente.

   Importante: Debes usar las credenciales que te proporciona el lab. No uses las credenciales de tu cuenta de Google Cloud. Nota: Usar tu propia cuenta de Google Cloud para este lab podría generar cargos adicionales.

7. Haz clic para avanzar por las páginas siguientes:

   • Acepta los términos y condiciones.
   • No agregues opciones de recuperación ni autenticación de dos factores, ya que esta cuenta es temporal.
   • No te registres para obtener pruebas gratuitas.

Después de un momento, se abrirá la consola de Google Cloud en esta pestaña.

Nota: Para acceder a los productos y servicios de Google Cloud, haz clic en el menú de navegación o escribe el nombre del servicio o producto en el campo Buscar.

Sistemas multiagente

El Kit de desarrollo de agentes permite a los desarrolladores obtener comportamientos más confiables, sofisticados y de varios pasos de los modelos generativos. En lugar de escribir instrucciones largas y complejas que pueden dar resultados poco confiables, puedes crear un flujo de varios agentes simples que colaboren en problemas complejos dividiendo tareas y responsabilidades.

Este enfoque arquitectónico ofrece varias ventajas clave, como las siguientes:

• Diseño más sencillo: Puedes pensar en términos de agentes con trabajos y habilidades específicos.
• Funciones especializadas con un rendimiento más confiable: Los agentes especializados pueden aprender de ejemplos claros para ser más confiables en sus tareas específicas.
• Organización: Dividir el flujo de trabajo en agentes distintos ofrece un enfoque más organizado y, por lo tanto, más fácil de entender.
• Capacidad de mejora y mantenimiento: Es más fácil mejorar o corregir un componente especializado que realizar cambios en un agente complejo que puede corregir un comportamiento, pero que podría afectar a otros.
• Modularidad: Los agentes distintos de un flujo de trabajo se pueden copiar fácilmente y se pueden incluir en otros flujos de trabajo similares.

El árbol de agentes jerárquico

En el Kit de desarrollo de agentes, organizas tus agentes en una estructura de árbol. Esto facilita limitar las opciones de transferencia para cada agente en el árbol, lo que simplifica el control y la predicción de las posibles rutas que puede tomar la conversación a través del árbol. Estos son algunos de los beneficios de la estructura jerárquica:

• Se inspira en equipos colaborativos del mundo real, lo que facilita el diseño y el razonamiento sobre el comportamiento del sistema multiagente.
• Es intuitiva para los desarrolladores, ya que refleja patrones comunes de desarrollo de software.
• Proporciona mayor control sobre el flujo de información y la delegación de tareas dentro del sistema, lo que facilita entender las posibles rutas y depurar el sistema. Por ejemplo, si un sistema tiene dos agentes de generación de informes en diferentes partes de su flujo con descripciones similares, la estructura de árbol facilita garantizar que se invoque el agente correcto.

La estructura siempre comienza con el agente definido en la variable root_agent (aunque puede tener un nombre diferente para identificarse ante el usuario). El root_agent puede actuar como superior de uno o más agentes secundarios. Cada agente secundario puede tener sus propios agentes secundarios.

Tarea 1: Instala el ADK y configura tu entorno

En este entorno de lab, ya se habilitó la API de Agent Platform. Si siguieras estos pasos en tu propio proyecto, deberías ir a Agent Platform y seguir las instrucciones para habilitarla.

Prepara una pestaña del editor de Cloud Shell

1. Con la ventana de la consola de Google Cloud seleccionada, abre Cloud Shell presionando la tecla G y, luego, la tecla S. También puedes hacer clic en el botón Activar Cloud Shell () en la parte superior derecha de la consola de Cloud.
2. Haz clic en Continuar.
3. Cuando se te solicite que autorices Cloud Shell, haz clic en Autorizar.
4. En la esquina superior derecha del panel de la terminal de Cloud Shell, haz clic en el botón Abrir en una ventana nueva .
5. Haz clic en el ícono de lápiz de Abrir Editor () en la parte superior del panel para ver los archivos.
6. En la parte superior del menú de navegación de la izquierda, haz clic en el ícono del Explorador () para abrir el explorador de archivos.
7. Haz clic en el botón Abrir carpeta.
8. En el diálogo Abrir carpeta que aparece, haz clic en OK para seleccionar la carpeta principal de tu cuenta de estudiante de Qwiklabs.
9. Cierra cualquier instructivo adicional o panel de Gemini que aparezca en el lado derecho de la pantalla para que el editor de código tenga más espacio en la ventana.
10. Durante el resto de este lab, puedes trabajar en la ventana como tu IDE con el Editor y la terminal de Cloud Shell.

Descarga e instala el ADK y las muestras de código para este lab

1. Pega los siguientes comandos en la terminal de Cloud Shell para copiar archivos de código de un bucket de Cloud Storage para este lab:

   gcloud storage cp -r gs://{{{project_0.project_id| YOUR_GCP_PROJECT_ID}}}-bucket/* .

2. Actualiza tu variable de entorno PATH e instala el ADK y los requisitos adicionales del lab ejecutando los siguientes comandos en la terminal de Cloud Shell.

   export PATH=$PATH:"/home/${USER}/.local/bin" python3 -m pip install google-adk[otel-gcp]==1.30.0 -r adk_multiagent_systems/requirements.txt

Tarea 2: Explora las transferencias entre agentes superiores, secundarios y pares

La conversación siempre comienza con el agente que fue designado con la variable root_agent.

El comportamiento predeterminado de un agente superior es comprender la descripción de cada agente secundario y determinar si el control de la conversación debe transferirse a un agente secundario en algún momento.

Puedes guiar esas transferencias en la instruction del agente superior haciendo referencia a los agentes secundarios por su nombre (los valores de sus parámetros name, no sus nombres de variables). Prueba con un ejemplo:

1. En la terminal de Cloud Shell, ejecuta el siguiente comando para crear un archivo .env y autenticar el agente en el directorio parent_and_subagents.

   cd ~/adk_multiagent_systems cat << EOF > parent_and_subagents/.env GOOGLE_GENAI_USE_VERTEXAI=TRUE GOOGLE_CLOUD_PROJECT={{{project_0.project_id| YOUR_GCP_PROJECT_ID}}} GOOGLE_CLOUD_LOCATION=global MODEL={{{project_0.startup_script.gemini_flash_model_id | gemini_flash_model_id}}} EOF

   Estas variables cumplen las siguientes funciones:

   • GOOGLE_GENAI_USE_VERTEXAI=TRUE indica que usarás Agent Platform para la autenticación en lugar de la autenticación con clave de API de Gemini.
   • GOOGLE_CLOUD_PROJECT y GOOGLE_CLOUD_LOCATION proporcionan el proyecto y la ubicación con los que se asociarán las llamadas al modelo.
   • MODEL se almacena aquí para que se pueda cargar como otra variable de entorno.

2. Ejecuta el siguiente comando para copiar ese archivo .env en el directorio workflow_agents, que usarás más adelante en el lab:

   cp parent_and_subagents/.env workflow_agents/.env

3. En el panel del explorador de archivos del editor de Cloud Shell, navega al directorio adk_multiagent_systems/parent_and_subagents.

4. Haz clic en el archivo agent.py para abrirlo.

5. Observa que hay tres agentes aquí:

   • un root_agent llamado steering (su nombre se usa para identificarlo en la IU de desarrollo y las interfaces de línea de comandos del ADK). Le hace una pregunta al usuario (si sabe a dónde le gustaría viajar o si necesita ayuda para decidir), y la respuesta del usuario a esa pregunta ayudará al agente de dirección a saber hacia cuál de sus dos agentes secundarios dirigir la conversación. Observa que solo tiene una instruction simple que no menciona a los agentes secundarios, pero conoce las descripciones de sus agentes secundarios
   • un travel_brainstormer que ayuda al usuario a obtener ideas de destinos si no sabe adónde le gustaría ir
   • un attactions_planner que ayuda al usuario a crear una lista de actividades para hacer una vez que sabe qué país le gustaría visitar

6. Haz que travel_brainstormer y attractions_planner sean subagentes del root_agent agregando la siguiente línea a la creación del root_agent:

   sub_agents=[travel_brainstormer, attractions_planner]

7. Guarda el archivo.

8. Ten en cuenta que no se agrega el parámetro parent correspondiente a los agentes secundarios. El árbol jerárquico se define solo especificando sub_agents cuando se crean agentes superiores.

9. En la terminal de Cloud Shell, usa la interfaz de línea de comandos del ADK para chatear con tu agente ejecutando este comando:

   cd ~/adk_multiagent_systems adk run parent_and_subagents

10. Cuando se te presente la instrucción [user]:, saluda al agente con lo siguiente:

    hello

    Resultado de ejemplo (el tuyo puede ser un poco diferente):

    [user]: hello [steering]: Hello! Welcome to your travel adventure. Do you already know where you'd like to travel, or would you like some help deciding?

11. Dile al agente lo siguiente:

    I could use some help deciding.

    Resultado de ejemplo (el tuyo puede ser un poco diferente):

    [user]: I could use some help deciding. [travel_brainstormer]: Hello! I'd love to help you decide on the perfect destination for your next trip. To start, here are a few highly popular countries that travelers love: * **Italy:** Famous for food, history, art, and beautiful landscapes. * **Japan:** A unique blend of ultra-modern cities, ancient temples, stunning nature, and incredible cuisine. * **Costa Rica:** A paradise for nature lovers, wildlife, and outdoor adventures. * **France:** Renowned for world-class art, fashion, gastronomy, and romantic cities. To help narrow things down to the perfect match for you, what are your primary goals for this trip? Are you looking for: 1. **Adventure** (hiking, wildlife, outdoor activities) 2. **Leisure** (relaxing on beaches, spas, slow-paced exploring) 3. **Learning** (history, museums, exploring different cultures) 4. **Shopping** (fashion, local markets, unique finds) 5. **Viewing Art** (galleries, architecture, world-famous masterpieces) Let me know what sounds most exciting to you, or if you have a mix of these in mind!

12. Observa que se usó el nombre [travel_brainstormer] entre corchetes en la respuesta, por lo que sabemos que el root_agent (llamado [steering]) transfirió la conversación al subagente adecuado solo en función de la description de ese subagente.

13. En el prompt user:, ingresa exit para finalizar la conversación.

14. También puedes proporcionarle a tu agente instrucciones más detalladas sobre cuándo transferir a un agente secundario como parte de sus instructions. En el archivo agent.py, agrega las siguientes líneas a la instruction del 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'.

15. Guarda el archivo.

16. En la terminal de Cloud Shell, ejecuta lo siguiente para iniciar la interfaz de línea de comandos nuevamente:

    adk run parent_and_subagents

17. Saluda al agente con lo siguiente:

    hello

18. Responde al saludo del agente con lo siguiente:

    I would like to go to Japan.

    Resultado de ejemplo (el tuyo puede ser un poco diferente):

    [user]: I would like to go to Japan. [attractions_planner]: Japan is an incredible destination with a perfect blend of ancient traditions and futuristic cities! Here are some of the top attractions and regions to consider for your trip, categorized by the type of experience: ### 1. **The Modern & Futuristic (Tokyo)** * **Shibuya Crossing & Harajuku:** Experience the bustling energy of the world's busiest pedestrian crossing and the quirky fashion of Takeshita Street. * **teamLab Planets:** An immersive, digital-art museum where you walk through water and interact with stunning light projections. * **Senso-ji Temple:** Tokyo's oldest and most iconic Buddhist temple, located in the historic Asakusa district. ### 2. **History & Tradition (Kyoto & Nara)** * **Fushimi Inari Shrine (Kyoto):** Famous for its path of thousands of vibrant red torii gates winding up the mountain. * **Kinkaku-ji (The Golden Pavilion, Kyoto):** A breathtaking Zen temple covered in gold leaf, reflecting over a serene pond. * **Nara Park (Nara):** Home to hundreds of freely roaming, bowing deer and the massive Great Buddha statue at Todai-ji Temple. ### 3. **Nature & Scenic Views** * **Mount Fuji & Lake Kawaguchiko:** Enjoy stunning views of Japan's iconic volcano, especially beautiful during cherry blossom or autumn foliage seasons. * **Arashiyama Bamboo Grove (Kyoto):** Walk through a towering forest of green bamboo that feels like another world. ### 4. **Food & Entertainment (Osaka)** * **Dotonbori:** Osaka's neon-lit food street, famous for street foods like *takoyaki* (octopus balls) and *okonomiyaki* (savory pancakes). * **Osaka Castle:** A magnificent historic landmark surrounded by a massive park and moat. --- To help me tailor the perfect itinerary for you, **what kinds of things are you most interested in?** * Historic temples and shrines? * Modern city life and pop culture (anime, gaming, shopping)? * Nature, hiking, and scenic landscapes? * Incredible food and culinary experiences? Let me know, and we can start building your custom list of stops!

19. Ten en cuenta que se te transfirió al otro subagente, attractions_planner.

20. Responde con lo siguiente:

    Actually I don't know what country to visit.

    Resultado de ejemplo (el tuyo puede ser un poco diferente):

    user: actually I don't know what country to visit [travel_brainstormer]: Okay! I can help you brainstorm some countries for travel...

21. Observa que se te transfirió al agente travel_brainstormer, que es un agente par de attractions_planner. Esta opción está habilitada de forma predeterminada. Si quieres evitar las transferencias a pares, puedes establecer el parámetro disallow_transfer_to_peers en True en el agente attractions_planner.

22. En el prompt user, escribe exit para finalizar la sesión.

Haz clic en Revisar mi progreso para verificar el objetivo. Explorar las transferencias entre agentes superiores, secundarios y pares

Tarea 3: Usa el estado de la sesión para almacenar y recuperar información específica

Cada conversación en el ADK se encuentra dentro de una Session, a la que pueden acceder todos los agentes involucrados en la conversación. Una sesión incluye el historial de conversación, que los agentes leen como parte del contexto que usan para generar respuestas. La sesión también incluye un diccionario de estado de la sesión, que puedes usar para tener un mayor control sobre la información más importante que te gustaría destacar y cómo se accede a ella.

Esto puede ser particularmente útil para pasar información entre agentes o para mantener una estructura de datos simple, como una lista de tareas, durante una conversación con un usuario.

Para explorar cómo agregar datos al estado y leerlos, haz lo siguiente:

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"}

3. En este código, observa lo siguiente:

   • La sesión se pasa a tu función de herramienta como ToolContext. Todo lo que debes hacer es asignar un parámetro para recibirlo, como se ve aquí con el parámetro llamado tool_context. Luego, puedes usar tool_context para acceder a la información de la sesión, como el historial de conversaciones (a través de tool_context.events) y el diccionario de estado de la sesión (a través de tool_context.state). Cuando tu función de herramienta modifica el diccionario tool_context.state, esos cambios se reflejan en el estado de la sesión después de que la herramienta termina su ejecución.
   • La cadena de documentación proporciona una descripción clara y secciones para los argumentos y los valores de devolución.
   • El código de la función comentado demuestra lo fácil que es actualizar el diccionario de estado.

4. Agrega la herramienta al agente attractions_planner agregando el parámetro tools cuando se cree el agente:

   tools=[save_attractions_to_state]

5. 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.

6. Observa la sección entre llaves: { attractions? }. Esta función del ADK, plantilla de claves, carga el valor de la clave attractions del diccionario de estados. El signo de interrogación después de la clave attractions evita que se produzca un error si el campo aún no está presente.

7. Ahora ejecutarás el agente desde la interfaz web, que proporciona una pestaña para que veas los cambios que se realizan en el estado de la sesión. Inicia la IU web del Kit de desarrollo de agentes con el siguiente comando:

   adk web --allow_origins "regex:https://.*\.cloudshell\.dev"

   Resultado

   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)

8. Para ver la interfaz web en una pestaña nueva, haz clic en el vínculo http://127.0.0.1:8000 en el resultado de la terminal.

9. Se abrirá una nueva pestaña del navegador con la IU de desarrollo del ADK.

10. En el menú desplegable Seleccionar un agente de la izquierda, elige el agente parent_and_subagents.

11. Comienza la conversación con: hola

12. Después de que el agente te salude, responde con lo siguiente:

    I'd like to go to Egypt.

    Se te debería transferir a attractions_planner y deberías recibir una lista de atracciones.

13. Elige una atracción, por ejemplo:

    I'll go to the Sphinx

14. Deberías recibir un acuse de recibo en la respuesta, como el siguiente: Bien, guardé la Esfinge en tu lista. Aquí tienes otras atracciones…

15. Haz clic en el cuadro de herramientas de respuesta (el que tiene 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 state_delta, que describe los cambios en el estado.

16. El agente debería pedirte que selecciones más atracciones. Responde al agente nombrando una de las opciones que te presentó.

17. En el menú de navegación de la izquierda, haz clic en la "X" para salir del enfoque en el evento que inspeccionaste antes.

18. Ahora, en la barra lateral, deberías ver la lista de eventos y algunas opciones de pestañas. Selecciona la pestaña State. Aquí puedes ver el estado actual, incluido tu array attractions con los dos valores que solicitaste.

    

19. Envía este mensaje al agente:

    What is on my list?

20. Debería devolver tu lista con el formato de una lista con viñetas según su instruction.

21. 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.

    Más adelante en este lab, demostrarás cómo usar el estado para la comunicación entre agentes.

Haz clic en Revisar mi progreso para verificar el objetivo. Usar el estado de la sesión para almacenar y recuperar información específica

Agentes de flujo de trabajo

Las transferencias de agente superior a agente secundario son ideales cuando tienes varios agentes secundarios especialistas y quieres que el usuario interactúe con cada uno de ellos.

Sin embargo, si quieres que los agentes actúen uno tras otro sin esperar al turno del usuario, puedes usar agentes de flujo de trabajo. Estas son algunas situaciones de ejemplo en las que podrías usar agentes de flujo de trabajo:

• Planificar y ejecutar: Cuando quieres que un agente prepare una lista de elementos y, luego, que otros agentes usen esa lista para realizar tareas de seguimiento, por ejemplo, escribir secciones de un documento
• Investigar y escribir: Cuando quieres que un agente llame a funciones para recopilar información contextual de la Búsqueda de Google o de otras fuentes de datos, y que otro agente use esa información para producir algún resultado
• Borradores y revisiones: Cuando quieres que un agente prepare un borrador de un documento y, luego, que otros agentes revisen el trabajo y lo iteren

Para realizar este tipo de tareas, los agentes de flujo de trabajo tienen agentes secundarios y garantizan que cada uno de ellos actúe. El Kit de desarrollo de agentes proporciona tres agentes de flujo de trabajo integrados y la oportunidad de definir los tuyos:

• SequentialAgent
• LoopAgent
• ParallelAgent

Durante el resto de este lab, crearás un sistema multiagente que usa varios agentes de LLM, agentes de flujo de trabajo y herramientas para controlar el flujo del agente.

Específicamente, crearás un agente que desarrollará un documento de presentación para una nueva película exitosa: una película biográfica basada en la vida de un personaje histórico. Tus agentes secundarios se encargarán de la investigación, un ciclo de escritura iterativo con un guionista y un crítico, y, por último, algunos agentes secundarios adicionales ayudarán a generar ideas de elenco y usarán datos históricos de taquilla para hacer algunas predicciones sobre los resultados de taquilla.

Al final, tu sistema multiagente se verá así (puedes hacer clic en la imagen para verla más grande):

Pero comenzarás con una versión más simple.

Tarea 4: Comienza a crear un sistema multiagente con un SequentialAgent

El SequentialAgent ejecuta sus agentes secundarios en una secuencia lineal. Cada agente secundario de su lista sub_agents se ejecuta uno tras otro en el orden en que se definen.

Esta opción es ideal para flujos de trabajo en los que las tareas deben realizarse en un orden específico y el resultado de una tarea sirve como entrada para la siguiente.

En esta tarea, ejecutarás un SequentialAgent para crear una primera versión de tu sistema multiagente de desarrollo de ideas para películas. El primer borrador de tu agente se estructurará de la siguiente manera:

• Un root_agent llamado greeter para darle la bienvenida al usuario y solicitar un personaje histórico como tema de una película

• Un SequentialAgent llamado film_concept_team incluirá lo siguiente:

  • Un investigador para obtener más información sobre la figura histórica solicitada de Wikipedia, usando una herramienta de LangChain que se aborda en el lab Potencia los agentes del ADK con herramientas. Un agente puede llamar a sus herramientas varias veces seguidas, por lo que el investigador puede tomar varios turnos seguidos si determina que necesita hacer más investigación
  • Un guionista para convertir la investigación en un esquema de la trama
  • Un file_writer para titular la película resultante y escribir los resultados de la secuencia en un archivo

1. En el editor de Cloud Shell, navega al directorio adk_multiagent_systems/workflow_agents.

2. Haz clic en el archivo agent.py en el directorio workflow_agents.

3. Lee este archivo de definición de agente. Como los agentes secundarios deben definirse antes de que se les pueda asignar uno superior, para leer el archivo en el orden del flujo conversacional, puedes leer los agentes desde la parte inferior del archivo hasta la parte superior.

4. También tienes una herramienta de función append_to_state. Esta función permite que los agentes con la herramienta puedan agregar contenido a un valor de diccionario en el estado. Es particularmente útil para los agentes que podrían llamar a una herramienta varias veces o actuar en múltiples pases de un LoopAgent, de modo que cada vez que actúan, su resultado se almacena.

5. Prueba la versión actual del agente iniciando la interfaz web desde la terminal de Cloud Shell. Usarás el argumento --reload_agents para habilitar la recarga en vivo de agentes en función de los cambios en los agentes:

   cd ~/adk_multiagent_systems adk web --allow_origins "regex:https://.*\.cloudshell\.dev" --reload_agents Nota: Si no cerraste la sesión anterior de adk web, el puerto predeterminado 8000 estará bloqueado, pero puedes iniciar la IU para desarrolladores con un puerto nuevo, por ejemplo, con adk web --port 8001.

6. Para ver la interfaz web en una pestaña nueva, haz clic en el vínculo http://127.0.0.1:8000 en el resultado de la terminal.

7. Se abrirá una nueva pestaña del navegador con la IU de desarrollo del ADK.

8. En el menú desplegable Selecciona un agente de la izquierda, elige workflow_agents.

9. Comienza la conversación con hola. El agente puede tardar unos minutos en responder, pero debería pedirte que ingreses una figura histórica para comenzar a generar la trama de tu película.

10. Cuando se te pida que ingreses una figura histórica, puedes ingresar una de tu elección o usar uno de estos ejemplos:

    • Zhang Zhongjing: Un reconocido médico chino del siglo II d.C.
    • Ada Lovelace: Matemática y escritora inglesa conocida por su trabajo en las primeras computadoras
    • Marco Aurelio: Emperador romano conocido por sus escritos filosóficos

11. El agente ahora debería llamar a sus agentes uno tras otro a medida que ejecuta el flujo de trabajo y escribe el archivo de esquema de la trama en tu directorio ~/adk_multiagent_systems/movie_pitches. Debería informarte cuando haya escrito el archivo en el disco.

    Si no ves que el agente informa que generó un archivo para ti o quieres probar con otro personaje, puedes hacer clic en + Nueva sesión en la parte superior derecha y volver a intentarlo.

12. Visualiza el resultado del agente en el Editor de Cloud Shell (es posible que debas usar el menú del editor de Cloud Shell para habilitar Ver > Ajuste de línea y ver el texto completo sin tener que desplazarte horizontalmente).

13. En la IU de desarrollo del ADK, haz clic en uno de los íconos de agente () que representan un turno de conversación para mostrar la vista de eventos.

14. La vista de eventos proporciona una representación visual del árbol de agentes y herramientas que se usaron en esta sesión. Es posible que debas desplazarte por el panel de eventos para ver el gráfico completo.

15. Además de la vista de gráfico, puedes hacer clic en la pestaña Solicitud del evento para ver la información que recibió este agente como parte de su solicitud, incluido el historial de conversación.
16. También puedes hacer clic en la pestaña Respuesta del evento para ver lo que devolvió el agente.

Haz clic en Revisar mi progreso para verificar el objetivo. Comenzar a crear un sistema multiagente con un SequentialAgent

Tarea 5: Agrega un LoopAgent para el trabajo iterativo

El LoopAgent ejecuta sus agentes secundarios en una secuencia definida y, luego, comienza de nuevo al principio de la secuencia sin detenerse para una entrada del usuario. Repite el bucle hasta que se alcanza una cantidad de iteraciones o uno de sus agentes secundarios realiza una llamada para salir del bucle (generalmente, llamando a una herramienta integrada exit_loop).

Esto es beneficioso para tareas que requieren un perfeccionamiento continuo, supervisión o flujos de trabajo cíclicos. Los ejemplos incluyen los siguientes:

• Perfeccionamiento iterativo: Mejora continuamente un documento o plan a través de ciclos de agentes repetidos.
• Supervisión continua: Comprueba periódicamente las fuentes de datos o las condiciones con una secuencia de agentes.
• Debate o negociación: Simula debates iterativos entre agentes para llegar a un mejor resultado.

Agregarás un LoopAgent a tu agente de presentación de películas para permitir varias rondas de investigación y de iteración mientras se crea la historia. Además de definir mejor la secuencia de comandos, esto permite que un usuario comience con una entrada menos específica: en vez de sugerir una figura histórica específica, es posible que solo sepa que quiere una historia sobre un médico antiguo, y un bucle de iteración de investigación y escritura permitirá que los agentes encuentren un buen candidato y, luego, trabajen en la historia.

Tu agente revisado tendrá el siguiente flujo:

• El root_agent greeter seguirá siendo el mismo.
• El film_concept_team SequentialAgent ahora consistirá en lo siguiente:
  • Un writers_room LoopAgent que comenzará la secuencia. Consistirá en lo siguiente:
    • El investigador será el mismo que antes.
    • El guionista será similar al anterior.
    • Un crítico que ofrecerá comentarios sobre el borrador actual para motivar la siguiente ronda de investigación y mejora a través del bucle.
  • Cuando el bucle finalice, volverá a derivar el control de la conversación al film_concept_team SequentialAgent, que luego pasará el control al próximo agente en su secuencia: el file_writer, que seguirá como antes para darle un título a la película y escribir los resultados de la secuencia en un archivo.

Para hacer estos cambios, sigue estos pasos:

1. En el archivo adk_multiagent_systems/workflow_agents/agent.py, agrega esta importación de herramientas para que puedas proporcionarle a un agente la capacidad de salir del bucle cuando lo desee:

   from google.adk.tools import exit_loop from google.adk.models import Gemini

2. Para determinar cuándo salir del bucle, agrega este agente crítico para decidir cuándo está listo el esquema de la trama. Pega el siguiente agente nuevo en el archivo agent.py en el encabezado de la sección # Agents (sin sobrescribir los agentes existentes). Ten en cuenta que tiene como una de sus herramientas a exit_loop, así como instrucciones sobre cuándo usarla:

   critic = Agent( name="critic", model=Gemini(model=model_name, retry_options=RETRY_OPTIONS), 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 un nuevo LoopAgent llamado writers_room, que crea el bucle iterativo del investigador, el guionista y el crítico. Cada paso por el bucle terminará con una revisión esencial del trabajo hasta el momento, lo que impulsará mejoras para la siguiente ronda. Pega lo siguiente encima del SequentialAgent film_concept_team existente.

   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. Ten en cuenta que la creación de LoopAgent incluye un parámetro para max_iterations. Esto define cuántas veces se ejecutará el bucle antes de que termine. Incluso si planeas interrumpir el bucle con otro método, es buena idea incluir un límite en la cantidad total de iteraciones.

5. Actualiza el film_concept_team SequentialAgent para reemplazar el researcher y el screenwriter por el writers_room LoopAgent que acabas de crear. El agente file_writer debe permanecer al final de la secuencia. El film_concept_team ahora debería verse de la siguiente manera:

   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 ], )

6. Vuelve a la pestaña de la IU de desarrollo del ADK y haz clic en el botón + Nueva sesión en la parte superior derecha para iniciar una nueva sesión.

7. Comienza una nueva conversación con: hola

8. Cuando se te pida que elijas un tipo de personaje histórico, elige uno que te interese. Aquí tienes algunas ideas:

   • un diseñador industrial que creó productos de consumo masivo
   • un cartógrafo
   • esa persona que hizo que los cultivos produjeran más alimentos

9. Una vez que elijas un tipo de personaje, el agente debe trabajar en las iteraciones del bucle y, por último, darle un título a la película y escribir el esquema en un archivo.

10. Con el editor de Cloud Shell, revisa el archivo generado, que debería guardarse en el directorio adk_multiagent_systems/movie_pitches (una vez más, es posible que debas usar el menú del editor para habilitar Ver > Ajuste de línea y ver el texto completo sin tener que desplazarte horizontalmente).

Haz clic en Revisar mi progreso para verificar el objetivo. Agregar un LoopAgent para el trabajo iterativo

Tarea 6: Usa un patrón de "distribución y recopilación" para la generación de informes con un ParallelAgent

El ParallelAgent permite la ejecución simultánea de sus agentes secundarios. Cada agente secundario opera en su propia rama y, de forma predeterminada, no comparten el historial de conversaciones ni el estado directamente entre sí durante la ejecución paralela.

Esto es valioso para tareas que se pueden dividir en subtareas independientes que se pueden procesar simultáneamente. Usar un ParallelAgent puede reducir significativamente el tiempo de ejecución general para estas tareas.

En este lab, agregarás algunos informes complementarios (investigación sobre el posible rendimiento en taquilla y algunas ideas iniciales sobre el elenco) para mejorar la presentación de tu nueva película.

Tu agente revisado tendrá el siguiente flujo:

• El greeter será el mismo.
• El film_concept_team SequentialAgent ahora consistirá en lo siguiente:
  • El writers_room LoopAgent, que seguirá siendo el mismo, incluye lo siguiente:
    • El agente investigador
    • El agente guionista
    • El agente crítico
  • Tu nuevo preproduction_team ParallelAgent actuará de la siguiente manera:
    • Un agente box_office_researcher para usar datos históricos de taquilla y generar un informe sobre el posible rendimiento de taquilla de esta película
    • Un agente casting_agent para generar algunas ideas iniciales sobre el casting en función de los actores que protagonizaron películas similares
  • El file_writer que permanecerá como antes para escribir los resultados de la secuencia en un archivo.

Si bien gran parte de este ejemplo demuestra el trabajo creativo que realizarían los equipos humanos, este flujo de trabajo representa cómo una cadena compleja de tareas se puede dividir en varios agentes secundarios para producir borradores de documentos complejos que los miembros del equipo humano pueden editar y mejorar.

1. Pega los siguientes agentes nuevos y ParallelAgent en tu archivo workflow_agents/agent.py, en el encabezado # Agents:

   box_office_researcher = Agent( name="box_office_researcher", model=Gemini(model=model_name, retry_options=RETRY_OPTIONS), 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=Gemini(model=model_name, retry_options=RETRY_OPTIONS), 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 del agente film_concept_team existente para incluir preproduction_team entre writers_room y file_writer:

   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 la instrucción de file_writer de la siguiente manera:

   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. Guarda el archivo.

5. En la IU de desarrollo del ADK, haz clic en + Nueva sesión en la parte superior derecha.

6. Ingresa hola para iniciar la conversación.

7. Cuando se te solicite, ingresa una nueva idea de personaje que te interese. Aquí tienes algunas ideas:

   • la actriz que inventó la tecnología Wi-Fi
   • un chef interesante
   • figuras clave en las exposiciones de las ferias mundiales

8. Cuando el agente haya terminado de escribir y generar el informe, inspecciona el archivo que produjo en el directorio adk_multiagent_systems/movie_pitches. Si falla una parte del proceso, haz clic en + Nueva sesión en la parte superior derecha y vuelve a intentarlo.

Agentes de flujo de trabajo personalizados

Cuando los agentes de flujo de trabajo predefinidos 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, organizaciones con estado o la integración de lógica empresarial personalizada en la capa de organización del framework.

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

¡Felicitaciones!

En este lab, aprendiste a crear varios agentes y relacionarlos entre sí con relaciones de agente principal a subagente, agregar al estado de la sesión y leerlo en las instrucciones del agente, y usar agentes de flujo de trabajo para pasar la conversación entre agentes directamente.

Capacitación y certificación de Google Cloud

Recibe la formación que necesitas para aprovechar al máximo las tecnologías de Google Cloud. Nuestras clases incluyen habilidades técnicas y prácticas recomendadas para ayudarte a avanzar rápidamente y a seguir aprendiendo. Para que puedas realizar nuestros cursos cuando más te convenga, ofrecemos distintos tipos de capacitación de nivel básico a avanzado: a pedido, presenciales y virtuales. Las certificaciones te ayudan a validar y demostrar tus habilidades y tu conocimiento técnico respecto a las tecnologías de Google Cloud.

Última actualización del manual: 26 de julio de 2026

Prueba más reciente del lab: 26 de julio de 2026

Copyright 2026 Google LLC. Todos los derechos reservados. Google y el logotipo de Google son marcas de Google LLC. El resto de los nombres de productos y empresas pueden ser marcas de las respectivas empresas a las que están asociados.