Google ADK Tutorial: Crea Agenti IA da Zero alla Produzione

Google ADK Tutorial: Crea Agenti IA da Zero alla Produzione

Google's Agent Development Kit (ADK) è il framework che finalmente rende i sistemi multi-agente accessibili. Se hai già costruito agenti IA con LangChain o CrewAI e hai la sensazione di combattere contro il framework invece di costruire con esso, questo tutorial su Google ADK ti guida attraverso tutto — dal tuo primo agente al deploy su Cloud Run.

Cos'è Google ADK (e Perché Dovrebbe Interessarti)?

Google's Agent Development Kit (ADK) è un framework Python open-source per costruire, valutare e distribuire agenti IA. Rilasciato nel 2025, è ottimizzato per Gemini ma supporta oltre 100 modelli tramite LiteLLM. La caratteristica vincente di ADK è l'orchestrazione nativa multi-agente — agenti che delegano compiti ad altri agenti senza codice di collegamento.

Dopo aver costruito agenti con LangChain, CrewAI e ora ADK, ecco cosa risalta: ADK è opinionato nei posti giusti. Ti offre una struttura di progetto, una UI di sviluppo integrata e un comando di deployment. Non devi mettere insieme cinque librerie per far girare un agente di base.

Se LangChain è un coltellino svizzero multiuso, ADK è il toolkit di Google progettato specificamente per flussi di lavoro multi-agente. CrewAI è più vicino per filosofia — agenti basati su ruoli che collaborano — ma ADK va oltre con valutazione integrata, ottimizzazione nativa per Gemini e deployment su Cloud Run con un solo comando. Per un'analisi più approfondita, leggi il nostro confronto dettagliato tra framework per agenti.

A chi si rivolge ADK? Sviluppatori Python che vogliono sistemi multi-agente strutturati. Team già su Google Cloud o Gemini. Chiunque sia stanco di scrivere logica di orchestrazione boilerplate.

Ecco un confronto rapido tra i framework:

La versione breve: se vuoi il percorso più rapido dall'"idea" al "sistema multi-agente in produzione", ADK è difficile da battere in questo momento.

Prerequisiti e Installazione di Google ADK

Per iniziare con Google ADK, serve Python 3.9+, una chiave API Gemini (livello gratuito disponibile su Google AI Studio), e il pacchetto google-adk. Installa con pip install google-adk, imposta la tua chiave API come variabile d'ambiente, e sei pronto a costruire il tuo primo agente in meno di 5 minuti.

Ecco la tua lista di controllo per la configurazione:

• Python 3.9+ (consigliato 3.10+ per il supporto completo ai type hint)
• Una chiave API Gemini — ottenine una gratis su aistudio.google.com. Il livello gratuito offre 15 richieste al minuto, più che sufficiente per lo sviluppo.
• pip (o uv se preferisci la velocità — funziona anche uv pip install google-adk)

Installa il pacchetto e imposta la chiave:

pip install google-adk

# Imposta la tua chiave API (aggiungila a .bashrc/.zshrc per la persistenza)
export GOOGLE_API_KEY="la-tua-chiave-api"

ADK si aspetta una struttura di cartelle specifica. Ogni agente vive nella propria directory di pacchetto:

my_agent/
  __init__.py    # Esporta root_agent
  agent.py       # Definizione dell'agente
.env             # Opzionale: GOOGLE_API_KEY=la-tua-chiave

Il nome della cartella diventa il nome del pacchetto del tuo agente, quindi scegli qualcosa di descrittivo. Non chiamarlo test o agent — confonderai il sistema di importazione di Python.

Consiglio pro: Se usi uv, crea prima un ambiente virtuale con uv venv && source .venv/bin/activate. È notevolmente più veloce di pip normale per la risoluzione delle dipendenze.

Costruire il Tuo Primo Agente Google ADK

Il tuo primo agente ADK ha bisogno solo di tre cose: un nome, un modello (come gemini-2.0-flash) e una stringa di istruzioni. Definiscilo in agent.py, inseriscilo in una cartella con un __init__.py, ed esegui adk web per chattare con lui in un'interfaccia browser. L'intera configurazione richiede circa 10 righe di Python.

Crea una cartella chiamata my_agent e aggiungi due file. Prima, la definizione dell'agente:

# my_agent/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"
)

Poi il file init che esporta il tuo agente:

# my_agent/__init__.py
from .agent import root_agent

Il nome di quella variabile è importante — ADK cerca specificatamente root_agent. Se lo salti, otterrai un errore "agent not found" che non spiega il perché.

Ora eseguilo. Hai due opzioni:

# Modalità CLI -- chatta nel terminale
adk run my_agent

# Modalità UI Web -- apre un'interfaccia browser
adk web my_agent

L'interfaccia adk web è genuinamente utile. Ti mostra la traccia completa della conversazione, quali strumenti l'agente ha chiamato, cosa ha ricevuto il modello e cosa ha restituito. Pensaci come Chrome DevTools per il tuo agente. Quando inizi a costruire sistemi multi-agente in seguito, questo diventa essenziale per capire il flusso di delega.

Prova a modificare le istruzioni per vedere come cambia il comportamento. Rendilo un pirata. Fagli rispondere solo in haiku. Acquisire familiarità con il modo in cui le istruzioni modellano il comportamento è la base per tutto il resto in questo tutorial.

Aggiungere Strumenti Personalizzati al Tuo Agente Google ADK

Gli agenti ADK diventano utili quando gli fornisci strumenti. Definisci una funzione Python con una docstring chiara, e ADK la converte automaticamente in uno strumento che l'agente può chiamare. La docstring è fondamentale — dice al modello cosa fa lo strumento e quando usarlo. ADK include anche strumenti integrati come Google Search e l'esecuzione di codice.

Gli strumenti sono le mani di un agente. Senza di essi, il tuo agente può solo parlare. Con essi, può interrogare database, chiamare API, eseguire calcoli e interagire con sistemi esterni. Se vuoi capire come funziona il function calling sotto il cofano, abbiamo un'analisi separata su questo argomento.

Strumenti con Funzioni Personalizzate

Ecco un esempio pratico — uno strumento che cerca i prezzi delle azioni:

# my_agent/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.
    """
    # In production, you'd call a real API here
    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"
)

Nota i type hint e la docstring. Non sono comodità opzionali — ADK li usa per generare lo schema dello strumento che il modello vede. Salta la docstring e il modello non saprà quando chiamare la tua funzione. Salta i type hint e riceverai un errore di firma.

Strumenti Integrati (Google Search, Esecuzione di Codice)

ADK include strumenti che puoi inserire senza scrivere alcun codice:

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 consente all'agente di interrogare il web in tempo reale. code_execution gli offre un ambiente Python in sandbox per eseguire calcoli. Questi due da soli coprono un numero sorprendente di casi d'uso.

Sistemi Multi-Agente: Come gli Agenti Google ADK Delegano il Lavoro

Il sistema multi-agente di ADK usa un agente radice che delega compiti a sotto-agenti specializzati. Ogni sotto-agente gestisce un dominio — ricerca, scrittura, programmazione. L'agente radice decide quale sotto-agente chiamare in base alla richiesta dell'utente. Puoi anche usare il pattern agent-as-tool, dove un agente chiama un altro come se fosse una funzione. Il blog ufficiale di Google sui sistemi multi-agente approfondisce i pattern architetturali.

Pensaci come un project manager che delega agli specialisti. L'agente radice legge la richiesta dell'utente, capisce quale specialista dovrebbe gestirla, e indirizza di conseguenza. Gli specialisti non si conoscono — fanno semplicemente il loro lavoro e riferiscono.

Pattern Agente Radice + Sotto-Agenti

Ecco un esempio funzionante con un agente radice che delega a un agente di ricerca e a un agente di scrittura:

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

# Sotto-agente 1: gestisce la ricerca
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"
)

# Sotto-agente 2: gestisce la scrittura
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 radice: delega al sotto-agente giusto
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"
)

Il campo description su ogni sotto-agente è il modo in cui l'agente radice capisce cosa può fare. Scrivi descrizioni chiare — quelle vaghe portano a decisioni di routing sbagliate.

Pattern Agent-as-Tool

A volte vuoi un maggiore controllo su come un agente chiama un altro. Il pattern agent-as-tool racchiude un sotto-agente come strumento chiamabile:

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 i sotto-agenti quando vuoi che l'agente radice deleghi completamente il controllo. Usa agent-as-tool quando vuoi che l'agente chiamante rimanga al volante e utilizzi semplicemente l'output del sotto-agente come input. Se stai costruendo sistemi in cui gli agenti hanno bisogno di un contesto condiviso, vedi la nostra guida completa alle architetture di memoria per agenti.

Agenti Workflow: Sequenziale, Parallelo e Loop

Oltre alla delega guidata dall'LLM, ADK offre tre tipi di agenti workflow per un'orchestrazione deterministica: SequentialAgent esegue i sotto-agenti uno dopo l'altro, ParallelAgent li esegue simultaneamente, e LoopAgent ripete una sequenza finché non viene soddisfatta una condizione. Sono utili quando hai bisogno di un ordine di esecuzione prevedibile invece di lasciare decidere all'LLM.

La distinzione è importante. La delega guidata dall'LLM (il pattern sub_agents sopra) lascia al modello la scelta di chi chiamare. Gli agenti workflow ti danno il controllo programmatico. Usa gli agenti workflow quando l'ordine di esecuzione è noto in anticipo.

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

# Tre agenti che devono essere eseguiti in ordine
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: ricerca -> bozza -> revisione
content_pipeline = SequentialAgent(
    name="content_pipeline",
    sub_agents=[research_agent, draft_agent, review_agent],
    description="Runs a complete content creation pipeline"
)

Per compiti indipendenti che possono essere eseguiti contemporaneamente, ParallelAgent fa risparmiare tempo reale:

# Tre fetcher di dati che vengono eseguiti in contemporanea
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"
)

Gestione dello Stato e della Memoria

ADK gestisce lo stato dell'agente a due livelli: lo stato di sessione (dati all'interno di una conversazione, come le preferenze utente raccolte durante la chat) e i servizi di memoria (dati che persistono tra le conversazioni). Lo stato di sessione è un semplice archivio chiave-valore accessibile tramite context.state. La memoria usa servizi come InMemoryMemoryService o VertexAIMemoryBankService per la produzione.

Lo stato di sessione è quello più semplice. È un dizionario allegato a ogni conversazione:

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"
)

Per la memoria tra conversazioni — il tipo in cui il tuo agente ricorda un utente dal martedì scorso — hai bisogno di un servizio di memoria:

from google.adk.memory import InMemoryMemoryService

# Per lo sviluppo (dati persi al riavvio)
memory_service = InMemoryMemoryService()

# Per la produzione, usa VertexAIMemoryBankService
# memory_service = VertexAIMemoryBankService(project="your-project")

Quando hai bisogno della memoria rispetto allo stato di sessione? Se è all'interno di una singola conversazione (carrello della spesa, contesto del compito corrente), usa lo stato di sessione. Se deve sopravvivere tra le conversazioni (preferenze utente, interazioni passate), usa un servizio di memoria. Consulta la nostra guida completa alle architetture di memoria per agenti per i pattern di produzione.

Callback: Controllare il Comportamento dell'Agente

I callback ADK ti permettono di intercettare e modificare il comportamento dell'agente in quattro punti: before_model_callback (prima della chiamata all'LLM), after_model_callback (dopo la risposta dell'LLM), before_tool_callback (prima dell'esecuzione dello strumento), e after_tool_callback (dopo il risultato dello strumento). Usali per la validazione dell'input, il filtraggio della sicurezza, il logging o la modifica delle risposte prima che raggiungano l'utente.

I callback sono dove aggiungi le guardrail. Pensaci come middleware per il tuo agente — ogni richiesta e risposta li attraversa, e puoi ispezionare, modificare o bloccare qualsiasi 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():
            # Return a response directly, skipping the model call
            return {"blocked": True, "reason": "Request matched safety filter"}
    
    # Return None to proceed normally
    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  # Don't modify the result

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"
)

Il before_model_callback è il più importante per la produzione. Viene eseguito prima di ogni chiamata LLM, dandoti la possibilità di bloccare prompt injection, validare gli input o aggiungere contesto di sistema. Se restituisci un oggetto risposta, ADK salta completamente il modello. Restituisci None per far passare la richiesta. Per altri pattern, vedi pattern avanzati per le guardrail di sicurezza LLM.

Test e Valutazione dei Tuoi Agenti ADK

ADK include un framework di valutazione integrato con due tipi di valutatori: ResponseEvaluator controlla se la risposta finale dell'agente è corretta, e TrajectoryEvaluator verifica che l'agente abbia eseguito i passaggi giusti — chiamato gli strumenti giusti nell'ordine giusto. Scrivi casi di test come file JSON ed eseguili con pytest per individuare regressioni prima del deployment.

Perché preoccuparsi di testare gli agenti? Perché sono non deterministici. Lo stesso input può produrre output diversi, e una piccola modifica alle tue istruzioni può rompere il function calling in modi sottili. Nella nostra esperienza, gli agenti che superano la valutazione della traiettoria sono molto più affidabili in produzione rispetto a quelli testati solo sulla qualità dell'output finale. Per strategie di valutazione più ampie, vedi la nostra guida alle strategie di valutazione LLM.

I tuoi casi di test vanno in un file 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"}}
    ]
  }
]

Poi esegui le valutazioni con pytest. Il repository Python di ADK contiene il riferimento completo all'API di valutazione:

# 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}"

Esegui con pytest test_agent.py -v. Imposta le soglie in base alla criticità — un'accuratezza dell'80% nella risposta potrebbe andare bene per un agente di scrittura creativa, ma vorresti il 95%+ per qualsiasi cosa che gestisce dati finanziari.

Distribuire il Tuo Agente Google ADK in Produzione

Distribuisci il tuo agente ADK su Google Cloud Run con un comando: adk deploy cloud_run --project YOUR_PROJECT --region us-central1. ADK pacchettizza il tuo codice, costruisce un container e avvia un endpoint serverless. Per l'hosting gestito, usa Vertex AI Agent Engine. Per infrastrutture personalizzate, ADK supporta anche la containerizzazione Docker.

Abbiamo distribuito agenti ADK su Cloud Run per strumenti interni, e i tempi di cold start sono sorprendentemente veloci — sotto i 3 secondi per un agente di base. Per i sistemi in produzione, considera di abbinare il deployment con strumenti di monitoraggio per agenti in produzione.

Deploy su Cloud Run (Consigliato per la Maggior Parte dei Casi)

Cloud Run è il percorso più semplice. Un comando, e il tuo agente è live con un endpoint HTTPS:

adk deploy cloud_run \
  --project your-gcp-project-id \
  --region us-central1 \
  --service-name my-agent-service \
  --with_ui

Il flag --with_ui distribuisce l'interfaccia ADK Web insieme al tuo agente, così ottieni una chat basata su browser per i test in produzione. Dietro le quinte, ADK costruisce un'immagine container, la invia a Google Artifact Registry e crea un servizio Cloud Run. Il flusso completo di deployment è documentato nel quickstart di Google Cloud Run per ADK.

Per infrastrutture personalizzate, ecco un Dockerfile minimale:

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", "my_agent"]

Alternativa: Vertex AI Agent Engine

Per i team enterprise che necessitano di scalabilità gestita, monitoraggio e versionamento, Vertex AI Agent Engine gestisce l'infrastruttura interamente. Si scambia flessibilità per convenienza — nessun container da gestire, scalabilità automatica, analisi integrata.

Considerazioni sui Costi

Numeri reali che dovresti conoscere:

• Livello gratuito Gemini API: 15 richieste al minuto, 1 milione di token al giorno. Sufficiente per lo sviluppo e le demo leggere.
• Gemini 2.0 Flash (a pagamento): $0,10 per milione di token in input, $0,40 per milione di token in output. Abbastanza economico per la produzione.
• Livello gratuito Cloud Run: 2 milioni di richieste al mese, 360.000 GB-secondi di calcolo. Un agente di base che gestisce 1.000 richieste al giorno rimane ben entro il livello gratuito.
• Consiglio di ottimizzazione: Usa gemini-2.0-flash (non gemini-2.0-pro) per i sotto-agenti che eseguono routing o formattazione semplici. Riserva i modelli più capaci agli agenti che fanno ragionamento complesso.

Come Techsy Si Approccia allo Sviluppo di Agenti IA

In Techsy, abbiamo costruito sistemi multi-agente per clienti usando ADK, LangGraph e CrewAI. La scelta del framework dipende dal tuo stack: se sei già su Google Cloud, ADK elimina una grande parte della frizione di integrazione. Se hai bisogno del supporto multi-provider LLM fin dal primo giorno, LangGraph ti dà più flessibilità.

Il nostro tipico coinvolgimento inizia con la consulenza sull'architettura — mappando il tuo caso d'uso ai pattern di agenti giusti — seguita dallo sviluppo del prototipo e dal deployment su Cloud Run. Abbiamo riscontrato che i team risparmiano 2-3 settimane ottenendo l'architettura giusta all'inizio invece di fare refactoring in seguito.

Stai costruendo agenti IA per il tuo team? Ottieni una consulenza gratuita — ti aiuteremo a scegliere il framework giusto e la strategia di deployment.

Errori Comuni e Risoluzione dei Problemi

Questi sono gli errori che incontriamo più spesso quando si inizia con ADK. Risparmia il tempo di debug:

Consiglio per il debug: adk web è il tuo migliore amico qui. Mostra la traccia completa della conversazione — ogni chiamata al modello, invocazione di strumenti e delega tra agenti — in tempo reale. Quando qualcosa va storto in un sistema multi-agente, la UI Web ti mostra esattamente dove si è rotta la catena.

FAQ

Cos'è Google ADK?

Google's Agent Development Kit (ADK) è un framework Python open-source per costruire, valutare e distribuire agenti IA. È ottimizzato per i modelli Google Gemini ma supporta oltre 100 LLM tramite l'integrazione LiteLLM. Il punto di forza principale di ADK è l'orchestrazione nativa multi-agente con strumenti integrati, una UI di sviluppo e il deployment su Cloud Run con un solo comando.

Google ADK è gratuito da usare?

Sì. ADK stesso è open-source con licenza Apache 2.0. Hai bisogno di una chiave API Gemini, che ha un livello gratuito che offre 15 richieste al minuto e 1 milione di token al giorno. I costi di deployment nel cloud dipendono dalla tua scelta di hosting — il livello gratuito di Cloud Run copre 2 milioni di richieste al mese.

Qual è la differenza tra Google ADK e LangChain?

ADK è il framework opinionato di Google ottimizzato per Gemini con orchestrazione nativa multi-agente e strumenti di deployment integrati. LangChain è indipendente dal modello con integrazioni di terze parti più ampie ma complessità significativamente maggiore. ADK è migliore per i team che usano Gemini come prima scelta e vogliono un deployment rapido; LangChain è adatto a configurazioni multi-provider che necessitano della massima flessibilità.

Google ADK supporta i sistemi multi-agente?

Sì, ed è la caratteristica di punta di ADK. Crei un agente radice che delega a sotto-agenti specializzati in base alle richieste degli utenti. ADK offre anche SequentialAgent, ParallelAgent e LoopAgent per l'orchestrazione deterministica del workflow. Il pattern agent-as-tool permette agli agenti di chiamare altri agenti come funzioni chiamabili.

Come distribuisco un agente Google ADK?

Esegui adk deploy cloud_run --project YOUR_PROJECT --region us-central1 per il deployment serverless su Google Cloud Run. Aggiungi --with_ui per includere l'interfaccia di chat basata su browser. Puoi anche distribuire su Vertex AI Agent Engine per l'hosting gestito, o costruire un container Docker per infrastrutture personalizzate.

Google ADK può usare modelli diversi da Gemini?

Sì. ADK supporta oltre 100 modelli attraverso l'integrazione LiteLLM, inclusi Anthropic Claude, OpenAI GPT-4, Meta Llama e Mistral. Imposta il parametro del modello sulla stringa del modello LiteLLM — per esempio, litellm/anthropic/claude-3-sonnet o litellm/openai/gpt-4o. I modelli Gemini funzionano nativamente senza il prefisso LiteLLM.

Cos'è la UI Web di ADK?

Un'interfaccia di debug basata su browser avviata con adk web cartella_del_tuo_agente. Mostra tracce delle conversazioni in tempo reale, chiamate agli strumenti, catene di delega tra agenti e cambiamenti di stato man mano che avvengono. La UI Web è essenziale per il debug dei sistemi multi-agente perché mostra esattamente quale sotto-agente ha gestito ogni richiesta.

Google ADK supporta MCP (Model Context Protocol)?

Sì. ADK ha il supporto nativo al Model Context Protocol, che consente agli agenti di connettersi a qualsiasi server di strumenti compatibile con MCP per strumenti e fonti di dati esterni. Questo rende gli agenti ADK interoperabili con l'ecosistema MCP in crescita. Per informazioni sul protocollo, vedi la nostra guida a MCP.

Come testo gli agenti ADK?

ADK include valutatori integrati: ResponseEvaluator per verificare la qualità dell'output rispetto alle risposte attese, e TrajectoryEvaluator per verificare che l'agente abbia chiamato gli strumenti giusti nell'ordine corretto. Scrivi casi di test come file JSON che definiscono input, output attesi e sequenze di chiamate agli strumenti attese, poi eseguili con pytest.

Quale versione di Python richiede Google ADK?

ADK richiede Python 3.9 o superiore. Python 3.10+ è consigliato per il supporto completo ai type hint, che è importante perché ADK usa i type hint per generare gli schemi degli strumenti. Python 3.11 o 3.12 offrono anche miglioramenti significativi delle prestazioni per i carichi di lavoro degli agenti. Installa con pip install google-adk.