Cómo crear tu primer agente con Google Agent Development Kit (ADK)

Los agentes de Inteligencia Artificial (IA) están transformando la forma en que interactuamos con la tecnología, actuando como asistentes autónomos capaces de razonar, planificar y ejecutar tareas. Desde ayudantes virtuales hasta complejos sistemas multiagente, la demanda de herramientas accesibles para construir estos agentes va en aumento. Aquí entra el Agent Development Kit (ADK) de Google, un framework de Python de código abierto lanzado el 9 de abril de 2025, diseñado para simplificar la creación de agentes de IA sofisticados. Integrado estrechamente con el ecosistema de Google —en particular los modelos Gemini y Vertex AI— ADK permite a los desarrolladores crear, probar y desplegar agentes con facilidad, ya sea para tareas sencillas o para flujos de trabajo colaborativos complejos.

Este artículo te guiará paso a paso en la creación de tu primer agente con ADK. Veremos cómo configurar tu entorno de desarrollo con el rápido instalador de paquetes uv, conectar tu agente a un modelo Gemini mediante la API de Google AI Studio, darle a tu agente la capacidad de recordar información usando el Session State (estado de sesión) y mejorarlo con búsqueda web en tiempo real gracias a la herramienta de búsqueda Tavily. Al final, tendrás un agente funcional listo para seguir explorando.

¿Qué es Google Agent Development Kit (ADK)?

El Agent Development Kit (ADK) de Google es un framework de Python de código abierto presentado por Google el 9 de abril de 2025, orientado a simplificar el desarrollo de agentes de IA. Construido pensando en la integración, ADK aprovecha la potente infraestructura de IA de Google —como la familia de modelos Gemini y Vertex AI— para permitir a los desarrolladores crear agentes que pueden razonar, usar herramientas y colaborar en sistemas multiagente. Tanto si estás construyendo un asistente de un solo propósito como un equipo de agentes especializados, ADK proporciona el andamiaje para hacerlo de forma eficiente.

Características clave de ADK

• Integración de herramientas: los agentes pueden llamar a APIs externas, realizar búsquedas web o ejecutar funciones personalizadas, lo que los convierte en solucionadores de problemas versátiles.
• Colaboración multiagente: ADK admite la creación de equipos de agentes que trabajan juntos, compartiendo tareas y memoria para flujos de trabajo complejos.
• Compatibilidad con el ecosistema de Google: la integración perfecta con Google Cloud, Vertex AI y los modelos Gemini garantiza un alto rendimiento y escalabilidad.
• Flexibilidad de código abierto: al ser de código abierto, ADK permite la personalización y las contribuciones de la comunidad, fomentando una innovación rápida.
• Facilidad de uso: con plantillas predefinidas y una API sencilla, incluso los principiantes pueden empezar rápidamente.

¿Por qué usar ADK para crear agentes?

ADK destaca en un campo saturado de herramientas de desarrollo de IA gracias a su equilibrio entre simplicidad y potencia. A diferencia de frameworks más genéricos, su estrecha integración con las ofertas de IA de Google —como las avanzadas capacidades de razonamiento de Gemini— da a los desarrolladores acceso a tecnología de vanguardia sin necesidad de construir todo desde cero. Además, su naturaleza de código abierto significa que no quedas atado a un sistema propietario, lo que ofrece libertad para adaptar tu agente a casos de uso únicos. Ya sea que estés automatizando una tarea personal o creando el prototipo de una solución empresarial, ADK proporciona un punto de partida sólido.

En resumen, ADK es ideal para cualquiera que quiera aprovechar los agentes de IA sin atascarse en la complejidad. Es un puente entre los potentes modelos de IA y las aplicaciones prácticas del mundo real: perfecto para tu primera aventura creando agentes.

Crea tu primer agente con Google Agent Development Kit (ADK)

Requisitos previos

Antes de sumergirnos en la creación de tu primer agente con Google Agent Development Kit (ADK) y uv, asegurémonos de que tienes todo lo necesario para seguir el tutorial. Esta sección describe las herramientas, cuentas y conocimientos básicos requeridos para completar el proyecto.

Herramientas y cuentas necesarias

1. Python 3.9+

   • ADK requiere Python 3.9 o superior. Usaremos uv para gestionar la versión de Python, así que no necesitas tenerla preinstalada: uv puede encargarse de ello. Sin embargo, tener una instalación base de Python (por ejemplo, mediante el gestor de paquetes de tu sistema o python.org) simplifica la configuración inicial de uv.

2. uv

   • ¡La estrella de la gestión de nuestro proyecto! Instalarás uv como un binario independiente (no se requiere Python de antemano). Veremos los pasos de instalación en la siguiente sección.

3. Clave de API de Google AI Studio

   • Para alimentar nuestro agente con el modelo Gemini 2.0 Flash, necesitarás una clave de API de Google AI Studio. Regístrate o inicia sesión en aistudio.google.com, ve a la sección de API y genera una clave. La configuraremos de forma segura usando variables de entorno.

4. Clave de API de Tavily

   • Para la funcionalidad de búsqueda, integraremos la herramienta de búsqueda Tavily, que proporciona resultados de búsqueda web en tiempo real diseñados para agentes de IA. Obtén una clave de API gratuita registrándote en tavily.com. La necesitarás para que tu agente pueda obtener información de la web.

5. Editor de texto o IDE

   • Usa el editor que prefieras: VS Code, PyCharm o incluso un editor de texto sencillo como Notepad++ funcionarán. Escribirás código Python y editarás archivos de configuración.

Conocimientos básicos asumidos

Esta guía asume que tienes:

• Conocimientos básicos de Python: familiaridad con la sintaxis de Python, las funciones y la ejecución de scripts. No necesitas ser un experto, pero debes saber escribir y ejecutar un programa simple de Python.
• Comprensión de los entornos virtuales: una idea general de por qué son útiles los entornos virtuales (aislar las dependencias del proyecto). Si has usado venv o pip antes, estás listo.
• Conceptos básicos de API: saber qué es una clave de API y cómo se usa para autenticar solicitudes. No se requiere experiencia profunda con APIs: te guiaremos en la configuración.

Con todo esto en marcha, estás listo para configurar tu proyecto y empezar a construir. En la siguiente sección instalaremos uv, inicializaremos tu proyecto y añadiremos las dependencias necesarias para poner ADK en funcionamiento.

Configuración de tu proyecto con uv

Ahora que tienes los requisitos previos resueltos, vamos a configurar tu proyecto de Python con uv. Esta sección te guía por la instalación de uv, la inicialización de un nuevo proyecto, la creación de un entorno virtual y la incorporación de las dependencias necesarias para Google Agent Development Kit (ADK) y la integración con la búsqueda de Tavily. Al usar uv en lugar de pip, disfrutarás de un flujo de trabajo más rápido y fluido.

Instalación de uv

uv es una herramienta independiente escrita en Rust, por lo que no necesitas una instalación previa de Python para empezar. A abril de 2025, la última versión está disponible en el sitio oficial del equipo de Astral. Así es como se instala:

• En macOS/Linux: Abre tu terminal y ejecuta:

  curl -LsSf https://astral.sh/uv/install.sh | sh

  Esto descarga e instala uv en ~/.local/bin. Tras la instalación, asegúrate de que esté en tu PATH reiniciando la terminal o ejecutando:

  source ~/.local/bin/env

• En Windows: En PowerShell, ejecuta:

  irm https://astral.sh/uv/install.ps1 | iex

  El instalador añade uv a tu PATH automáticamente, pero puede que tengas que reiniciar PowerShell para usarlo.

Verifica la instalación:

uv --version

Deberías ver una salida como uv 0.6.6 (o una versión posterior a abril de 2025). Si falla, revisa tu PATH o reinstala.

Inicialización de un nuevo proyecto de Python

Con uv instalado, vamos a crear un nuevo proyecto:

1. Inicializa el proyecto: Ejecuta:

   uv init my-adk-agent
   cd my-adk-agent

   Esto crea un directorio my-adk-agent con una estructura básica:

   my-adk-agent/
   ├── .python-version  # Pins Python version (e.g., "3.12")
   ├── main.py         # Starter script
   ├── pyproject.toml  # Project configuration
   └── README.md       # Project documentation

   El archivo pyproject.toml viene rellenado con metadatos mínimos:

   [project]
   name = "my-adk-agent"
   version = "0.1.0"
   description = "Add your description here"
   readme = "README.md"
   requires-python = ">=3.12"
   dependencies = []

2. Define la versión de Python: La versión de Python por defecto en .python-version (p. ej., 3.12) funciona con ADK, pero asegurémonos de usar 3.12 explícitamente:

   uv python pin 3.12

   Si 3.12 no está instalada, uv puede descargarla:

   uv python install 3.12

Configuración de un entorno virtual

A diferencia de pip y venv, uv simplifica la creación de entornos:

uv venv

Esto crea un directorio .venv en la raíz de tu proyecto usando Python 3.12. Verás:

Using Python 3.12.x
Creating virtual environment at: .venv
Activate with: source .venv/bin/activate

Puedes activarlo manualmente si es necesario (source .venv/bin/activate en macOS/Linux, .venv\Scripts\activate en Windows), pero uv run se encargará de esto automáticamente más adelante.

Añadir ADK y las dependencias

Ahora, añadamos el paquete ADK y el soporte de Tavily:

1. Añade Google ADK:

   uv add google-adk

   Esto actualiza pyproject.toml:

   [project]
   dependencies = [
       "google-adk>=x.x.x",  # Latest version as of April 2025
   ]

2. Añade el soporte de Tavily: Como usaremos Tavily a través de la integración de LangChain, instala langchain-community y tavily-python:

   uv add langchain-community tavily-python

   El pyproject.toml ahora incluye:

   [project]
   dependencies = [
       "google-adk>=x.x.x",
       "langchain-community>=x.x.x",
       "tavily-python>=x.x.x",
   ]

3. Sincroniza el entorno: Instala todas las dependencias en .venv:

   uv sync

   Verás una salida que lista los paquetes instalados (p. ej., google-adk, langchain-community, tavily-python y sus dependencias) en apenas milisegundos: aquí es donde la velocidad de uv brilla frente a pip.

Tu proyecto ya está configurado con uv, listo para construir un agente ADK. En la siguiente sección configuraremos la API de Google AI Studio para alimentar nuestro agente con el modelo Gemini.

Bien, aquí está la siguiente sección:

Conexión con Gemini a través de AI Studio

Tu agente ADK necesita una forma de comunicarse con el Large Language Model (LLM) Gemini que impulsa su inteligencia. Esta comunicación se realiza mediante llamadas seguras a la API, que requieren credenciales de autenticación, normalmente una clave de API. Sin una clave válida, el servicio del LLM rechazará las solicitudes del agente, impidiendo que funcione.

Para desarrollo y prototipado, Google AI Studio ofrece una forma sencilla de obtener una clave de API.

Obtén tu clave de API

1. Ve al sitio web de Google AI Studio.
2. Si aún no tienes una, crea una clave de API. Copia esta clave de forma segura: la necesitarás en el siguiente paso.

Configura tu entorno

La mejor forma de proporcionar la clave de API a tu aplicación ADK es mediante variables de entorno, gestionadas habitualmente con un archivo .env dentro del directorio de tu proyecto.

1. Dentro de la carpeta de tu proyecto de agente (la que contiene tu archivo agent.py), crea un nuevo archivo llamado .env.

2. Abre el archivo .env y añade las siguientes líneas, reemplazando "PASTE_YOUR_ACTUAL_API_KEY_HERE" con la clave que copiaste de AI Studio:

   # Use Google AI Studio (not Vertex AI)
   GOOGLE_GENAI_USE_VERTEXAI="False"
   
   # Your API Key
   GOOGLE_API_KEY="PASTE_YOUR_ACTUAL_API_KEY_HERE"

La línea GOOGLE_GENAI_USE_VERTEXAI="False" indica explícitamente a ADK que use el backend de Google AI (que utiliza la GOOGLE_API_KEY) en lugar del backend de Vertex AI. ADK cargará automáticamente estas variables cuando tu agente se ejecute, permitiéndole autenticarse de forma segura con la API de Gemini.

Bien, aquí está la siguiente sección:

Construcción de tu primer agente básico

Con el entorno configurado y la clave de API establecida, vamos a crear el núcleo de nuestra aplicación de agente.

Configura la estructura del proyecto

Una estructura recomendada ayuda a mantener organizado el código de tu agente. En el directorio principal de tu proyecto (donde creaste la carpeta .venv), crea una estructura como esta:

google-adk/
├── agent_module/
│   ├── __init__.py
│   └── agent.py
├── .venv/
└── .env

1. Crea una carpeta llamada agent_module. Contendrá el código de tu agente.
2. Dentro de agent_module, crea un archivo vacío llamado __init__.py. Esto le indica a Python que trate la carpeta como un paquete. Añade la siguiente línea:

   # agent_module/__init__.py
   from . import agent

3. Dentro de agent_module, crea el archivo principal de la lógica de tu agente: agent.py.
4. Ya deberías tener el archivo .env en el directorio your_agent_project del paso anterior.

Define tu agente

Ahora, abre agent.py y define tu primer agente usando la clase Agent de ADK. Esta clase es la pieza central para definir la identidad, el modelo y las instrucciones de tu agente.

# agent_module/agent.py
from google.adk.agents import Agent

# Define the root agent for your application
root_agent = Agent(
    # A unique name for your agent [cite: 167, 639]
    name="my_first_adk_agent",

    # Specify the Gemini model to use (ensure compatibility with AI Studio key) [cite: 19, 56, 168, 645]
    model="gemini-2.0-flash-exp", # Or "gemini-1.0-pro" etc.

    # A brief description of what the agent does [cite: 169, 642]
    description="A basic agent that can chat.",

    # Instructions guiding the agent's behavior and persona [cite: 171, 648]
    instruction="You are a friendly and helpful assistant. Respond concisely to user queries.",

    # Initially, we won't add specific tools [cite: 172, 659]
    tools=[]
)

print(f"Agent '{root_agent.name}' defined.")

En este código:

• name: le da a tu agente un ID único.
• model: indica al agente qué modelo de Gemini usar para pensar y responder. Usamos un modelo Flash reciente adecuado para chat general.
• description: resume brevemente el propósito del agente, algo especialmente útil en configuraciones multiagente.
• instruction: proporciona la guía principal al LLM sobre cómo debe comportarse.
• tools: una lista vacía por ahora, ya que este agente básico aún no usará herramientas externas.

Ejecución de tu agente (brevemente)

ADK proporciona herramientas de línea de comandos para interactuar con tu agente. Navega en tu terminal al directorio your_agent_project (el que contiene agent_module y .env) y puedes probar:

• adk web: lanza una interfaz web interactiva en tu navegador, que te permite chatear con tu agente.
• adk run agent_module: te permite chatear con el agente directamente en tu terminal.

Todavía no profundizaremos en la ejecución del agente, ya que primero necesitamos añadir memoria y herramientas, pero esto te da una idea de cómo interactuar con él más adelante.

Añadir memoria con Session State

Nuestro agente básico puede chatear, pero no tiene memoria. Cada vez que interactúas con él, empieza de cero, olvidando todo lo de los turnos anteriores. Para construir agentes más atractivos y útiles, necesitamos darles la capacidad de recordar el contexto y las interacciones pasadas. ADK lo consigue mediante el Session State (estado de sesión).

¿Qué es Session State?

Session State es esencialmente un banco de memoria para cada sesión de conversación individual. Técnicamente, es un diccionario de Python asociado a una sesión de usuario concreta. La información almacenada en este diccionario persiste a lo largo de múltiples turnos dentro de esa única conversación. Tanto tu agente como sus herramientas pueden leer y escribir en este estado, lo que les permite:

• Recordar las preferencias del usuario.
• Recuperar información mencionada antes en la conversación.
• Personalizar las respuestas basándose en interacciones pasadas.

Uso de InMemorySessionService

Para este tutorial usaremos InMemorySessionService de ADK. Como su nombre indica, almacena el historial y el estado de la sesión directamente en la memoria de tu ordenador. Es perfecto para desarrollo y pruebas, aunque la memoria se perderá cuando tu aplicación se detenga.

Configuración del Runner y el servicio de sesión

Para gestionar sesiones y ejecutar tu agente necesitas dos componentes más: InMemorySessionService y Runner. Añadamos el código de configuración, normalmente en un script principal o junto a la definición de tu agente:

# Add these imports to your agent.py or a main script
from google.adk.sessions import InMemorySessionService
from google.adk.runners import Runner
from google.adk.agents import Agent # Assuming root_agent is defined as before

# Define constants for the app and session identification
APP_NAME = "my_first_adk_app"
USER_ID = "user_test_1" # Identifier for the user
SESSION_ID = "session_abc_123" # Identifier for this specific conversation

# 1. Create the Session Service instance
session_service = InMemorySessionService()
print("Session Service created.")

# 2. Create the specific session (can initialize state here if needed)
session = session_service.create_session(
    app_name=APP_NAME,
    user_id=USER_ID,
    session_id=SESSION_ID
    # state={"initial_key": "initial_value"} # Optional: initial state
)
print(f"Session '{SESSION_ID}' created.")

# 3. Create the Runner instance
# The Runner orchestrates the agent's execution and uses the session service
runner = Runner(
    agent=root_agent, # Your agent defined earlier
    app_name=APP_NAME,
    session_service=session_service
)
print(f"Runner created for agent '{root_agent.name}'.")

# (You would then use 'runner.run()' or 'runner.run_async()' to interact)

Acceso al estado en las herramientas

La principal forma en que las herramientas interactúan con la memoria es a través del objeto ToolContext. Si defines una función de herramienta que acepta tool_context: ToolContext como último argumento, ADK proporciona automáticamente este objeto cuando se llama a la herramienta.

# Example tool demonstrating state access
from google.adk.tools.tool_context import ToolContext

def remember_something(data_to_remember: str, tool_context: ToolContext) -> dict:
    """Reads previous data from state and saves new data."""
    print("--- Tool: remember_something called ---")

    # Read from state (use .get() for safety)
    previous_data = tool_context.state.get("user_data", "nothing")
    print(f"--- Tool: Found previous data: '{previous_data}' ---") #

    # Write new data to state
    tool_context.state["user_data"] = data_to_remember # [cite: 354]
    print(f"--- Tool: Saved new data: '{data_to_remember}' ---")

    return {"status": "success", "message": f"I remembered '{data_to_remember}'. Before that, I knew about '{previous_data}'."}

# (You would add 'remember_something' to the agent's 'tools' list)

Esto permite a las herramientas adaptar dinámicamente su comportamiento según lo que haya ocurrido antes en la conversación.

Nota rápida sobre output_key: ADK también ofrece un atajo. Al definir output_key="some_name" al crear un Agent, la respuesta de texto final del agente en cada turno se guardará automáticamente en session.state["some_name"].

Ahora que nuestro agente tiene una forma de recordar cosas, ¡démosle algunas herramientas para interactuar con el mundo exterior!

Mejora de tu agente con herramientas: búsqueda Tavily

Nuestro agente ya puede chatear y recordar cosas dentro de una sesión. Sin embargo, su conocimiento está limitado a aquello con lo que se entrenó el modelo Gemini subyacente. Para hacerlo realmente potente, necesitamos darle acceso a información en tiempo real y capacidades externas. En ADK, esto se hace con Tools (herramientas).

Las herramientas son funciones o servicios que permiten a tu agente interactuar con el mundo exterior: obtener datos de APIs, consultar bases de datos, realizar cálculos o, como haremos ahora, buscar en la web.

Integración de herramientas de terceros: LangChain y Tavily

ADK está diseñado para ser extensible y funciona bien con otros frameworks populares de IA. Podemos integrar fácilmente herramientas creadas para librerías como LangChain. Usaremos el wrapper LangchainTool de ADK para incorporar la API de búsqueda de Tavily, un servicio diseñado específicamente para que los agentes de IA obtengan resultados de búsqueda actualizados.

Configuración de Tavily

1. Instala las dependencias: añade las librerías necesarias de LangChain y Tavily usando uv:

   # Run this in your activated virtual environment
   uv add langchain_community tavily-python

2. Obtén la clave de API de Tavily:

   • Regístrate para obtener una clave de API gratuita en el sitio web de Tavily.
   • Añade esta clave a tu archivo .env:

     # .env file content (add this line)
     TAVILY_API_KEY="PASTE_YOUR_TAVILY_API_KEY_HERE"

     Asegúrate de que tu aplicación cargue las variables de entorno desde este archivo (ADK suele hacerlo automáticamente, o puedes usar una librería como python-dotenv).

Uso del wrapper LangchainTool

Ahora, integremos Tavily en el código de nuestro agente:

1. Importa las clases necesarias en tu agent.py:

   # Add these imports
   from google.adk.tools.langchain_tool import LangchainTool
   from langchain_community.tools import TavilySearchResults
   import os # To potentially check for the API key

2. Instancia y envuelve la herramienta: crea una instancia de la herramienta de LangChain y envuélvela para ADK:

   # Instantiate the LangChain Tavily tool
   # You can configure options like max_results
   tavily_search_tool_instance = TavilySearchResults(
       max_results=3,
       include_answer=True # Ask Tavily to provide a direct answer if possible
   )
   
   # Wrap it with ADK's LangchainTool
   adk_tavily_tool = LangchainTool(tool=tavily_search_tool_instance)
   
   print("Tavily search tool wrapped for ADK.")

Actualiza la definición de tu agente

Por último, modifica la definición de tu agente para incluir la nueva herramienta y actualiza sus instrucciones para que sepa cuándo usarla:

# Modify your existing root_agent definition in agent.py

root_agent = Agent(
    name="my_first_adk_agent", # Or maybe rename to "research_agent"
    model="gemini-2.0-flash-exp",
    description="A helpful assistant that can search the web for current information.",
    instruction="""You are a friendly and helpful assistant.
If the user asks for information that might require up-to-date details, recent events, or searching the web, use the 'TavilySearchResults' tool.
Otherwise, answer directly based on your knowledge.
Remember information provided earlier in the conversation using session state.""", # Added mention of memory

    # Add the wrapped Tavily tool to the list
    tools=[adk_tavily_tool] # Add any other tools like 'remember_something' here too if desired
)

print(f"Agent '{root_agent.name}' updated with Tavily tool.")

# Ensure your Runner is using this updated 'root_agent' instance
runner = Runner(
    agent=root_agent, # Make sure this uses the updated agent
    app_name=APP_NAME,
    session_service=session_service
)

Ahora, cuando ejecutes tu agente y hagas una pregunta que requiera información actual (p. ej., «¿Cuáles son las últimas noticias sobre agentes de IA?» o «¿Qué tiempo hace en Londres ahora mismo?»), el agente, guiado por sus instrucciones, debería reconocer la necesidad de usar la herramienta TavilySearchResults para obtener y ofrecer una respuesta relevante y actualizada.

Código completo:

# agent_module/agent.py

import os
import asyncio
from dotenv import load_dotenv

from google.adk.sessions import InMemorySessionService
from google.adk.runners import Runner
from google.adk.agents import Agent
from google.adk.tools.tool_context import ToolContext
from google.adk.tools.langchain_tool import LangchainTool
from langchain_community.tools import TavilySearchResults
from google.genai import types # For creating message Content/Parts

# --- Load Environment Variables ---
# Ensure you have a .env file in the parent directory with your keys
# Requires: pip install python-dotenv (or uv install python-dotenv)
load_dotenv()

# Check if keys are loaded (optional but good practice)
if not os.getenv("GOOGLE_API_KEY"):
    print("Warning: GOOGLE_API_KEY environment variable not set.")
if not os.getenv("TAVILY_API_KEY"):
    print("Warning: TAVILY_API_KEY environment variable not set.")

# --- Tool Definitions ---

def remember_something(data_to_remember: str, tool_context: ToolContext) -> dict:
    """
    Reads previous data from state ('user_data') and saves new data
    to the same state key. Used to demonstrate agent memory.
    """
    print("--- Tool: remember_something called ---")
    # Read from state (use .get() for safety, provide default)
    previous_data = tool_context.state.get("user_data", "nothing")
    print(f"--- Tool: Found previous data in state['user_data']: '{previous_data}' ---")

    # Write new data to state
    tool_context.state["user_data"] = data_to_remember
    print(f"--- Tool: Saved new data to state['user_data']: '{data_to_remember}' ---")

    return {"status": "success", "message": f"Okay, I've noted down '{data_to_remember}'. Before that, I had noted '{previous_data}'."}

# --- Tool Setup ---

# Instantiate the LangChain Tavily tool
tavily_search_tool_instance = TavilySearchResults(
    max_results=3,             # Limit the number of search results
    include_answer=True        # Ask Tavily to provide a direct answer if possible
)

# Wrap it with ADK's LangchainTool for compatibility
adk_tavily_tool = LangchainTool(tool=tavily_search_tool_instance)

print("Tavily search tool wrapped for ADK.")

# --- Agent Definition ---

root_agent = Agent(
    name="my_adk_agent_with_tools",
    # Ensure this model is available with your GOOGLE_API_KEY (AI Studio)
    model="gemini-2.0-flash-exp", # Or gemini-1.0-pro, etc.
    description="A helpful assistant that can search the web using Tavily and remember user data.",
    instruction="""You are a friendly and helpful assistant.
1. If the user asks for information that might require up-to-date details, recent events, or specific web searching, use the 'TavilySearchResults' tool.
2. If the user asks you to remember something specific, use the 'remember_something' tool to save it. Also mention what was previously remembered if anything.
3. Use information remembered earlier (from session state) if relevant to the current query.
4. Otherwise, answer directly based on your general knowledge.""",

    # Include both tools the agent can use
    tools=[adk_tavily_tool, remember_something]
)

print(f"Agent '{root_agent.name}' defined with tools.")

# --- Session and Runner Setup ---

APP_NAME = "my_first_adk_app"
USER_ID = "user_dev_1" # Identifier for the user
SESSION_ID = "session_main_1" # Identifier for this specific conversation

# Create the Session Service instance (stores memory)
session_service = InMemorySessionService()
print("Session Service created.")

# Create the specific session for this user and app
session = session_service.create_session(
    app_name=APP_NAME,
    user_id=USER_ID,
    session_id=SESSION_ID
    # state={"user_data": "initial value"} # Optional: prime the state memory
)
print(f"Session '{SESSION_ID}' created.")

# Create the Runner instance (orchestrates agent execution)
runner = Runner(
    agent=root_agent,
    app_name=APP_NAME,
    session_service=session_service
)
print(f"Runner created for agent '{root_agent.name}'.")

# --- Interaction Logic ---

async def run_conversation():
    """Runs a simple interactive loop to chat with the agent."""
    print("\n--- Starting Conversation (type 'quit' to exit) ---")
    while True:
        try:
            user_query = input("You: ")
            if user_query.lower() == 'quit':
                print("Exiting conversation.")
                break

            # Prepare the user message in ADK format
            content = types.Content(role='user', parts=[types.Part(text=user_query)])

            final_response_text = "Agent did not produce a final response."

            # Use run_async to process the message and get events
            async for event in runner.run_async(user_id=USER_ID, session_id=SESSION_ID, new_message=content):
                # You can uncomment below to see all events (tool calls, etc.)
                # print(f"  [Event] Author: {event.author}, Type: {type(event).__name__}, Final: {event.is_final_response()}")

                # Look for the final response event
                if event.is_final_response():
                    if event.content and event.content.parts:
                        # Assuming text response in the first part
                        final_response_text = event.content.parts[0].text
                    elif event.actions and event.actions.escalate:
                        final_response_text = f"Agent escalated: {event.error_message or 'No specific message.'}"
                    break # Stop processing events for this turn

            print(f"Agent: {final_response_text}")

            # Optional: Print current state for debugging
            # current_session = session_service.get_session(APP_NAME, USER_ID, SESSION_ID)
            # print(f"  (Debug State: {current_session.state})")

        except Exception as e:
            print(f"An error occurred: {e}")

# --- Run the Application ---

if __name__ == "__main__":
    # Check dependencies are installed
    try:
        import langchain_community
        import tavily
    except ImportError:
        print("Error: Missing dependencies. Please run:")
        print("uv add langchain_community tavily-python python-dotenv")
        exit()

    # Run the asynchronous conversation loop
    try:
        asyncio.run(run_conversation())
    except RuntimeError as e:
         # Handle specific error when running asyncio.run in an already running loop (like Jupyter/Colab)
        if "cannot be called from a running event loop" in str(e):
            print("\nCannot start a new event loop. If in a Jupyter Notebook, run:")
            print("await run_conversation()")
        else:
            raise e # Re-raise other runtime errors

Ejecutar en la terminal

Puedes usar la terminal para ejecutar la herramienta, con:

uv run python -m agent_module.agent

Esto producirá algo como:

Tavily search tool wrapped for ADK.
Agent 'my_adk_agent_with_tools' defined with tools.
Session Service created.
Session 'session_main_1' created.
Runner created for agent 'my_adk_agent_with_tools'.
<frozen runpy>:128: RuntimeWarning: 'agent_module.agent' found in sys.modules after import of package 'agent_module', but prior to execution of 'agent_module.agent'; this may result in unpredictable behaviour
Tavily search tool wrapped for ADK.
Agent 'my_adk_agent_with_tools' defined with tools.
Session Service created.
Session 'session_main_1' created.
Runner created for agent 'my_adk_agent_with_tools'.

--- Starting Conversation (type 'quit' to exit) ---
You: what are the latest news on tech in april 2025
Warning: there are non-text parts in the response: ['function_call'],returning concatenated text result from text parts,check out the non text parts for full response from model.
Agent: In April 2025, some of the biggest tech news included: Apple releasing new software updates, Amazon developing an AI model to enhance customer experience, Google announcing a quantum computing breakthrough, and NVIDIA advancing confidential computing on its Blackwell infrastructure.

You:

Conclusión

¡Enhorabuena! Has construido con éxito tu primer agente de IA usando Google Agent Development Kit. Hemos repasado los pasos esenciales:

• Configurar tu entorno de desarrollo usando uv para la gestión de paquetes.
• Conectar tu agente a los potentes modelos Gemini mediante una clave de API de Google AI Studio.
• Definir una estructura básica de agente con su identidad e instrucciones principales.
• Añadir memoria usando Session State, habilitando conversaciones contextuales.
• Integrar una herramienta de terceros (búsqueda Tavily) usando los wrappers de ADK, dando a tu agente acceso a información web en tiempo real.

Este recorrido demuestra la flexibilidad y la potencia de ADK. Has visto lo rápido que puedes poner en marcha un agente básico y lo fácil que es mejorarlo con memoria y herramientas externas. ADK proporciona los bloques de construcción para todo, desde bots simples hasta sistemas multiagente complejos capaces de una orquestación sofisticada y de aprovechar un rico ecosistema de herramientas.

¿A dónde ir ahora?

Tu primer agente es solo el principio. Aquí tienes algunas ideas para seguir explorando ADK:

• Explora los tutoriales: profundiza en conceptos como la delegación multiagente, la gestión avanzada del estado y los callbacks de seguridad siguiendo los tutoriales oficiales de ADK.
• Integra APIs reales: sustituye los datos de ejemplo o las herramientas simples por APIs del mundo real para el tiempo, finanzas u otros servicios.
• Añade más herramientas: experimenta con otras herramientas integradas como Code Execution o Vertex AI Search, o integra más herramientas de LangChain o CrewAi.
• Construye equipos de agentes: diseña sistemas con varios agentes especializados que colaboren en tareas.
• Memoria persistente: investiga cómo almacenar el estado de la sesión de forma más permanente usando bases de datos en lugar de solo memoria.
• Revisa los ejemplos: echa un vistazo a los ADK Sample Agents para más ejemplos.

La documentación oficial de ADK es tu recurso completo para todas las funciones, referencias de API y guías avanzadas.

Ahora tienes una base sólida para construir agentes inteligentes y capaces con Google Agent Development Kit. ¡Feliz construcción!