Cómo crear agentes personalizados con ADK, MCP y Memory Bank

1. Introducción

La pila de agentes modernos

Crear un agente de IA apto para la producción requiere más que un modelo de lenguaje grande (LLM). Si bien un LLM proporciona las capacidades de razonamiento, un agente sólido necesita interactuar con el mundo exterior, administrar el estado de la conversación y recordar las preferencias del usuario a lo largo del tiempo.

demo1 demo2

En este taller, aprenderás a diseñar y crear un sistema integral basado en agentes con tres tecnologías fundamentales:

Conectividad (MCP): Para darle a tu agente acceso a herramientas y datos locales
Organización (ADK): Para administrar el bucle de razonamiento y el estado del agente.
Memoria (Memory Bank): Para proporcionar contexto personalizado a largo plazo

workshop_overview

Conceptos básicos

Componente	Función
Model Context Protocol (MCP)	Es un estándar universal que conecta modelos de IA a sistemas externos (bases de datos, sistemas de archivos, APIs) sin integraciones personalizadas.
Kit de desarrollo de agentes (ADK)	Es un framework que proporciona el entorno de ejecución para los agentes, ya que administra el bucle de eventos, las transiciones de estado y la ejecución de herramientas.
Servicio de sesión	Controla la memoria a corto plazo. Conserva el contexto inmediato de la conversación (p.ej., ¿Qué acaba de preguntar el usuario?"), pero se borra cuando finaliza la sesión.
Vertex AI Memory Bank	Controla la memoria a largo plazo. Conserva los hechos y las preferencias específicos del usuario (p.ej., "El usuario prefiere Python") de forma indefinida, lo que permite que el agente personalice las interacciones futuras.
Vertex AI Agent Engine	Es el servicio de infraestructura administrado que aloja los componentes de lógica y memoria de tu agente a gran escala.

Qué compilarás

Para demostrar estos conceptos, crearás un Asistente de diseño de festividades. Este agente podrá tomar solicitudes de alto nivel de los usuarios y coordinar de forma autónoma herramientas locales de Python para generar código e imágenes personalizados.

Avanzarás por tres etapas:

Capa de herramientas: Crea un servidor de MCP para exponer funciones locales de Python a la IA.
Capa de agente: Usa el ADK para compilar un agente que planifique y ejecute flujos de trabajo de varios pasos.
Capa de memoria: Integra Memory Bank para permitir que el agente aprenda y recuerde las preferencias de estilo del usuario.

2. Configurar

Para potenciar nuestros agentes de IA, necesitamos dos cosas: un proyecto de Google Cloud que proporcione la base.

Parte uno: Habilita la cuenta de facturación

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

Parte dos: Entorno abierto

👉 Haz clic en este vínculo para navegar directamente al editor de Cloud Shell.
👉 Si se te solicita autorización en algún momento, haz clic en Autorizar para continuar.
👉 Si la terminal no aparece en la parte inferior de la pantalla, ábrela:
- Haz clic en Ver.
- Haz clic en Terminal.
👉💻 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/cuppibla/holiday_workshop

👉💻 Ejecuta la secuencia de comandos de configuración desde el directorio del proyecto.
```
cd ~/holiday_workshop
./init.sh
```
⚠️ Nota sobre el ID del proyecto: La secuencia de comandos sugerirá un ID del proyecto predeterminado generado de forma aleatoria. Puedes presionar Intro para aceptar este valor predeterminado.

Sin embargo, si prefieres crear un proyecto nuevo específico, puedes escribir el ID de proyecto que desees cuando el script te lo solicite.

La secuencia de comandos se encargará del resto del proceso de configuración automáticamente.

👉💻 Establece el ID del proyecto necesario:

gcloud config set project $(cat ~/project_id.txt) --quiet

Parte tres: Cómo configurar el permiso

👉💻 Habilita las APIs requeridas con el siguiente comando. Esto puede tardar algunos minutos.

gcloud services enable \
    cloudresourcemanager.googleapis.com \
    servicenetworking.googleapis.com \
    run.googleapis.com \
    aiplatform.googleapis.com \
    compute.googleapis.com

👉💻 Ejecuta los siguientes comandos en la terminal para otorgar los permisos necesarios:
```
. ~/holiday_workshop/set_env.sh
```

Observa que se creó un archivo .env para ti. Se mostrará la información de tu proyecto.

3. Potencia tu trabajo con MCP

El momento del "USB-C" para la IA

Imagina que cada vez que compras un mouse nuevo, tienes que soldarlo a la placa madre. Ese era el estado de las herramientas de IA hasta hace poco. Los desarrolladores debían escribir "código de conexión" personalizado para conectar los LLM a bases de datos, sistemas de archivos o APIs.

Ingresa el Protocolo de contexto del modelo (MCP). Piensa en MCP como el puerto USB-C para aplicaciones de IA. Proporciona una forma estandarizada de conectar modelos de IA a fuentes de datos y herramientas.

Si compilas un servidor de MCP para tus herramientas una vez, puedes conectarlo a la CLI de Gemini, un IDE o cualquier otro cliente compatible con MCP sin cambiar una sola línea de código.

Qué compilarás

mcp_server

En este codelab, compilarás un Asistente de diseño de festividades que hará lo siguiente:

Se conecta a tu entorno local (herramientas de estudio) con MCP.
Administra el contexto de la conversación de forma confiable con el Kit de desarrollo de agentes (ADK).
Recuerda tus preferencias (p.ej., Prefiero el código de Python") en diferentes sesiones con Vertex AI Memory Bank.

Compila la lógica del servidor

Preparamos el entorno, pero la lógica del servidor está incompleta. Debemos implementar las cuatro herramientas específicas que nuestro agente usará para crear nuestra tarjeta de festividades.

Parte uno: Abre el esqueleto del servidor

Trabajaremos en el directorio 01-MCP-Files-Testing/01-starter.

En la terminal de Cloud Shell, asegúrate de estar en el directorio correcto:
```
cd ~/holiday_workshop/01-MCP-Files-Testing/01-starter/
```

Para abrir el archivo en el editor de Cloud Shell, ejecuta el siguiente comando:

cloudshell edit ~/holiday_workshop/01-MCP-Files-Testing/01-starter/mcp_server.py

Notarás que el código estándar (configuración del servidor de MCP, control de conexiones e inicialización del cliente de Vertex AI) ya está listo. Sin embargo, las cuatro funciones principales son marcadores de posición vacíos por el momento.

Segunda parte: Implementa el Generador de escenas de festividades

Primero, necesitamos una herramienta que tome el interés de un usuario (p.ej., "pájaros") y la convierte en una instrucción detallada y enriquecida, optimizada para la generación de imágenes.

Ubica el comentario #REPLACE_GENERATE_HOLIDAY_SCENE dentro de la función generate_holiday_scene.

Reemplaza toda esta línea por el siguiente código:

    prompt = (
        f"""
        Create a cozy, high-fidelity 3D render of a winter holiday scene.
        The scene should be warm and inviting with soft cinematic lighting.
        
        Seamlessly integrate the following specific theme/interest into the 
        holiday decor or landscape: {interest}.
        
        The style should be whimsical but detailed.
        Aspect Ratio: 16:9 Landscape.
        """
    )
    generate_image(prompt, "16:9", "static/generated_scene.png")
    return "Done! Saved at generated_scene.png"

Parte tres: Implementa el resultado final de la foto

Por último, queremos asegurarnos de que la iluminación y el estilo se vean fotorrealistas y festivos.

Ubica el comentario #REPLACE_GENERATE_FINAL_PHOTO.

Reemplaza toda esta línea por el siguiente código para realizar la transferencia y la renderización finales del estilo:

    prompt = (
        """
        Generate a photorealistic close-up shot of a rustic wooden fireplace mantle.
        
        Lighting: Warm, glowing ambient light from a fire below (out of frame).
        Background: Softly blurred (bokeh) pine garland and twinkling lights.
        
        Foreground Composition:
        1. A wooden picture frame containing the [attached selfie image]. 
           The face in the photo must be clearly visible.
        2. A folded holiday greeting card standing upright next to the frame. 
           The front of the card displays the [attached holiday scene image] as a print.
           
        Ensure the perspective is grounded and realistic, as if taken with a 50mm lens.
        """
    )
    generate_image(prompt, "16:9", "static/generated_final_photo.png", ["static/generated_selfie.png", "static/generated_scene.png"])
    return "Done! Saved at generated_final_photo.png"

Configuración del entorno

Ahora que el código está en su lugar, debemos asegurarnos de que nuestras dependencias estén instaladas. Usaremos uv, un administrador de proyectos y paquetes de Python rápido.

👉💻 En tu terminal, ejecuta el siguiente comando para agregar FastMCP como dependencia de nuestro proyecto:

cd ~/holiday_workshop/01-MCP-Files-Testing/01-starter/
uv add fastmcp

Verás que se agregó una nueva dependencia fastmcp>=2.13.3 a tu archivo ~/holiday_workshop/01-MCP-Files-Testing/01-starter/pyproject.toml.

4. Pruebas con la CLI de Gemini para el servidor de MCP

Ahora que completamos el código del servidor, ¿cómo lo probamos?

Por lo general, probar un servidor de backend requiere compilar una IU de frontend o escribir solicitudes curl complejas. Sin embargo, aquí podemos usar la CLI de Gemini.

Esto es muy útil para el desarrollo, ya que aísla la lógica. Puedes verificar que el modelo comprenda tus herramientas y las llame correctamente antes de preocuparte por crear una interfaz web o un framework de agentes.

Conectar y ejecutar

Le indicaremos a Gemini CLI que administre nuestro servidor con el comando mcp add.

En tu terminal, ejecuta lo siguiente:

gemini mcp add holidays uv run ~/holiday_workshop/01-MCP-Files-Testing/01-starter/mcp_server.py

add holidays: Le dimos un apodo a nuestro servidor ("holidays").
uv run ...: Proporcionamos el comando explícito para iniciar el servidor de Python que acabamos de modificar.

¡Hagamos magia!

Ahora, inicia la sesión de chat:

gemini

Prueba la siguiente instrucción para verificar si Gemini puede "ver" tus nuevas herramientas. Ten en cuenta que es posible que debas permitir que Gemini CLI use nuestra herramienta de días festivos.

👉 Usuario:

"I want to create a festive holiday photo. I like birds a lot."

Gemini:

*Thinking...*
*Calling tool: generate_holiday_scene(interest='birds')*

Done! Saved at generated_scene.png

👉 Usuario:

"Great! Now generate a knitting pattern for a sweater with reindeer on it."

Gemini:

*Thinking...*
*Calling tool: generate_sweater_pattern(motif='reindeer')*

Done! Saved at generated_pattern.png

Como usaste MCP, la IA comprendió exactamente qué función de Python llamar para satisfacer tu solicitud.

Revisa la imagen

Para finalizar la Gemini CLI, presiona Control+C.
Verifica la imagen generada en tu carpeta: ~/holiday_workshop/01-MCP-Files-Testing/01-starter/static.

Revisa tu foto aquí:

Conclusión y próximos pasos

¡Felicitaciones! Creaste correctamente un servidor de MCP en funcionamiento. Ahora tienes un conjunto funcional de "herramientas de IA" que pueden generar patrones, componer imágenes y refinar escenas.

Sin embargo, ¿notaste algo en la prueba anterior? Tú tuviste que dirigir el proceso. Tenías que pedir la escena, luego pedir el patrón y luego pedir que se combinaran.

Si bien Gemini es inteligente, para un flujo de trabajo de producción complejo, en el que necesitamos generar un patrón antes de poder colocarlo en un suéter y controlar los errores si falla la generación de imágenes, necesitamos más control. Queremos un sistema dedicado que pueda planificar, criticar su propio trabajo y administrar el estado de nuestra tarjeta de festividades sin que tengamos que guiarlo en cada paso.

En la siguiente sección, pondremos orden en este caos creativo. Implementaremos el Kit de desarrollo de agentes (ADK) para crear un agente estructurado que coordine estas herramientas de MCP en una canalización de producción perfecta.

5. Vibe coding de un agente de ADK

Tenemos un conjunto de herramientas que funciona (nuestro servidor de MCP), pero, actualmente, somos nosotros quienes hacemos todo el trabajo pesado: le decimos a Gemini exactamente qué herramienta llamar y cuándo.

En esta sección, crearemos un agente de IA: un sistema que puede razonar, planificar y ejecutar tareas de varios pasos de forma autónoma. Para ello, usaremos el Kit de desarrollo de agentes (ADK).

agent_mcp

¿Qué es un agente?

Si las herramientas de MCP son las "manos" (las que hacen el trabajo), el agente es el "cerebro". Un agente usa un LLM para comprender la intención de un usuario ("Hazme una tarjeta de vacaciones"), la desglosa en pasos ("Primero necesito una escena, luego un patrón…") y decide qué herramientas usar para lograr el objetivo.

¿Qué es el ADK?

El Kit de desarrollo de agentes (ADK) es un framework de Google que facilita la creación de estos agentes. Se encarga de la compleja "plomería", como administrar el historial de chat, conectarse a herramientas y cambiar entre diferentes modelos, para que puedas concentrarte en la personalidad y la lógica de tu app.

Vibe coding basado en el contexto

Es un patrón común usar una sola instrucción masiva para generar código. Sin embargo, cuando se crean aplicaciones complejas, suele ser mejor tratar a la IA como un socio que mantiene el contexto con el tiempo.

Usaremos las funciones de Memoria de la CLI de Gemini para preparar el escenario antes de escribir una sola línea de código.

1. Prepare el entorno

Abre la terminal y navega al directorio de inicio:

cd ~/holiday_workshop/02-Vibe-Coding-ADK-Agent/01-starter

Inicia Gemini CLI:

gemini

2. Administración del contexto y la memoria

Cuando se codifica la vibra, la IA necesita saber quién es y qué sabe. La CLI de Gemini nos permite administrar esto de forma explícita.

/memory show: Escribe esto para ver lo que la IA sabe actualmente sobre tu proyecto y sesión.
/memory add: Usa este parámetro para insertar conocimiento fundamental que la IA debe recordar durante toda la conversación.

Comencemos por definir el arquetipo de nuestro socio de codificación. Ejecuta el siguiente comando en la CLI de Gemini:

/memory add "You are an expert Python developer specialized in the Google Agent Development Kit (ADK). You write clean, modular code and prefer using the latest ADK patterns."

Ahora Gemini comprende su rol. Este contexto influirá en cada respuesta posterior, lo que garantizará código de alta calidad que cumpla con los requisitos del ADK.

3. Paso 1: Vibe-Coding del agente básico

En lugar de intentar generar todo el sistema de una vez, comencemos con el esqueleto. Queremos establecer la estructura de archivos y la personalidad básica del agente.

Ingresa la siguiente instrucción en Gemini CLI:

Let's start by building the basic agent structure. 

Please create a file structure for a `root_agent`. 
1. Create `root_agent/__init__.py` that imports `agent`.
2. Create `root_agent/agent.py` by following exactly how this file is doing import and agent creation @~/holiday_workshop/02-Vibe-Coding-ADK-Agent/01-starter/agent_reference.py

In `agent.py`:
- Create an `Agent` named "root_agent" using the model "gemini-2.5-flash".
- The instruction string should define a "Holiday Magic Assistant". 
- The personality should be enthusiastic (`🎄✨`) and prefer "cute, kawaii, cartoon" styles for any visual tasks.

Gemini generará la estructura de archivos y el código de Python inicial. Revísala para asegurarte de que se vea correctamente y, luego, aplica o acepta los cambios.

4. Paso 2: Agrega el servidor de MCP (las herramientas)

Ahora que tenemos un agente básico, debemos darle "manos". Tenemos que conectar el agente al servidor de MCP que compilamos en el lab anterior.

Ingresa la siguiente instrucción en Gemini CLI:

Now, let's give the agent access to tools. Update `agent.py` to include our local MCP server. By following exactly how this agent is connecting to mcp tool @~/holiday_workshop/02-Vibe-Coding-ADK-Agent/01-starter/agent_reference.py

In `agent.py`:
- Import `McpToolset` to define our STDIO MCP server. as @~/holiday_workshop/02-Vibe-Coding-ADK-Agent/01-starter/agent_reference.py
- Connect to the python file located at `../mcp_server.py` relative to agent.py.

Gemini ahora refactorizará tu agent.py existente para incluir las definiciones de herramientas y la lógica de conexión.

Nota: Si quieres verificar tu trabajo o si el código generado no funciona como se espera, puedes comparar tus archivos con la solución de referencia que se encuentra en: ~/holiday_workshop/02-Vibe-Coding-ADK-Agent/solution

6. Ejecuta la interfaz web del agente

El ADK incluye una interfaz de pruebas integrada llamada adk web. Esto inicia una IU de chat liviana para que podamos hablar con nuestro agente de inmediato.

Si aún tienes abierto GeminiCLI, presiona control+C para cerrarlo. Ahora, en tu terminal(esto se encuentra en la carpeta solution, puedes ir a starter para probar tu código ejecutando uv run adk web en tu carpeta starter), ejecuta lo siguiente:
```
cd ~/holiday_workshop/02-Vibe-Coding-ADK-Agent/02-solution
uv run adk web --port 8000
```
Cloud Shell te alertará que un servicio se está ejecutando en el puerto 8000. Haz clic en "Vista previa en la Web" -> "Vista previa en el puerto 8000".

Prueba el agente

Ahora deberías ver una interfaz de chat. Veamos si nuestro agente sigue las nuevas instrucciones y accede correctamente a las herramientas de MCP.

Prueba estas instrucciones:

"¡Hola! ¿Quién eres?".
- (Se espera una respuesta festiva y entusiasta).
"Necesito un fondo para mi tarjeta de festividades. Haz que sea un pueblo nevado".
- (El agente debe llamar a generate_holiday_scene. Observa cómo se aplica automáticamente el estilo "tierno/de dibujos animados" definido en las instrucciones del sistema.
"Genera un patrón de suéter con pequeñas porciones de pizza".
- (El agente debe llamar al generate_sweater_pattern).

Aquí puedes ver la imagen generada:

Presiona Control+C para salir si terminas de realizar pruebas.

Conclusión y próximos pasos

Ya "Vibe-Codificaste" correctamente un agente del ADK de Google con un enfoque basado en el contexto.

Establecimos el contexto: Usamos /memory add para definir un arquetipo de experto.
Creamos Iteratively: Primero creamos el esqueleto y, luego, agregamos las conexiones de herramientas.

La vista previa web del ADK integrado es ideal para las pruebas, pero, para nuestro producto final, queremos una experiencia personalizada con la marca. En la siguiente sección, integraremos este agente en un frontend web personalizado.

7. Cómo conectar el ADK con la IU

backend_architecture

Ahora que tenemos una definición de Agent, debemos ejecutarla. Aquí es donde entran en juego el ejecutor y el servicio de sesión.

Implementación

👉 Escribe lo siguiente en el comando:
```
cloudshell edit ~/holiday_workshop/03-Connect-ADK-MCP-UI/01-starter/backend/main.py
```
Se abrirá ~/holiday_workshop/03-Connect-ADK-MCP-UI/01-starter/backend/main.py en tu editor.
Reemplaza # TODO: Create Session Service por lo siguiente:
```
from google.adk.sessions import InMemorySessionService
from google.adk.memory import InMemoryMemoryService
session_service = InMemorySessionService()
memory_service = InMemoryMemoryService()
```
El servicio de sesión es la "memoria de trabajo" de tu agente.
- Rol: Almacena el historial inmediato y desordenado de la conversación actual (p.ej., "¿Qué acabo de preguntar?").
- Dos sabores:
- InMemorySessionService: Rápido, fácil, pero amnésico. Si reinicias el servidor, el agente olvidará todo. Es ideal para pruebas.
- VertexAiSessionService: Es robusto y está respaldado por una base de datos. Guarda el estado en Google Cloud, por lo que la conversación puede continuar semanas después o después de reiniciar el servidor.

Reemplaza # TODO: Initialize Runner por lo siguiente:

runner = Runner(
    app_name="agents",
    agent=christmas_agent,
    session_service=session_service,
    memory_service=memory_service,
)

Revisa la línea 158 en este ~/holiday_workshop/03-Connect-ADK-MCP-UI/01-starter/backend/main.py(no se requiere ninguna acción): ¿Te preguntas cómo obtiene la aplicación la respuesta final? A continuación, se muestra el bucle de eventos que ejecuta el corredor:
```
async for event in runner.run_async(
    user_id=user_id,
    session_id=session_id,
    new_message=content
)
```

Análisis detallado: Arquitectura y desarrollo

Usamos FastAPI para entregar este agente.

¿Por qué FastAPI?: Los agentes suelen estar vinculados a la E/S (esperando a los LLM). La naturaleza asíncrona de FastAPI controla esto a la perfección.
Sin estado: Observa que nuestro extremo de API es sin estado. No guardamos variables en el alcance global. Nos basamos en session_id y SessionService para reconstruir el estado de cada solicitud. Esto significa que puedes implementar esta solución en Cloud Run (sin servidores) y escalar a cero.

8. Prueba la aplicación con la magia del agente

👉💻 Escribe lo siguiente en el comando:
```
cd ~/holiday_workshop/03-Connect-ADK-MCP-UI/01-starter
./start_app.sh
```
Se abrirá ~/holiday_workshop/03-Connect-ADK-MCP-UI/01-starter/backend/main.py en tu editor.
Verás el resultado como se muestra a continuación:👉👉 Asegúrate de hacer clic en http://localhost:5173/ o de abrir una ventana nueva y escribir http://localhost:5173/.
Ten en cuenta que NO es el vínculo del servidor de backend: Uvicorn running on http://0.0.0.0:8000
Luego, verás el sitio web con la interfaz de chat:
Prueba subiendo una imagen(puede ser tuya o de tu mascota).

👉 Luego, pregunta

Can you generate a picture my cat wearing snowflake pattern sweater?

Aquí verás la imagen generada: cat

👉💻 Cuando termines de probar, presiona control+C en la terminal para finalizar el proceso.

Si no ves que las cosas funcionan como esperabas, puedes ir a ~/holiday_workshop/03-Connect-ADK-MCP-UI/02-solution, ejecutar ./start_app.sh y, luego, seguir los mismos pasos que se indicaron anteriormente.

9. Banco de memoria de Vertex AI

agent_memory

Memoria a corto plazo vs. memoria a largo plazo

Contexto a corto plazo: "¿Qué acabo de decir?" (Historial de sesiones). Esta información se pierde cuando se cierra la ventana de chat.
Memoria a largo plazo: "¿Cuál es mi lenguaje de programación favorito?" (Preferencias del usuario). Esto debería persistir para siempre.

Vertex AI Memory Bank proporciona este almacenamiento a largo plazo. Permite que el agente almacene y recupere información personalizada sobre el usuario.

Comparación entre Sesiones y Memory Bank

Sesiones (VertexAiSessionService): Este es el registro. Almacena la secuencia cronológica sin procesar de cada mensaje, llamada a herramienta y evento (AppendEvent, ListEvents). Proporciona la verdad fundamental sobre lo que sucedió.
Banco de memoria (VertexAiMemoryBankService): Es el Conocimiento. Almacena hechos sintetizados a largo plazo (GenerateMemories, RetrieveMemories) y se limita a un user_id específico, lo que garantiza la privacidad y el aislamiento.

👉💻 Escribe lo siguiente en el comando:
```
cloudshell edit ~/holiday_workshop/04-Adding-Memory-Bank/01-starter/backend/main.py
```
Se abrirá ~/holiday_workshop/04-Adding-Memory-Bank/01-starter/backend/main.py en tu editor.

Busca # TODO: Create Vertex AI Session Service & Memory Bank Service y reemplaza toda la línea por lo siguiente:

    session_service = VertexAiSessionService(
        project=PROJECT_ID, location=LOCATION, agent_engine_id=AGENT_ENGINE_ID
    )
    memory_service = VertexAiMemoryBankService(
        project=PROJECT_ID, location=LOCATION, agent_engine_id=AGENT_ENGINE_ID
    )

memory_compare

👉💻 Escribe lo siguiente en el comando:
```
cloudshell edit ~/holiday_workshop/04-Adding-Memory-Bank/01-starter/backend/deploy_agent.py
```
Se abrirá ~/holiday_workshop/04-Adding-Memory-Bank/01-starter/backend/deploy_agent.py en tu editor.

Reemplaza # TODO: Set Up Configuration por lo siguiente:

# Basic configuration types
MemoryBankConfig = types.ReasoningEngineContextSpecMemoryBankConfig
SimilaritySearchConfig = (
    types.ReasoningEngineContextSpecMemoryBankConfigSimilaritySearchConfig
)
GenerationConfig = types.ReasoningEngineContextSpecMemoryBankConfigGenerationConfig

# Advanced configuration types
CustomizationConfig = types.MemoryBankCustomizationConfig
MemoryTopic = types.MemoryBankCustomizationConfigMemoryTopic
CustomMemoryTopic = types.MemoryBankCustomizationConfigMemoryTopicCustomMemoryTopic
GenerateMemoriesExample = types.MemoryBankCustomizationConfigGenerateMemoriesExample
ConversationSource = (
    types.MemoryBankCustomizationConfigGenerateMemoriesExampleConversationSource
)
ConversationSourceEvent = (
    types.MemoryBankCustomizationConfigGenerateMemoriesExampleConversationSourceEvent
)
ExampleGeneratedMemory = (
    types.MemoryBankCustomizationConfigGenerateMemoriesExampleGeneratedMemory
)

memory_process

👉 En el mismo archivo: 04-Adding-Memory-Bank/01-starter/backend/deploy_agent.py. Busca # TODO: Set up topic y reemplaza toda la línea por lo siguiente:

    custom_topics = [
        # Topic 1: Sweater Preference
        MemoryTopic(
            custom_memory_topic=CustomMemoryTopic(
                label="sweater_preference",
                description="""Extract the user's preferences for sweater styles, patterns, and designs. Include:
                - Specific patterns (snowflake, reindeer, geometric, fair isle, solid, etc.)
                - Style preferences (chunky knit, cardigan, pullover, turtleneck, oversized, fitted)
                - Color preferences (red, green, navy, pastel, etc.)
                - Material preferences if mentioned (wool, cotton, cashmere, itchy/soft)
                - Themes (retro, modern, ugly christmas sweater, elegant)

                Example: "User wants a retro style sweater with a pixelated reindeer pattern."
                Example: "User prefers dark blue colors and hates itchy wool."
                """,
            )
        ),
        # Topic 2: Personal Context
        MemoryTopic(
            custom_memory_topic=CustomMemoryTopic(
                label="personal_context",
                description="""Extract the user's personal context including hobbies, pets, interests, job, and preferred scenes. Include:
                - Hobbies and activities (skiing, reading, gaming, cooking, etc.)
                - Pets (type, breed, name, color)
                - Job or profession if relevant to their style
                - General interests (sci-fi, nature, vintage, tech)
                - Preferred scenes or vibes (cozy fireplace, snowy mountain, cyberpunk city, beach)

                Example: "User has a golden retriever named Max."
                Example: "User loves skiing and wants a snowy mountain background."
                Example: "User is a software engineer who likes cyberpunk aesthetics."
                """,
            )
        )
    ]

👉 En el mismo archivo: 04-Adding-Memory-Bank/01-starter/backend/deploy_agent.py. Busca # TODO: Create Agent Engine y reemplaza toda la línea por lo siguiente:

    agent_engine = client.agent_engines.create(
        config={
            "display_name": AGENT_DISPLAY_NAME,
            "context_spec": {
                "memory_bank_config": {
                    "generation_config": {
                        "model": f"projects/{PROJECT_ID}/locations/{LOCATION}/publishers/google/models/gemini-2.5-flash"
                    },
                    "customization_configs": [customization_config]
                }
            },
        }
    )

¿Por qué no usar solo la instrucción?

Podrías preguntar: "¿Por qué no pegamos el historial del usuario en la instrucción?".

Límites de tamaño: Las ventanas de contexto son grandes, pero no infinitas. No puedes incluir 5 años de historial.
Costo: Procesar 1 millón de tokens para cada "Hola" es prohibitivamente costoso.
Enfoque: Memory Bank actúa como un motor de búsqueda para tu agente. Recupera solo los hechos pertinentes.

👉💻 Escribe lo siguiente en el comando:
```
cloudshell edit ~/holiday_workshop/04-Adding-Memory-Bank/01-starter/backend/agent.py
```
Se abrirá ~/holiday_workshop/04-Adding-Memory-Bank/01-starter/backend/agent.py en tu editor.
En el archivo ~/holiday_workshop/04-Adding-Memory-Bank/01-starter/backend/agent.py, reemplaza # TODO: Add PreloadMemoryTool por lo siguiente:
```
if USE_MEMORY_BANK:
    agent_tools.append(PreloadMemoryTool())
```

`PreloadMemoryTool` y `add_session_to_memory`

En agent.py, verás dos componentes clave:

PreloadMemoryTool: Es una herramienta que permite que el agente "se busque a sí mismo en Google". Si el usuario pregunta algo vago como "Tráeme mi café habitual", el agente puede usar esta herramienta para consultar el Banco de memoria sobre las "preferencias de café" antes de responder.
add_session_to_memory: Esta es una devolución de llamada en segundo plano.
- ¿Por qué usar Async? Guardar la memoria lleva tiempo (resumir el chat, extraer hechos). No queremos que el usuario espere a que esto suceda. Lo ejecutamos en segundo plano (add_session_to_memory) con after_agent_callback.

10. Memory Bank en acción

👉💻 Escribe lo siguiente en el comando:
```
cd ~/holiday_workshop/04-Adding-Memory-Bank/01-starter
./use_memory_bank.sh
```
Verás el siguiente resultado:
Esta secuencia de comandos use_memory_bank.sh primero usa el archivo 04-Adding-Memory-Bank/01-starter/backend/deploy_agent.py para adjuntar el motor de agentes a tu agente, de modo que este pueda usar el banco de memoria de Vertex AI. Luego, actualizará el archivo .env para que el ID del motor del agente se guarde como un environmental variable.

Revisa tu archivo ~/holiday_workshop/.env y verás (no se requiere ninguna acción).
```
USE_MEMORY_BANK=TRUE
AGENT_ENGINE_ID={agent_engine_id}
```
👉💻 Prueba la memoria con la IU de la aplicación. Escribe lo siguiente en el comando:
```
cd ~/holiday_workshop/04-Adding-Memory-Bank/01-starter
./start_app.sh
```
Asegúrate de hacer clic en http://localhost:5173/ o abre una ventana nueva y escribe http://localhost:5173/. Ten en cuenta que Uvicorn running on http://0.0.0.0:8000 es solo el servidor de backend, no el vínculo real en el que queremos hacer clic. Ahora, la interfaz de chat del sitio web se convirtió en tu agente personalizado.

👉 Prueba la memoria. Si escribes en la IU, haz lo siguiente:

I want a sweater that matches my dog. He's a golden retriever.

I'm a programmer, so I want something geeky. Maybe a matrix style?

I like snowflake sweater pattern

El agente identificará esto como una preferencia y la almacenará en el banco de memoria.

La próxima semana(o en cualquier momento en que reinicies la aplicación con Control+C y ./start_app.sh), si preguntas lo siguiente:

what is my preference on sweater pattern?

El agente consultará el Banco de memoria, verá tu preferencia y generará el patrón del suéter sin que se lo pidas. 10 resultados

Verifica en Vertex AI Agent Engine. Para ello, ve a Google Cloud Console Agent Engine
- Asegúrate de seleccionar el proyecto en el selector de proyectos de la parte superior izquierda:
- Verifica el motor del agente que acabas de implementar con el comando anterior use_memory_bank.shHaz clic en el motor del agente que acabas de crear.
Haz clic en la pestaña Memories en este agente implementado para ver toda la memoria aquí.

¡Felicitaciones! Acabas de adjuntar el banco de memoria a tu agente.

11. Conclusión

Resumen

Diseñaste y creaste correctamente un sistema completo basado en agentes.

Conectividad: Usaste MCP para estandarizar la forma en que tu agente accede a las herramientas locales.
Orquestación: Usaste el ADK para administrar el bucle de razonamiento complejo que se requiere para las tareas de varios pasos.
Personalización: Usaste Memory Bank para crear una capa persistente de aprendizaje que recuerda el contexto del usuario.

Próximos pasos

Crea tu propio servidor de MCP: Crea un servidor para tu API o base de datos interna.
Explora los patrones del ADK: Obtén información sobre los "bucles de razonamiento" y la "orquestación" en la documentación del ADK.
Implementación: Lleva tu agente de una secuencia de comandos local a un servicio de producción en Cloud Run.

Cómo crear agentes personalizados con ADK, MCP y Memory Bank

1. Introducción

La pila de agentes modernos

Conceptos básicos

Qué compilarás

2. Configurar

Parte uno: Habilita la cuenta de facturación

Parte dos: Entorno abierto

Parte tres: Cómo configurar el permiso

3. Potencia tu trabajo con MCP

El momento del "USB-C" para la IA

Qué compilarás

Compila la lógica del servidor

Parte uno: Abre el esqueleto del servidor

Segunda parte: Implementa el Generador de escenas de festividades

Parte tres: Implementa el resultado final de la foto

Configuración del entorno

4. Pruebas con la CLI de Gemini para el servidor de MCP

Conectar y ejecutar

¡Hagamos magia!

Revisa la imagen

Conclusión y próximos pasos

5. Vibe coding de un agente de ADK

¿Qué es un agente?

¿Qué es el ADK?

Vibe coding basado en el contexto

1. Prepare el entorno

2. Administración del contexto y la memoria

3. Paso 1: Vibe-Coding del agente básico

4. Paso 2: Agrega el servidor de MCP (las herramientas)

6. Ejecuta la interfaz web del agente

Prueba el agente

Conclusión y próximos pasos

7. Cómo conectar el ADK con la IU

Implementación

Análisis detallado: Arquitectura y desarrollo

8. Prueba la aplicación con la magia del agente

9. Banco de memoria de Vertex AI

Memoria a corto plazo vs. memoria a largo plazo

Comparación entre Sesiones y Memory Bank

¿Por qué no usar solo la instrucción?

PreloadMemoryTool y add_session_to_memory

10. Memory Bank en acción

11. Conclusión

Resumen

Próximos pasos

`PreloadMemoryTool` y `add_session_to_memory`