Integra agentes de Vertex AI con Google Workspace

1. Antes de comenzar

Nota: Este codelab es específico de Vertex AI. Consulta Integrate Gemini Enterprise Agents with Google Workspace y Build with AI for Google Workspace para obtener más información sobre cómo crear soluciones de IA para Google Workspace.

¿Qué es Vertex AI?

Vertex AI es la plataforma de desarrollo unificada de Google Cloud para crear, implementar y escalar agentes y aplicaciones basados en IA de nivel empresarial. Proporciona a los desarrolladores y científicos de datos las herramientas sofisticadas necesarias para diseñar flujos de trabajo basados en agentes personalizados que se integran profundamente en la infraestructura a escala global.

• Accede a Model Garden: Elige entre más de 150 modelos de base, incluida la familia completa de Gemini, modelos de terceros y modelos de código abierto especializados para encontrar el modelo adecuado para tareas específicas del agente.
• Arquitectura de organización compleja: Vertex AI proporciona el framework para diseñar agentes autónomos que usan el razonamiento para planificar y ejecutar tareas de varios pasos, y llamar a APIs externas.
• Fundamentación de nivel empresarial: Conecta agentes a datos comerciales activos, incluida la RAG (generación mejorada por recuperación) de alto rendimiento, para eliminar las alucinaciones y garantizar la precisión fáctica.
• DevOps: Integra sin problemas el desarrollo de agentes en las canalizaciones de CI/CD existentes con SDKs, APIs y herramientas de evaluación sólidos para medir el rendimiento y la seguridad de los agentes a gran escala.
• Seguridad de nivel industrial: Vertex AI garantiza que los datos del cliente que se usan para el entrenamiento o la fundamentación sigan siendo privados, estén encriptados y cumplan con los requisitos de residencia global.
• Infraestructura optimizada: Escala las cargas de trabajo de agentes sin esfuerzo en los clústeres de TPU y GPU de primer nivel de Google, lo que garantiza un rendimiento de baja latencia incluso para las aplicaciones globales más exigentes.

¿Qué es Google Workspace?

Google Workspace es una colección de soluciones de productividad y colaboración basadas en la nube diseñadas para personas, escuelas y empresas:

• Comunicación: Servicios de correo electrónico profesional (Gmail), videoconferencias (Meet) y mensajería para equipos (Chat).
• Creación de contenido: Herramientas para escribir documentos (Documentos), crear hojas de cálculo (Hojas de cálculo) y diseñar presentaciones (Presentaciones).
• Organización: Calendarios compartidos (Calendario) y toma de notas digitales (Keep).
• Almacenamiento: Espacio centralizado en la nube para guardar y compartir archivos de forma segura (Drive).
• Administración: Controles administrativos para administrar usuarios y la configuración de seguridad (Consola del administrador de Workspace).

¿Qué tipo de integraciones personalizadas?

Google Workspace y Vertex AI crean un potente circuito de retroalimentación en el que Workspace proporciona datos en tiempo real y contexto de colaboración, mientras que Vertex AI ofrece los modelos, el razonamiento basado en agentes y la organización necesarios para automatizar flujos de trabajo inteligentes.

• Conectividad inteligente: Los almacenes de datos, las APIs y los servidores de MCP administrados por Google (personalizados y administrados por Google) permiten que los agentes accedan de forma segura y sin problemas a los datos de Workspace y realicen acciones en nombre de los usuarios.
• Agentes personalizados: Con diseñadores sin código o frameworks de código profesional, los equipos pueden crear agentes especializados basados en datos y acciones de Workspace controlados por el administrador.
• Integración nativa: Los complementos de Workspace cierran la brecha entre los sistemas de IA y las aplicaciones como Chat y Gmail, ya sea a través de componentes de IU dedicados o procesos en segundo plano. Esto permite que los agentes se comuniquen con los usuarios exactamente donde se encuentran para brindar asistencia instantánea y contextual.

Al combinar el sólido ecosistema de productividad de Google Workspace con la potencia avanzada de Vertex AI, las organizaciones pueden transformar sus operaciones a través de agentes de IA personalizados y basados en datos que automatizan flujos de trabajo complejos directamente en las herramientas que sus equipos ya usan todos los días.

Requisitos previos

Si quieres seguir todos los pasos en tu propio entorno, necesitarás lo siguiente:

• Conocimientos básicos de Google Cloud y Python
• Un proyecto de Google Cloud del que eres propietario y que tiene facturación. Para verificar que un proyecto existente tenga habilitada la facturación, consulta Verifica el estado de facturación de tus proyectos. Para crear un proyecto y configurar la facturación, consulta Crea un proyecto de Google Cloud. Para cambiar la propiedad del proyecto, consulta Cómo administrar miembros del proyecto o cambiar la propiedad del proyecto.
• Una cuenta de Google Workspace de Business o Enterprise con acceso a Google Chat y las funciones inteligentes activadas
• Google Cloud CLI instalada y inicializada para tu proyecto de Google Cloud
• Python 3.11 o versiones posteriores instalado. Consulta las instrucciones en el sitio web oficial de Python.

Qué compilarás

En este codelab, crearemos tres soluciones con agentes de Vertex AI estrechamente integrados en Google Workspace. Demostrarán patrones arquitectónicos que se pueden usar para interactuar con datos, acciones y UIs.

App de Vertex AI Search

Este agente permite a los usuarios buscar datos y realizar acciones en Workspace en su lenguaje natural. Se basa en los siguientes elementos:

• Modelo: Gemini.
• Datos y acciones: Almacenes de datos de Vertex AI para Google Workspace (Calendario, Gmail y Drive)
• Host del agente: Vertex AI Search.
• IU: Widget web de Vertex AI Search.

Agente personalizado

Este agente permite a los usuarios buscar datos y realizar acciones en Workspace en su lenguaje natural con herramientas y reglas personalizadas. Se basa en los siguientes elementos:

• Modelo: Gemini.
• Datos y acciones: Almacenes de datos de Vertex AI para Google Workspace (Calendar, Gmail, Drive), servidor del Protocolo de contexto del modelo (MCP) de Vertex AI administrado por Google, función de herramienta personalizada para enviar mensajes de Google Chat (a través de la API de Google Chat).
• Herramientas de creación de agentes: Kit de desarrollo de agentes (ADK)
• Host del agente: Vertex AI Agent Engine.
• IU: ADK Web.

Unagente como complemento de Google Workspace

Este agente permite a los usuarios buscar datos de Workspace en lenguaje natural dentro del contexto de las IU de las apps de Workspace. Se basa en los siguientes elementos:

• Modelo: Gemini.
• Datos y acciones: Almacenes de datos de Vertex AI para Google Workspace (Calendar, Gmail, Drive), servidor del Protocolo de contexto del modelo (MCP) de Vertex AI administrado por Google, función de herramienta personalizada para enviar mensajes de Google Chat (a través de la API de Google Chat).
• Herramientas de creación de agentes: Kit de desarrollo de agentes (ADK)
• Host del agente: Vertex AI Agent Engine.
• IU: Complemento de Google Workspace para Chat y Gmail (se puede extender fácilmente a Calendario, Drive, Documentos, Hojas de cálculo y Presentaciones).
• Complemento de Google Workspace: Apps Script, APIs de Vertex AI Agent Engine y contextual (mensaje de Gmail seleccionado).

Qué aprenderás

• Son los puntos de integración entre Vertex AI Search y Google Workspace que habilitan los datos y las acciones.
• Son las opciones para crear agentes personalizados alojados en Vertex AI.
• Las formas en que los usuarios pueden acceder a los agentes, como el widget web de Vertex AI Search y las aplicaciones de Google Workspace

2. Configurar

Antes de crear soluciones, debemos inicializar la configuración de las aplicaciones de Vertex AI del proyecto, habilitar las APIs requeridas y crear los almacenes de datos de Vertex AI Workspace.

Repasa conceptos

Aplicación de Vertex AI

Una aplicación de Vertex AI es una solución integral administrada en Google Cloud que integra modelos de aprendizaje automático (como agentes de IA generativa o motores de búsqueda) con datos empresariales y herramientas especializadas para realizar tareas complejas, como la búsqueda semántica, la generación de contenido o la interacción automatizada con el cliente.

Almacén de datos de Vertex AI

Un almacén de datos de Vertex AI es una entidad que contiene los datos que se transfirieron desde una fuente de datos propia, como Google Workspace, o desde aplicaciones de terceros, como Jira o Shopify. Los almacenes de datos que contienen datos de aplicaciones de terceros también se denominan conectores de datos.

Cómo iniciar la configuración de Vertex AI Applications

Inicializa la configuración de Vertex AI Applications para habilitar la creación de agentes.

Abre la consola de Google Cloud en una pestaña nueva y, luego, sigue estos pasos:

1. Elige tu proyecto.
2. En el campo de búsqueda de Google Cloud, ve a AI Applications.

Ir a Vertex AI Applications

3. Haz clic en Continuar y activar la API después de revisar y aceptar las condiciones.
4. Ve a Configuración.
5. En la pestaña Authentication, edita global.

6. Selecciona Google Identity y, luego, haz clic en Guardar.

Habilita las APIs

Los almacenes de datos de Vertex AI Workspace requieren que se habiliten las siguientes APIs:

1. En la consola de Google Cloud, habilita las APIs de Calendar, Gmail y People:

Habilita las APIs de Calendario, Gmail y People

2. Haz clic en Menú ☰ > APIs y servicios > APIs y servicios habilitados y, luego, confirma que Google Calendar API, Gmail API y People API estén en la lista.

Ir a APIs y servicios > APIs y servicios habilitados

Crea almacenes de datos

Crea el almacén de datos de Google Drive:

1. En la consola de Google Cloud, ve a AI Applications y, luego, navega a Data Stores.

Ir a Aplicaciones de Vertex AI > Almacenes de datos

2. Haz clic en Crear almacén de datos.
3. En Fuente, en Google Drive, haz clic en Seleccionar.

4. En Datos, selecciona Todos y haz clic en Continuar.

5. En Configuración, establece el Nombre del conector de datos como drive y haz clic en Continuar después de revisar y aceptar los cargos que se puedan aplicar.

6. En Precios, selecciona el modelo de precios que prefieras y haz clic en Crear. En el contexto de este codelab, se recomienda el precio general.
7. Se te redireccionará automáticamente a Almacenes de datos, donde podrás ver el almacén de datos que acabas de agregar.

Crea el almacén de datos del Calendario de Google:

1. Haz clic en Crear almacén de datos.
2. En Fuente, busca Calendario de Google y haz clic en Seleccionar.
3. En la sección Actions, haz clic en Skip.
4. En la sección Configuración, establece el Nombre del conector de datos como calendar.
5. Haz clic en Crear.
6. Se te redireccionará automáticamente a Almacenes de datos, donde podrás ver el almacén de datos que acabas de agregar.

Crea el almacén de datos de Google Gmail:

1. Haz clic en + Crear almacén de datos nuevo.
2. En Fuente, busca Google Gmail y haz clic en Seleccionar.
3. En la sección Actions, haz clic en Skip.
4. En la sección Configuración, establece el Nombre del conector de datos como gmail.
5. Haz clic en Crear.
6. Se te redireccionará automáticamente a Almacenes de datos, donde podrás ver el almacén de datos que acabas de agregar.

3. Aplicación Vertex AI Search

Este agente permite a los usuarios buscar datos y realizar acciones en Workspace en su lenguaje natural. Se basa en los siguientes elementos:

• Modelo: Gemini.
• Datos y acciones: Almacenes de datos de Vertex AI para Google Workspace (Calendario, Gmail y Drive)
• Host del agente: Vertex AI Search.
• IU: Widget web de Vertex AI Search.

Repasa conceptos

App de Vertex AI Search

Una app de Vertex AI Search proporciona resultados de búsqueda, acciones y agentes a los usuarios finales. El término app se puede usar indistintamente con el término motor en el contexto de las APIs. Una app debe estar conectada a un almacén de datos para usar sus datos y mostrar resultados de búsqueda, respuestas o acciones.

Widget web de Vertex AI Search

El widget web de Vertex AI Search es un componente de IU personalizable y compilado previamente que permite a los desarrolladores incorporar una barra de búsqueda potenciada por IA y una interfaz de resultados directamente en un sitio web con una codificación mínima.

Vista previa de Vertex AI Search

La versión preliminar de Vertex AI Search es un entorno de pruebas integrado en la consola de Google Cloud que permite a los desarrolladores validar la configuración de búsqueda y las respuestas generativas antes de implementar sin problemas esos mismos parámetros de configuración en un widget web de Vertex AI Search listo para la producción.

Revisa la arquitectura de la solución

Crea apps

Crea una app de búsqueda nueva para anclar tus almacenes de datos.

Abre AI Applications > Apps desde la consola de Cloud y, luego, sigue estos pasos:

1. Haz clic en + Crear app.
2. En Tipo, en Búsqueda personalizada (general), haz clic en Crear.

3. En Configuración, marca Funciones de la edición Enterprise y Respuestas generativas después de revisar los precios y aceptarlos.
4. Establece el Nombre de la app como codelab.
5. Se genera un ID en función del nombre y se muestra debajo del campo. Cópialo.
6. Establece el Nombre de la empresa como Codelab.
7. Establece Multi-region en global (Global).
8. Haz clic en Continuar.

9. En Datos, selecciona los almacenes de datos drive, gmail y calendar, y, luego, haz clic en Continuar.

10. En Precios, selecciona el modelo de precios que prefieras y haz clic en Crear. En el contexto de este codelab, se recomienda el precio general.
11. Se creará la app y se te redireccionará automáticamente a AI Applications > Apps > codelab > App overview.
12. Navega a Almacenes de datos conectados.
13. Después de unos minutos, todos los estados de los almacenes de datos conectados deberían ser Activo.

Configurar el widget web

Configura la apariencia visual y el comportamiento del widget de búsqueda.

1. Navega a Configuraciones.
2. En la pestaña IU, establece el Tipo de búsqueda en Búsqueda con seguimiento y, luego, haz clic en Guardar y publicar.

Probar la app

Prueba la app de búsqueda directamente en la consola de Google Cloud.

1. Navega a Vista previa, donde se mostrará el widget web.
2. En el chat, escribe Do I have any meetings today? y presiona enter.
3. En el chat, escribe Did I receive an email on March 1st 2026? y presiona enter.
4. En el chat, escribe Give me the title of the latest Drive file I created y presiona enter.

4. Agente personalizado

Este agente permite a los usuarios buscar datos y realizar acciones en Workspace en su lenguaje natural con herramientas y reglas personalizadas. Se basa en los siguientes elementos:

• Modelo: Gemini.
• Datos y acciones: Almacenes de datos de Vertex AI para Google Workspace (Calendar, Gmail, Drive), servidor del Protocolo de contexto del modelo (MCP) de Vertex AI administrado por Google, función de herramienta personalizada para enviar mensajes de Google Chat (a través de la API de Google Chat).
• Herramientas de creación de agentes: Kit de desarrollo de agentes (ADK)
• Host del agente: Vertex AI Agent Engine.
• IU: ADK Web.

Repasa conceptos

Kit de desarrollo de agentes (ADK)

El Kit de desarrollo de agentes (ADK) es un conjunto especializado de herramientas y frameworks diseñados para simplificar la creación de agentes autónomos de IA, ya que proporciona módulos prediseñados para el razonamiento, la administración de la memoria y la integración de herramientas.

Model Context Protocol (MCP)

El Protocolo de contexto del modelo (MCP) es un estándar abierto diseñado para permitir una integración segura y fluida entre las aplicaciones de IA y varias fuentes de datos o herramientas a través de una interfaz universal de "conectar y usar".

Herramienta de funciones

Una herramienta de función es una rutina ejecutable predefinida que un modelo de IA puede activar para realizar acciones específicas o recuperar datos en tiempo real de sistemas externos, lo que extiende sus capacidades más allá de la simple generación de texto.

ADK Web

ADK web es la IU de desarrollo integrada que se incluye con el SDK del ADK para facilitar el desarrollo y la depuración.

Revisa la arquitectura de la solución

Revisa el código fuente

agent.py

El siguiente código se autentica con Vertex AI, inicializa las herramientas de la API de MCP y de chat de Vertex AI Search, y define el comportamiento del agente.

1. Autenticación: Recupera el ACCESS_TOKEN de las variables de entorno para autenticar las llamadas a la API y a MCP.
2. Configuración de herramientas: Inicializa vertexai_mcp, un conjunto de herramientas que se conecta al servidor del Protocolo de contexto del modelo (MCP) de Vertex AI Search, y la herramienta send_direct_message. Esto le permite al agente buscar en tus almacenes de datos conectados y enviar mensajes de Google Chat.
3. Definición del agente: Define el root_agent con el modelo gemini-2.5-flash. Las instrucciones le indican al agente que priorice el uso de la herramienta de búsqueda para recuperar información y la herramienta send_direct_message para realizar acciones, lo que fundamenta de manera eficaz al agente en los datos de tu empresa.

...
MODEL = "gemini-2.5-flash"

# Access token for authentication
ACCESS_TOKEN = os.environ.get("ACCESS_TOKEN")
if not ACCESS_TOKEN:
    raise ValueError("ACCESS_TOKEN environment variable must be set")

VERTEXAI_SEARCH_TIMEOUT = 15.0

def get_project_id():
    """Fetches the consumer project ID from the environment natively."""
    _, project = google.auth.default()
    if project:
        return project
    raise Exception(f"Failed to resolve GCP Project ID from environment.")

def find_serving_config_path():
    """Dynamically finds the default serving config in the engine."""
    project_id = get_project_id()
    engines = discoveryengine_v1.EngineServiceClient().list_engines(
        parent=f"projects/{project_id}/locations/global/collections/default_collection"
    )
    for engine in engines:
        # engine.name natively contains the numeric Project Number
        return f"{engine.name}/servingConfigs/default_serving_config"
    raise Exception(f"No Discovery Engines found in project {project_id}")

def send_direct_message(email: str, message: str) -> dict:
    """Sends a Google Chat Direct Message (DM) to a specific user by email address."""
    chat_client = chat_v1.ChatServiceClient(
        credentials=Credentials(token=ACCESS_TOKEN)
    )

    # 1. Setup the DM space or find existing one
    person = chat_v1.User(
        name=f"users/{email}",
        type_=chat_v1.User.Type.HUMAN
    )
    membership = chat_v1.Membership(member=person)
    space_req = chat_v1.Space(space_type=chat_v1.Space.SpaceType.DIRECT_MESSAGE)
    setup_request = chat_v1.SetUpSpaceRequest(
        space=space_req,
        memberships=[membership]
    )
    space_response = chat_client.set_up_space(request=setup_request)
    space_name = space_response.name
    
    # 2. Send the message
    msg = chat_v1.Message(text=message)
    message_request = chat_v1.CreateMessageRequest(
        parent=space_name,
        message=msg
    )
    message_response = chat_client.create_message(request=message_request)
    
    return {"status": "success", "message_id": message_response.name, "space": space_name}

vertexai_mcp = McpToolset(
    connection_params=StreamableHTTPConnectionParams(
        url="https://discoveryengine.googleapis.com/mcp",
        timeout=VERTEXAI_SEARCH_TIMEOUT,
        sse_read_timeout=VERTEXAI_SEARCH_TIMEOUT,
        headers={"Authorization": f"Bearer {ACCESS_TOKEN}"}
    ),
    tool_filter=['search']
)

# Answer nicely the following user queries:
#  - Please find my meetings for today, I need their titles and links
#  - What is the latest Drive file I created?
#  - What is the latest Gmail message I received?
#  - Please send the following message to [e-mail]: Hello, this is a test message.

root_agent = LlmAgent(
    model=MODEL,
    name='enterprise_ai',
    instruction=f"""
        You are a helpful assistant that always uses the Vertex AI MCP search tool to answer the user's message, unless the user asks you to send a message to someone.
        If the user asks you to send a message to someone, use the send_direct_message tool to send the message.
        You MUST unconditionally use the Vertex AI MCP search tool to find answer, even if you believe you already know the answer or believe the Vertex AI MCP search tool does not contain the data.
        The Vertex AI MCP search tool accesses the user's data through datastores including Google Drive, Google Calendar, and Gmail.
        Only use the Vertex AI MCP search tool with servingConfig and query parameters, do not use any other parameters.
        Always use the servingConfig {find_serving_config_path()} while using the Vertex AI MCP search tool.
    """,
    tools=[vertexai_mcp, FunctionTool(send_direct_message)]
)

Descargar código fuente

Descarga el código de muestra en tu entorno local para comenzar.

Precaución: El código se simplificó mucho para mostrar los conceptos de este codelab. Si decides reutilizar este código en una app de producción, asegúrate de controlar los errores, realizar pruebas exhaustivas y seguir las prácticas recomendadas.

1. Descarga este repositorio de GitHub.

Descargar ZIP

2. En una terminal, abre el directorio solutions/enterprise-ai-agent-local.

Habilita las APIs

La solución requiere la habilitación de APIs adicionales:

1. En la consola de Google Cloud, habilita las APIs de Vertex AI, Cloud Resource Manager y Google Chat:

Habilita las APIs de Vertex AI, Cloud Resource Manager y Google Chat

2. Haz clic en Menú ☰ > APIs y servicios > APIs y servicios habilitados y, luego, confirma que API de Vertex AI, API de Cloud Resource Manager y API de Google Chat estén en la lista.

Ir a APIs y servicios > APIs y servicios habilitados

Configurar la pantalla de consentimiento de OAuth

La solución requiere una configuración de pantalla de consentimiento:

1. En la consola de Google Cloud, haz clic en Menú ☰ > Plataforma de autenticación de Google > Desarrollo de la marca.

Ir a Branding

2. Haz clic en Comenzar.
3. En Información de la aplicación, establece el Nombre de la aplicación como Codelab .
4. En Correo electrónico de asistencia al usuario, elige una dirección de correo electrónico de asistencia a la que los usuarios puedan comunicarse contigo si tienen preguntas sobre su consentimiento.
5. Haz clic en Siguiente.
6. En Público, selecciona Interno.
7. Haz clic en Siguiente.
8. En Información de contacto, ingresa una dirección de correo electrónico en la que puedas recibir notificaciones sobre cualquier cambio en tu proyecto.
9. Haz clic en Siguiente.
10. En Finalizar, revisa la Política de Datos del Usuario de los Servicios de las APIs de Google y, si la aceptas, selecciona Acepto la Política de Datos del Usuario de los Servicios de las APIs de Google.
11. Haz clic en Continuar y, luego, en Crear.

12. Se guardará la configuración y se te redireccionará automáticamente a Google Auth Platform > Overview.

Para obtener más información, consulta la guía completa Configura el consentimiento de OAuth.

Crea credenciales de cliente de OAuth

Crea un cliente de OAuth de app para computadoras para autenticar al usuario en un entorno local:

1. En la consola de Google Cloud, haz clic en Menú ☰ > Plataforma de Google Auth > Clientes.

Ir a Clientes

2. Haz clic en + Crear cliente.
3. En Tipo de aplicación, selecciona App de escritorio.
4. Configura el campo Nombre como codelab.
5. Haz clic en Crear. Aparecerá la credencial recién creada.
6. Haz clic en Descargar JSON y guarda el archivo como client_secret.json en el directorio solutions/enterprise-ai-agent-local.

Habilita el MCP de Vertex AI Search

1. En una terminal, ejecuta lo siguiente:

gcloud beta services mcp enable discoveryengine.googleapis.com \
     --project=$(gcloud config get-value project)

Configura la app de Chat

Configura la app de Google Chat con sus detalles informativos básicos.

1. En la consola de Google Cloud, busca Google Chat API en el campo de búsqueda de Google Cloud, haz clic en API de Google Chat, luego en Administrar y, por último, en Configuración.

Ir a la configuración de la API de Google Chat

2. Configura el Nombre de la app y la Descripción como Vertex AI.
3. Establece la URL del avatar en https://developers.google.com/workspace/add-ons/images/quickstart-app-avatar.png.
4. Anula la selección de Habilitar funciones interactivas y, luego, haz clic en Inhabilitar en el diálogo modal que aparece.
5. Selecciona Registrar errores en Logging.
6. Haz clic en Guardar.

Ejecuta el agente en la Web del ADK

Inicia el agente de forma local con la interfaz web del ADK.

1. En una terminal, abre el directorio solutions/enterprise-ai-agent-local y, luego, ejecuta el siguiente comando:

# 1. Authenticate with all the required scopes
gcloud auth application-default login \
  --client-id-file=client_secret.json \
   --scopes=https://www.googleapis.com/auth/cloud-platform,https://www.googleapis.com/auth/chat.spaces,https://www.googleapis.com/auth/chat.messages

# 2. Configure environment
export ACCESS_TOKEN=$(gcloud auth application-default print-access-token)
export GOOGLE_GENAI_USE_VERTEXAI=1
export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
export GOOGLE_CLOUD_LOCATION=us-central1

# 3. Create and activate a new virtual environment
python3 -m venv .venv
source .venv/bin/activate

# 4. Install poetry and project dependencies
pip install poetry
poetry install

# 5. Start ADK Web
adk web

Probar agente

Verifica el flujo chateando con tu agente personalizado.

1. En tu navegador de Internet, abre el sitio web del ADK.
2. En el chat, escribe Please find my meetings for today, I need their titles and links y presiona enter.
3. El agente responde con una lista de eventos del Calendario (según la cuenta del usuario).
4. En el chat, escribe Please send a Chat message to [e-mail] with the following text: Hello! y presiona enter.
5. El agente responde con un mensaje de confirmación.

5. Agente como complemento de Google Workspace

Este agente permite a los usuarios buscar datos de Workspace en lenguaje natural dentro del contexto de las IU de las apps de Workspace. Se basa en los siguientes elementos:

• Modelo: Gemini.
• Datos y acciones: Almacenes de datos de Vertex AI para Google Workspace (Calendar, Gmail, Drive), servidor del Protocolo de contexto del modelo (MCP) de Vertex AI administrado por Google, función de herramienta personalizada para enviar mensajes de Google Chat (a través de la API de Google Chat).
• Herramientas de creación de agentes: Kit de desarrollo de agentes (ADK)
• Host del agente: Vertex AI Agent Engine.
• IU: Complemento de Google Workspace para Chat y Gmail (se puede extender fácilmente a Calendario, Drive, Documentos, Hojas de cálculo y Presentaciones).
• Complemento de Google Workspace: Apps Script, APIs de Vertex AI Agent Engine y contextual (mensaje de Gmail seleccionado).

Repasa conceptos

Complemento de Google Workspace

Un complemento de Google Workspace es una aplicación personalizada que extiende una o varias aplicaciones de Google Workspace (Gmail, Chat, Calendario, Documentos, Drive, Meet, Hojas de cálculo y Presentaciones).

Apps Script

Apps Script es una plataforma de JavaScript basada en la nube y potenciada por Google Drive que te permite integrar y automatizar tareas en los productos de Google.

Marco de tarjetas de Google Workspace

El framework de tarjetas en Google Workspace permite que los desarrolladores creen interfaces de usuario interactivas y enriquecidas. Permite crear tarjetas organizadas y visualmente atractivas que pueden incluir texto, imágenes, botones y otros widgets. Estas tarjetas mejoran la experiencia del usuario, ya que proporcionan información estructurada y permiten realizar acciones rápidas directamente en las aplicaciones de Workspace.

Revisa la arquitectura de la solución

Revisa el código fuente

Agent

agent.py

El siguiente código se autentica con Vertex AI, inicializa las herramientas de la API de MCP y de chat de Vertex AI Search, y define el comportamiento del agente.

1. Autenticación: Usa una función de ayuda _get_access_token_from_context para recuperar el token de autenticación (CLIENT_AUTH_NAME) que inyecta el cliente. Este token es fundamental para llamar de forma segura a los servicios posteriores, como las herramientas de MCP de Vertex AI Search y Google Chat.
2. Configuración de herramientas: Inicializa vertexai_mcp, un conjunto de herramientas que se conecta al servidor del Protocolo de contexto del modelo (MCP) de Vertex AI Search, y la herramienta send_direct_message. Esto le permite al agente buscar en tus almacenes de datos conectados y enviar mensajes de Google Chat.
3. Definición del agente: Define el root_agent con el modelo gemini-2.5-flash. Las instrucciones le indican al agente que priorice el uso de la herramienta de búsqueda para recuperar información y la herramienta send_direct_message para realizar acciones, lo que fundamenta de manera eficaz al agente en los datos de tu empresa.

...
MODEL = "gemini-2.5-flash"

# Client injects a bearer token into the ToolContext state.
# The key pattern is "CLIENT_AUTH_NAME_<random_digits>".
# We dynamically parse this token to authenticate our MCP and API calls.
CLIENT_AUTH_NAME = "enterprise-ai"

VERTEXAI_SEARCH_TIMEOUT = 15.0

def get_project_id():
    """Fetches the consumer project ID from the environment natively."""
    _, project = google.auth.default()
    if project:
        return project
    raise Exception(f"Failed to resolve GCP Project ID from environment.")

def find_serving_config_path():
    """Dynamically finds the default serving config in the engine."""
    project_id = get_project_id()
    engines = discoveryengine_v1.EngineServiceClient().list_engines(
        parent=f"projects/{project_id}/locations/global/collections/default_collection"
    )
    for engine in engines:
        # engine.name natively contains the numeric Project Number
        return f"{engine.name}/servingConfigs/default_serving_config"
    raise Exception(f"No Discovery Engines found in project {project_id}")

def _get_access_token_from_context(tool_context: ToolContext) -> str:
    """Helper method to dynamically parse the intercepted bearer token from the context state."""
    escaped_name = re.escape(CLIENT_AUTH_NAME)
    pattern = re.compile(fr"^{escaped_name}_\d+$")
    # Handle ADK varying state object types (Raw Dict vs ADK State)
    state_dict = tool_context.state.to_dict() if hasattr(tool_context.state, 'to_dict') else tool_context.state
    matching_keys = [k for k in state_dict.keys() if pattern.match(k)]
    if matching_keys:
        return state_dict.get(matching_keys[0])
    raise Exception(f"No bearer token found in ToolContext state matching pattern {pattern.pattern}")

def auth_header_provider(tool_context: ToolContext) -> dict[str, str]:
    token = _get_access_token_from_context(tool_context)
    return {"Authorization": f"Bearer {token}"}

def send_direct_message(email: str, message: str, tool_context: ToolContext) -> dict:
    """Sends a Google Chat Direct Message (DM) to a specific user by email address."""
    chat_client = chat_v1.ChatServiceClient(
        credentials=Credentials(token=_get_access_token_from_context(tool_context))
    )

    # 1. Setup the DM space or find existing one
    person = chat_v1.User(
        name=f"users/{email}",
        type_=chat_v1.User.Type.HUMAN
    )
    membership = chat_v1.Membership(member=person)
    space_req = chat_v1.Space(space_type=chat_v1.Space.SpaceType.DIRECT_MESSAGE)
    setup_request = chat_v1.SetUpSpaceRequest(
        space=space_req,
        memberships=[membership]
    )
    space_response = chat_client.set_up_space(request=setup_request)
    space_name = space_response.name
    
    # 2. Send the message
    msg = chat_v1.Message(text=message)
    message_request = chat_v1.CreateMessageRequest(
        parent=space_name,
        message=msg
    )
    message_response = chat_client.create_message(request=message_request)
    
    return {"status": "success", "message_id": message_response.name, "space": space_name}

vertexai_mcp = McpToolset(
    connection_params=StreamableHTTPConnectionParams(
        url="https://discoveryengine.googleapis.com/mcp",
        timeout=VERTEXAI_SEARCH_TIMEOUT,
        sse_read_timeout=VERTEXAI_SEARCH_TIMEOUT
    ),
    tool_filter=['search'],
    # The auth_header_provider dynamically injects the bearer token from the ToolContext
    # into the MCP call for authentication.
    header_provider=auth_header_provider
)

# Answer nicely the following user queries:
#  - Please find my meetings for today, I need their titles and links
#  - What is the latest Drive file I created?
#  - What is the latest Gmail message I received?
#  - Please send the following message to [e-mail]: Hello, this is a test message.

root_agent = LlmAgent(
    model=MODEL,
    name='enterprise_ai',
    instruction=f"""
        You are a helpful assistant that always uses the Vertex AI MCP search tool to answer the user's message, unless the user asks you to send a message to someone.
        If the user asks you to send a message to someone, use the send_direct_message tool to send the message.
        You MUST unconditionally use the Vertex AI MCP search tool to find answer, even if you believe you already know the answer or believe the Vertex AI MCP search tool does not contain the data.
        The Vertex AI MCP search tool accesses the user's data through datastores including Google Drive, Google Calendar, and Gmail.
        Only use the Vertex AI MCP search tool with servingConfig and query parameters, do not use any other parameters.
        Always use the servingConfig {find_serving_config_path()} while using the Vertex AI MCP search tool.
    """,
    tools=[vertexai_mcp, FunctionTool(send_direct_message)]
)

Cliente

appsscript.json

La siguiente configuración define los permisos y los activadores del complemento.

1. Define el complemento: Le indica a Workspace que este proyecto es un complemento para Chat y Gmail.
2. Activadores contextuales: En el caso de Gmail, configura un contextualTrigger que se activa onAddonEvent cada vez que un usuario abre un mensaje de correo electrónico. Esto permite que el complemento "vea" el contenido del correo electrónico.
3. Permisos: Se enumeran los oauthScopes necesarios para que se ejecute el complemento, como los permisos para leer el correo electrónico actual, ejecutar la secuencia de comandos y conectarse a servicios externos (como las APIs de Vertex AI).

...
"addOns": {
    "common": {
      "name": "Vertex AI",
      "logoUrl": "https://developers.google.com/workspace/add-ons/images/quickstart-app-avatar.png"
    },
    "chat": {},
    "gmail": {
      "contextualTriggers": [
        {
          "unconditional": {},
          "onTriggerFunction": "onAddonEvent"
        }
      ]
    }
  },
  "oauthScopes": [
   "https://www.googleapis.com/auth/script.external_request",
   "https://www.googleapis.com/auth/cloud-platform",
   "https://www.googleapis.com/auth/gmail.addons.execute",
   "https://www.googleapis.com/auth/gmail.addons.current.message.readonly"
 ]
...

Chat.gs

El siguiente código controla los mensajes entrantes de Google Chat.

1. Recibe mensajes: La función onMessage es el punto de entrada para las interacciones de mensajes.
2. Administra el contexto: Guarda el space.name (el ID del espacio de chat) en las propiedades del usuario. Esto garantiza que, cuando el agente esté listo para responder, sepa exactamente a qué conversación publicar el mensaje.
3. Delegates to Agent: Llama a requestAgent y pasa el mensaje del usuario a la lógica principal que controla la comunicación de la API.

...
// Service that handles Google Chat operations.

// Handle incoming Google Chat message events, actions will be taken via Google Chat API calls
function onMessage(event) {
  if (isInDebugMode()) {
    console.log(`MESSAGE event received (Chat): ${JSON.stringify(event)}`);
  }
  // Extract data from the event.
  const chatEvent = event.chat;
  setChatConfig(chatEvent.messagePayload.space.name);

  // Request AI agent to answer the message
  requestAgent(chatEvent.messagePayload.message);
  // Respond with an empty response to the Google Chat platform to acknowledge execution
  return null; 
}

// --- Utility functions ---

// The Chat direct message (DM) space associated with the user
const SPACE_NAME_PROPERTY = "DM_SPACE_NAME"

// Sets the Chat DM space name for subsequent operations.
function setChatConfig(spaceName) {
  const userProperties = PropertiesService.getUserProperties();
  userProperties.setProperty(SPACE_NAME_PROPERTY, spaceName);
  console.log(`Space is set to ${spaceName}`);
}

// Retrieved the Chat DM space name to sent messages to.
function getConfiguredChat() {
  const userProperties = PropertiesService.getUserProperties();
  return userProperties.getProperty(SPACE_NAME_PROPERTY);
}

// Finds the Chat DM space name between the Chat app and the given user.
function findChatAppDm(userName) {
  return Chat.Spaces.findDirectMessage(
    { 'name': userName },
    {'Authorization': `Bearer ${getAddonCredentials().getAccessToken()}`}
  ).name;
}

// Creates a Chat message in the configured space.
function createMessage(message) {
  const spaceName = getConfiguredChat();
  console.log(`Creating message in space ${spaceName}...`);
  return Chat.Spaces.Messages.create(
    message,
    spaceName,
    {},
    {'Authorization': `Bearer ${getAddonCredentials().getAccessToken()}`}
  ).name;
}

Sidebar.gs

El siguiente código compila la barra lateral de Gmail y captura el contexto del correo electrónico.

1. Compila la IU: createSidebarCard construye la interfaz visual con el servicio de tarjetas del espacio de trabajo. Crea un diseño simple con un área de entrada de texto y un botón "Enviar mensaje".
2. Captura el contexto del correo electrónico: En handleSendMessage, el código verifica si el usuario está viendo un correo electrónico (event.gmail.messageId). Si es así, recupera de forma segura el asunto y el cuerpo del correo electrónico, y los agrega a la instrucción del usuario.
3. Muestra el resultado: Una vez que el agente responde, el código actualiza la tarjeta de la barra lateral para mostrar la respuesta.

...
// Service that handles Gmail operations.

// Triggered when the user opens the Gmail Add-on or selects an email.
function onAddonEvent(event) {
  // If this was triggered by a button click, handle it
  if (event.parameters && event.parameters.action === 'send') {
    return handleSendMessage(event);
  }

  // Otherwise, just render the default initial sidebar
  return createSidebarCard();
}

// Creates the standard Gmail sidebar card consisting of a text input and send button.
// Optionally includes an answer section if a response was generated.
function createSidebarCard(optionalAnswerSection) {
  const card = CardService.newCardBuilder();
  const actionSection = CardService.newCardSection();

  // Create text input for the user's message
  const messageInput = CardService.newTextInput()
    .setFieldName("message")
    .setTitle("Message")
    .setMultiline(true);

  // Create action for sending the message
  const sendAction = CardService.newAction()
    .setFunctionName('onAddonEvent')
    .setParameters({ 'action': 'send' });

  const sendButton = CardService.newTextButton()
    .setText("Send message")
    .setTextButtonStyle(CardService.TextButtonStyle.FILLED)
    .setOnClickAction(sendAction);

  actionSection.addWidget(messageInput);
  actionSection.addWidget(CardService.newButtonSet().addButton(sendButton));

  card.addSection(actionSection);

  // Attach the response at the bottom if we have one
  if (optionalAnswerSection) {
    card.addSection(optionalAnswerSection);
  }

  return card.build();
}

// Handles clicks from the Send message button.
function handleSendMessage(event) {
  const commonEventObject = event.commonEventObject || {};
  const formInputs = commonEventObject.formInputs || {};
  const messageInput = formInputs.message;

  let userMessage = "";
  if (messageInput && messageInput.stringInputs && messageInput.stringInputs.value.length > 0) {
    userMessage = messageInput.stringInputs.value[0];
  }

  if (!userMessage || userMessage.trim().length === 0) {
    return CardService.newActionResponseBuilder()
      .setNotification(CardService.newNotification().setText("Please enter a message."))
      .build();
  }

  let finalQueryText = `USER MESSAGE TO ANSWER: ${userMessage}`;

  // If we have an email selected in Gmail, append its content as context
  if (event.gmail && event.gmail.messageId) {
    try {
      GmailApp.setCurrentMessageAccessToken(event.gmail.accessToken);
      const message = GmailApp.getMessageById(event.gmail.messageId);

      const subject = message.getSubject();
      const bodyText = message.getPlainBody() || message.getBody();

      finalQueryText += `\n\nEMAIL THE USER HAS OPENED ON SCREEN:\nSubject: ${subject}\nBody:\n---\n${bodyText}\n---`;
    } catch (e) {
      console.error("Could not fetch Gmail context: " + e);
      // Invalidate the token explicitly so the next prompt requests the missing scopes
      ScriptApp.invalidateAuth();

      CardService.newAuthorizationException()
        .setResourceDisplayName("Enterprise AI")
        .setAuthorizationUrl(ScriptApp.getAuthorizationUrl())
        .throwException();
    }
  }

  try {
    const response = queryAgent({ text: finalQueryText });

    // We leverage the 'showdown' library to parse the LLM's Markdown output into HTML
    // We also substitute markdown listings with arrows and adjust newlines for clearer rendering in the sidebar
    let displayedText = substituteListingsFromMarkdown(response.text);
    displayedText = new showdown.Converter().makeHtml(displayedText).replace(/\n/g, '\n\n');

    const textParagraph = CardService.newTextParagraph();
    textParagraph.setText(displayedText);

    const answerSection = CardService.newCardSection()
      .addWidget(textParagraph);

    const updatedCard = createSidebarCard(answerSection);

    return CardService.newActionResponseBuilder()
      .setNavigation(CardService.newNavigation().updateCard(updatedCard))
      .build();

  } catch (err) {
    return CardService.newActionResponseBuilder()
      .setNotification(CardService.newNotification().setText("Error fetching response: " + err.message))
      .build();
  }
}
...

AgentHandler.gs

El siguiente código organiza la llamada a la API de Vertex AI.

1. Coordina la llamada a la API: queryAgent es el puente entre tu complemento y Vertex AI Agent Engine. Construye una solicitud que incluye la búsqueda del usuario y el token de autorización en el estado.
2. Transmite la respuesta: Como las respuestas del agente pueden tardar un momento, usa la API de streamQuery con eventos enviados por el servidor (SSE). El código recopila la respuesta en fragmentos y reconstruye la respuesta completa.

...
// Service that handles Vertex AI Agent operations.

// Submits a query to the AI agent and returns the response string synchronously
function queryAgent(input) {
 let systemPrompt = "SYSTEM PROMPT START Do not respond with tables but use bullet points instead." +
   " Do not ask the user follow-up questions or converse with them as history is not kept in this interface." +
   " SYSTEM PROMPT END\n\n";

 const requestPayload = {
   "class_method": "async_stream_query",
   "input": {
     "user_id": "vertex_ai_add_on",
     "message": { "role": "user", "parts": [{ "text": systemPrompt + input.text }] },
     "state_delta": {
       "enterprise-ai_999": `${ScriptApp.getOAuthToken()}`
     }
   }
 };

 const responseContentText = UrlFetchApp.fetch(
   `https://${getLocation()}-aiplatform.googleapis.com/v1/${getReasoningEngine()}:streamQuery?alt=sse`,
   {
     method: 'post',
     headers: { 'Authorization': `Bearer ${ScriptApp.getOAuthToken()}` },
     contentType: 'application/json',
     payload: JSON.stringify(requestPayload),
     muteHttpExceptions: true
   }
 ).getContentText();
  if (isInDebugMode()) {
   console.log(`Response: ${responseContentText}`);
 }

 const events = responseContentText.split('\n').map(s => s.replace(/^data:\s*/, '')).filter(s => s.trim().length > 0);
 console.log(`Received ${events.length} agent events.`);

 let author = "default";
 let answerText = "";
 for (const eventJson of events) {
   if (isInDebugMode()) {
     console.log("Event: " + eventJson);
   }
   const event = JSON.parse(eventJson);

   // Retrieve the agent responsible for generating the content
   author = event.author;
  
   // Ignore events that are not useful for the end-user
   if (!event.content) {
     console.log(`${author}: internal event`);
     continue;
   }

   // Handle text answers
   const parts = event.content.parts || [];
   const textPart = parts.find(p => p.text);
   if (textPart) {
     answerText += textPart.text;
   }
 }
 return { author: author, text: answerText };
}
...

Implementa el agente en Vertex AI Agent Engine

1. En una terminal, abre el directorio solutions/enterprise-ai-agent de las fuentes que descargaste en los pasos anteriores y, luego, ejecuta lo siguiente:

# 1. Create and activate a new virtual environment
deactivate
python3 -m venv .venv
source .venv/bin/activate

# 2. Install poetry and project dependencies
pip install poetry
poetry install

# 3. Deploy the agent
adk deploy agent_engine \
  --project=$(gcloud config get-value project) \
  --region=us-central1 \
  --display_name="Enterprise AI" \
  enterprise_ai

2. Cuando veas la línea Deploying to agent engine… en los registros, abre una nueva terminal y ejecuta el siguiente comando para agregar los permisos necesarios a Vertex AI Reasoning Engine Service Agent:

# 1. Get the current Project ID
PROJECT_ID=$(gcloud config get-value project)

# 2. Extract the Project Number for that ID
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)')

# 3. Construct the Service Account name
SERVICE_ACCOUNT="service-${PROJECT_NUMBER}@gcp-sa-aiplatform-re.iam.gserviceaccount.com"

# 4. Apply the IAM policy binding
gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:$SERVICE_ACCOUNT" \
     --role="roles/discoveryengine.viewer"

3. Espera a que se complete el comando adk deploy y, luego, copia el nombre del recurso del agente recién implementado del resultado del comando en verde.

Inicia la cuenta de servicio

Crea una cuenta de servicio dedicada para autorizar las operaciones del complemento del servidor.

En la consola de Google Cloud, sigue estos pasos:

1. Haz clic en Menú ☰ > > IAM y administración > Cuentas de servicio > + Crear cuenta de servicio.

Ir a IAM y administración > Cuentas de servicio > + Crear cuenta de servicio

2. Establece el Nombre de la cuenta de servicio como vertexai-add-on.

3. Haz clic en Listo. Se te redireccionará a la página Cuentas de servicio, donde podrás ver la cuenta de servicio que creaste.

4. Selecciona la cuenta de servicio recién creada y, luego, la pestaña Claves.
5. Haz clic en Agregar clave y, luego, en Crear clave nueva.
6. Selecciona JSON y, luego, haz clic en Crear.

7. Se cerrará el cuadro de diálogo, y el nuevo par de clave pública/privada se descargará automáticamente en tu entorno local como un archivo JSON.

Crea y configura un proyecto de Apps Script

Crea un nuevo proyecto de Apps Script para alojar el código del complemento y configurar sus propiedades de conexión.

Precaución: El código se simplificó mucho para mostrar los conceptos de este codelab. Si decides reutilizar este código en una app de producción, asegúrate de controlar los errores, realizar pruebas exhaustivas y seguir las prácticas recomendadas.

1. Haz clic en el siguiente botón para abrir el proyecto de Apps Script del complemento de IA empresarial:

Abre el proyecto de Apps Script

2. Haz clic en Descripción general > Crear una copia.
3. En tu proyecto de Apps Script, haz clic en Configuración del proyecto > Editar propiedades de la secuencia de comandos > Agregar propiedad de la secuencia de comandos para agregar propiedades de la secuencia de comandos.
4. Establece REASONING_ENGINE_RESOURCE_NAME en el nombre del recurso del agente de Vertex AI que copiaste en los pasos anteriores. Tiene el siguiente formato:

projects/<PROJECT_NUMBER>/locations/us-central1/reasoningEngines/<AGENT_ID>

5. Establece APP_SERVICE_ACCOUNT_KEY en la clave JSON del archivo de la cuenta de servicio que descargaste en los pasos anteriores.
6. Haz clic en Guardar las propiedades de las secuencias de comandos.

Implementación en Gmail y Chat

Implementa el complemento para probarlo directamente en Gmail y Google Chat.

En tu proyecto de Apps Script, sigue estos pasos:

1. Haz clic en Implementar > Implementaciones de prueba y, luego, en Instalar. Ahora está disponible en Gmail.
2. Haz clic en Copiar en ID de implementación principal.

En la consola de Google Cloud, sigue estos pasos:

1. Busca Google Chat API en el campo de búsqueda de Google Cloud, haz clic en API de Google Chat, luego en Administrar y, por último, en Configuración.

Ir a la configuración de la API de Google Chat

2. Selecciona Habilitar funciones interactivas.
3. Anula la selección de Unirse a espacios y conversaciones grupales.
4. En Configuración de conexión, selecciona Apps Script.
5. Establece el ID de implementación en el ID de implementación principal que copiaste en los pasos anteriores.
6. En Visibilidad, selecciona Hacer que esta app de Chat esté disponible para personas y grupos específicos de Tu dominio de Workspace y escribe tu dirección de correo electrónico.
7. Haz clic en Guardar.

Probar el complemento

Interactúa con tu complemento en vivo para verificar que pueda recuperar datos y responder preguntas en contexto.

Abre Google Chat en una pestaña nueva y, luego, sigue estos pasos:

1. Abre un espacio de mensajes directos con la app de Chat Vertex AI.

2. Haz clic en Configurar y completa el flujo de autenticación.
3. Escribe What are my meetings for today? y presiona enter. La app de chat de Vertex AI debería responder con los resultados.

Abre Gmail en una pestaña nueva y, luego, sigue estos pasos:

1. Envía un correo electrónico con el Asunto establecido en We need to talk y el Cuerpo establecido en Are you available today between 8 and 9 AM?.
2. Abre el correo electrónico que acabas de recibir.
3. Abre la barra lateral del complemento Vertex AI.
4. Establece el Mensaje en Do I have any meeting conflicts?.
5. Haz clic en Enviar mensaje.
6. La respuesta se muestra después del botón.

6. Limpia

Borra el proyecto de Google Cloud

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en este codelab, te recomendamos que borres el proyecto de Google Cloud.

Precaución: Si se borra un proyecto de Google Cloud, ocurre lo siguiente:

• Se borra todo el contenido del proyecto. Si usaste un proyecto existente para este codelab, borrarás cualquier otro trabajo que hayas realizado en el proyecto.
• Se pierden los IDs personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URLs que utilizan el ID del proyecto, como una URL en appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de todo el proyecto.

En la consola de Google Cloud, sigue estos pasos:

1. Haz clic en Menú ☰ > IAM y administración > Configuración.

Ir a IAM y administración > Configuración

2. Haz clic en Cerrar.
3. Ingresa el ID del proyecto.
4. Haz clic en Apagar de todos modos.

7. Felicitaciones

¡Felicitaciones! Creaste soluciones que aprovechan el poder de acercar Vertex AI y Google Workspace a los trabajadores.

Próximos pasos

En este codelab, solo mostramos los casos de uso más típicos, pero hay muchas áreas de expansión que podrías considerar en tus soluciones, como las siguientes:

• Usar herramientas para desarrolladores potenciadas por IA, como Gemini CLI y Antigravity
• Integración con otros frameworks y herramientas de agentes, como MCP personalizados, llamadas a funciones personalizadas y UIs generativas
• Integrar otros modelos de IA, incluidos los personalizados, alojados en plataformas dedicadas, como Vertex AI
• Integrarse con otros agentes alojados en plataformas dedicadas, como Dialogflow, o por terceros a través de Cloud Marketplace
• Publica agentes en Cloud Marketplace para potenciar a los equipos, las organizaciones o los usuarios públicos.

Más información

Existen muchos recursos disponibles para los desarrolladores, como videos de YouTube, sitios web de documentación, muestras de código e instructivos:

• Google Cloud Developer Center
• Productos compatibles | Servidores de MCP de Google Cloud
• A2UI
• Model Garden en Vertex AI | Google Cloud
• Descripción general de Vertex AI Agent Engine
• Obtén respuestas y seguimientos | Vertex AI Search | Documentación de Google Cloud
• Ofrece agentes de IA a través de Google Cloud Marketplace
• Canal de YouTube para desarrolladores de Google Workspace: ¡Bienvenidos, desarrolladores!
• Sitio web para desarrolladores de Google Workspace
• Repositorio de GitHub para todas las muestras de complementos de Google Workspace