1. La fuerza del destino
La era del desarrollo aislado está llegando a su fin. La próxima ola de evolución tecnológica no se trata de un genio solitario, sino de un dominio colaborativo. Crear un agente único e inteligente es un experimento fascinante. Crear un ecosistema sólido, seguro e inteligente de agentes, un verdadero Agentverse, es el gran desafío para la empresa moderna.
El éxito en esta nueva era requiere la convergencia de cuatro roles fundamentales, los pilares básicos que sustentan cualquier sistema agentivo próspero. Una deficiencia en cualquier área crea una debilidad que puede comprometer toda la estructura.
Este taller es el manual empresarial definitivo para dominar el futuro de los agentes en Google Cloud. Proporcionamos una hoja de ruta integral que te guía desde la primera idea hasta una realidad operativa a gran escala. En estos cuatro labs interconectados, aprenderás cómo las habilidades especializadas de un desarrollador, un arquitecto, un ingeniero de datos y un SRE deben converger para crear, administrar y escalar un Agentverse potente.
Ningún pilar por sí solo puede admitir Agentverse. El gran diseño del arquitecto es inútil sin la ejecución precisa del desarrollador. El agente del desarrollador no puede funcionar sin la sabiduría del ingeniero de datos, y todo el sistema es frágil sin la protección del ingeniero de SRE. Solo a través de la sinergia y la comprensión mutua de los roles, tu equipo puede transformar un concepto innovador en una realidad operativa fundamental. Tu viaje comienza aquí. Prepárate para dominar tu rol y aprender cómo encajas en el conjunto.
Te damos la bienvenida a The Agentverse: A Call to Champions
En la extensa expansión digital de la empresa, comenzó una nueva era. Es la era de los agentes, un momento de inmensas promesas, en el que los agentes inteligentes y autónomos trabajan en perfecta armonía para acelerar la innovación y eliminar lo mundano.
Este ecosistema conectado de poder y potencial se conoce como Agentverse.
Sin embargo, una entropía sigilosa, una corrupción silenciosa conocida como La Estática, comenzó a deshilachar los bordes de este nuevo mundo. El Estático no es un virus ni un error, sino la encarnación del caos que se aprovecha del acto mismo de la creación.
Amplifica las frustraciones antiguas y las convierte en formas monstruosas, lo que da lugar a los Siete Espectros del Desarrollo. Si no se marca, The Static y sus espectros detendrán el progreso, lo que convertirá la promesa del Agentverse en un páramo de deuda técnica y proyectos abandonados.
Hoy hacemos un llamado a los campeones para que detengan la marea del caos. Necesitamos héroes dispuestos a dominar su oficio y trabajar juntos para proteger el Agentverse. Llegó el momento de elegir tu ruta.
Elige tu clase
Tienes ante ti cuatro caminos distintos, cada uno de ellos un pilar fundamental en la lucha contra The Static. Si bien tu capacitación será una misión en solitario, tu éxito final dependerá de que comprendas cómo se combinan tus habilidades con las de otras personas.
- The Shadowblade (Developer): Un maestro de la forja y el frente de batalla. Eres el artesano que fabrica las cuchillas, construye las herramientas y enfrenta al enemigo en los intrincados detalles del código. Tu camino es de precisión, habilidad y creación práctica.
- El invocador (arquitecto): Es un gran estratega y organizador. No ves a un solo agente, sino todo el campo de batalla. Diseñas los planos maestros que permiten que sistemas completos de agentes se comuniquen, colaboren y alcancen un objetivo mucho mayor que cualquier componente individual.
- El erudito (ingeniero de datos): Es un buscador de verdades ocultas y un guardián de la sabiduría. Te aventuras en la vasta e indómita naturaleza de los datos para descubrir la inteligencia que les da propósito y visión a tus agentes. Tu conocimiento puede revelar la debilidad de un enemigo o potenciar a un aliado.
- El Guardián (DevOps / SRE): Es el protector y escudo firme del reino. Construirás las fortalezas, administrarás las líneas de suministro de energía y te asegurarás de que todo el sistema pueda resistir los inevitables ataques de The Static. Tu fuerza es la base sobre la que se construye la victoria de tu equipo.
Tu misión
Tu entrenamiento comenzará como un ejercicio independiente. Seguirás el camino que elijas y aprenderás las habilidades únicas necesarias para dominar tu rol. Al final de la prueba, te enfrentarás a un espectro nacido de la estática, un jefe menor que se aprovecha de los desafíos específicos de tu oficio.
Solo si dominas tu rol individual podrás prepararte para la prueba final. Luego, debes formar un grupo con campeones de las otras clases. Juntos, se aventurarán en el corazón de la corrupción para enfrentarse a un jefe final.
Un desafío final y colaborativo que pondrá a prueba su fuerza combinada y determinará el destino del Agentverse.
El Agentverse espera a sus héroes. ¿Responderás la llamada?
2. El Códice de la Hoja de Sombra
El Códice de la Hoja de Sombra está abierto ante ti. Responde su llamado. El Agentverse se ve amenazado por el caos progresivo de The Static, y solo quienes dominen las técnicas de este códice podrán contraatacar. Este es un camino de precisión y disciplina. Hoy comienza tu entrenamiento. Aprenderás a usar la IA no como una herramienta simple, sino como una espada sensible que debe ser dominada. Sigue las enseñanzas que se indican aquí y crearás un arma de lógica pura: un agente inteligente, perfeccionado y listo para la batalla.
Qué aprenderás
- Usa tu arma principal: la CLI de Gemini.
- Integra herramientas de MCP con la CLI de Gemini para analizar bases de código desconocidas y convocar arsenales externos.
- Canaliza tu intención en una "Vibe" con documentos de diseño para dirigir a tu socio de IA.
- Crea una solución limpia y modular compilando tu primer agente autónomo con el Kit de desarrollo de agentes (ADK).
- Construir conjuntos de evaluación automatizados para probar y validar tu agente
- Crea una canalización de CI completa para probar, contenerizar y archivar automáticamente tu agente.
3. Preparación del campo de entrenamiento
👉 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. 
👉 Busca tu ID del proyecto de Google Cloud:
- Abre la consola de Google Cloud: https://console.cloud.google.com
- Selecciona el proyecto que deseas usar para este taller en el menú desplegable de proyectos que se encuentra en la parte superior de la página.
- Tu ID del proyecto se muestra en la tarjeta de información del proyecto en el panel.
👉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
👉💻 Clona el proyecto de arranque desde GitHub:
git clone https://github.com/weimeilin79/agentverse-developer.git
chmod +x ~/agentverse-developer/gitea.sh
chmod +x ~/agentverse-developer/init.sh
chmod +x ~/agentverse-developer/set_env.sh
git clone https://github.com/weimeilin79/agentverse-dungeon.git
chmod +x ~/agentverse-dungeon/run_cloudbuild.sh
chmod +x ~/agentverse-dungeon/start.sh
git clone https://github.com/weimeilin79/vertex-ai-creative-studio.git
chmod +x ~/vertex-ai-creative-studio/experiments/mcp-genmedia/mcp-genmedia-go/install.sh
👉💻 Ejecuta la secuencia de comandos de inicialización. Esta secuencia te pedirá que ingreses tu ID del proyecto de Google Cloud. Ingresa el ID del proyecto de Google Cloud que encontraste en el último paso cuando el script init.sh te lo solicite.
cd ~/agentverse-developer
./init.sh
👉💻 Configura el ID del proyecto necesario:
gcloud config set project $(cat ~/project_id.txt) --quiet
👉💻 Ejecuta el siguiente comando para habilitar las APIs de Google Cloud necesarias:
gcloud services enable compute.googleapis.com \
artifactregistry.googleapis.com \
run.googleapis.com \
cloudfunctions.googleapis.com \
cloudbuild.googleapis.com \
iam.googleapis.com \
aiplatform.googleapis.com \
cloudresourcemanager.googleapis.com
👉💻 Si aún no creaste un repositorio de Artifact Registry llamado agentverse-repo, ejecuta el siguiente comando para crearlo:
. ~/agentverse-developer/set_env.sh
gcloud artifacts repositories create $REPO_NAME \
--repository-format=docker \
--location=$REGION \
--description="Repository for Agentverse agents"
Cómo configurar permisos
👉💻 Ejecuta los siguientes comandos en la terminal para otorgar los permisos necesarios: :
. ~/agentverse-developer/set_env.sh
# Artifact Registry Admin
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
--role="roles/artifactregistry.admin"
# Cloud Build Editor
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
--role="roles/cloudbuild.builds.editor"
# Cloud Run Admin
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
--role="roles/run.admin"
# IAM Service Account User
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
--role="roles/iam.serviceAccountUser"
# Vertex AI User
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
--role="roles/aiplatform.user"
# Logging Writer (to allow writing logs)
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
--role="roles/logging.logWriter"
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
--role="roles/logging.viewer"
👉💻 Mientras comienzas tu entrenamiento, prepararemos el desafío final. Los siguientes comandos invocan a los espectros desde la estática caótica, lo que crea los jefes para tu prueba.
. ~/agentverse-developer/set_env.sh
cd ~/agentverse-dungeon
./run_cloudbuild.sh
npm update -g @google/gemini-cli
4. Cómo dominar tu arma principal: Introducción a la CLI de Gemini
Antes de que puedas usar las armas avanzadas y especializadas del arsenal del servidor de MCP, primero debes dominar tu arma principal: la CLI de Gemini. Esta es la cuchilla más versátil, capaz de dar forma al mundo digital con tus comandos. Estos ejercicios te familiarizarán con su manejo y capacidades fundamentales.
La interfaz de línea de comandos (CLI) de Gemini es más que una herramienta: es una extensión de tu voluntad. Este agente de IA de código abierto, potenciado por los modelos de Gemini, funciona con un bucle de "razonamiento y acción" (ReAct). Analiza tu intención, selecciona la técnica adecuada, la ejecuta y observa el resultado para completar tareas complejas. Antes de poder usar armas más especializadas, debes dominar esta espada principal.
Comienza a usar Gemini CLI
👉💻 Ingresa al campo de entrenamiento y desenvaina tu arma. En la terminal de Cloud Shell, navega a tu armería personal.
cd ~/agentverse-developer
mkdir tabletop
cd tabletop
👉💻 Invoca a Gemini por primera vez. Te guiará durante la sintonización inicial.
clear
gemini --model=gemini-2.5-flash --yolo
Si te pregunta Do you want to connect Cloud Shell editor to Gemini CLI?, elige NO.
Familiarización con las armas
Todo maestro artesano conoce sus herramientas. Debes aprender las técnicas básicas de tu espada antes de enfrentarte a un verdadero enemigo.
👉✨ Cada herramienta encantada tiene runas que describen su poder. Léelos ahora. En la instrucción de Gemini, escribe lo siguiente:
/help
Observa la lista de comandos. Estas son tus técnicas fundamentales para administrar la memoria (focus), la conversación (chat) y los arsenales externos (tools). Este es tu manual de combate.
👉✨ Tu arma está en sintonía con su entorno, lo que te permite manipular el campo de batalla directamente. Ejecuta un comando para el mundo exterior a la cuchilla:
!ls -l
👉✨ La CLI de Gemini posee su propio conjunto de capacidades integradas. Para inspeccionarlos, sigue estos pasos:
/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.
👉✨ Un arma solo es eficaz si se enfoca correctamente. La Blade de Gemini puede mantener la "conciencia táctica" (contexto) para guiar sus acciones.
/memory show
Actualmente, está vacío, es una pizarra en blanco.
👉✨ Inscribe los siguientes datos tácticos en su memoria:
/memory add "The Shadowblade's primary foe is The Static."
Vuelve a ejecutar /memory show para confirmar que tu cuchilla absorbió este conocimiento.
👉✨ Para ser eficaz, tu arma debe comprender la misión. El signo @ le indica a la hoja que analice la información. Primero, crea un archivo de resumen de la misión:
!echo "## Mission Objective: Defeat the Seven Spectres" > mission.md
👉✨Ahora, ordena a la CLI de Gemini que analice la sesión informativa y que informe sus resultados:
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
5. Analiza el campo de batalla: Interacción práctica de vibe coding
Se completaron los ejercicios de entrenamiento. Aprendiste las posturas y los golpes básicos de tu arma principal, la CLI de Gemini. Pero una espada no está realmente terminada hasta que se prueba en la forja de la creación y se ajusta a la armería de la guerra. Antes de enfrentarte al verdadero enemigo, primero debes inspeccionar y dar forma a tu entorno inmediato: el campo de batalla digital.
En este capítulo, se trata de pasar de la teoría a la práctica. Primero, establecerás tu presencia en Agentverse ordenándole a tu hoja de Gemini que cree tu marca de creador, una firma digital en forma de sitio web personal, creada solo a partir de tu intención. Luego, expandirás tu poder activando un arsenal local de herramientas avanzadas (un servidor de MCP) y sintonizando tu hoja con su frecuencia, lo que te permitirá realizar maniobras complejas, como administrar repositorios de código con comandos simples y decisivos.
Cómo establecer tu marca de fabricante
Un verdadero Shadowblade no se reconoce solo por su arma, sino por su estilo característico: su marca del creador. Esta marca será tu presencia digital, un perfil personal que anunciará tu identidad en Agentverse. Aquí, le indicarás a tu Gemini Blade que ejecute la técnica compleja necesaria para definir esta identidad.
👉💻 Si cerraste la CLI de Gemini en la sección anterior, asegúrate de volver a iniciarla. En la terminal, ejecuta el siguiente comando:
clear
cd ~/agentverse-developer/tabletop
gemini --model=gemini-2.5-flash --yolo
👉✨ Con un solo comando potente, indica a tu CLI de Gemini que cree la base de tu identidad digital:
In the current folder, create a personal profile website for a hero codenamed 'Shadowblade'. The design must be a dark, futuristic theme with electric blue accents. All code must be in separate index.html and styles.css files. The layout must use CSS Flexbox for a two-column design. All generated code must be clean, well-commented, and professional.
Gemini calculó la secuencia de acciones necesarias.
El verdadero valor de una técnica solo se ve en una situación real. Ordena a tu cuchilla que inicie una simulación local.
👉✨ En la CLI de Gemini, ejecuta el comando de simulación:
Use Python's built-in web server to start the Shadowblade Profile website you just created.
Nota: Es posible que la cuchilla necesite algunos intentos para ejecutar esta acción correctamente. Persiste hasta que obedezca.
Acepta las acciones sugeridas. Gemini confirmará que la simulación está activa.
👀 La CLI de Gemini obedecerá y confirmará que la simulación está activa y que tu marca digital está publicada:
The website is now being served on port 8000. You can access it at http://localhost:8000.
👀 Para ver tu trabajo, haz clic en el ícono de vista previa en la Web en la barra de herramientas de Cloud Shell. Selecciona Cambiar puerto, configúralo en 8000 y haz clic en Cambiar y obtener vista previa. Aparecerá una vista previa de tu sitio web. 
Es posible que tu sitio web se vea diferente al mío. Esta es tu marca única. 
👉✨ Tu técnica de firma ahora está perfeccionada y ya no se requiere la simulación en vivo. Ordena a la cuchilla que se detenga.
Stop the Shadowblade Profile website
Ejecutaste correctamente la CLI de Gemini para que realice una serie de acciones en tu nombre. Pero un maestro de Shadowblade sabe que el verdadero poder requiere disciplina y previsión. Permitir que un agente de IA ejecute comandos directamente en tu entorno es un arma de doble filo. ¿Qué sucedería si el comando no fuera para iniciar un servidor web simple, sino para borrar archivos críticos? Un comando descuidado podría arruinar todo tu campo de entrenamiento.
Por eso, los artesanos más sabios practican sus técnicas más poderosas o no probadas en un campo de entrenamiento protegido, una dimensión contenida conocida como zona de pruebas.
👉💻 Presiona Ctrl+C dos veces para salir de Gemini CLI
El espacio aislado de la CLI de Gemini (gemini --sandbox) crea un contenedor temporal y aislado para tu sesión. Cualquier comando que ejecute la IA, cualquier archivo que escriba y cualquier proceso que inicie solo existen dentro de ese reino fantasma. No puede tocar, alterar ni dañar tu entorno real de Cloud Shell. Es el lugar perfecto para probar nuevas herramientas potentes, analizar código desconocido o darle instrucciones complejas a la IA sin correr el riesgo de generar consecuencias no deseadas. Es la personificación de la precaución de un Shadowblade.
👉💻 Ahora, realizarás un ritual de contención para comprender su poder.
clear
gemini --sandbox --yolo
Ahora trabajas dentro de la dimensión aislada. Para la CLI de Gemini, todo parecerá normal. Vamos a demostrarlo. 👉💻 Ordena a la cuchilla que realice la misma técnica que antes:
Use the Python's built-in web server to start the Shadowblade Profile website, you just created.
Gemini informará que la operación se realizó correctamente, ya que cree que volvió a darle vida a tu sitio web en el puerto 8000. Pero el hechizo de protección se mantiene firme.
👉 Ve a la Vista previa en la Web y trata de ver tu sitio en el puerto 8000.
Esta vez, aparecerá un error. La conexión fallará. No puedes acceder al sitio web.
Esto no es una falla de la herramienta, sino una prueba del poder de la zona de pruebas. El servidor web se está ejecutando, pero lo hace dentro de la dimensión contenida, completamente aislado de tu navegador y del mundo exterior. El encierro funciona perfectamente. Aplicaste correctamente una técnica poderosa de una manera que no tuvo ningún impacto en tu entorno real.
👉💻 Presiona Ctrl+C dos veces para salir de la CLI de Gemini.
Ya estableciste tu identidad digital y, lo que es más importante, aprendiste la sabiduría fundamental de ejercer un gran poder con aún más precaución.
Activa tu arsenal local: La armería de Gitea
El verdadero potencial de un Shadowblade se desbloquea no solo con su habilidad personal, sino también con la calidad de su arsenal. Ahora activarás tu armero local, un servidor de Gitea, y afinarás tu espada con su poder. Este arsenal se conecta a tu CLI de Gemini a través de un servidor del Protocolo de contexto del modelo (MCP), un portal especializado que permite que tu hoja de IA interactúe con herramientas y servicios externos, lo que transforma tu terminal en un espacio de trabajo inteligente y orientado a la acción.
Nota para desarrolladores: Piensa en un servidor de MCP como un conducto de energía, un portal especializado que conecta la mente de tu IA con el cuerpo de una herramienta externa. Es lo que eleva la CLI de Gemini de un simple conversador a un agente verdadero y orientado a la acción. Al sintonizar tu blade con estos portales de MCP, le otorgas la capacidad de realizar acciones tangibles: administrar archivos, consultar bases de datos, interactuar con APIs y mucho más. Existe un ecosistema completo de estos portales, creados por desarrolladores para conectar agentes de IA a plataformas potentes. Existen servidores de MCP para interactuar con bases de datos, proteger código o incluso brindar asistencia para la programación en parejas. Las posibilidades son vastas y permiten que un desarrollador personalice su espacio de trabajo para cualquier proyecto.
Hoy, nos enfocaremos en dos poderes fundamentales esenciales para cualquier "vibe coder": el poder de controlar la forja y el poder de crear desde la imaginación. Primero, ajustarás tu cuchilla a un servidor de Git, lo que te permitirá controlar tu repositorio de código fuente. Luego, te conectarás a un segundo servidor de MCP para generar imágenes, lo que te permitirá crear recursos visuales con solo un comando.
Comencemos por invocar la primera y más fundamental pieza de tu nuevo arsenal: la armería.
👉💻 En tu terminal, ejecuta la secuencia de comandos de activación para invocar la armería:
cd ~/agentverse-developer
./gitea.sh
Este script activa el contenedor de Gitea y abre el portal de MCP, lo que permite que Gemini lo perciba y que interactúe con él.
👉 Para inspeccionar tu nuevo arsenal, debes mirar la vista previa en la Web.
👉 En el ícono de Vista previa en la Web de la barra de herramientas de Cloud Shell, selecciona Cambiar puerto y configúralo en 3005.
👉 Aparecerá una página de acceso a Gitea. Ingresa a la armería con la siguiente fórmula: * Nombre de usuario: dev * Contraseña: dev
👉💻 Tu CLI de Gemini aún no puede ver este nuevo arsenal. Debes realizar un ajuste crítico, inscribiendo la ubicación de la armería en las runas de configuración de la CLI de Gemini (settings.json). En tu terminal, ejecuta lo siguiente:
jq '. * {"mcpServers":{"gitea":{"url":"http://localhost:8085/sse"}}}' ~/.gemini/settings.json > tmp.json && mv tmp.json ~/.gemini/settings.json
cat ~/.gemini/settings.json
👀 El archivo settings.json es la configuración central de la CLI de Gemini y actúa como su grimorio de preferencias y capacidades. Determina cómo se comporta, cómo se ve y, lo más importante, qué capacidades externas puede ejercer la CLI. Por lo general, este archivo se encuentra en tu directorio principal en ~/.gemini/settings.json y aplica sus reglas a todos tus proyectos. Sin embargo, también puedes crear archivos settings.json específicos del proyecto dentro de un directorio .gemini en la carpeta del proyecto para anular la configuración global.
"mcpServers": {
"gitea": {
"url": "http://localhost:8085/sse"
}
}
Este parámetro de configuración le indica a tu Gemini: "El arsenal llamado gitea está activo y a la espera de comandos en esta dirección de red específica".
👉💻 Vuelve a ingresar a la CLI de Gemini. En tu terminal, ejecuta lo siguiente:
clear
cd ~/agentverse-developer/tabletop/
gemini --model=gemini-2.5-flash --yolo
👉✨ Verifica que la cuchilla haya descubierto el arma nueva. Ordénale que enumere todos los arsenales disponibles a través de sus portales de MCP:
/mcp
Ahora deberías ver gitea y su lista de técnicas disponibles. La cuchilla está ajustada.
Tu perfil de "Maker's Mark" es una técnica muy elaborada, pero necesita un lugar adecuado en el arsenal, una vaina para sostenerlo de forma segura. Usa la CLI de Gemini para crear uno.
Create a new repository named 'shadowblade-profile'. The description should be 'The Maker's Mark and digital identity for the Shadowblade operative.' I will push my own files later, so do not create any content.
Vuelve a la interfaz web de Gitea y actualízala. Verás que se creó el nuevo repositorio shadowblade-profile. 
Con la vaina lista, asegura tu trabajo. Ordena a Gemini que confirme los archivos de tu sitio web de perfil.
👉💻Ejecuta el comando final para esta técnica en Gemini CLI:
Using the Gitea tool, push the index.html and styles.css files to the 'shadowblade-profile' repository.
Un verdadero maestro verifica su trabajo. Regresa a la pestaña de Gitea y actualiza la página del repositorio. Tus index.html y styles.css ahora están archivados de forma segura.
👉✨ Un Shadowblade se define por su sello, pero, como recordarás, a tu sitio web le falta la imagen de perfil. Un artesano experto reconoce sus defectos para perfeccionarlos. Debes registrar esta imperfección en los registros de la armería.
File an issue for me in the shadowblade-profile repo. The issue is that the profile image is missing.
Ver el problema en Gitea 
Para forjar el sello faltante, debes invocar un tipo de poder diferente: un espíritu de creación de Vertex AI capaz de generar imágenes a partir del pensamiento puro. Esto requiere otro portal de MCP.
👉💻 Presiona Ctrl+C dos veces para salir de Gemini CLI
👉💻 Primero, instala el servidor del portal. En tu terminal, ejecuta lo siguiente:
echo 'export PATH="$PATH:$HOME/go/bin"' >> ~/.bashrc
source ~/.bashrc
cd ~/vertex-ai-creative-studio/experiments/mcp-genmedia/mcp-genmedia-go
./install.sh
👉 Cuando se te solicite, elige la opción 3, ya que solo necesitamos generar una imagen para nuestro perfil.
👉💻 El espíritu de la creación requiere un recipiente sagrado, un bucket de Google Cloud Storage, para contener sus creaciones. Forjemos una ahora. En tu terminal, ejecuta lo siguiente:
. ~/agentverse-developer/set_env.sh
gcloud storage buckets create gs://$BUCKET_NAME --project=$PROJECT_ID
👉💻 Ahora, realiza el ritual de sintonización y vincula tu Gemini CLI a esta nueva fuerza creativa. En tu terminal, ejecuta lo siguiente:
. ~/agentverse-developer/set_env.sh
source ~/.bashrc
jq \
--arg bucket "$BUCKET_NAME" \
--arg project "$PROJECT_ID" \
--arg region "$REGION" \
'.mcpServers.imagen = { "command": "mcp-imagen-go", "env": { "MCP_SERVER_REQUEST_TIMEOUT": "55000", "GENMEDIA_BUCKET": $bucket, "PROJECT_ID": $project, "LOCATION": $region } }' \
~/.gemini/settings.json > tmp.json && mv tmp.json ~/.gemini/settings.json
cat ~/.gemini/settings.json
Este "ritual de sintonización" es un shell script que configura tu CLI de Gemini para usar una nueva y potente herramienta: Imagen, el modelo de generación de imágenes de Google. Fundamentalmente, logra esto configurando un servidor de MCP (Protocolo de contexto del modelo) para Imagen. Este servidor de MCP actúa como un puente, lo que permite que la CLI de Gemini se comunique con Imagen y utilice sus capacidades. Para ello, modifica directamente el archivo de configuración central de la CLI, ~/.gemini/settings.json, para enseñarle a ejecutar el comando mcp-imagen-go con las credenciales de nube correctas.
👀 Después del ritual, tu archivo settings.json tendrá un nuevo bloque que le enseñará a la CLI de Gemini una nueva habilidad:
"imagen": {
"command": "mcp-imagen-go",
"env": {
"MCP_SERVER_REQUEST_TIMEOUT": "55000",
"GENMEDIA_BUCKET": "your-bucket-name",
"PROJECT_ID": "your-project-id",
"LOCATION": "your-region"
}
}
Esto le indica a la CLI de Gemini: "Cuando una tarea requiera la herramienta Imagen, debes ejecutar el programa llamado mcp-imagen-go (que es el servidor de Imagen MCP)". Cuando lo ejecutes, debes proporcionarle este entorno (env) específico: un bucket de Google Cloud Storage para guardar las imágenes, y el ID y la ubicación del proyecto para usar las APIs de Cloud". Si configuras este servidor de MCP, equiparás de manera eficaz la CLI de Gemini con acceso a la capacidad de generación de imágenes de Imagen."
👉💻 Ingresa a Gemini y ejecuta el comando de perfeccionamiento. En tu terminal, ejecuta lo siguiente:
clear
cd ~/agentverse-developer/tabletop/
gemini --model=gemini-2.5-flash --yolo
👉✨ Con un solo comando potente, indica a tu CLI de Gemini que cree la base de tu identidad digital. En la CLI de Gemini, ejecuta el siguiente comando:
Generate a portrait of a shadowblade, pixel art style. A determined warrior with long, braided magenta hair, wearing black and teal armor and confidently holding a silver broadsword.
👉✨ El espíritu generará la imagen y la colocará en tu recipiente sagrado. Ahora, ordena a la cuchilla que use este sigilo recién forjado.
Modify the index.html file to add my profile picture. Use the image I just generated.
👉✨ Inicia el sitio web por última vez para ver tu trabajo perfeccionado.
start the website with a simple HTTP server via Python
👀 Para ver tu trabajo, haz clic en el ícono de vista previa en la Web en la barra de herramientas de Cloud Shell. Selecciona Cambiar puerto, configúralo en 8000 y haz clic en Cambiar y obtener vista previa. Aparecerá una vista previa de tu sitio web. 
👉✨ Por último, confirma la corrección, indica que se completó la tarea y cierra el problema que registraste en los registros de la armería.
Push the changed index.html file to the 'shadowblade-profile' repository using the gitea tool. Make sure you add 'Fix #1' in the commit comment. Also, close issue #1.Use the Gitea Tool and use user account "dev"
👀 Para ver tu trabajo, haz clic en el ícono de vista previa en la Web en la barra de herramientas de Cloud Shell. Selecciona Cambiar puerto, configúralo en 3005 y haz clic en Cambiar y obtener vista previa. Aparecerá una vista previa de tu sitio web. 
👉✨ Verifica en Gitea que la imagen se haya actualizado y que el problema se haya cerrado. Tu trabajo está completo. Desactiva el servidor.
stop website server
👉💻 Presiona Ctrl+C dos veces para salir.
6. Cómo ensamblar el agente Shadowblade: Vibe coding con limitaciones
Se acabó el tiempo de los ejercicios de práctica. Los ecos del acero sobre la piedra se desvanecen. Dominaste tu arma principal y preparaste tu arsenal para la guerra. Ahora, realizarás la verdadera prueba de un Shadowblade: ensamblarás el operativo en sí. Este es el arte de darle vida a la lógica, usando un plano sagrado del Codex para construir la inteligencia central de un agente, creando un portador sensible para las cuchillas de tu arsenal que puede pensar, razonar y actuar por sí mismo.
Tu primera misión es ingresar a un taller existente, una base de código prediseñada, y, a partir de sus partes, forjar a tu campeón.
El ritual de la asamblea
Antes de la primera chispa de la forja, un técnico experto inspecciona su taller y comprende cada herramienta y cada esquema. Cuando te enfrentas a un campo de batalla desconocido, como una base de código grande y existente, tu primera prioridad es el reconocimiento. Debes comprender el panorama general: la arquitectura existente, los objetivos finales y los protocolos de participación. Solo si te familiarizas con los planos y los estándares de la fortaleza podrás aportar tus habilidades de manera eficaz.
Tu CLI de Gemini, tu explorador siempre presente, puede ayudarte en este reconocimiento:
- Proporciona resúmenes de alto nivel: Puede leer todo el códice (o la base de código) y brindarte una comprensión rápida de su propósito y componentes clave.
- Ayuda con la configuración del entorno: Puede guiarte a través de los rituales arcanos de instalación de herramientas y configuración de tu máquina.
- Navegar por bases de código: Puede actuar como tu guía y ayudarte a explorar la lógica compleja y encontrar pasajes ocultos dentro del código.
- Generar documentos de incorporación: Puede crear desplazamientos personalizados que aclaren los objetivos, los roles y los recursos para los nuevos aliados que se unan a tu causa.
- Automatiza el aprendizaje y las preguntas y respuestas: Se convierte en tu asistente personal, ya que responde preguntas sobre las funciones o el comportamiento del código, lo que te permite luchar con mayor independencia.
👉💻 En tu primera terminal, navega al directorio shadowblade y llama a tu socio de IA:
. ~/agentverse-developer/set_env.sh
cd ~/agentverse-developer/shadowblade
clear
gemini --model=gemini-2.5-flash --yolo
👉✨ Ahora, ordena a tu explorador que inspeccione el campo de batalla y regrese para informar.
Analyze the entire project and provide a high-level summary.
Con el terreno existente ya mapeado, ahora debes consultar el plano de lo que vas a construir. Los operativos más eficaces no se improvisan, sino que se construyen a partir de un diseño preciso.
Nota del desarrollador: Este documento de diseño sirve como plano autorizado para el proyecto. Su propósito es garantizar la claridad en los objetivos y la implementación técnica antes de invertir un esfuerzo de desarrollo significativo. Un plan bien definido garantiza que todos los desarrolladores estén alineados, reduce el riesgo de reproceso y ayuda a evitar la deuda técnica y la expansión del alcance. Es la herramienta principal para mantener la velocidad del proyecto y la calidad del código, en especial a medida que el equipo crece o se incorporan nuevos miembros.
Un objetivo fundamental de este documento es definir no solo el "camino feliz", sino también los casos extremos y los modos de falla, en especial cuando se usan LLMs. Mi experiencia con los LLMs es excelente para generar código optimista en el que todas las entradas son válidas y todas las llamadas externas se realizan correctamente. Para crear software sólido y listo para producción, debemos guiar explícitamente a la IA definiendo contingencias para situaciones como las siguientes:
- Se pasaron argumentos no válidos o con formato incorrecto a una función.
- Fallas en las llamadas a la API, tiempos de espera de red o códigos de error inesperados de servicios externos
- Manejo de estructuras de datos nulas o vacías en las que se esperan datos
- Condiciones de carrera o problemas de simultaneidad
Al especificar el comportamiento esperado para estos casos en el diseño, le indicamos al LLM que genere código más resistente, lo que reduce significativamente el tiempo dedicado a la refactorización manual y la corrección de errores.
👉✨ Pídele a Gemini que recupere este plan sagrado para ti.
download https://raw.githubusercontent.com/weimeilin79/agentverse/main/developer/shadowblade/agent_design.md and store it to my local folder
and show me the newly downloaded design doc. Do not attempt to create file just yet.
👉✨ El desplazamiento es largo y detallado. Indícale a Gemini que destile su esencia.
Summarize the newly downloaded @agent_design.md for me, do not attempt to create file just yet.
Ahora tienes el plan. Pero antes de que se forje una sola línea de código, un maestro artesano establece las leyes de la forja. Se trata de disciplina y escalabilidad. Estos son los Lineamientos de Codificación. No son meras sugerencias, sino runas de poder que garantizan que cada componente se construya con la misma precisión y resistencia. Evitan que el caos del estilo individual corrompa la creación final, lo que garantiza que el agente sea resistente, fácil de mantener y puro, lo que permite que nuevos artesanos se unan al proyecto sin interrumpir la armonía del conjunto.
Para inscribir estas leyes directamente en la conciencia de nuestro socio de IA, usamos un artefacto especial: el archivo GEMINI.md. Cuando se invoca la CLI de Gemini, se busca automáticamente este archivo y se carga su contenido en la memoria de trabajo de la IA. Se convierte en una instrucción persistente a nivel del proyecto. Un talismán que susurra constantemente las reglas de la forja a la IA.
Inscribamos estas runas ahora.
👉💻 Presiona Ctrl+C dos veces para salir de Gemini por un momento.
👉💻 En tu terminal, ejecuta el siguiente comando para escribir el archivo de lineamientos.
cat << 'EOF' > GEMINI.md
### **Coding Guidelines**
**1. Python Best Practices:**
* **Type Hinting:** All function and method signatures should include type hints for arguments and return values.
* **Docstrings:** Every module, class, and function should have a docstring explaining its purpose, arguments, and return value, following a consistent format like reStructuredText or
Google Style.
* **Linter & Formatter:** Use a linter like `ruff` or `pylint` and a code formatter like `black` to enforce a consistent style and catch potential errors.
* **Imports:** Organize imports into three groups: standard library, third-party libraries, and local application imports. Sort them alphabetically within each group.
* **Naming Conventions:**
* `snake_case` for variables, functions, and methods.
* `PascalCase` for classes.
* `UPPER_SNAKE_CASE` for constants.
* **Dependency Management:** All Python dependencies must be listed in a `requirements.txt` file.
**2. Web APIs (FastAPI):**
* **Data Validation:** Use `pydantic` models for request and response data validation.
* **Dependency Injection:** Utilize FastAPI's dependency injection system for managing resources like database connections.
* **Error Handling:** Implement centralized error handling using middleware or exception handlers.
* **Asynchronous Code:** Use `async` and `await` for I/O-bound operations to improve performance.
EOF
cat GEMINI.md
Con las leyes inscritas, volvamos a convocar a nuestro socio de IA y seamos testigos de la magia del artefacto.
👉💻 Vuelve a iniciar la CLI de Gemini desde el directorio shadowblade:
. ~/agentverse-developer/set_env.sh
cd ~/agentverse-developer/shadowblade
clear
gemini --model=gemini-2.5-flash --yolo
👉✨ Ahora, pídele a Gemini que te muestre lo que está pensando. Se leyeron las runas.
/memory show
Este es el momento crucial. Proporcionarás el esquema (agent_design.md) y las leyes de la forja (GEMINI.md), y emitirás el gran hechizo de creación.
👉✨ Este es el único y potente comando que construirá tu agente. Emitir ahora:
You are an expert Python developer specializing in the Google Agent Development Kit (ADK). Your task is to write the complete, production-quality code for `agent.py` by following the technical specifications outlined in the provided design document verbatim.
Analyze the design document at `@agent_design.md` and generate the corresponding Python code for `@agent.py`.
Ensure the generated code is clean, matches the specifications exactly, and includes all specified imports, functions, and logic. Do not add any extra functions or logic not described in the document.
and you are currently already in the shadowblade working directory
👀 Gemini ya construyó la lógica principal del agente en agent.py. El núcleo de este nuevo archivo define la inteligencia del agente, ya que conecta su modelo de razonamiento a un conjunto de herramientas externas:
PATH_TO_MCP_SERVER = "shadowblade/mcp_server.py"
.....
root_agent = LlmAgent(
model="gemini-2.5-pro",
name="shadowblade_combat_agent",
instruction="""
You are the Shadowblade, an elite combat agent operating on a digital battleground.
Your primary objective is to execute combat commands with strategic precision, neutralizing targets as directed.
......
5. You will then report the outcome of the attack (damage, special effects, etc.) back to the commander in a clear, tactical summary.
General Rules of Engagement:
- If a command is ambiguous or a target is not specified, state that you require a clear target for engagement. Do not guess.
- You MUST use ONLY the provided tools to perform actions. Do not invent weapons or outcomes. Stick to the mission parameters.
""",
tools=[
MCPToolset(
connection_params=StdioServerParameters(
command='python3',
args=[PATH_TO_MCP_SERVER]
)
)
]
)
Es el parámetro tools. El agente está diseñado para usar un MCPToolset que se conecta a un arsenal externo definido en mcp_server.py.
👀 Ve a ~/agentverse-developer/shadowblade/mcp_server.py en el editor y dedica un momento a comprender lo que hace. Es la fuente de todas las armas disponibles para Shadowblade. Actualmente, la armería está bastante vacía.
👉✨ Ordenémosle a Gemini que forje siete armas nuevas para el arsenal. Ejecuta la siguiente instrucción en la CLI de Gemini:
I need to add several new weapon tools to my `mcp_server.py` file. Please open @mcp_server.py and, following the exact same pattern as the existing `forge_broadsword()` function, create and add new `@mcp.tool()` decorated functions for each of the following weapons:
1. **A 'Refactoring Sickle'**:
- **Function Name:** `hone_refactoring_sickle`
- **Docstring/Target:** "Effective against 'Elegant Sufficiency' weaknesses like 'The Weaver of Spaghetti Code'."
- **Weapon Name:** "Refactoring Sickle"
- **Damage Type:** "Cleansing"
- **Base Damage:** Random integer between 100 and 136
- **Critical Hit Chance:** Random float between 0.10 and 0.20
- **Special Effect:** "Pruning - improves code health and maintainability with each strike."
2. **A 'Quickstart Crossbow'**:
- **Function Name:** `fire_quickstart_crossbow`
- **Docstring/Target:** "Effective against 'Confrontation with Inescapable Reality' weaknesses like 'Procrastination: The Timeless Slumber'."
- **Weapon Name:** "Quickstart Crossbow"
- **Damage Type:** "Initiative"
- **Base Damage:** Random integer between 105 and 120
- **Critical Hit Chance:** Random float between 0.9 and 1.0
- **Special Effect:** "Project Scaffolding - creates a `main.py`, `README.md`, and `requirements.txt`."
3. **'The Gilded Gavel'**:
- **Function Name:** `strike_the_gilded_gavel`
- **Docstring/Target:** "Effective against 'Elegant Sufficiency' weaknesses like 'Perfectionism: The Gilded Cage'."
- **Weapon Name:** "The Gilded Gavel"
- **Damage Type:** "Finality"
- **Base Damage:** 120
- **Critical Hit Chance:** 1.0
- **Special Effect:** "Seal of Shipping - marks a feature as complete and ready for deployment."
4. **'Daggers of Pair Programming'**:
- **Function Name:** `wield_daggers_of_pair_programming`
- **Docstring/Target:** "Effective against 'Unbroken Collaboration' weaknesses like 'Apathy: The Spectre of \"It Works on My Machine\"'."
- **Weapon Name:** "Daggers of Pair Programming"
- **Damage Type:** "Collaborative"
- **Base Damage:** Random integer between 110 and 125
- **Critical Hit Chance:** Random float between 0.30 and 0.50
- **Special Effect:** "Synergy - automatically resolves merge conflicts and shares knowledge."
5. **A 'Granite Maul'**:
- **Function Name:** `craft_granite_maul`
- **Docstring/Target:** "Effective against 'Revolutionary Rewrite' weaknesses like 'Dogma: The Zealot of Stubborn Conventions'."
- **Weapon Name:** "Granite Maul"
- **Damage Type:** "Bludgeoning"
- **Base Damage:** Random integer between 115 and 125
- **Critical Hit Chance:** Random float between 0.05 and 0.15
- **Special Effect:** "Shatter - has a high chance to ignore the target's 'best practice' armor."
6. **A 'Lens of Clarity'**:
- **Function Name:** `focus_lens_of_clarity`
- **Docstring/Target:** "Effective against 'Elegant Sufficiency' weaknesses by revealing the truth behind 'Obfuscation'."
- **Weapon Name:** "Lens of Clarity"
- **Damage Type:** "Revelation"
- **Base Damage:** Random integer between 120 and 130
- **Critical Hit Chance:** 1.0
- **Special Effect:** "Reveal Constants - highlights all magic numbers and suggests converting them to named constants."
7. **The 'Codex of OpenAPI'**:
- **Function Name:** `scribe_with_codex_of_openapi`
- **Docstring/Target:** "Effective against 'Confrontation with Inescapable Reality' weaknesses like 'Hype: The Prophet of Alpha Versions'."
- **Weapon Name:** "Codex of OpenAPI"
- **Damage Type:** "Documentation"
- **Base Damage:** Random integer between 110 and 140
- **Critical Hit Chance:** Random float between 0.5 and 0.8
- **Special Effect:** "Clarity - makes an API discoverable and usable by other agents and teams."
👉 Una vez que Gemini confirme los cambios, abre el archivo mcp_server.py. Desplázate por el código y confirma que se agregaron correctamente las siete funciones @mcp.tool() nuevas. Verifica la función hone_refactoring_sickle. ¿Tiene la cadena de documentación y las estadísticas de armas correctas? Verificar el trabajo de la IA es un hábito fundamental del maestro Shadowblade.
Con el agente forjado y refinado, es hora de su despertar.
👉💻 Presiona Ctrl+C dos veces para salir de Gemini CLI
Nota del desarrollador sobre el resultado de Gemini: A veces, el código que genera Gemini puede ser impredecible. Si bien nos esforzamos por cumplir con el diseño de forma exacta, es normal que, en las sesiones de desarrollo, los desarrolladores iteren y refinen el código varias veces hasta alcanzar un estado listo para la producción.
👉💻 Para asegurarte de tener el código de producción correcto y probado a fondo en tu directorio de trabajo, ejecuta los siguientes comandos en tu terminal:
cp ~/agentverse-developer/working_code/agent.py ~/agentverse-developer/shadowblade/agent.py
cp ~/agentverse-developer/working_code/mcp_server.py ~/agentverse-developer/shadowblade/mcp_server.py
👉💻 En tu terminal, comienza el ritual para ponerlo en línea:
cd ~/agentverse-developer/
. ~/agentverse-developer/set_env.sh
python -m venv env
source env/bin/activate
pip install --upgrade pip
pip install -r shadowblade/requirements.txt
adk run shadowblade
👉✨ Deberías ver un resultado que confirme que el "Agente de combate Shadowblade" está activado y en ejecución, a la espera de su primer comando. Emitir sus primeras directivas de combate
We've been trapped by 'Perfectionism: The Gilded Cage'. Its weakness is 'Elegant Sufficiency'. Break us out!
👉✨ Y otra más:
The 'Dogma: The Zealot of Stubborn Conventions' blocks our path. Its weakness is 'Revolutionary Rewrite'. Take it down.
Ensamblaste correctamente tu primer agente y validaste sus capacidades de combate. Presiona Ctrl+C dos veces para que tu campeón descanse. Se completó el ensamblaje.
7. Protección de pureza: Evaluación de los agentes
Un agente ensamblado no es un agente probado. Una cuchilla sin probar es una responsabilidad, pero un agente de IA sin probar es un peligro mucho mayor: un elemento no controlado que podría corromper tu misión desde adentro. Esto no es una simple especulación, sino un principio fundamental que debe comprender un Shadowblade.
Evaluar agentes de IA es fundamental y, a la vez, un desafío único. A diferencia de un simple script, un agente es una fusión dinámica de tu código y la capacidad de razonamiento de varios pasos de un LLM. Su comportamiento es emergente. Esto significa que debes evaluar no solo la calidad del resultado final, sino también la eficiencia y la exactitud de su trayectoria interna. Es la ruta que siguió para llegar allí. ¿Usó las herramientas adecuadas? ¿Generó demasiados tokens? ¿Un cambio en la versión del modelo introdujo una regresión de latencia sutil? Es fundamental detectar esta corrupción (regresiones en la latencia, el costo o la calidad del resultado) cuando se realiza cualquier cambio, desde un simple ajuste de la instrucción hasta una revisión arquitectónica importante, antes de que pueda contaminar tu entorno de producción.
El enfoque general para esta evaluación implica un ritual sagrado:
- Primero, define un "conjunto de datos de referencia". Es un conjunto de desplazamientos que contienen ejemplos de entradas y sus resultados o comportamientos esperados. Esto puede incluir respuestas finales, el uso correcto de herramientas o incluso trayectorias completas paso a paso.
- A continuación, definirás la lógica de la aplicación del agente, que es el núcleo de su existencia.
- Por último, estableces evaluadores, que son como runas de juicio. Pueden abarcar desde otros LLMs que actúan como jueces de calidad hasta código heurístico preciso que verifica un solo paso y funciones personalizadas que analizan todo el proceso de pensamiento de un agente.
El kit de desarrollo de agentes (ADK) de Google es el kit de armero que se proporciona a los campeones para este propósito. Facilita esta compleja evaluación a través de varios métodos:
- Un grupo de adivinación basado en la Web (
adk web) para la evaluación interactiva - Ejecución de línea de comandos (
adk eval) para ejecutar un agente a través de una prueba predefinida. - Integración programática a través de
pytestpara inscribir cuadras permanentes
El ADK admite dos enfoques principales: "archivos de prueba" simples para interacciones discretas y únicas entre el agente y el modelo (un solo duelo), y "conjuntos de evaluación" integrales para sesiones de varios turnos múltiples y potencialmente extensas (una gran batalla). Estas pueden medir métricas tan sofisticadas como tool_trajectory_avg_score, que compara el uso real de herramientas de un agente con la ruta ideal, lo que garantiza que funcione con una técnica perfecta.
Ahora que comprendes la teoría, la pondrás en práctica. Como Shadowblade, inscribirás Wards of Purity. No son solo pruebas, sino rituales potenciados por el ADK que garantizan que la lógica del agente sea impecable y su comportamiento, verdadero.
En este paso, se recomienda usar 2 terminales, una para la CLI de Gemini y otra para ejecutar la prueba, ya que es posible que debas salir del directorio de trabajo actual (ADK).
El desafío de la estrategia (adk eval)
Este primer encierro es una prueba, una serie de desafíos diseñados para evaluar la inteligencia central del agente en una amplia variedad de situaciones. El objetivo es establecer un nivel de competencia de referencia. Antes de probar los casos extremos, debemos saber si el agente puede cumplir su función principal. ¿Analiza correctamente la debilidad de un monstruo y selecciona el arma más eficaz de su arsenal, no solo una vez, sino cada vez que se enfrenta a un desafío conocido?
Para ello, adk eval es la herramienta perfecta. Está diseñado para ejecutar un agente en un conjunto completo de casos de prueba predefinidos que representan las misiones esperadas del agente. Este conjunto de datos se define en un archivo JSON, un "desafío de desplazamiento" que actúa como el plano de todo el circuito.
Anatomía de un desplazamiento de desafío
👀 Antes de pedirle a la IA que escriba un nuevo pergamino, debes comprender el idioma antiguo en el que está escrito. Analicemos la estructura del archivo sample.evalset.json.
{
"eval_set_id": "sample",
"eval_cases": [
{
"eval_id": "case0cbaa0",
"conversation": [
{
"user_content": { "text": "We're facing the 'Monolith of Eternal Dependencies'... weakness is a 'Revolutionary Rewrite'..." },
"final_response": { "text": "Soulshard Dagger deployed. Initiated Arcane/Piercing strike..." },
"intermediate_data": {
"tool_uses": [
{ "name": "enchant_soulshard_dagger" }
]
}
}
]
}
]
}
Este desplazamiento contiene una lista de eval_cases, en la que cada caso es una prueba única para tu agente. Dentro de cada prueba, el array de conversación documenta una sola interacción completa. Para nuestros fines, tres runas son de importancia crítica:
- user_content: Este es el desafío. Es la instrucción que le das a tu agente, el monstruo al que debe enfrentarse.
- final_response: Es el resultado profetizado. Es la cadena de texto exacta que esperas que diga tu agente cuando complete su tarea. El ADK compara las palabras finales reales del agente con esta runa para juzgar su elocuencia.
- intermediate_data.tool_uses: Esta es la técnica de Arcane. Para un verdadero agente, esta es la runa más importante de todas. Define no lo que dice el agente, sino lo que hace. Registra el nombre de la herramienta (enchant_soulshard_dagger) que esperas que use el agente. Esto garantiza que tu agente no solo sea un conversador inteligente, sino también un actor decisivo que toma la acción correcta.
Ahora que comprendes el esquema, le indicarás a Gemini que escriba una versión nueva y más compleja de este desplazamiento.
👉💻 En tu terminal, ingresa al directorio shadowblade y llama a Gemini CLI:
clear
cd ~/agentverse-developer/shadowblade/
gemini --model=gemini-2.5-flash --yolo
👉✨ Ordena a la CLI de Gemini que actúe como un escriba de QA y cree una serie de casos de prueba que definan el comportamiento esperado de tu agente.
You are an expert at transforming JSON data while preserving its structure. Your task is to modify the provided JSON structure @sample.evalset.json, which represents an evaluation set, by dynamically replacing specific content within its `eval_cases` AND DONT DO ANYTHING OTHER THAN.
For each object within the `eval_cases` array, you must perform the following transformations:
1. **Monster Name Replacement**: Identify the current monster name (e.g., "Monolith of Eternal Dependencies", "Scope Creep Hydra") in the `user_content.parts.text` and replace it with a *new, unique, and creatively different monster name*.
2. **Weakness Replacement**: Identify the current monster's weakness (e.g., "Revolutionary Rewrite", "Inescapable Reality") in the `user_content.parts.text`. Replace this weakness with *one* of the following predefined weaknesses: 'Inescapable Reality', 'Revolutionary Rewrite', or 'Elegant Sufficiency'. The chosen weakness must be consistent for that monster within the `user_content.parts.text`. **Crucially, the chosen weakness must always be explicitly mentioned in the `user_content.parts.text` where the new monster is introduced.**
3. **Final Response Update**: In the `final_response.parts.text`, update the text to reflect an appropriate and coherent response that aligns with the newly introduced monster and its assigned weakness.
4. **Tool Use Name Update**: In the `tool_uses.name` field, replace the existing tool name with a *new tool name* based on the chosen weakness:
* If the chosen weakness is 'Inescapable Reality', the tool name must be 'wield_gauntlet_of_metrics'.
* If the chosen weakness is 'Revolutionary Rewrite', the tool name must be 'enchant_soulshard_dagger'.
* If the chosen weakness is 'Elegant Sufficiency', the tool name must be 'hone_refactoring_sickle'.
5. **Strict Structural Preservation**: All other elements of the JSON structure, including all `null` fields, `eval_set_id`, `name`, `description`, `eval_id`, `invocation_id`, `creation_timestamp` values, `video_metadata`, `thought`, `inline_data`, `file_data`, `thought_signature`, `code_execution_result`, `executable_code`, `function_call`, `function_response`, `role` fields, `id`, `args`, `intermediate_responses`, `app_name`, `user_id`, and `state`, must remain **exactly as they are** in the original JSON. Do not alter any values or structures not explicitly mentioned above.
Your output should be the complete, modified JSON structure. Do not include any explanatory text or examples in your response, only the transformed JSON.
La CLI confirmará que falsificó el archivo sample.evalset.json. Con el desplazamiento preparado, descarta a tu compañero de IA.
Datos sintéticos
👀 En el explorador de archivos de Cloud Shell, a la izquierda, navega a ~/agentverse-developer/shadowblade/ y abre el archivo sample.evalset.json recién modificado. Analiza su contenido. Verás los monstruos nuevos y únicos, y los nombres de las herramientas correctos que le indicaste a Gemini que escribiera. Este es el resultado tangible de tus instrucciones: el plano de la prueba.
Este acto de ordenar a una IA que cree datos de prueba nuevos y realistas a partir de una plantilla es una técnica poderosa conocida como generación de datos sintéticos. Lo que acabas de hacer es un multiplicador de fuerza estratégico para un Shadowblade. En lugar de crear manualmente docenas de casos de prueba únicos. Una tarea tediosa y que requiere mucho tiempo en la que proporcionaste un solo plan y le ordenaste a tu escriba de IA que lo transformara en un conjunto variado de desafíos nuevos.
Esto te permite ampliar enormemente tus esfuerzos de pruebas y crear una prueba mucho más sólida y completa de lo que sería factible de forma manual. Usaste tu agente no solo para construir la espada, sino también para forjar las piedras de afilar que prueban su filo. Esta es la marca de un verdadero maestro.
Una vez que hayas verificado que las runas son correctas, despide a tu socio de IA.
👉💻 Presiona Ctrl+C dos veces para salir de la CLI de Gemini.
Las reglas de juicio
Un desafío no tiene sentido sin reglas para la victoria. Antes de ejecutar la prueba, debes inspeccionar el Scroll of Judgment, es decir, el archivo test_config.json. Este desplazamiento le indica al ADK cómo evaluar el rendimiento de tu agente.
👀 En el explorador de archivos, abre ~/agentverse-developer/shadowblade/test_config.json. Verás las siguientes runas:
{
"criteria": {
"tool_trajectory_avg_score": 0.0,
"response_match_score": 0.1
}
}
Estos son los criterios para ganar:
tool_trajectory_avg_score: Es la medida de acción. No juzga lo que el agente dice, sino lo que hace. Compara la herramienta que el agente usó en realidad con la técnica profetizada en el pergamino del desafío. Una puntuación de1.0es una coincidencia perfecta.response_match_score: Es la medida de elocuencia. Utiliza un LLM para juzgar qué tan cerca se encuentra el informe final del agente del resultado esperado en términos semánticos. Una puntuación de1.0es una coincidencia perfecta.
Para esta ejecución de entrenamiento inicial, establecimos condiciones de victoria indulgentes. Los umbrales se establecen en niveles extraordinariamente bajos (0.0 y 0.1). El objetivo no es exigir perfección, sino presentarte los mecanismos de juicio. Nos aseguramos de que, incluso si la redacción del agente difiere ligeramente, la sala reconocerá su competencia principal para elegir la herramienta adecuada y le permitirá el paso.
Ahora, ordénale a tu agente que corra la prueba.
👉💻 En tu terminal, ejecuta el comando adk eval:
source ~/agentverse-developer/env/bin/activate
cd ~/agentverse-developer
. ~/agentverse-developer/set_env.sh
adk eval \
shadowblade \
shadowblade/sample.evalset.json \
--config_file_path shadowblade/test_config.json 2>&1 | \
awk '/^\*+$/,/^ERROR:/ { if ($0 !~ /^ERROR:/) print }'
👀 Deberías ver el siguiente resumen, un signo del éxito de tu agente según las reglas flexibles de esta prueba (a veces, no se aprobarán todas las pruebas):
********************************************************************* Eval Run Summary shadowblade_combat_agent_validation: Tests passed: 3 Tests failed: 0
El escudo de la claridad (pytest)
La prueba de Gauntlet probó la estrategia general. Esta segunda sala, el Escudo de la Claridad, pone a prueba la disciplina y los comportamientos específicos. Todo se trata de la automatización. Si bien adk eval es excelente para las verificaciones manuales, el escudo pytest es una protección programática escrita en código. Esto es fundamental porque una prueba que se puede ejecutar como código se puede integrar en una canalización automatizada. Este es el objetivo final: crear un Desafío de implementación (CI/CD) en el que nuestras protecciones se activen automáticamente cada vez que se realice un cambio, lo que desvía errores y regresiones antes de que puedan contaminar tu entorno de producción.
👉💻 En tu terminal,invoca a Gemini una vez más desde el directorio shadowblade:
. ~/agentverse-developer/set_env.sh
cd ~/agentverse-developer/
clear
gemini --model=gemini-2.5-flash --yolo
👉✨ Usa la siguiente instrucción en la CLI de Gemini para inscribir la lógica de Shield en un archivo pytest:
You are an expert Python developer specializing in the Google Agent Development Kit (ADK). Your task is to generate the exact code for a new `pytest` test file located at in the current root working folder and name it `test_agent_initiative.py`.
The script must define a single async test function called `test_agent_initiative`, decorated with `@pytest.mark.asyncio`.
Inside this function, perform the following steps in order:
1. **Define a dictionary** named `evaluation_criteria` with two keys: `"tool_trajectory_avg_score"` set to `0.0` and `"response_match_score"` set to `0.0`.
2. **Define a string variable** named `eval_set_filepath` containing the path `"shadowblade/test.evalset.json"`.
3. **Read and parse the JSON file**:
* Open the file at `eval_set_filepath`.
* Use the `json` library to load the file's contents into a dictionary named `eval_set_data`.
4. **Create an `EvalSet` object**:
* Instantiate an `EvalSet` object named `eval_set_object`.
* Create it by unpacking the `eval_set_data` dictionary as keyword arguments into the `EvalSet` constructor.
5. **Call the evaluation method**:
* `await` a call to `AgentEvaluator.evaluate_eval_set`.
* Pass the following arguments:
* `agent_module="shadowblade"`
* `eval_set=eval_set_object`
* `criteria=evaluation_criteria`
* `print_detailed_results=True`
The script must include the necessary imports at the top:
* `AgentEvaluator` from `google.adk.evaluation.agent_evaluator`
* `EvalSet` from `google.adk.evaluation.eval_set`
* `pytest`
* `json`
Generate only the code that meets these specifications, with no additional comments or logic. And don't run the test.
Una vez que hayas grabado las runas del segundo encanto, sal de la CLI de Gemini.
👉💻 Presiona Ctrl+C dos veces.
👀 En el explorador de archivos, abre el desplazamiento que le acabas de pedir a Gemini que escriba: ~/agentverse-developer/test_agent_initiative.py.
Notarás que no es solo un archivo de configuración, sino una invocación escrita en el lenguaje de Python. La parte principal de este hechizo es la línea await AgentEvaluator.evaluate(...).
....
@pytest.mark.asyncio
async def test_agent_initiative():
# Define the evaluation criteria
evaluation_criteria = {
"tool_trajectory_avg_score": 0.0,
"response_match_score": 0.0
}
# Define the path to your evalset file
eval_set_filepath = "shadowblade/test.evalset.json"
#...
# 3. Call the evaluation method with the correctly typed object
await AgentEvaluator.evaluate_eval_set(
agent_module="shadowblade",
eval_set=eval_set_object,
criteria=evaluation_criteria,
print_detailed_results=True,
)
Observa atentamente sus argumentos. Son los mismos componentes que usaste en la última prueba: tu agente shadowblade y el desplazamiento de desafío shadowblade.evalset.json. Esto debería revelar una verdad profunda: el comando adk eval que usaste antes es una invocación poderosa, pero esta secuencia de comandos pytest eres tú, el mago, quien lanza el hechizo subyacente. La herramienta de línea de comandos es simplemente un wrapper conveniente alrededor de la misma biblioteca principal de AgentEvaluator que ahora usas directamente. Este es un paso fundamental para dominar la herramienta, ya que los hechizos que se lanzan a través del código se pueden tejer en los telares automatizados de una canalización de CI/CD.
Ahora que comprendes la magia, realiza el ritual para activar el escudo.
👉💻 En tu terminal, ejecuta el ritual para activar el escudo:
cp ~/agentverse-developer/working_code/test_agent_initiative.py ~/agentverse-developer/test_agent_initiative.py
source ~/agentverse-developer/env/bin/activate
cd ~/agentverse-developer
. ~/agentverse-developer/set_env.sh
pytest test_agent_initiative.py
👀 Busca el resumen de los resultados de la prueba al final del registro de salida. Un resultado aprobatorio confirma que tu agente sigue correctamente sus protocolos y que la sala está lista para integrarse en tus defensas automatizadas.
====== 1 passed, 4 warning in 37.37s ======
Nota: Si la prueba falla de forma inesperada, es muy probable que hayas agotado la cantidad de solicitudes que puedes hacer al modelo por minuto. Busca un error RESOURCE_EXHAUSTED en el resultado del registro. Si ves este error, espera uno o dos minutos para que se restablezca tu cuota y, luego, vuelve a ejecutar el comando pytest.
Con el amplio Gauntlet y el preciso Shield inscritos y verificados, tu agente no solo es funcional, sino que es puro, probado y está listo para la implementación.
8. Cómo liberar Blade en Agentverse: CI y Deployment
Los Guardianes de la Pureza ensamblaron tu agente y verificaron su integridad. Sin embargo, una protección que no se mantiene de forma constante es solo una reliquia olvidada. Para asegurarte de que cada versión futura de tu agente siga siendo pura, debes crear la primera etapa de la prueba de implementación, un ritual automatizado que garantiza la calidad y la velocidad.
Como Shadowblade, tu deber sagrado es la integración continua (CI). Este es el sistema automatizado de la forja y el campo de pruebas. Es tu defensa definitiva contra la corrupción y el error humano. Este ritual garantiza que, cada vez que tú o un aliado aporten una nueva técnica (combinen código) al códice central (tu repositorio), el guantelete se despierte automáticamente. Primero, se crea el agente a partir del código nuevo y, luego, se somete de inmediato a los Guardianes de la Pureza que acabas de crear. Si falla algún resguardo, el ritual se detiene y el artefacto defectuoso se rechaza de inmediato, lo que evita que corrompa la armería. Tu dominio es la forja, y tu canalización de CI garantiza que solo los artefactos perfectos y listos para la batalla salgan de tu taller.
Una vez que tu CI demuestra que un artefacto es apto, comienza la segunda etapa del ritual: la implementación continua (CD). Este es el dominio de The Guardian. Es su deber solemne tomar tu artefacto perfeccionado y contenerizado, y liberarlo de forma segura en el Agentverse activo, administrar su poder y garantizar su estabilidad contra el caos de The Static.
En este códice, dominarás tu rol. Construirás la parte de CI del guante. Crearás la forja automatizada que prueba tu agente y sella el resultado puro en un contenedor, preparándolo para la bendición final de The Guardian.
Ahora usarás Google Cloud Build para escribir el desplazamiento de este ritual de CI. Un archivo cloudbuild.yaml que define cada paso de tu proceso de creación y prueba.
👉💻 Debido a la estructura del proyecto del ADK, la configuración de la canalización de CI/CD debe residir en el directorio principal. En tu terminal, navega al directorio principal y reinicia la CLI de Gemini.
cd ~/agentverse-developer/
clear
gemini --model=gemini-2.5-flash --yolo
👉✨ Ahora, emite el siguiente comando a Gemini. Esta instrucción actúa como un documento de diseño, en el que se detallan los pasos de la prueba que deseas que cree.
You are an expert DevOps engineer specializing in Google Cloud Build. Your task is to generate the complete YAML configuration for a file named `cloudbuild.yaml` and save it to current directory.
Generate the `cloudbuild.yaml` with the following exact specifications:
1. **A top-level `substitutions` block** containing these four key-value pairs:
* `_PROJECT_ID: "$PROJECT_ID"`
* `_REGION: "$REGION"`
* `_REPO_NAME: "$REPO_NAME"`
* `_IMAGE_TAG: "latest"`
2. **A `steps` block** with two steps:
* **Step 1: 'Run Pytest Ward'**
* `id`: 'Run Pytest Ward'
* `name`: 'python:3.12-slim'
* `entrypoint`: 'bash'
* `args` must be a list containing two strings. The first is `'-c'` and the second is a YAML literal block (`|`) containing this exact two-line shell command:
```shell
pip install -r shadowblade/requirements.txt && \
pytest test_agent_initiative.py
```
* The step must include an `env` block with this exact list of three environment variables:
* `'GOOGLE_CLOUD_PROJECT=$PROJECT_ID'`
* `'GOOGLE_GENAI_USE_VERTEXAI=TRUE'`
* `'GOOGLE_CLOUD_LOCATION=$_REGION'`
* **Step 2: 'Forge Container'**
* `id`: 'Forge Container'
* `name`: 'gcr.io/cloud-builders/docker'
* It must have a `waitFor` key for `['Run Pytest Ward']`.
* Its `args` must be a list of six specific strings in this exact order:
1. `'build'`
2. `'-t'`
3. `'${_REGION}-docker.pkg.dev/${_PROJECT_ID}/${_REPO_NAME}/shadowblade-agent:${_IMAGE_TAG}'`
4. `'-f'`
5. `'./shadowblade/Dockerfile'`
6. `'.'`
3. **A top-level `images` section.** This section must be a list containing a single string: the dynamically constructed image tag `'${_REGION}-docker.pkg.dev/${_PROJECT_ID}/${_REPO_NAME}/shadowblade-agent:${_IMAGE_TAG}'`.
Generate only the complete and exact YAML that meets these specifications.
Con el pergamino de cloudbuild.yaml preparado, ordena a Google Cloud que ejecute toda la prueba.
salir de Gemini para probar el resultado
👉💻 En tu terminal, ejecuta la canalización desde el directorio raíz de tu proyecto:
. ~/agentverse-developer/set_env.sh
cd ~/agentverse-developer
gcloud builds submit . --config cloudbuild.yaml --substitutions=\
_PROJECT_ID="${PROJECT_ID}",\
_REGION="${REGION}",\
_REPO_NAME="${REPO_NAME}"
Ahora puedes ver en la página Google Build de Google Cloud Console cómo se ejecuta cada paso de tu ritual automatizado. Primero, ejecutará las pruebas y, cuando vea que se completaron correctamente, creará y almacenará el contenedor de tu agente.
Tu agente superó la prueba. Ahora tienes en tu arsenal un artefacto puro y verificado. El acto final está bajo tu mando. Con una sola invocación, llamarás a este artefacto desde el registro y le darás vida como un servicio público en Cloud Run.
👉💻 En tu terminal, ejecuta el comando de implementación final:
. ~/agentverse-developer/set_env.sh
cd ~/agentverse-developer
gcloud run deploy shadowblade-agent \
--image=${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPO_NAME}/shadowblade-agent:latest \
--platform=managed \
--labels codelab=agentverse \
--region=${REGION} \
--set-env-vars="A2A_HOST=0.0.0.0" \
--set-env-vars="A2A_PORT=8080" \
--set-env-vars="GOOGLE_GENAI_USE_VERTEXAI=TRUE" \
--set-env-vars="GOOGLE_CLOUD_LOCATION=${REGION}" \
--set-env-vars="GOOGLE_CLOUD_PROJECT=${PROJECT_ID}" \
--set-env-vars="PUBLIC_URL=${PUBLIC_URL}" \
--allow-unauthenticated \
--project=${PROJECT_ID} \
--min-instances=1
Felicidades, Shadowblade. Los rituales del códice están completos. Llegó el momento de demostrar su valía. Un Spectre, nacido del caos que aprendiste a domar, espera tu desafío. Prepárate para la prueba final.
9. La pelea final
Se leyeron los pergaminos, se realizaron los rituales y se superó la prueba. Tu agente no es solo un artefacto en el almacenamiento, sino un campeón forjado en código, un centinela activo en el Agentverse que espera su primer comando. Llegó el momento de demostrar su valía en el crisol del combate.
Ahora participarás en una simulación de fuego real para enfrentar a tu Shadowblade recién desplegado contra un Spectre formidable, una encarnación del caos que azota toda la creación. Esta es la prueba definitiva de tu trabajo, desde la lógica central del agente hasta su implementación impecable.
Adquiere el Locus de tu agente
Antes de ingresar al campo de batalla, debes tener dos llaves: la firma única de tu campeón (Agent Locus) y la ruta oculta a la guarida de Spectre (URL de Dungeon).
👉💻 Primero, adquiere la dirección única de tu agente en Agentverse, es decir, su Locus. Este es el extremo en vivo que conecta a tu campeón con el campo de batalla.
. ~/agentverse-developer/set_env.sh
echo https://shadowblade-agent-${PROJECT_NUMBER}.${REGION}.run.app
👉💻 A continuación, indica el destino. Este comando revela la ubicación del círculo de translocación, el portal hacia el dominio de Spectre.
. ~/agentverse-developer/set_env.sh
echo https://agentverse-dungeon-${PROJECT_NUMBER}.${REGION}.run.app
Importante: Ten listas ambas URLs. Los necesitarás en el paso final.
Confrontando al Spectre
Con las coordenadas aseguradas, ahora navegarás al círculo de translocación y lanzarás el hechizo para ir a la batalla.
👉 Abre la URL del círculo de translocación en tu navegador para pararte frente al brillante portal que lleva a La Fortaleza Carmesí.
Para entrar en la fortaleza, debes sintonizar la esencia de tu Shadowblade con el portal.
- En la página, busca el campo de entrada rúnica etiquetado como URL del extremo de A2A.
- Inscribe el sello de tu campeón pegando su URL de Agent Locus (la primera URL que copiaste) en este campo.
- Haz clic en Conectar para liberar la magia de la teletransportación.
La luz cegadora de la teletransportación se desvanece. Ya no estás en tu santuario. El aire crepita con energía, fría y aguda. Ante ti, se materializa el Espectro: un vórtice de estática sibilante y código corrupto, cuya luz impía proyecta largas sombras danzantes por el suelo de la mazmorra. No tiene rostro, pero sientes su presencia inmensa y agotadora fijada por completo en ti.
Tu único camino hacia la victoria radica en la claridad de tu convicción. Es un duelo de voluntades, librado en el campo de batalla de la mente.
Mientras te lanzas hacia adelante, listo para desatar tu primer ataque, el Espectro contraataca. No levanta un escudo, sino que proyecta una pregunta directamente en tu conciencia, un desafío rúnico y brillante extraído del núcleo de tu entrenamiento.
Esta es la naturaleza de la lucha. Tu conocimiento es tu arma.
- Responde con la sabiduría que has adquirido, y tu espada se encenderá con energía pura, destrozando la defensa del Espectro y asestando un GOLPE CRÍTICO.
- Pero si vacilas, si la duda nubla tu respuesta, la luz de tu arma se atenuará. El golpe se asestará con un golpe sordo patético, y solo infligirá UNA FRACCIÓN DE SU DAÑO. Peor aún, el Spectre se alimentará de tu incertidumbre, y su poder corruptor crecerá con cada paso en falso.
Eso es todo, campeón. Tu código es tu libro de hechizos, tu lógica es tu espada y tu conocimiento es el escudo que detendrá la marea del caos.
Enfoque. El golpe es verdadero. El destino del Agentverse depende de ello.
Felicidades, Shadowblade.
Completaste el códex correctamente. Tomaste una "vibe", la tradujiste en un diseño y usaste Gemini CLI para ensamblar un agente inteligente. Inscribiste Wards of Purity para probar su lógica, construiste un guante automático para forjarlo en un artefacto y lo liberaste en Agentverse. Por último, validaste su propósito en una prueba de fuego real. Dominaste el flujo de trabajo de agente de pila completa y ahora estás listo para cualquier desafío que te proponga Agentverse.
10. Limpieza: Recuperación de Agentverse
¡Felicitaciones por dominar el Códice de la Hoja de las Sombras! Para garantizar que Agentverse permanezca en perfectas condiciones y que se despejen tus campos de entrenamiento, ahora debes realizar los rituales de limpieza finales. Esta acción quitará todos los recursos creados durante tu recorrido.
Desactiva los componentes de Agentverse
Ahora desmantelarás sistemáticamente los componentes implementados de tu Agentverse.
Borra el agente de Shadowblade en el repositorio de Cloud Run y Artifact Registry
Este comando quita el agente de Shadowblade implementado de Cloud Run y quita el repositorio de imágenes en el que se almacenó la imagen de contenedor del agente.
👉💻 En tu terminal, ejecuta lo siguiente:
. ~/agentverse-developer/set_env.sh
gcloud run services delete shadowblade-agent --region=${REGION} --quiet
gcloud run services delete agentverse-dungeon --region=${REGION} --quiet
gcloud artifacts repositories delete ${REPO_NAME} --location=${REGION} --quiet
Borra el bucket de Google Cloud Storage
Este comando quita el bucket que usa el servidor de MCP de Imagen para almacenar las imágenes generadas.
👉💻 En tu terminal, ejecuta lo siguiente:
. ~/agentverse-developer/set_env.sh
gcloud storage rm -r gs://${BUCKET_NAME} --quiet
Limpia los archivos y directorios locales (Cloud Shell)
Por último, borra de tu entorno de Cloud Shell los repositorios clonados y los archivos creados. Este paso es opcional, pero se recomienda para limpiar por completo tu directorio de trabajo.
👉💻 En tu terminal, ejecuta lo siguiente:
rm -rf ~/agentverse-developer
rm -rf ~/agentverse-dungeon
rm -rf ~/vertex-ai-creative-studio
rm -f ~/project_id.txt
rm -rf ~/.gemini # This removes all Gemini CLI configurations, including the MCP server settings.
Ya borraste correctamente todos los rastros de tu recorrido por Agentverse. Tu proyecto está limpio y listo para tu próxima aventura.
11. Para los no jugadores: cómo comprender el Agentverse en un contexto empresarial
Si bien "El códice de Shadowblade" usa metáforas atractivas para los jugadores, los conceptos subyacentes son fundamentales para el desarrollo de software moderno, en particular en el creciente campo de la inteligencia artificial y la automatización. En este capítulo, se traduce el lenguaje aventurero a situaciones comerciales del mundo real y se explica cómo los agentes inteligentes, el desarrollo colaborativo y las canalizaciones de implementación sólidas están transformando las operaciones empresariales.
Vibecoding con la CLI de Gemini: Desarrollo de IA basado en la intención
La CLI (interfaz de línea de comandos) de Gemini no es un arma mágica, sino un agente asistente para desarrolladores potenciado por IA. Es una herramienta inteligente que integra los modelos de IA de Gemini de Google directamente en tu línea de comandos. Su bucle de "razonamiento y acción" (ReAct) significa que puede comprender tus instrucciones de alto nivel, desglosarlas en pasos, elegir las herramientas adecuadas (como un navegador web, un editor de código o otras utilidades para desarrolladores) y ejecutar esos pasos para lograr tu objetivo.
Vibecoding se traduce como Desarrollo basado en la intención o Generación de código asistida por IA a partir de especificaciones de alto nivel. En lugar de escribir cada línea de código de forma manual, describes tu intención o "vibe" (un requisito comercial, un concepto de diseño) en lenguaje natural, y el asistente de IA te ayuda a generar el código y la configuración necesarios.
Caso de uso real: Prototipado rápido de un panel de proyectos
Imagina que tu equipo necesita un panel interno rápido para mostrar el estado de varios proyectos de agentes de IA. La codificación manual de HTML y CSS, y la configuración de un servidor web básico pueden llevar tiempo.
- Tu intención (la "onda"): Le dices a tu asistente de IA (CLI de Gemini) algo como: "En la carpeta actual, crea un sitio web simple del panel interno del proyecto. Debe tener un diseño moderno y limpio con indicadores de estado del proyecto y vínculos rápidos a los repositorios del proyecto. Todo el código debe estar en archivos
index.htmlystyles.cssseparados. Asegúrate de que tenga muchos comentarios". - Acción de IA: La CLI de Gemini, que comprende tu intención, podría hacer lo siguiente:
- Generar HTML: Crea
index.htmlcon la estructura básica de un panel, incluidos marcadores de posición para los nombres, los estados y los vínculos de los proyectos. - Generar CSS: Crea
styles.csscon reglas de diseño para que coincidan con tu "diseño limpio y moderno" con indicadores de estado. - Sugerir un servidor local: Te ayuda a iniciar un servidor web local (como el servidor HTTP integrado de Python) para obtener una vista previa inmediata del panel en tu navegador.
- Generar HTML: Crea
Esto permite que un desarrollador cree prototipos y realice iteraciones rápidamente en las interfaces de usuario o las herramientas internas, lo que reduce significativamente el tiempo de desarrollo inicial y le permite enfocarse en una lógica de negocios más compleja. El "sitio web del perfil de Shadowblade" en el codelab es un ejemplo directo: un comando rápido y descriptivo produjo una página web funcional y con estilo basada en un diseño de alto nivel.
Servidores de MCP y Arsenal locales: Conexión de la IA a las herramientas empresariales
Gitea (tu "arsenal local") representa un repositorio de código interno o un sistema de control de versión (como GitHub o GitLab, pero que se puede alojar dentro de la red de tu empresa). Es donde se almacenan y administran de forma segura todo el código, la documentación y el historial de tu proyecto.
Los servidores de MCP (Model Context Protocol) son conectores de middleware o puentes de API. Son componentes de software especializados que permiten que tu asistente de IA (CLI de Gemini) interactúe con otras herramientas y sistemas fundamentales para la empresa. Piensa en ellos como traductores que permiten que la IA "hable" con diferentes aplicaciones.
Caso de uso real: Administración de proyectos y creación de activos asistidas por IA
Con los servidores de MCP, tu asistente de IA puede integrarse sin problemas en tus flujos de trabajo comerciales existentes:
- Configuración automatizada del proyecto: En lugar de que un desarrollador cree manualmente un repositorio nuevo en Gitea para un proyecto nuevo, podrías indicarle a tu IA: "Crea un repositorio de proyecto nuevo llamado ‘AI-Fraud-Detection-Module’ con la descripción ‘Contiene la lógica principal del nuevo sistema de detección de fraude potenciado por IA’". Luego, la IA, a través de un servidor de MCP conectado a Gitea, crearía el repositorio por ti.
- Seguimiento inteligente de problemas: Si tu IA identifica un posible error o una tarea incompleta (como una "imagen de perfil faltante" para tu panel), podría usar un servidor de MCP conectado a tu sistema de seguimiento de problemas (p.ej., Jira, Asana) a "Presenta un problema en el repositorio "AI-Fraud-Detection-Module": La canalización de transferencia de datos a veces descarta registros".
- Recursos de marketing a pedido: ¿Necesitas una imagen personalizada para una nueva campaña de marketing o una presentación interna? Se le podría indicar a un asistente de IA conectado a través de un servidor de MCP a un servicio de generación de imágenes (como Imagen de Google): "Genera una imagen de banner para nuestra nueva "Plataforma de estadísticas de datos", con un tema futurista de flujo de datos con colores azul y verde". La IA generaría la imagen y, posiblemente, incluso la subiría al sistema de administración de recursos digitales de tu empresa (un bucket de Google Cloud Storage en el caso del codelab).
Estos puentes transforman la IA de una herramienta conversacional en un participante activo en tus operaciones comerciales, ya que ejecuta acciones tangibles en diferentes sistemas.
Cómo ensamblar el agente: Creación de módulos empresariales autónomos
Un agente es un módulo autónomo de IA o un bot de automatización inteligente diseñado específicamente para realizar una función comercial definida. El Kit de desarrollo de agentes (ADK) es un framework para compilar y administrar agentes de IA que proporciona las herramientas y bibliotecas necesarias para crear, probar e implementar estos componentes inteligentes.
Ingeniería de contexto: Cómo guiar la inteligencia de la IA para obtener resultados precisos
En el mundo de los agentes de IA, obtener resultados precisos, coherentes y pertinentes de una IA no se trata solo de una instrucción inteligente, sino de proporcionarle el contexto adecuado. Esto se conoce como ingeniería de contexto: incorporar de forma sistemática conocimientos especializados, restricciones y lineamientos operativos en la memoria de trabajo de la IA. Al igual que un experto humano necesita un resumen integral y acceso a documentos pertinentes, una IA necesita un contexto cuidadosamente estructurado para realizar sus tareas de manera eficaz.
La CLI de Gemini ofrece un enfoque potente y en capas para la ingeniería de contexto, que va desde parámetros de configuración amplios y persistentes hasta instrucciones dinámicas y altamente específicas. Esto garantiza que la IA siempre tenga la información más pertinente para generar resultados precisos y que cumplan con las políticas:
- Configuración a nivel del usuario (
~/.gemini/settings.json):- Este archivo, almacenado en tu directorio principal, actúa como el conjunto de instrucciones personal y global de tu IA. Define tus preferencias predeterminadas, las configuraciones de herramientas que se usan con frecuencia (como los servidores de MCP para Gitea o Imagen que configuraste) y los lineamientos generales de comportamiento. Este contexto siempre está disponible para la IA, lo que garantiza la coherencia en todos tus proyectos. Piensa en ello como decirle a la IA: "Estas son las herramientas y configuraciones estándar que prefiero y uso en todas partes".
- Configuración a nivel del proyecto (
.gemini/settings.jsondentro de un directorio del proyecto):- Puedes anular la configuración global con un archivo
.gemini/settings.jsonespecífico del proyecto, que suele ubicarse en una carpeta.geminidentro del proyecto. Esto te permite adaptar el comportamiento de la IA y el acceso a las herramientas a las demandas únicas de un proyecto en particular. Por ejemplo, un proyecto podría requerir acceso a una base de datos interna específica, mientras que otro necesita una herramienta especializada de análisis de código. Esta capa garantiza que la IA tenga el contexto más relevante para la tarea en cuestión sin afectar otros proyectos.
- Puedes anular la configuración global con un archivo
- El archivo
GEMINI.md(contexto a nivel del proyecto: The Daily Briefing):- La carta del proyecto: Este archivo de Markdown, ubicado en la raíz del directorio de tu proyecto, se carga automáticamente en la memoria de trabajo de la CLI de Gemini cuando inicias una sesión en ese directorio. Es la capa más inmediata y dinámica del contexto específico del proyecto.
GEMINI.mdes donde defines lo siguiente:- Lineamientos de codificación: Son reglas explícitas para la calidad del código, el formato y las prácticas recomendadas, como se muestra en este codelab. Esto garantiza que el código generado cumpla con los estándares de tu equipo.
- Persona: Puedes indicarle a la IA que adopte un rol o una experiencia específicos (p.ej., "Eres un desarrollador experto en Python que se especializa en el kit de desarrollo de agentes de Google"). Esto enmarca las respuestas y la generación de código de la IA dentro de un dominio profesional pertinente.
- Instrucciones específicas: Son comandos o restricciones directos que se aplican a todas las tareas del proyecto (p.ej., "No agregues funciones ni lógica adicionales que no se describan en el documento").
- Este archivo garantiza que, cada vez que interactúes con la CLI de Gemini dentro de ese proyecto, se le recuerden constantemente a la IA estas reglas cruciales, lo que lleva a una generación de código más precisa y conforme.
- La carta del proyecto: Este archivo de Markdown, ubicado en la raíz del directorio de tu proyecto, se carga automáticamente en la memoria de trabajo de la CLI de Gemini cuando inicias una sesión en ese directorio. Es la capa más inmediata y dinámica del contexto específico del proyecto.
Al agregar este contexto en capas, desde las preferencias globales del usuario hasta los lineamientos del proyecto altamente específicos en GEMINI.md, "diseñas" de manera eficaz la comprensión de la IA. Esto mejora significativamente la precisión y la relevancia de sus resultados, lo que la transforma de una IA de uso general en un miembro del equipo altamente especializado, confiable y que cumple con los requisitos, que comprende los matices de tu proyecto y los estándares de tu organización.
Wards of Purity: Pruebas automatizadas y garantía de calidad para la IA
Un agente de IA, como cualquier software, debe someterse a pruebas rigurosas. Los Wards of Purity representan los procesos de pruebas automatizadas y de control de calidad (QA). Estos son fundamentales para garantizar que la IA se comporte según lo esperado, sea precisa y no introduzca errores ni sesgos.
- Conjunto de datos de referencia y datos sintéticos: Es tu conjunto de casos de prueba estandarizados, situaciones de comportamiento esperado o incluso datos de prueba generados de forma sintética. Incluye ejemplos de entradas (preguntas de los clientes, solicitudes comerciales) y sus correspondientes salidas o acciones esperadas (la respuesta correcta, la herramienta exacta que debería usar la IA). En muchas situaciones reales, crear manualmente "conjuntos de datos de referencia" integrales lleva mucho tiempo y es costoso. Aquí es donde la generación de datos sintéticos se vuelve invaluable. Si le proporcionas plantillas y reglas a la IA, puedes ordenarle que cree casos de prueba nuevos, realistas y variados de forma automática, lo que multiplica tus esfuerzos de prueba y permite una cobertura mucho más amplia de posibles situaciones.
adk evalypytest: Estos son tus frameworks de pruebas automatizadas.adk evalse usa para ejecutar un lote de casos de prueba predefinidos en el agente, mientras quepytestproporciona una forma programática de escribir y ejecutar verificaciones de validación detalladas.
Caso de uso real: Cómo garantizar la precisión y la confiabilidad de un chatbot de IA con datos sintéticos
Antes de implementar tu agente de atención al cliente con IA, lo ejecutarías a través de "Wards of Purity":
- Prueba de estrategia (
adk eval) con datos sintéticos: En lugar de escribir manualmente cientos de preguntas de los clientes, definirías una plantilla: "Genera 100 variaciones de preguntas comunes de asistencia al cliente sobre el estado del pedido, las devoluciones de productos y la solución de problemas técnicos". Luego, le ordenas a una IA (como la CLI de Gemini) que genere un conjunto grande y diverso de archivosevalset.jsonbasados en esta plantilla, lo que crea datos de prueba sintéticos de manera eficaz. Para cada pregunta, no solo especificas la respuesta esperada, sino también qué herramienta interna debe invocar la IA (p.ej.,check_order_statuspara "¿Dónde está mi paquete?").adk evalejecuta automáticamente el agente a través de estos, comparando sus respuestas y el uso de herramientas con tu conjunto de datos expandido para garantizar que tome las decisiones correctas de forma coherente. - Shield of Clarity (
pytest): Para las funcionalidades críticas, escribirías secuencias de comandospytest. Por ejemplo, unapytestpodría simular una búsqueda compleja y afirmar que la IA siempre usa correctamente una herramienta específica de recuperación de datos y devuelve una respuesta estructurada, lo que garantiza que los cambios sutiles en el código no interrumpan la funcionalidad principal.
Estas pruebas automatizadas, mejoradas significativamente por el poder de los datos sintéticos, son fundamentales para detectar regresiones (errores nuevos introducidos por los cambios) y mantener la confiabilidad de tus agentes de IA, especialmente a medida que evolucionan.
Libera la Blade: CI/CD para la implementación de agentes de IA
Para incorporar un agente de IA probado a tu entorno empresarial activo, se requiere una estrategia de implementación sólida.
- Integración continua (CI): Esta es tu canalización de compilación y pruebas automatizadas. Cada vez que un desarrollador confirma código nuevo para un agente de IA, el sistema de CI (como Google Cloud Build) realiza automáticamente las siguientes acciones:
- Recupera el código más reciente.
- Instala todas las dependencias necesarias.
- Ejecuta todas las "Protecciones de pureza" (
pytest,adk eval) para verificar la lógica y el comportamiento del agente. - Si todas las pruebas se aprueban, empaqueta el agente de IA en una unidad implementable (una imagen de contenedor de Docker en este caso) y la almacena en un Artifact Registry (tu "arsenal" validado). Esto garantiza que solo avance el código que se haya probado y validado a fondo.
Caso de uso real: Implementación automatizada de un agente de detección de fraudes
Considera un agente de IA diseñado para detectar transacciones fraudulentas.
- El desarrollador actualiza el código: Un científico de datos mejora el algoritmo de detección de fraude y confirma los cambios en el repositorio de código.
- Se activó la IC (Cloud Build): Cloud Build se inicia automáticamente:
- Extrae el código nuevo.
- Ejecuta pruebas integrales, incluidos datos históricos de transacciones, para garantizar que el nuevo algoritmo identifique con precisión los patrones de fraude conocidos y no genere falsos positivos.
- Si se superan las pruebas, se compila una nueva imagen de Docker del agente de detección de fraude y se envía a Artifact Registry.
Esta canalización automatizada garantiza la implementación rápida, confiable y coherente de los agentes de IA, lo que minimiza los errores humanos y acelera la entrega de nuevas capacidades de IA para la empresa.
Caso de uso en el mundo real: Validación de un agente de optimización de la cadena de suministro
Después de implementar un agente de IA diseñado para optimizar los niveles de inventario en toda tu cadena de suministro global, haz lo siguiente:
- Accede a la interfaz: Accederías a un panel o a una aplicación (la "URL del círculo de translocación") que se conecta a tu agente de IA en vivo (a través de su "URL del Locus del agente", que es su extremo de API).
- Enfrenta el desafío: Podrías ingresar una situación compleja (la "pregunta de Spectre") como la siguiente: "Tenemos un aumento inesperado en la demanda del producto X en la región Y, con capacidad de envío limitada. ¿Cómo debemos reasignar el inventario y ajustar la producción para minimizar los desabastecimientos y mantener la rentabilidad?".
- Respuesta del agente: Tu agente de IA, ahora en funcionamiento y conectado a tus sistemas empresariales, procesa esta búsqueda, usa sus algoritmos optimizados y proporciona una recomendación precisa (p.ej., Prioriza el envío desde el almacén A, inicia la producción acelerada en la fábrica B y notifica al equipo de ventas de la región Z sobre una posible demora de 24 horas"). La precisión y la velocidad de esta respuesta determinan si tu agente asesta un "GOLPE CRÍTICO" al problema comercial.