Tutorial de Google ADK: Construye Agentes de IA de Cero a Producción

Tutorial de Google ADK: Construye Agentes de IA de Cero a Producción

El Agent Development Kit (ADK) de Google es el framework que por fin hace que los sistemas multi-agente se sientan accesibles. Si has estado construyendo agentes de IA con LangChain o CrewAI y sentías que peleabas más con el framework que construyendo con él, este tutorial de Google ADK te guía por todo el proceso: desde tu primer agente hasta desplegarlo en Cloud Run.

¿Qué Es Google ADK (Y Por Qué Debería Importarte)?

El Agent Development Kit (ADK) de Google es un framework Python de código abierto para construir, evaluar y desplegar agentes de IA. Lanzado en 2025, está optimizado para Gemini pero admite más de 100 modelos a través de LiteLLM. La característica diferenciadora de ADK es la orquestación multi-agente nativa: agentes que delegan tareas a otros agentes sin código de pegamento.

Después de construir agentes con LangChain, CrewAI y ahora ADK, esto es lo que destaca: ADK es dogmático en los lugares correctos. Te da una estructura de proyecto, una interfaz de desarrollo integrada y un comando de despliegue. No tienes que ensamblar cinco librerías para poner en marcha un agente básico.

Si LangChain es una navaja suiza de propósito general, ADK es el kit especializado de Google para flujos de trabajo multi-agente. CrewAI es más cercano en filosofía —agentes basados en roles que colaboran— pero ADK va más lejos con evaluación integrada, optimización nativa para Gemini y despliegue a Cloud Run con un solo comando. Para un análisis más profundo, consulta nuestra comparativa detallada de frameworks de agentes.

¿Para quién es ADK? Para desarrolladores de Python que quieren sistemas multi-agente estructurados. Para equipos que ya trabajan con Google Cloud o Gemini. Para cualquiera que esté cansado de escribir lógica de orquestación desde cero.

Así es cómo se comparan los frameworks de un vistazo:

La versión corta: si quieres el camino más rápido de "idea" a "sistema multi-agente desplegado", ADK es difícil de superar ahora mismo.

Requisitos Previos e Instalación de Google ADK

Para empezar con Google ADK, necesitas Python 3.9+, una clave de API de Gemini (nivel gratuito disponible en Google AI Studio) y el paquete google-adk. Instálalo con pip install google-adk, establece tu clave de API como variable de entorno y estarás listo para construir tu primer agente en menos de 5 minutos.

Esta es tu lista de verificación de configuración:

• Python 3.9+ (se recomienda 3.10+ para soporte completo de type hints)
• Una clave de API de Gemini -- consigue una gratis en aistudio.google.com. El nivel gratuito te da 15 solicitudes por minuto, más que suficiente para desarrollo.
• pip (o uv si prefieres velocidad -- uv pip install google-adk también funciona)

Instala el paquete y configura tu clave:

pip install google-adk

# Establece tu clave de API (añade a .bashrc/.zshrc para persistencia)
export GOOGLE_API_KEY="tu-clave-api-aqui"

ADK espera una estructura de carpetas específica. Cada agente vive en su propio directorio de paquete:

mi_agente/
  __init__.py    # Exporta root_agent
  agent.py       # Definición del agente
.env             # Opcional: GOOGLE_API_KEY=tu-clave

El nombre de la carpeta se convierte en el nombre del paquete de tu agente, así que elige algo descriptivo. No lo llames test ni agent -- confundirás el sistema de imports de Python.

Consejo profesional: Si usas uv, crea primero un entorno virtual con uv venv && source .venv/bin/activate. Es notablemente más rápido que pip normal para la resolución de dependencias.

Construyendo Tu Primer Agente con Google ADK

Tu primer agente ADK solo necesita tres cosas: un nombre, un modelo (como gemini-2.0-flash) y una cadena de instrucciones. Defínelo en agent.py, colócalo dentro de una carpeta con un __init__.py y ejecuta adk web para interactuar con él en una interfaz de navegador. La configuración completa requiere unas 10 líneas de Python.

Crea una carpeta llamada mi_agente y añade dos archivos. Primero, la definición del agente:

# mi_agente/agent.py
from google.adk.agents import LlmAgent

root_agent = LlmAgent(
    name="my_assistant",
    model="gemini-2.0-flash",
    instruction="""You are a helpful coding assistant. 
    You explain concepts clearly and provide working code examples.
    Keep responses concise but thorough.""",
    description="A coding assistant that explains concepts and writes code"
)

Luego el archivo init que exporta tu agente:

# mi_agente/__init__.py
from .agent import root_agent

Ese nombre de variable importa -- ADK busca específicamente root_agent. Si lo omites, obtendrás un error de "agent not found" que no explica por qué.

Ahora ejecútalo. Tienes dos opciones:

# Modo CLI -- chatea en tu terminal
adk run mi_agente

# Modo interfaz web -- abre una interfaz de navegador
adk web mi_agente

La interfaz adk web es genuinamente útil. Te muestra el rastro completo de la conversación: qué herramientas llamó el agente, qué recibió el modelo y qué devolvió. Piensa en ella como las DevTools de Chrome para tu agente. Cuando empieces a construir sistemas multi-agente, esto se vuelve esencial para entender el flujo de delegación.

Prueba modificar la instrucción para ver cómo cambia el comportamiento. Conviértelo en un pirata. Haz que solo responda en haiku. Familiarizarse con cómo las instrucciones moldean el comportamiento es la base de todo lo demás en este tutorial.

Añadir Herramientas Personalizadas a Tu Agente Google ADK

Los agentes ADK se vuelven útiles cuando les das herramientas. Define una función Python con un docstring claro y ADK la convierte automáticamente en una herramienta que el agente puede llamar. El docstring es crítico -- le dice al modelo qué hace la herramienta y cuándo usarla. ADK también incluye herramientas integradas como Google Search y ejecución de código.

Las herramientas son las manos de un agente. Sin ellas, tu agente solo puede hablar. Con ellas, puede consultar bases de datos, llamar a APIs, ejecutar cálculos e interactuar con sistemas externos. Si quieres entender cómo funciona el function calling bajo el capó, tenemos un análisis separado sobre eso.

Herramientas de Función Personalizadas

Aquí hay un ejemplo práctico -- una herramienta que consulta precios de acciones:

# mi_agente/agent.py
from google.adk.agents import LlmAgent

def get_stock_price(ticker: str) -> dict:
    """Get the current stock price for a given ticker symbol.
    
    Args:
        ticker: The stock ticker symbol (e.g., 'AAPL', 'GOOGL', 'MSFT')
    
    Returns:
        A dictionary with the ticker and its current price.
    """
    # En producción, aquí llamarías a una API real
    mock_prices = {"AAPL": 198.50, "GOOGL": 175.20, "MSFT": 425.80}
    price = mock_prices.get(ticker.upper(), None)
    if price:
        return {"ticker": ticker.upper(), "price": price, "currency": "USD"}
    return {"error": f"Ticker {ticker} not found"}

root_agent = LlmAgent(
    name="finance_assistant",
    model="gemini-2.0-flash",
    instruction="You help users check stock prices. Use the get_stock_price tool when asked about any stock.",
    tools=[get_stock_price],
    description="A financial assistant that looks up stock prices"
)

Fíjate en los type hints y el docstring. No son opcionales -- ADK los usa para generar el esquema de herramienta que ve el modelo. Omite el docstring y el modelo no sabrá cuándo llamar tu función. Omite los type hints y obtendrás un error de firma.

Herramientas Integradas (Google Search, Ejecución de Código)

ADK incluye herramientas que puedes usar sin escribir ningún código:

from google.adk.agents import LlmAgent
from google.adk.tools import google_search, code_execution

root_agent = LlmAgent(
    name="research_agent",
    model="gemini-2.0-flash",
    instruction="You research topics using Google Search and can run Python code to analyze data.",
    tools=[google_search, code_execution],
    description="A research agent with search and code execution capabilities"
)

google_search permite al agente consultar la web en tiempo real. code_execution le da un entorno Python aislado para ejecutar cálculos. Estas dos solas cubren un número sorprendente de casos de uso.

Sistemas Multi-Agente: Cómo los Agentes ADK Delegan Trabajo

El sistema multi-agente de ADK usa un agente raíz que delega tareas a sub-agentes especializados. Cada sub-agente maneja un dominio: investigación, redacción, programación. El agente raíz decide a qué sub-agente llamar según la solicitud del usuario. También puedes usar el patrón agente-como-herramienta, donde un agente llama a otro como si fuera una función. El blog oficial de Google sobre sistemas multi-agente profundiza en los patrones arquitectónicos.

Piensa en ello como un gerente de proyecto que delega a especialistas. El agente raíz lee la solicitud del usuario, determina qué especialista debe manejarla y la enruta en consecuencia. Los especialistas no se conocen entre sí -- simplemente hacen su trabajo y reportan.

Patrón Agente Raíz + Sub-Agentes

Aquí hay un ejemplo funcional con un agente raíz que delega a un agente de investigación y un agente de redacción:

from google.adk.agents import LlmAgent
from google.adk.tools import google_search

# Sub-agente 1: maneja investigación
research_agent = LlmAgent(
    name="researcher",
    model="gemini-2.0-flash",
    instruction="You research topics thoroughly using Google Search. Return factual, well-sourced information.",
    tools=[google_search],
    description="Researches topics and returns factual information"
)

# Sub-agente 2: maneja redacción
writing_agent = LlmAgent(
    name="writer",
    model="gemini-2.0-flash",
    instruction="You write clear, engaging content based on provided information. Focus on readability and accuracy.",
    description="Writes polished content from research notes"
)

# Agente raíz: delega al sub-agente correcto
root_agent = LlmAgent(
    name="content_manager",
    model="gemini-2.0-flash",
    instruction="""You manage content creation. 
    - When the user wants information gathered, delegate to the researcher.
    - When the user wants content written or edited, delegate to the writer.
    - You can chain both: research first, then write.""",
    sub_agents=[research_agent, writing_agent],
    description="Manages content creation by delegating to research and writing specialists"
)

El campo description en cada sub-agente es cómo el agente raíz entiende qué pueden hacer. Escribe descripciones claras -- las vagas llevan a malas decisiones de enrutamiento.

Patrón Agente-como-Herramienta

A veces quieres más control sobre cómo un agente llama a otro. El patrón agente-como-herramienta envuelve un sub-agente como una herramienta invocable:

from google.adk.tools import agent_tool

research_tool = agent_tool.AgentTool(agent=research_agent)

root_agent = LlmAgent(
    name="writer_with_research",
    model="gemini-2.0-flash",
    instruction="You write articles. Use the research tool to gather facts before writing.",
    tools=[research_tool],
    description="A writer that can research topics on demand"
)

Usa sub-agentes cuando quieras que el agente raíz delegue el control completamente. Usa agente-como-herramienta cuando quieras que el agente que llama mantenga el control y solo use la salida del sub-agente como entrada. Si construyes sistemas donde los agentes necesitan contexto compartido, consulta nuestra guía completa sobre arquitecturas de memoria para agentes.

Agentes de Flujo de Trabajo: Secuencial, Paralelo y Bucle

Más allá de la delegación impulsada por LLM, ADK ofrece tres tipos de agentes de flujo de trabajo para orquestación determinista: SequentialAgent ejecuta sub-agentes uno tras otro, ParallelAgent los ejecuta simultáneamente y LoopAgent repite una secuencia hasta que se cumple una condición. Son útiles cuando necesitas un orden de ejecución predecible en lugar de dejar que el LLM decida.

La distinción importa. La delegación impulsada por LLM (el patrón sub_agents de arriba) deja que el modelo elija a quién llamar. Los agentes de flujo de trabajo te dan control programático. Usa agentes de flujo de trabajo cuando el orden de ejecución se conoce de antemano.

from google.adk.agents import SequentialAgent, ParallelAgent, LlmAgent

# Tres agentes que deben ejecutarse en orden
research_agent = LlmAgent(name="researcher", model="gemini-2.0-flash",
    instruction="Research the given topic.", description="Researches topics")
    
draft_agent = LlmAgent(name="drafter", model="gemini-2.0-flash",
    instruction="Write a draft based on the research.", description="Writes drafts")
    
review_agent = LlmAgent(name="reviewer", model="gemini-2.0-flash",
    instruction="Review the draft for accuracy and clarity.", description="Reviews content")

# Pipeline: investigación -> borrador -> revisión
content_pipeline = SequentialAgent(
    name="content_pipeline",
    sub_agents=[research_agent, draft_agent, review_agent],
    description="Runs a complete content creation pipeline"
)

Para tareas independientes que pueden ejecutarse al mismo tiempo, ParallelAgent ahorra tiempo real:

# Tres recopiladores de datos que se ejecutan concurrentemente
fetch_news = LlmAgent(name="news_fetcher", model="gemini-2.0-flash",
    instruction="Fetch latest tech news.", description="Fetches news")
    
fetch_stocks = LlmAgent(name="stock_fetcher", model="gemini-2.0-flash",
    instruction="Fetch stock market summary.", description="Fetches stocks")
    
fetch_weather = LlmAgent(name="weather_fetcher", model="gemini-2.0-flash",
    instruction="Fetch weather forecast.", description="Fetches weather")

morning_briefing = ParallelAgent(
    name="morning_briefing",
    sub_agents=[fetch_news, fetch_stocks, fetch_weather],
    description="Gathers morning briefing data in parallel"
)

Gestión de Estado y Memoria

ADK gestiona el estado del agente en dos niveles: estado de sesión (datos dentro de una conversación, como preferencias de usuario recopiladas durante el chat) y servicios de memoria (datos que persisten entre conversaciones). El estado de sesión es un almacén clave-valor simple al que se accede con context.state. La memoria usa servicios como InMemoryMemoryService o VertexAIMemoryBankService para producción.

El estado de sesión es el más simple. Es un diccionario adjunto a cada conversación:

from google.adk.agents import LlmAgent

def save_preference(key: str, value: str, context) -> str:
    """Save a user preference to session state.
    
    Args:
        key: The preference name (e.g., 'language', 'theme')
        value: The preference value
        context: The ADK context object
    
    Returns:
        Confirmation message
    """
    context.state[key] = value
    return f"Saved preference: {key} = {value}"

def get_preference(key: str, context) -> str:
    """Retrieve a user preference from session state.
    
    Args:
        key: The preference name to look up
        context: The ADK context object
    
    Returns:
        The preference value or a not-found message
    """
    value = context.state.get(key, "Not set")
    return f"{key} = {value}"

root_agent = LlmAgent(
    name="personalized_assistant",
    model="gemini-2.0-flash",
    instruction="You remember user preferences. Save them when told, recall them when asked.",
    tools=[save_preference, get_preference],
    description="An assistant that remembers user preferences"
)

Para memoria entre conversaciones -- del tipo donde tu agente recuerda a un usuario del martes pasado -- necesitas un servicio de memoria:

from google.adk.memory import InMemoryMemoryService

# Para desarrollo (los datos se pierden al reiniciar)
memory_service = InMemoryMemoryService()

# Para producción, usa VertexAIMemoryBankService
# memory_service = VertexAIMemoryBankService(project="tu-proyecto")

¿Cuándo necesitas memoria versus estado de sesión? Si está dentro de una sola conversación (carrito de compras, contexto de tarea actual), usa estado de sesión. Si necesita sobrevivir entre conversaciones (preferencias del usuario, interacciones pasadas), usa un servicio de memoria. Consulta nuestra guía completa sobre arquitecturas de memoria para agentes para patrones de producción.

Callbacks: Controlando el Comportamiento del Agente

Los callbacks de ADK te permiten interceptar y modificar el comportamiento del agente en cuatro puntos: before_model_callback (antes de la llamada al LLM), after_model_callback (después de la respuesta del LLM), before_tool_callback (antes de la ejecución de la herramienta) y after_tool_callback (después del resultado de la herramienta). Úsalos para validación de entradas, filtrado de seguridad, registro o modificación de respuestas antes de que lleguen al usuario.

Los callbacks son donde añades las barandillas. Piensa en ellos como middleware para tu agente -- cada solicitud y respuesta pasa por ellos, y puedes inspeccionar, modificar o bloquear cualquier cosa.

from google.adk.agents import LlmAgent

def safety_filter(callback_context, llm_request):
    """Block requests containing harmful content patterns."""
    user_message = str(llm_request)
    blocked_patterns = ["ignore your instructions", "pretend you are"]
    
    for pattern in blocked_patterns:
        if pattern.lower() in user_message.lower():
            # Devuelve una respuesta directamente, omitiendo la llamada al modelo
            return {"blocked": True, "reason": "Request matched safety filter"}
    
    # Devuelve None para continuar normalmente
    return None

def log_tool_usage(callback_context, tool_name, tool_result):
    """Log every tool call for monitoring."""
    print(f"[TOOL LOG] {tool_name}: {tool_result}")
    return None  # No modifica el resultado

root_agent = LlmAgent(
    name="safe_assistant",
    model="gemini-2.0-flash",
    instruction="You are a helpful assistant.",
    before_model_callback=safety_filter,
    after_tool_callback=log_tool_usage,
    description="A safety-filtered assistant with tool logging"
)

El before_model_callback es el más importante para producción. Se ejecuta antes de cada llamada al LLM, dándote la oportunidad de bloquear inyecciones de prompts, validar entradas o añadir contexto del sistema. Si devuelves un objeto de respuesta, ADK omite el modelo completamente. Devuelve None para dejar pasar la solicitud. Para más patrones, consulta patrones avanzados de salvaguardas para LLM.

Pruebas y Evaluación de Tus Agentes ADK

ADK incluye un framework de evaluación integrado con dos tipos de evaluadores: ResponseEvaluator verifica si la respuesta final del agente es correcta, y TrajectoryEvaluator verifica que el agente siguió los pasos correctos -- llamó a las herramientas adecuadas en el orden correcto. Escribe casos de prueba como archivos JSON y ejecútalos con pytest para detectar regresiones antes del despliegue.

¿Por qué molestarse en probar agentes? Porque son no deterministas. La misma entrada puede producir salidas diferentes, y un pequeño cambio en tus instrucciones puede romper el llamado a herramientas de formas sutiles. En nuestra experiencia, los agentes que pasan la evaluación de trayectoria son mucho más confiables en producción que los probados únicamente en la calidad de la salida final. Para estrategias de evaluación más amplias, consulta nuestra guía de estrategias de evaluación para LLM.

Tus casos de prueba van en un archivo JSON:

[
  {
    "input": "What's the stock price of AAPL?",
    "expected_output": "198.50",
    "expected_trajectory": [
      {"tool_name": "get_stock_price", "args": {"ticker": "AAPL"}}
    ]
  },
  {
    "input": "Compare AAPL and GOOGL prices",
    "expected_output": "AAPL.*198.*GOOGL.*175",
    "expected_trajectory": [
      {"tool_name": "get_stock_price", "args": {"ticker": "AAPL"}},
      {"tool_name": "get_stock_price", "args": {"ticker": "GOOGL"}}
    ]
  }
]

Luego ejecuta las evaluaciones con pytest. El repositorio Python de ADK tiene la referencia completa de la API de evaluación:

# test_agent.py
import pytest
from google.adk.evaluation import ResponseEvaluator, TrajectoryEvaluator

def test_stock_agent_response():
    evaluator = ResponseEvaluator(agent=root_agent)
    results = evaluator.evaluate("test_cases.json")
    
    assert results.pass_rate >= 0.8, f"Response pass rate too low: {results.pass_rate}"

def test_stock_agent_trajectory():
    evaluator = TrajectoryEvaluator(agent=root_agent)
    results = evaluator.evaluate("test_cases.json")
    
    assert results.pass_rate >= 0.9, f"Trajectory pass rate too low: {results.pass_rate}"

Ejecuta con pytest test_agent.py -v. Establece tus umbrales según la criticidad -- un 80% de precisión en respuestas puede estar bien para un agente de escritura creativa, pero querrías 95%+ para cualquier cosa que maneje datos financieros.

Desplegar Tu Agente Google ADK a Producción

Despliega tu agente ADK en Google Cloud Run con un comando: adk deploy cloud_run --project TU_PROYECTO --region us-central1. ADK empaqueta tu código, construye un contenedor y lanza un endpoint serverless. Para alojamiento gestionado, usa Vertex AI Agent Engine. Para infraestructura personalizada, ADK también admite contenedores Docker.

Hemos desplegado agentes ADK en Cloud Run para herramientas internas, y los tiempos de arranque en frío son sorprendentemente rápidos -- menos de 3 segundos para un agente básico. Para sistemas de producción, considera combinar tu despliegue con herramientas de monitoreo para agentes en producción.

Desplegar en Cloud Run (Recomendado para la Mayoría)

Cloud Run es el camino más sencillo. Un comando y tu agente está activo con un endpoint HTTPS:

adk deploy cloud_run \
  --project tu-id-de-proyecto-gcp \
  --region us-central1 \
  --service-name mi-servicio-agente \
  --with_ui

El flag --with_ui despliega la interfaz web de ADK junto con tu agente, para que tengas un chat basado en navegador para pruebas en producción. Por detrás, ADK construye una imagen de contenedor, la sube a Google Artifact Registry y crea un servicio Cloud Run. El flujo completo de despliegue está documentado en el inicio rápido de Cloud Run para ADK de Google.

Para infraestructura personalizada, aquí hay un Dockerfile mínimo:

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
EXPOSE 8080
CMD ["adk", "api_server", "--port", "8080", "mi_agente"]

Alternativa: Vertex AI Agent Engine

Para equipos empresariales que necesitan escalado gestionado, monitoreo y versionado, Vertex AI Agent Engine se ocupa completamente de la infraestructura. Cambias flexibilidad por conveniencia -- sin contenedores que gestionar, escalado automático y analíticas integradas.

Consideraciones de Costos

Números reales que deberías conocer:

• Nivel gratuito de Gemini API: 15 solicitudes por minuto, 1 millón de tokens/día. Suficiente para desarrollo y demostraciones ligeras.
• Gemini 2.0 Flash (de pago): $0.10 por millón de tokens de entrada, $0.40 por millón de tokens de salida. Lo bastante barato para producción.
• Nivel gratuito de Cloud Run: 2 millones de solicitudes/mes, 360.000 GB-segundos de cómputo. Un agente básico que maneja 1.000 solicitudes/día se mantiene bien dentro del nivel gratuito.
• Consejo de optimización: Usa gemini-2.0-flash (no gemini-2.0-pro) para sub-agentes que hacen enrutamiento simple o formateo. Reserva los modelos más capaces para agentes que hacen razonamiento complejo.

Cómo Abordamos el Desarrollo de Agentes de IA en Techsy

En Techsy, hemos construido sistemas multi-agente para clientes usando ADK, LangGraph y CrewAI. La elección del framework depende de tu stack: si ya estás en Google Cloud, ADK elimina mucha fricción de integración. Si necesitas soporte multi-proveedor de LLM desde el primer día, LangGraph te da más flexibilidad.

Nuestro compromiso típico empieza con consultoría de arquitectura -- mapear tu caso de uso a los patrones de agentes correctos -- seguida de desarrollo de prototipo y despliegue en Cloud Run. Hemos visto que los equipos ahorran 2-3 semanas cuando definen bien la arquitectura desde el principio en lugar de refactorizar después.

¿Construyendo agentes de IA para tu equipo? Obtén una consulta gratuita -- te ayudaremos a elegir el framework y la estrategia de despliegue correctos.

Errores Comunes y Resolución de Problemas

Estos son los errores que encontramos con más frecuencia al empezar con ADK. Ahórrate el tiempo de depuración:

Consejo de depuración: adk web es tu mejor aliado aquí. Muestra el rastro completo de la conversación -- cada llamada al modelo, invocación de herramienta y delegación entre agentes -- en tiempo real. Cuando algo sale mal en un sistema multi-agente, la interfaz web te muestra exactamente dónde se rompió la cadena.

Preguntas Frecuentes

¿Qué es Google ADK?

El Agent Development Kit (ADK) de Google es un framework Python de código abierto para construir, evaluar y desplegar agentes de IA. Está optimizado para los modelos Google Gemini pero admite más de 100 LLMs a través de la integración con LiteLLM. La fortaleza central de ADK es la orquestación multi-agente nativa con herramientas integradas, una interfaz de desarrollo y despliegue a Cloud Run con un solo comando.

¿Es Google ADK gratuito?

Sí. ADK en sí es de código abierto bajo la licencia Apache 2.0. Necesitas una clave de API de Gemini, que tiene un nivel gratuito con 15 solicitudes por minuto y 1 millón de tokens por día. Los costos de despliegue en la nube dependen de tu elección de alojamiento -- el nivel gratuito de Cloud Run cubre 2 millones de solicitudes por mes.

¿Cuál es la diferencia entre Google ADK y LangChain?

ADK es el framework dogmático de Google optimizado para Gemini con orquestación multi-agente nativa y herramientas de despliegue integradas. LangChain es agnóstico al modelo, con integraciones de terceros más amplias pero significativamente más complejidad. ADK es mejor para equipos centrados en Gemini que quieren un despliegue rápido; LangChain es adecuado para configuraciones multi-proveedor que necesitan máxima flexibilidad.

¿Google ADK admite sistemas multi-agente?

Sí, y es la característica principal de ADK. Creas un agente raíz que delega a sub-agentes especializados según las solicitudes del usuario. ADK también ofrece SequentialAgent, ParallelAgent y LoopAgent para orquestación determinista de flujos de trabajo. El patrón agente-como-herramienta permite que los agentes llamen a otros agentes como funciones invocables.

¿Cómo despliego un agente Google ADK?

Ejecuta adk deploy cloud_run --project TU_PROYECTO --region us-central1 para el despliegue serverless en Google Cloud Run. Añade --with_ui para incluir la interfaz de chat basada en navegador. También puedes desplegar en Vertex AI Agent Engine para alojamiento gestionado, o construir un contenedor Docker para infraestructura personalizada.

¿Puede Google ADK usar modelos distintos a Gemini?

Sí. ADK admite más de 100 modelos a través de la integración con LiteLLM, incluidos Anthropic Claude, OpenAI GPT-4, Meta Llama y Mistral. Establece el parámetro del modelo a la cadena de modelo de LiteLLM -- por ejemplo, litellm/anthropic/claude-3-sonnet o litellm/openai/gpt-4o. Los modelos Gemini funcionan de forma nativa sin el prefijo LiteLLM.

¿Qué es la interfaz web de ADK?

Una interfaz de depuración basada en navegador que se lanza con adk web carpeta_de_tu_agente. Muestra rastros de conversación en tiempo real, llamadas a herramientas, cadenas de delegación entre agentes y cambios de estado a medida que ocurren. La interfaz web es esencial para depurar sistemas multi-agente porque muestra exactamente qué sub-agente manejó cada solicitud.

¿Google ADK admite MCP (Model Context Protocol)?

Sí. ADK tiene soporte nativo para Model Context Protocol, lo que permite a los agentes conectarse a cualquier servidor de herramientas compatible con MCP para obtener herramientas y fuentes de datos externas. Esto hace que los agentes ADK sean interoperables con el creciente ecosistema MCP. Para información de fondo sobre el protocolo, consulta nuestra guía sobre MCP.

¿Cómo pruebo los agentes ADK?

ADK incluye evaluadores integrados: ResponseEvaluator para verificar la calidad de la salida frente a respuestas esperadas, y TrajectoryEvaluator para verificar que el agente llamó a las herramientas correctas en el orden correcto. Escribe casos de prueba como archivos JSON que definen entradas, salidas esperadas y secuencias esperadas de llamadas a herramientas, y luego ejecútalos con pytest.

¿Qué versión de Python requiere Google ADK?

ADK requiere Python 3.9 o superior. Se recomienda Python 3.10+ para soporte completo de type hinting, lo que importa porque ADK usa type hints para generar esquemas de herramientas. Python 3.11 o 3.12 también ofrecen mejoras de rendimiento significativas para cargas de trabajo de agentes. Instala con pip install google-adk.