Google ADK vs Strands: guía técnica y despliegue en AWS
Resumen
Hace poco hice el curso de Agentes de la Academia GEAR de Google, donde experimenté con sesiones, state, tools, modelos locales y ejecución de código. En este artículo comparo Google ADK con Strands Agents a partir de un mismo caso real, un pipeline multiagente que construye un knowledge graph.
También muestro cómo desplegarlo en Amazon Bedrock AgentCore con Terraform, cómo invocarlo y los resultados.
Introducción
Google ADK y Strands Agents (cuyo SDK hoy la documentación llama Strands Harness SDK) son dos frameworks open source para construir agentes de IA en Python, y los dos corren en AWS.
La diferencia está en cómo piensan el problema: ADK pone primero la estructura (un grafo de nodos y aristas que se define en código) y trae un entorno de desarrollo visual, mientras que Strands parte de un agente que decide con el modelo y suma patrones (Graph, Swarm, Workflow) cuando hace falta estructura.
En este artículo comparo los dos con un caso real, el mismo pipeline multiagente que construí con Strands en una serie anterior, reescrito con ADK 2.12.0 y Amazon Nova vía Bedrock, y desplegado en AgentCore.
Conceptos clave de ADK
ADK (Agent Development Kit) es el framework open source de Google para construir, evaluar y desplegar agentes. Tiene SDKs en Python, TypeScript, Go, Java y Kotlin , está optimizado para Gemini y admite otros modelos mediante integraciones como LiteLLM, Ollama o vLLM.
Construir un agente con ADK
Un agente mínimo se crea en una carpeta con un agent.py que define root_agent , el único elemento obligatorio. Las tools son funciones Python con type hints y docstring. ADK las envuelve solo en un FunctionTool , y en ADK Python no existe el decorador @tool .
Para programar y ejecutar un ejemplo funcional en Python hacen falta tres cosas: Python 3.12 o superior. Un entorno virtual, para no mezclar dependencias con otros proyectos. Acceso a un modelo, que puede ser una API key de Gemini (se crea en Google AI Studio), un modelo local o Amazon Bedrock vía LiteLLM.
python -m venv .venv
source .venv/bin/activate # Windows (Git Bash): source .venv/Scripts/activate
pip install google-adk
Según lo que se use, hay extras que se instalan aparte:
pip install "google-adk[eval]"para adk eval y la pestaña Eval de adk web .pip install "google-adk[extensions]"para LiteLlm (Bedrock, Ollama y otros modelos que no son Gemini).
El comando adk create mi_agente crea una estructura mínima. Pregunta qué modelo se va a usar y guarda la configuración en el .env :
mi_agente/
├── __init__.py
├── agent.py # defines root_agent
└── .env
GOOGLE_API_KEY=tu_key_real
GOOGLE_GENAI_USE_VERTEXAI=FALSE
Con GOOGLE_GENAI_USE_VERTEXAI=TRUE , ADK ignora la API key y pide credenciales de Vertex AI.
Para probar, ejecutar desde la carpeta padre adk run mi_agente (consola) o adk web (navegador). Ambos cargan el .env solos; si en cambio se corre un script propio, hay que llamar a load_dotenv() antes de importar el agente.
from google . adk . agents import Agent
def get_capital_city ( country : str ) -> dict :
"""Retrieves the capital city for a given country."""
return { "status" : "success" , "capital" : "Paris" }
root_agent = Agent ( model = "gemini-flash-latest" , name = "geo_agent" , instruction = "Answer questions about country capitals." , tools = [ get_capital_city ] , )
Para usar un modelo que no es Gemini, como Amazon Nova en Bedrock, solo se cambia el model por un LiteLlm (requiere el extra [extensions] ). Las credenciales salen de la cadena estándar de AWS. Si el agente corre en tu máquina, usa el perfil configurado en la AWS CLI. Si está desplegado en AWS, usa el rol IAM que tiene asignado.
from google . adk . models . lite_llm import LiteLlm
root_agent = Agent ( model = LiteLlm ( model = "bedrock/us.amazon.nova-2-lite-v1:0" ) , . . . )
Las piezas que más se usan al pasar del prototipo a algo real:
- Concepto Qué es y cómo se usa Agente ( LlmAgent ) Agente que razona con un LLM. Se declara un model , instruction y tools Runner Motor que ejecuta el flujo de eventos entre agentes, modelo y tools. En scripts se usa run_async y create_session con await Sesión y state Historial y datos de la conversación. Prefijos de alcance: sin prefijo (sesión), user: , app: , temp: (un turno) output_key Guarda la respuesta del agente en el state. Otro agente la lee con {clave} en su instruction output_schema Respuesta JSON validada con un esquema Pydantic Servicios de sesión InMemorySessionService (no persiste), SQLite (el que usa adk web en local), DatabaseSessionService (base SQL) y VertexAiSessionService . Misma interfaz Callbacks Hooks antes y después de llamar al modelo. Sirven de guardrails ( before_model_callback , after_model_callback )
Estos tres detalles los descubrí realizando pequeñas pruebas:
En las plantillas de instruction , {topic} lanza KeyError si la clave no existe en el state y {topic?} la reemplaza por vacío ( state ). La tool google_search es grounding de Gemini: ADK valida que el modelo sea Gemini antes de usarla (con otro modelo no funciona). ADK permite combinar output_schema con tools , pero con Nova vía LiteLLM el modelo respondió directamente con el JSON sin llamar a la tool. LiteLlm declara que el modelo soporta las dos cosas juntas, así que ADK envía el esquema y las tools en la misma petición, y el modelo eligió el formato. Si un agente necesita usar tools, conviene que otro nodo se encargue de la salida estructurada.
Sesiones asíncronas
En ADK, el servicio de sesiones y el Runner son asíncronos. Mi primer script de prueba en el curso lo escribí con hábitos síncronos y no funcionaba por dos motivos: create_session es una corrutina: sin await devuelve un objeto pendiente y la sesión nunca se crea. La sesión que devuelve el servicio es una copia ( InMemorySessionService hace deepcopy ). Leer session.state de esa variable después de ejecutar el agente muestra el state viejo.
# Wrong: synchronous habits
session = session_service . create_session ( app_name = APP , user_id = USER , session_id = SID ) # coroutine, never awaited . . . print ( session . state ) # stale copy: does not show what the agent wrote
# Right: create, run and read the session again
await session_service . create_session ( app_name = APP , user_id = USER , session_id = SID )
async for event in runner . run_async ( user_id = USER , session_id = SID , new_message = message ) : . . .
session = await session_service . get_session ( app_name = APP , user_id = USER , session_id = SID )
print ( session . state ) # fresh copy, includes the agent's writes
En Strands con Python , invocar un agente es una llamada síncrona ( agent("...") ) y el session manager que se le pasa al crearlo guarda la conversación y el state por su cuenta. En ADK el control es explícito: se crea la sesión, se ejecuta y se vuelve a leer.
State: el prefijo define cuánto dura cada dato
El state de una sesión es un diccionario que comparten agentes, tools y nodos. El prefijo de la clave define su alcance:
- Prefijo Alcance Ejemplo de uso Sin prefijo La sesión actual El progreso de una tarea o un resultado que se va acumulando user: Todas las sesiones del mismo usuario Preferencias o datos del perfil app: Todos los usuarios y sesiones de la app Configuración global temp: Una sola invocación Datos intermedios que no hace falta guardar
def accumulate_graph ( ctx : Context , node_input ) :
ctx . state [ "kg_accumulated" ] = graph # session: the next message extends it
ctx . state [ "user:last_paper" ] = title # user: shared across this user's sessions
ctx . state [ "temp:partial_graphs" ] = parts # temp: discarded after this invocation
Con InMemorySessionService , todo esto vive en la memoria del proceso. Para que user: y app: sobrevivan a un reinicio hace falta un servicio persistente, como DatabaseSessionService .
adk web : la herramienta que marca la diferencia
adk web es una interfaz de desarrollo local, se levanta una app estilo chat en el navegador que muestra, para cada mensaje, el grafo del workflow, el state de la sesión, los eventos y las trazas con tokens y tiempos.
En la documentación de Strands no hay un equivalente. Más abajo muestro cómo se visualiza con el caso práctico.
Multiagente: grafos en ADK y patrones en Strands
ADK 2.x ofrece varias formas de coordinar agentes ( workflows ):
- Workflows basados en grafos ( Workflow ): nodos y aristas definidos en código. Un nodo puede ser un agente LLM, una función Python o una tool, y las aristas pueden tener rutas condicionales. Es la forma recomendada en ADK 2.x ( graphs ).
- Workflows dinámicos : la orquestación se escribe en código y los nodos se lanzan con ctx.run_node , por ejemplo uno por cada fragmento de un documento.
- Delegación guiada por el LLM : el agente padre transfiere el control a un sub-agente, o llama a otro agente como tool con AgentTool .
Las clases de plantilla SequentialAgent , ParallelAgent y LoopAgent todavía funcionan, pero en el código de ADK 2.12 están marcadas como deprecated. Si se arranca un proyecto nuevo, usar Workflow .
Strands ordena lo mismo en patrones: Agents as tools, Graph, Swarm y Workflow, más un wrapperpara implementar A2A que permite usar un agente remoto igual que uno local.
Lo que los distingue de acuerdo a mis prácticas, es cómo se determina el camino de ejecución: en Graph se definen nodos y aristas con condiciones opcionales, en Swarm los agentes se pasan el control por su cuenta de manera autonoma, y Workflow es un grafo de tareas con dependencias.
Para comparar los dos frameworks conviene ordenar sus mecanismos con una sola pregunta: ¿quién decide el siguiente paso? En un extremo lo decide el código escrito por el desarrollador; en el otro, el modelo en tiempo de ejecución.
Posición orientativa según la documentación oficial de cada framework. AgentTool (ADK) y Agents as tools (Strands) son el mismo patrón. El agente principal llama a un especialista como si fuera una tool, recibe su respuesta y sigue al mando . El modelo decide a quién llamar, pero el control vuelve siempre al orquestador.
La transferencia (ADK) y Swarm (Strands) van un paso más allá, el agente cede la conversación a otro y deja de participar. En ADK, el LLM lo hace llamando a una tool interna, transfer_to_agent , y elige el destino según la descripción de cada sub-agente. En Swarm, los agentes se pasan el control entre sí sin un orquestador central.
Mecanismo En ADK En Strands Quién decide Orden fijo con dependencias Workflow (grafo) Workflow, Graph El código Orden decidido en código durante la ejecución Workflow dinámico ( ctx.run_node ) Graph con condiciones El código, con datos de la ejecución Un agente consulta a otro y retoma el control AgentTool Agents as tools El modelo elige a quién consultar Un agente cede la conversación a otro Transferencia ( transfer_to_agent ) Swarm El modelo
Caso de uso: un knowledge graph con ADK y Strands
Para comparar con algo concreto, reescribí en ADK el pipeline de mi artículo sobre Graph en Strands : el ejemplo toma el abstract de un paper y lo convierte en un knowledge graph , una lista de entidades y relaciones sujeto → predicado → objeto . Sirve para resumir quién hizo qué en un texto, conectar conocimiento entre documentos o alimentar una base de grafos.
📦 El código Python original en Strands está en strands-graph . 📦 El repositorio de la versión ADK está en adk-knowledge-graph . Todo el detalle (instalación, pruebas, evals, despliegue con Terraform, costos y limpieza) está en el README del repositorio.
La topología es la misma en los dos frameworks: tres extractores en paralelo, un agregador que une sus resultados y un validador que puede devolver el borrador para revisión. Cada agente LLM tiene su color; los nodos de código (funciones y JoinNode ) tienen borde punteado.
En ADK, el grafo completo se declara en un solo lugar:
root_agent = Workflow ( name = "kg_pipeline" , edges = [ ( "START" , split_text ) , * [ ( split_text , extractor , join_extractions ) for extractor in extractors ] , ( join_extractions , aggregator , validator , route_verdict ) , # Back-edge: a cycle needs at least one routed edge ( route_verdict , { "revise" : aggregator , "publish" : publish_graph } ) , ] , )
Qué resuelve ADK de otra manera Necesidad Strands (Graph, Python) ADK ( Workflow ) Esperar a los 3 extractores El default es OR: el nodo se dispara cuando termina cualquier predecesor. Hay que escribir una condición all_dependencies_complete() en cada arista del grafo JoinNode espera a todos los predecesores Pasos que no necesitan un LLM El coordinator y el publisher eran agentes split_text , route_verdict y publish_graph son funciones Python: deterministas y sin tokens Salir del loop de revisión Condiciones en las aristas que leen la salida del validador Un nodo de código que emite Event(route="revise") o Event(route="publish") Ver qué pasó Logs y trazas Cada ejecución lleva su número de iteración ( aggregator@2 ) y adk web muestra el grafo
En Strands con TypeScript el default de Graph es AND, así que el problema del join es propio del SDK de Python.
Lo que aprendí construyendo el knowledge graph con ADK
El repositorio tiene dos versiones del multiagente: la del pipeline fijo de tres extractores ( kg_pipeline ), que es la que se compara con Strands, y una versión ampliada para textos largos ( kg_pipeline_docs ), que divide el documento en fragmentos, lanza un extractor por fragmento y va acumulando el grafo entre mensajes. La versión ampliada es la que después despliego en AWS.
En el pipeline fijo ( kg_pipeline ) El código decide, el LLM propone. En una corrida, el validador (Nova 2 Lite) aprobó con consistent: true un grafo con 4 entidades usadas en relaciones pero ausentes de la lista. route_verdict lo detectó con un chequeo en código, devolvió el borrador al agregador con el problema puntual y la segunda pasada lo corrigió. Un validador LLM chico no alcanza: los controles críticos van en código.
No pedirle a un LLM que copie JSON. El publisher como agente corrompía el grafo; como función es determinista y no gast
Comments
No comments yet. Start the discussion.