GENAI106

Descripción general

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

Aquí, 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 principal 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

Lea estas instrucciones. Los labs tienen un tiempo límite; no puede ponerlos en pausa. El cronómetro, que comienza a funcionar cuando hace clic en Comenzar lab, indica por cuánto tiempo estarán los recursos en la nube a su disposición.

Este lab práctico de Qwiklabs le permitirá llevar a cabo las actividades correspondientes en un entorno de nube real, no en uno de simulación o demostración. Para ello, recibe nuevas credenciales temporales que utilizará para acceder a Google Cloud Platform durante el transcurso del lab.

Lo que necesita

Para completar este lab, necesitará lo siguiente:

• Acceso a un navegador de Internet estándar. Se recomienda el navegador Chrome
• Tiempo para completar el lab

Nota: Si ya tiene un proyecto o una cuenta personal de GCP, no los use para este lab.

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 Elegir 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 o autenticación de dos factores (esta es una cuenta 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 no dar resultados confiables, puedes crear un flujo de varios agentes simples que puedan colaborar 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 permite 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 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 ayuda a limitar las opciones de transferencia para cada agente en el árbol, lo que facilita 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 la comprensión de las posibles rutas y la depuración del 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 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 principal 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, la API de Vertex AI ya está habilitada para ti. Si siguieras estos pasos en tu propio proyecto, podrías habilitarla navegando a Vertex AI y siguiendo la instrucción para hacerlo.

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 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 Open folder.
8. En el diálogo Open Folder que se abre, 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 esta 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/adk_multiagent_systems .

2. Actualiza tu variable de entorno PATH, 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 -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 ayudar a guiar esas transferencias en la instruction del agente superior haciendo referencia a los agentes secundarios por su nombre (los valores de su parámetro 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

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 greeting (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á a este 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 generar ideas de destinos si no sabe dó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 agentes secundarios 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:

    hola

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

    user: hola [steering]: ¡Hola! ¿Ya tienes un país en mente para tu viaje o te gustaría que te ayudemos a decidir adónde ir?

11. Dile al agente:

    Me caería bien ayuda para decidir.

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

    usuario: Me caería bien ayuda para decidir. [travel_brainstormer]: ¡De acuerdo! Para darte las mejores recomendaciones, necesito entender qué buscas en un viaje. ...

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 agente secundario adecuado solo en función de la description de ese agente secundario.

13. En la instrucción user:, ingresa salida 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:

    Si necesita ayuda para decidir, envíalo a 'travel_brainstormer'. Si sabe qué país le gustaría visitar, envíalo al '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:

    hola

18. Responde al saludo del agente con lo siguiente:

    Me gustaría ir a Japón.

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

    usuario: Me gustaría ir a Japón. [attractions_planner]: ¡De acuerdo! Puedo ayudarte con eso. Estas son algunas atracciones populares en Japón: * **Tokio:** * Templo Sensō-ji * Cruce de Shibuya * Tokyo Skytree * **Kioto:** ...

19. Ten en cuenta que te transfirieron al otro agente secundario, attractions_planner.

20. Responde con lo siguiente:

    En realidad, no sé qué país visitar.

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

    usuario: En realidad no sé qué país visitar [travel_brainstormer]: ¡De acuerdo! Puedo ayudarte a generar ideas sobre países para viajar…

21. Observa que se te transfirió al agente travel_brainstormer, que es un agente par del attractions_planner. Esta opción está habilitada de forma predeterminada. Si querías evitar las transferencias a pares, podrías haber establecido el parámetro disallow_transfer_to_peers en True en el agente attractions_planner.

22. En el mensaje de usuario, 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 se usa para generar una respuesta. 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 el transcurso de 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]: """Guarda la lista de atracciones en el estado["attractions"]. Args: attractions [str]: una lista de cadenas para agregar a la lista de atracciones Devuelve: None """ # Carga las atracciones existentes del estado. Si no existe ninguna, inicia una lista vacía existing_attractions = tool_context.state.get("attractions", []) # Actualiza la clave 'attractions' con una combinación de listas nuevas y anteriores. # Cuando se ejecuta la herramienta, el ADK crea un evento y realiza # las actualizaciones correspondientes en el estado de la sesión. tool_context.state["attractions"] = existing_attractions + attractions # Una práctica recomendada para las herramientas es devolver un mensaje de estado en un diccionario de devolución 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 reflejarán en el estado de la sesión después de que la herramienta termine su ejecución.
   • La cadena de documentación proporciona una descripción clara y secciones para los argumentos y los valores de retorno.
   • El código de la función comentado demuestra lo fácil que es hacer actualizaciones en el diccionario de estado.

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

   tools=[save_attractions_to_state]

5. Agrega las siguientes viñetas a la instruction existente del agente attractions_planner:

   - Cuando responda, usa tu herramienta para guardar la atracción que seleccionó y, luego, proporciona más atracciones posibles. - Si te piden ver la lista, proporciona una lista con viñetas de { attractions? } y, luego, sugiere algunas más.

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

   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, selecciona 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:

    Me gustaría ir a Egipto.

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

13. Elige una atracción, por ejemplo:

    Voy a la Esfinge

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

15. 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 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:

    ¿Qué hay en mi lista?

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 el turno del usuario, puedes usar agentes de flujo de trabajo. Algunas situaciones de ejemplo en las que podrías usar agentes de flujo de trabajo son las siguientes:

• 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
• Borrador y revisión: 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 ayudar a 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, finalmente, algunos agentes secundarios adicionales ayudarán a generar ideas de casting 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.

Esto 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 elegir 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 salida 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 --reload_agents Nota: Si no cerraste tu sesión anterior de adk web, el puerto predeterminado 8000 estará bloqueado, pero puedes iniciar la IU de desarrollo con un nuevo puerto usando adk web --port 8001, por ejemplo.

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, selecciona 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. El curso consistirá en lo siguiente:
    • El investigador será el mismo que antes.
    • El guionista será similar al anterior.
    • Un crítico que ofrecerá comentarios críticos 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 siguiente 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

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 la herramienta exit_loop como una de sus herramientas y las instrucciones sobre cuándo usarla:

   critic = Agent( name="critic", model=model_name, description="Revisa el esquema para mejorarlo"., instruction=""" INSTRUCTIONS: Considera estas preguntas sobre el PLOT_OUTLINE: - ¿Cumple con una estructura cinemática de tres actos satisfactoria? - ¿Las luchas de los personajes parecen atractivas? - ¿Se siente que está basado en un período histórico real? - ¿Incorpora de manera suficiente los detalles históricos de la INVESTIGACIÓN? Si el PLOT_OUTLINE hace un buen trabajo con estas preguntas, sal del bucle de escritura con tu herramienta “exit_loop”. Si se pueden realizar mejoras significativas, usa la herramienta “append_to_state” para agregar tus comentarios al campo “CRITICAL_FEEDBACK”. Explica tu decisión y resume brevemente los comentarios que proporcionaste. 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 film_concept_team SequentialAgent existente.

   writers_room = LoopAgent( name="writers_room", description="Itera en la investigación y la escritura para mejorar el esquema de la trama de una película"., 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 una 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="Escribe un esquema de la trama de una película y guárdalo como un archivo de texto"., 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. Estas son algunas ideas…

   • un diseñador industrial que creó productos para las masas
   • un cartógrafo (un creador de mapas)
   • 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, finalmente, 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 casting) 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=model_name, description="Considera el potencial de tanquilla de esta película", instruction=""" PLOT_OUTLINE: { PLOT_OUTLINE? } INSTRUCTIONS: Escribe un informe sobre el potencial de taquilla de una película como la descrita en el PLOT_OUTLINE, con base en el rendimiento de taquilla informado de otras películas recientes. """, output_key="box_office_report" ) casting_agent = Agent( name="casting_agent", model=model_name, description="Genera algunas ideas de casting para esta película", instruction=""" PLOT_OUTLINE: { PLOT_OUTLINE? } INSTRUCTIONS: Genera ideas para el casting de los personajes descritos en PLOT_OUTLINE sugiriendo actores que hayan recibido comentarios positivos de la crítica o los fans cuando interpretaron roles similares. """, 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 el preproduction_team entre writers_room y file_writer:

   film_concept_team = SequentialAgent( name="film_concept_team", description="Escribe un esquema de la trama de una película y guárdalo como un archivo de texto"., sub_agents=[ writers_room, preproduction_team, file_writer ], )

3. Actualiza la instrucción de file_writer de la siguiente manera:

   INSTRUCTIONS: - Crea una sugerencia de un título de una película comercial y contemporánea para la película descrita en el PLOT_OUTLINE. Si se sugirió un título en PLOT_OUTLINE, puedes usarlo o reemplazarlo por uno mejor. - Usa tu herramienta “write_file” para crear un nuevo archivo txt con los siguientes argumentos: - Para el nombre de archivo, usa el título de la película. - Escribe en el directorio “movie_pitches”. - Para el “contenido” que se debe escribir, incluye lo siguiente: - El PLOT_OUTLINE - El BOX_OFFICE_REPORT - El 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. Estas son algunas ideas…

   • la actriz que inventó la tecnología Wi-Fi
   • un chef emocionante
   • 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 superior a agente secundario, 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 recomendaciones 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: 3 de febrero de 2026

Prueba más reciente del lab: 3 de febrero de 2026

Copyright 2020 Google LLC. All rights reserved. Google y el logotipo de Google son marcas de Google LLC. Los demás nombres de productos y empresas pueden ser marcas de las respectivas empresas a las que estén asociados.