AI Agent End to End - Workshop

1. Qué aprenderás

Pila completa de Vibe con agente de IA

¡Te damos la bienvenida! Estás a punto de aprender la siguiente habilidad fundamental en el desarrollo de software: cómo guiar de manera eficaz a la Inteligencia Artificial para compilar, probar y, luego, implementar software de calidad para producción. La IA generativa no es un "piloto automático"; es un copiloto potente que necesita un director capacitado.

En este taller, se proporciona una metodología estructurada y repetible para asociarse con la IA en cada etapa del ciclo de vida del desarrollo de software (SDLC) profesional. Pasarás de ser un escritor de código línea por línea a un director técnico, un arquitecto con una visión y un contratista general que usa la IA para ejecutar esa visión con precisión. 🚀

Al final de este instructivo, tendrás lo siguiente:

• Tradujo una idea de alto nivel en una arquitectura de nube con IA.
• Se generó un backend de Python completo con instrucciones específicas y orientadas.
• Usé la IA como programador par para depurar y corregir código.
• Se delegó en la IA la creación de pruebas de unidades, incluidos los simulacros.
• Se generó infraestructura como código (IaC) lista para la producción con Terraform.
• Se creó una canalización de CI/CD completa en Acciones de GitHub con una sola instrucción.
• Supervisaste y administrase tu aplicación en producción con herramientas operativas potenciadas por IA.

No solo te irás con una app que funciona, sino también con un plan para el desarrollo aumentado por IA. Comencemos.

2. Requisitos previos y configuración

Antes de comenzar, preparemos tu entorno. Este es un paso fundamental para garantizar una experiencia fluida en el taller.

Crea una cuenta de GCP nueva y vincula tu facturación

Para potenciar nuestros agentes de IA, necesitamos dos cosas: un proyecto de Google Cloud que proporcione la base y una clave de API de Gemini para acceder a los potentes modelos de Google.

Paso 1: Habilita la cuenta de facturación

• Reclama tu cuenta de facturación con un crédito de USD 5, ya que lo necesitarás para la implementación. Asegúrate de que sea tu cuenta de Gmail.

No se requiere tarjeta de crédito ni pago: Recibirás USD 5 en créditos gratis. Solo te llevará menos de 2 minutos. Ingresa tu nombre y acepta los créditos.

Paso 2: Crea un proyecto de GCP nuevo

• Ve a Google Cloud Console y crea un proyecto nuevo.

• Abre el panel izquierdo, haz clic en Billing y verifica si la cuenta de facturación está vinculada a esta cuenta de GCP.

Si ves esta página, marca manage billing account, elige la prueba de Google Cloud One y vincúlala.

Paso 3: Genera tu clave de API de Gemini

Antes de proteger la llave, debes tener una.

• Navega a Google AI Studio : https://aistudio.google.com/
• Accede con tu cuenta de Gmail.
• Haz clic en el botón "Obtener clave de API", que suele encontrarse en el panel de navegación de la izquierda o en la esquina superior derecha.
• En el cuadro de diálogo “Claves de API”, haz clic en “Crear clave de API en un proyecto nuevo”.
• Elige el proyecto nuevo que creaste y que tiene configurada la cuenta de facturación.
• Se generará una nueva clave de API para ti. Copia esta clave de inmediato y guárdala en un lugar seguro de forma temporal (como un administrador de contraseñas o una nota segura). Este es el valor que usarás en los siguientes pasos.

Autenticación de GitHub

Asegúrate de usar la misma cuenta de Gmail para GitHub y tu proyecto de Google Cloud.

Abre Cloud Shell. Para ello, ve a Google Cloud Console y haz clic en el botón "Activar Cloud Shell" en la parte superior derecha.

Paso 1: Abre Cloud Shell

👉 Haz clic en "Activar Cloud Shell" en la parte superior de la consola de Google Cloud (es el ícono con forma de terminal en la parte superior del panel de Cloud Shell).

👉 Haz clic en el botón "Abrir editor" (tiene forma de carpeta abierta con un lápiz). Se abrirá el editor de código de Cloud Shell en la ventana. Verás un explorador de archivos en el lado izquierdo.

👉 Una vez que hayas abierto el editor, abre la terminal en el IDE de Cloud.

👉💻 En la terminal, verifica que ya te autenticaste y que el proyecto esté configurado con tu ID del proyecto usando el siguiente comando:

gcloud auth list

Paso 2: Autentícate con GitHub y bifurca

Autentícate con GitHub:

👉💻 Copia y pega el comando en tu terminal de Cloud:

gh auth login

• En "Where do you use GitHub", elige "GitHub.com".
• En "What is you preferred protocol for Git operations on this host?", elige "HTTPS".
• En “¿Deseas autenticar Git con tus credenciales de GitHub?”, elige “Sí”.
• "How would you like to authenticate GitHub CLI?", elige "Login with a web browser".

¡¡Importante!! No presiones "Intro" aún

Ten en cuenta que debes copiar y pegar el vínculo de la terminal para abrir la página de autenticación de GitHub.

copia el código de la terminal en la página de verificación de acceso

Cuando termines de ingresar el código, vuelve a la terminal de Cloud Shell y presiona "Intro" para continuar.

Paso 4: Bifurca y clona el repo:

👉💻 Copia y pega el comando en tu terminal de Cloud:

gh repo fork cuppibla/storygen-learning --clone=true

3. Arquitectura: De la idea al plano con Cloud Assist

Todo gran proyecto comienza con una visión clara. Usaremos nuestro copiloto de IA, Cloud Assist, para diseñar la arquitectura de nuestra app.

Acciones

• Abre la consola de Google Cloud: [https://console.cloud.google.com](consola de Google Cloud)
• En la esquina superior derecha, haz clic en "Abrir el chat de Cloud Assist".

Habilita Cloud Assist

• Haz clic en Get Gemini Assist y, luego, en Enable Cloud Assist at no cost.
• ¡Y comienza a chatear!

Proporciona la siguiente instrucción detallada a Cloud Assist:

Ingresa tu idea

Generate a Python web application that uses AI to generate children's stories and illustrations. It has Python backend and React frontend host separately on Cloudrun. They communicate through Websocket. It needs to use a generative model for text and another for images. The generated images must be used by Imagen from Vertex AI and stored in a Google Cloud Storage bucket so that frontend can fetch from the bucket to render images. I do not want any load balancer or a database for the story text. We need a solution to store the API key.

Obtén el plan de tu app

• Haz clic en "Editar diseño de la app" y verás el diagrama. Haz clic en el panel superior derecho "<> Get Code" para descargar el código de Terraform.
• Cloud Assist generará un diagrama de arquitectura. Este es nuestro plano visual.

No se requiere ninguna acción con este código. Sigue leyendo para obtener más información

Comprende el código de Terraform generado. Acabas de recibir un conjunto completo de archivos de Terraform de Cloud Assist. Por el momento, no se requiere ninguna acción con este código, pero analicemos rápidamente qué es y por qué es tan potente.

¿Qué es Terraform? Terraform es una herramienta de infraestructura como código (IaC). Considéralo como un plano de tu entorno de nube, escrito en código. En lugar de hacer clic manualmente en la consola de Google Cloud para crear servicios, almacenamiento y permisos, defines todos esos recursos en estos archivos de configuración. Luego, Terraform lee tu plano y compila ese entorno exacto automáticamente.

From Visual Plan to Executable Code. El diagrama de arquitectura que proporcionó Cloud Assist es tu plan visual. El código de Terraform es la versión legible por máquina de ese mismo plan. Es el vínculo fundamental que convierte un concepto de diseño en una realidad reproducible y automatizada. Si defines tu infraestructura en el código, puedes hacer lo siguiente:

• Automatizar la creación: Crea de forma confiable el mismo entorno una y otra vez.
• Usa el control de versiones: Haz un seguimiento de los cambios en tu infraestructura en Git, al igual que el código de tu aplicación.
• Evita errores: Evita los errores manuales que pueden ocurrir cuando haces clic en una interfaz web.

Para este taller, no necesitarás ejecutar este código de Terraform por tu cuenta. Considéralo como el plano profesional, la "clave de respuestas" de la infraestructura que compilarás e implementarás en los próximos pasos.

4. Desarrollo: Introducción a la CLI de Gemini

👉💻 En la terminal de Cloud Shell, navega a tu directorio personal.

cd ~/storygen-learning

👉💻 Prueba Gemini por primera vez.

clear
gemini --model=gemini-2.5-flash

Si te pregunta Do you want to connect Cloud Shell editor to Gemini CLI?, elige NO.

👉✨ Todas las herramientas de Gemini tienen una descripción. Léelos ahora. En la instrucción de Gemini, escribe lo siguiente:

En la CLI de Gemini

/help

👉✨ La CLI de Gemini posee su propio conjunto de capacidades integradas. Para inspeccionarlos, sigue estos pasos:

En la CLI de Gemini

/tools

Verás una lista que incluye ReadFile, WriteFile y GoogleSearch. Estas son las técnicas predeterminadas que puedes usar sin necesidad de recurrir a un arsenal externo.

👉✨ La Blade de Gemini puede mantener la "conciencia táctica" (contexto) para guiar sus acciones.

En la CLI de Gemini

/memory show

Actualmente, está vacío, es una pizarra en blanco.

👉✨ Primero, agrega un arquetipo a la memoria del agente. Esto definirá su área de especialización:

En la CLI de Gemini

/memory add "I am master at python development"

Vuelve a ejecutar /memory show para confirmar que tu cuchilla absorbió este conocimiento.

👉✨ Para demostrar cómo hacer referencia a archivos con el símbolo @, primero crearemos un archivo de "resumen de la misión".

Abre una terminal nueva y ejecuta el siguiente comando para crear el archivo de la misión:

!echo "## Mission Objective: Create Imagen ADK Agent for Story Book" > mission.md

👉✨Ahora, ordena a la CLI de Gemini que analice la sesión informativa y que informe sus resultados:

En la CLI de Gemini

Explain the contents of the file @mission.md

Tu arma principal ahora conoce su objetivo.

👉💻 Presiona Ctrl+C dos veces para salir de Gemini CLI

Aprendizaje:

Cómo obtiene sus superpoderes la CLI de Gemini: gemini.md Antes de continuar, es importante comprender cómo se puede adaptar la CLI de Gemini a un proyecto específico. Si bien puedes usarlo como una herramienta de chat de uso general, su verdadero potencial proviene de un archivo de configuración especial: gemini.md.

Cuando ejecutas el comando gemini, se busca automáticamente un archivo gemini.md en el directorio actual. Este archivo actúa como un manual de instrucciones específico del proyecto para la IA. Puede definir tres aspectos clave:

• Arquetipo: Puedes decirle a la IA quién debería ser. Por ejemplo, "Eres un desarrollador experto en Python que se especializa en Google Cloud". Esto enfoca sus respuestas y su estilo.
• Herramientas: Puedes darle acceso a archivos específicos (@file.py) o incluso a búsquedas de Google (@google). Esto le proporciona a la IA el contexto que necesita para responder preguntas sobre el código de tu proyecto.
• Memoria: Puedes proporcionar hechos o reglas que la IA siempre debe recordar para este proyecto, lo que ayuda a mantener la coherencia.

Con un archivo gemini.md, conviertes el modelo genérico de Gemini en un asistente especializado que ya conoce los objetivos de tu proyecto y tiene acceso a la información correcta.

5. Desarrollo: Compilación del ADK con Gemini CLI

Configuración inicial

Asegúrate de que usemos la CLI de Gemini para bifurcar el repositorio y preparar el espacio de trabajo:

Configuración del entorno

Ve a Cloud Shell y haz clic en el botón "Abrir terminal".

1. Copia la plantilla del entorno:

   cd ~/storygen-learning
   cp ~/storygen-learning/env.template ~/storygen-learning/.env
   

Cómo ver el archivo oculto en el editor si no encuentras .env

• Haz clic en Ver en la barra de menú superior.
• Selecciona Toggle Hidden Files.

👉 Busca tu ID del proyecto de Google Cloud:

• Abre la consola de Google Cloud: vínculo
• Selecciona el proyecto que deseas usar para este taller en el menú desplegable de la parte superior de la página.
• Tu ID del proyecto se muestra en la tarjeta de información del proyecto en el panel.

👉Cómo encontrar tu nombre de usuario de GitHub:

• Ve a GitHub y busca tu nombre de usuario de GitHub.

Edita el archivo .env. 2. Reemplaza los siguientes valores en .env:

GOOGLE_API_KEY=[REPLACE YOUR API KEY HERE]
GOOGLE_CLOUD_PROJECT_ID=[REPLACE YOUR PROJECT ID]
GITHUB_USERNAME=[REPLACE YOUR USERNAME]
GENMEDIA_BUCKET=[REPLACE YOUR PROJECT ID]-bucket

p.ej., si el ID de tu proyecto es testproject, debes ingresar GOOGLE_CLOUD_PROJECT_ID=testproject y GENMEDIA_BUCKET=testproject-bucket

Secuencias de comandos de configuración

Ve a 00_Starting_Here Abre una terminal nueva (no en Gemini CLI).

cd ~/storygen-learning/00_Starting_Here

Ejecuta la configuración completa:

./setup-complete.sh

Deberías ver los resultados de la configuración en la terminal

Crea tu primer agente

Ve a 01a_First_Agent_Ready. Usemos la CLI de Gemini para crear el agente del ADK:**

cd ~/storygen-learning/01a_First_Agent_Ready

Abre la CLI de Gemini

gemini

Dentro de la ventana de la CLI de Gemini, prueba la siguiente instrucción:

I need you to help me create a Google ADK (Agent Development Kit) agent for story generation. I'm working on a children's storybook app that generates creative stories with visual scenes.

Please create a complete `agent.py` file that implements an LlmAgent using Google's ADK framework. The agent should:

**Requirements:**
1. Use the `google.adk.agents.LlmAgent` class
2. Use the "gemini-2.5-flash" model (supports streaming)
3. Be named "story_agent"
4. Generate structured stories with exactly 4 scenes each
5. Output valid JSON with story text, main characters, and scene data
6. No tools needed (images are handled separately)

**Agent Specifications:**
- **Model:** gemini-2.5-flash
- **Name:** story_agent  
- **Description:** "Generates creative short stories and accompanying visual keyframes based on user-provided keywords and themes."
**Story Structure Required:**
- Exactly 4 scenes: Setup → Inciting Incident → Climax → Resolution
- 100-200 words total
- Simple, charming language for all audiences
- Natural keyword integration
**JSON Output Format:**

{
  "story": "Complete story text...",
  "main_characters": [
    {
      "name": "Character Name",
      "description": "VERY detailed visual description with specific colors, features, size, etc."
    }
  ],
  "scenes": [
    {
      "index": 1,
      "title": "The Setup",
      "description": "Scene action and setting WITHOUT character descriptions",
      "text": "Story text for this scene"
    }
    // ... 3 more scenes
  ]
}


**Key Instructions for the Agent:**
- Extract 1-2 main characters maximum
- Character descriptions should be extremely detailed and visual
- Scene descriptions focus on ACTION and SETTING only
- Do NOT repeat character appearance in scene descriptions
- Always respond with valid JSON

Please include a complete example in the instructions showing the exact format using keywords like "tiny robot", "lost kitten", "rainy city".

The file should start with necessary imports, define an empty tools list, include a print statement for initialization, and then create the LlmAgent with all the detailed instructions.

Can you create this agent in backend/story_agent/agent.py

Cuando termines, desactiva la terminal de Gemini CLI con Control+C

—————————————— Opcional, puedes omitir la parte de Solución——————————————–

Ahora verifica tu cambio en ADK Web

cd ~/storygen-learning/01a_First_Agent_Ready/backend

source ../../.venv/bin/activate

adk web --port 8080

Para continuar, necesitarás un símbolo del sistema.

Puedes abrir una nueva ventana de terminal o detener el servidor web actual del ADK presionando Ctrl + C.

Cómo poner en funcionamiento el sitio web

cd ~/storygen-learning/01a_First_Agent_Ready

./start.sh

Si el cambio no funciona, deberías ver errores en la IU web y el sitio web del ADK.

—————————————— Solución a partir de aquí ——————————————–

Solución

Finaliza el proceso anterior con Control+C o puedes abrir otra terminal:

cd ~/storygen-learning/01b_First_Agent_Done

Cómo iniciar el sitio web:

./start.sh

Verás el sitio web:

Prueba la IU del ADK: Abre otra terminal:

cd ~/storygen-learning/01b_First_Agent_Done/backend

source ../../.venv/bin/activate

adk web --port 8080

Verás la IU del ADK, en la que podrás hacerle preguntas al agente.

Antes de pasar a la siguiente sección, presiona Ctrl + C para finalizar el proceso.

6. Desarrollo: Crea tu agente personalizado con Imagen

Genera la herramienta Imagen (segundo agente)

cd ~/storygen-learning/02a_Image_Agent_Ready

Usa la CLI de Gemini para crear el agente de generación de imágenes:

gemini generate "I need you to help me create a custom Google ADK (Agent Development Kit) agent for image generation. This is different from the story agent - this one handles image generation directly using the BaseAgent pattern for full control over tool execution.

Please create a complete `agent.py` file that implements a custom image generation agent. The agent should:

**Requirements:**
1. Use the `google.adk.agents.BaseAgent` class (NOT LlmAgent)
2. Be named "custom_image_agent" 
3. Directly execute the ImagenTool without LLM intermediation
4. Handle JSON input with scene descriptions and character descriptions
5. Store results in session state for retrieval by main.py
6. Use async generators and yield Events

**Key Specifications:**
- **Class Name:** CustomImageAgent (inherits from BaseAgent)
- **Agent Name:** "custom_image_agent"
- **Tool:** Uses ImagenTool for direct image generation
- **Purpose:** Bypass LLM agent limitations and directly call ImagenTool

**Input Format:**
The agent should handle JSON input like:
{
  "scene_description": "Scene action and setting",
  "character_descriptions": {
    "CharacterName": "detailed visual description"
  }
}


**Core Method:** `async def _run_async_impl(self, ctx: InvocationContext) -> AsyncGenerator[Event, None]:`
   - Extract user message from `ctx.user_content.parts`
   - Parse JSON input or fallback to plain text
   - Extract scene_description and character_descriptions
   - Build image prompt with style prefix: "Children's book cartoon illustration with bright vibrant colors, simple shapes, friendly characters."
   - Include character descriptions for consistency
   - Call `await self.imagen_tool.run()` directly
   - Store results in `ctx.session.state["image_result"]`
   - Yield Event with results


 **Session State:**
   - Store JSON results in `ctx.session.state["image_result"]`
   - Include success/error status
   - Store actual image URLs or error messages

Expected Output Structure:
- Successful results stored as JSON with image URLs
- Error results stored as JSON with error messages
- Results accessible via session state in main.py

Can you create this agent in backend/story_image_agent/agent.py

"

—————————————— Opcional, puedes omitir la parte de Solución——————————————–

Ahora verifica tu cambio en ADK Web

cd ~/storygen-learning/02a_Image_Agent_Ready/backend

source ../../.venv/bin/activate

adk web --port 8080

Cómo poner en funcionamiento el sitio web

cd ~/storygen-learning/02a_Second_Agent_Ready

./start.sh

Si el cambio no funciona, deberías ver errores en la IU web y el sitio web del ADK.

—————————————— Solución a partir de aquí ——————————————–

Solución

Finaliza el proceso anterior con Control+C o puedes abrir otra terminal:

# Open new terminal
cd ~/storygen-learning/02b_Image_Agent_Done

Cómo iniciar el sitio web:

./start.sh

Verás el sitio web:

Prueba la IU del ADK: Abre otra terminal:

# Open new terminal
cd ~/storygen-learning/02b_Image_Agent_Done/backend

source ../../.venv/bin/activate

adk web --port 8080

Verás la IU del ADK, en la que podrás hacerle preguntas al agente:

Antes de pasar a la siguiente sección, presiona Ctrl + C para finalizar el proceso.

Aprendizaje

Nuestro primer agente era excelente para generar texto, pero ahora necesitamos generar imágenes. Para esta tarea, necesitamos un control más directo. No queremos que el LLM decida si crear una imagen, sino que queremos ordenarle que lo haga directamente. Este es el trabajo perfecto para un BaseAgent.

A diferencia de LlmAgent, que es declarativo, BaseAgent es imperativo. Esto significa que tú, el desarrollador, escribes la lógica exacta paso a paso de Python dentro del método _run_async_impl. Tienes el control total del flujo de ejecución.

Elegirías un BaseAgent en los siguientes casos:

Lógica determinista: El agente debe seguir una secuencia de pasos específica e inalterable.

Ejecución directa de herramientas: Deseas llamar a una herramienta directamente sin la intervención del LLM.

Flujos de trabajo complejos: El proceso implica la manipulación de datos personalizados, llamadas a la API y lógica que es demasiado compleja para que un LLM la infiera de forma confiable a partir de una sola instrucción.

En nuestra app, usaremos un BaseAgent para recibir las descripciones de la escena del primer agente y llamar directamente a la herramienta Imagen para garantizar que se genere una imagen para cada escena.

7. Pruebas: Evaluación del agente

Nuestra app funciona, pero necesitamos una red de seguridad automatizada de pruebas. Esta es una tarea perfecta para delegar en nuestro copiloto de IA.

Acciones

cd ~/storygen-learning/03a_Agent_Evaluation_Ready/backend

Usa la CLI de Gemini para escribir pruebas integrales:

Abre la CLI de Gemini

gemini

Dentro de la ventana de la CLI de Gemini, prueba la siguiente instrucción:

I need you to create comprehensive test files for my backend/story_agent in Google ADK. I need three specific JSON files that match the testing structure used in ADK evaluation.

**Context:** 
- The story agent generates structured JSON stories with exactly 4 scenes
- It uses LlmAgent with no tools, just direct LLM responses
- Input: Keywords
- Output: JSON with story, main_characters, and scenes arrays

**Files to Create:**

### 1. `story_agent_eval.evalset.json` (Comprehensive Integration Tests)
Create a comprehensive evaluation set with:
- **eval_set_id**: "story_agent_comprehensive_evalset"
- **name**: "Story Agent Comprehensive Evaluation Set" 
- **description**: "Comprehensive evaluation scenarios for story_agent covering various keyword combinations, edge cases, and story quality metrics"


Each eval_case should include:
- Full conversation arrays with invocation_id, user_content, final_response
- Complete expected JSON responses with detailed stories, characters, and 4 scenes
- session_input with app_name "story_agent"
- All fields: story (narrative text), main_characters (with detailed visual descriptions), scenes (with index, title, description, text)

### 2. `story_generation.test.json` (Unit Tests)
Create basic generation tests with:
- **eval_set_id**: "story_agent_basic_generation_tests"
- **name**: "Story Agent Basic Generation Tests"
- **description**: "Unit tests for story_agent focusing on JSON structure compliance, scene generation, and keyword integration"

### 3. `test_config.json` (Evaluation Configuration)
Create test configuration with:
- **criteria**: response_match_score: 0.7, tool_trajectory_avg_score: 1.0
- **custom_evaluators**: 
  - json_structure_validator (validates required fields, scene count, character fields)
  - story_quality_metrics (word count 80-250, keyword integration threshold 0.8)
- **evaluation_notes**: Story agent specifics and trajectory expectations

**Important Requirements:**
1. All responses must be valid, parseable JSON
2. Stories must have exactly 4 scenes with indices 1-4
3. Each scene must have: index, title, description, text
4. Main characters must have detailed visual descriptions
5. No tool_uses expected (empty arrays) since story agent uses direct LLM
6. Word count should be 100-200 words total
7. Keywords must be naturally integrated into the narrative

Please generate all three files with realistic example stories and comprehensive test coverage matching the ADK evaluation format.

—————————————— Opcional, puedes omitir la parte de Solución——————————————–

Para ver la evaluación, sigue estos pasos:

./run_adk_web_persistent.sh

Ve a la pestaña eval en la IU del ADK.

Deberías ver la IU web de ADK con capacidades de prueba persistentes

Momento clave de aprendizaje: La IA es un socio poderoso para automatizar el control de calidad. Puede controlar el código estándar de la escritura de pruebas, lo que te permite concentrarte en la creación de funciones.

—————————————— Solución a partir de aquí ——————————————–

Solución

• Ve a la carpeta de la solución:

cd ~/storygen-learning/03b_Agent_Evaluation_Done/backend

• Abrir la IU web del ADK

./run_adk_web_persistent.sh

Puedes ver los casos de prueba en la pestaña Eval:

Ajusta las métricas aquí:

Consulta el resultado de la ejecución de la evaluación aquí:

Aprendizaje

Un agente puede "funcionar" en el sentido de que se ejecuta sin errores, pero ¿cómo sabemos si produce el resultado correcto? ¿La historia es buena? ¿El formato JSON es correcto? Aquí es donde entra en juego el marco de evaluación del ADK.

La evaluación del agente es un sistema de pruebas automatizado diseñado para medir la calidad y la exactitud de las respuestas de tu agente. En lugar de solo verificar si hay errores de código, comprueba si el comportamiento del agente cumple con tus expectativas. El framework usa principalmente algunos archivos clave:

evalset.json: Este es tu conjunto de pruebas principal. Cada "caso de evaluación" dentro de este archivo contiene una conversación de muestra (p.ej., una instrucción del usuario) y la respuesta ideal o "dorada" que esperas que produzca el agente.

test_config.json: Este archivo define las reglas para el éxito. Aquí puedes establecer criterios, como los siguientes:

response_match_score: ¿Qué tan cerca debe coincidir la respuesta del agente con la respuesta "ideal"? (Una puntuación de 1.0 significa que debe ser idéntica).

custom_evaluators: Puedes crear tus propias reglas, como "La respuesta debe ser un JSON válido" o "El cuento debe contener más de 100 palabras".

Si ejecutas una evaluación, puedes probar automáticamente tu agente en docenas de situaciones, lo que garantiza que los cambios en tus instrucciones o herramientas no interrumpan accidentalmente su funcionalidad principal. Es una poderosa red de seguridad para crear agentes de IA listos para producción.

8. Infraestructura como código (IaC): Construcción de una casa en la nube

Nuestro código se probó, pero necesita un lugar listo para la producción. Usaremos la "infraestructura como código" para definir nuestro entorno.

¿Qué es Docker?

Docker es una plataforma para crear y ejecutar aplicaciones en contenedores. Piensa en un contenedor como un contenedor de envío estandarizado para software. Agrupa todo lo que tu aplicación necesita para ejecutarse en un solo paquete aislado:

• El código de la aplicación
• El tiempo de ejecución requerido (p.ej., la versión específica de Python)
• Todas las herramientas y bibliotecas del sistema

Luego, esta aplicación alojada en un contenedor se puede ejecutar en cualquier máquina que tenga instalado Docker, lo que resuelve el clásico problema de "funciona en mi máquina".

En esta sección, le pediremos a Gemini que genere un Dockerfile, que es simplemente la receta o el plano para compilar la imagen del contenedor de nuestra aplicación.

Acciones

cd ~/storygen-learning/04a_Manual_Deployment_Ready

Usa la CLI de Gemini para crear un Dockerfile para el backend: Abre la CLI de Gemini

Gemini

Dentro de la CLI de Gemini, prueba la siguiente instrucción:

Create a manual deployment plan for my StoryGen app with Google Cloud Platform. I have a Next.js frontend, Python backend, and Terraform infrastructure.

Generate these deployment files:
1. **01-setup.sh** - Environment setup and authentication
2. **02-build-images.sh** - Build and push Docker images to Google Container Registry
3. **03-deploy-infrastructure.sh** - Deploy with Terraform and configure services
4. **load-env.sh** - Load environment variables for deployment

**Requirements:**
- Use Google Cloud Run for both frontend and backend
- Configure Imagen API and storage buckets
- Set up proper IAM permissions
- Use environment variables from .env file
- Include error handling and status checks

Keep scripts simple, well-commented, and production-ready for manual execution.

Solución:

cd ~/storygen-learning/04b_Manual_Deployment_Done

Ejecuta lo siguiente:

source ../.venv/bin/activate
./01-setup.sh

./02-build-images.sh

./03-deploy-infrastructure.sh

Deberías ver los resultados de la implementación y la creación de la infraestructura

9. Automatización (CI/CD): La línea de ensamblaje digital

Implementar nuestra aplicación de forma manual es una excelente manera de comprender las partes móviles, pero es lento, requiere esfuerzo manual y puede generar errores humanos. En el desarrollo de software profesional, todo este proceso se automatiza con una práctica llamada CI/CD.

CI/CD significa integración continua y implementación continua. Es un método para compilar, probar e implementar tu código automáticamente cada vez que realizas un cambio.

• Integración continua (CI): Esta es la fase de "compilación y prueba". En cuanto un desarrollador envía un cambio de código a un repositorio compartido (como GitHub), se activa un sistema automatizado. Compila la aplicación y ejecuta todas las pruebas (como las evaluaciones de agentes que creamos) para garantizar que el código nuevo se integre correctamente y no introduzca errores.
• Implementación continua (CD): Esta es la fase de "lanzamiento". Si la fase de IC se completa correctamente, el sistema implementa automáticamente la versión nueva y probada de la aplicación en producción, lo que la pone a disposición de los usuarios.

Esta canalización automatizada crea una "línea de ensamblaje digital" que lleva el código de la máquina de un desarrollador a la producción de forma rápida, segura y confiable. En esta sección, le pediremos a nuestro asistente de IA que cree esta línea de ensamblaje por nosotros con las acciones de GitHub y Google Cloud Build.

Acciones

cd ~/storygen-learning/05a_CICD_Pipeline_Ready

Usa la CLI de Gemini para compilar tu canalización de CI/CD con GitHub:

Abre Gemini CLI

Gemini

Dentro de la CLI de Gemini, prueba la siguiente instrucción:

Create a CI/CD pipeline for my StoryGen app using Google Cloud Build and GitHub integration.

Generate these automation files:
1. **cloudbuild.yaml** (for backend) - Automated build, test, and deploy pipeline
2. **GitHub Actions workflow** - Trigger builds on push/PR
3. **Deployment automation scripts** - Streamlined deployment process

**Requirements:**
- Auto-trigger on GitHub push to main branch
- Build and push Docker images
- Run automated tests if available
- Deploy to Google Cloud Run
- Environment-specific deployments (staging/prod)
- Notification on success/failure

Focus on fully automated deployment with minimal manual intervention. Include proper secret management and rollback capabilities.

—————————————— Solución a partir de aquí ——————————————–

Solución:

cd ~/storygen-learning/06_Final_Solution/
# Copy the GitHub workflow to parent folder
cp -r 06_Final_Solution/.GitHub ../../../.GitHub

Regresa a la carpeta 06_Final_Solution y ejecuta la secuencia de comandos:

cd ~/storygen-learning/06_Final_Solution/

./setup-cicd-complete.sh

Deberías ver que se completó la configuración de la canalización de CI/CD

Activa el flujo de trabajo: Confirma y envía tu código a main. Ten en cuenta que debes configurar tu nombre y correo electrónico de GitHub para permitir el permiso.

git add .
git commit -m "feat: Add backend, IaC, and CI/CD workflow"
git push origin main

Ve a la pestaña "Actions" de tu repositorio de GitHub para ver la ejecución de tu implementación automatizada.

10. Operaciones: La torre de control de la IA

¡Ya estamos en vivo! Pero el viaje no termina aquí. Este es el "día 2": las operaciones. Volvamos a Cloud Assist para administrar nuestra aplicación en ejecución.

Acciones

1. Navega a tu servicio de Cloud Run en la consola de Google Cloud. Interactúa con tu app en vivo para generar tráfico y registros.
2. Abre el panel de Cloud Assist y úsalo como copiloto operativo con instrucciones como las siguientes:

Análisis de registros:

Summarize the errors in my Cloud Run logs for the service 'genai-backend' from the last 15 minutes.

Ajuste del rendimiento:

My Cloud Run service 'genai-backend' has high startup latency. What are common causes for a Python app and how can I investigate with Cloud Trace?

Optimización de costos:

Analyze the costs for my 'genai-backend' service and its GCS bucket. Are there any opportunities to save money?

Momento clave de aprendizaje: El SDLC de la IA es un ciclo continuo. El mismo copiloto de IA que ayudó a compilar la aplicación es un socio indispensable para supervisarla, solucionar problemas y optimizarla en producción.