Tutorial Google ADK: Construiește Agenți AI de la Zero la Producție

Tutorial Google ADK: Construiește Agenți AI de la Zero la Producție

Agent Development Kit (ADK) de la Google este framework-ul care face în sfârșit ca sistemele multi-agent să pară accesibile. Dacă ai construit agenți AI cu LangChain sau CrewAI și ai avut sentimentul că te lupți mai mult cu framework-ul decât construiești cu el, acest tutorial Google ADK te ghidează prin tot procesul, de la primul tău agent până la implementarea acestuia pe Cloud Run.

Ce este Google ADK (și De Ar Trebui Să Te Intereseze)?

Agent Development Kit (ADK) de la Google este un framework Python open-source pentru construirea, evaluarea și implementarea agenților AI. Lansat în 2025, este optimizat pentru Gemini, dar suportă peste 100 de modele prin LiteLLM. Funcția principală a ADK este orchestrarea nativă multi-agent, permițând agenților să delegheze sarcini către alți agenți fără cod intermediar („glue code”).

După ce am construit agenți cu LangChain, CrewAI și acum cu ADK, iată ce iese în evidență: ADK are opinii ferme în locurile potrivite. Îți oferă o structură de proiect, o interfață de dezvoltare integrată și o comandă de implementare. Nu trebuie să îmbini cinci biblioteci diferite pentru a face un agent de bază să funcționeze.

Dacă LangChain este un briceag elvețian generalist, ADK este trusa de scule specializată a Google pentru fluxuri de lucru multi-agent. CrewAI este mai apropiat ca filosofie, cu agenți bazați pe roluri care colaborează, dar ADK merge mai departe cu evaluare integrată, optimizare nativă pentru Gemini și implementare pe Cloud Run printr-o singură comandă. Pentru o analiză mai detaliată, consultă comparația noastră aprofundată a framework-urilor de agenți.

Pentru cine este ADK? Dezvoltatori Python care doresc sisteme multi-agent structurate. Echipe care folosesc deja Google Cloud sau Gemini. Oricine s-a săturat să scrie logică boilerplate pentru orchestrare.

Iată cum se compară framework-urile într-o privire rapidă:

Pe scurt: dacă dorești cea mai rapidă cale de la „idee” la „sistem multi-agent implementat”, ADK este greu de bătut în acest moment.

Cerințe Preliminare și Instalarea Google ADK

Pentru a începe cu Google ADK, ai nevoie de Python 3.9+, o cheie API Gemini (nivel gratuit disponibil la Google AI Studio) și pachetul google-adk. Instalează-l cu pip install google-adk, setează cheia API ca variabilă de mediu și ești gata să îți construiești primul agent în mai puțin de 5 minute.

Iată lista ta de verificare pentru configurare:

• Python 3.9+ (se recomandă 3.10+ pentru suport complet de type hinting)
• O cheie API Gemini, pe care o poți obține gratuit de la aistudio.google.com. Nivelul gratuit îți oferă 15 cereri pe minut, suficient pentru dezvoltare.
• pip (sau uv dacă preferi viteza, uv pip install google-adk funcționează de asemenea)

Instalează pachetul și setează cheia ta:

pip install google-adk

# Set your API key (add to .bashrc/.zshrc for persistence)
export GOOGLE_API_KEY="your-api-key-here"

ADK se așteaptă la o structură specifică de foldere. Fiecare agent locuiește în propriul său director de pachet:

my_agent/
  __init__.py    # Exports root_agent
  agent.py       # Agent definition
.env             # Optional: GOOGLE_API_KEY=your-key

Numele folderului devine numele pachetului agentului tău, așa că alege ceva descriptiv. Nu îl numi test sau agent, vei confunda sistemul de import al Python.

Sfat pro: Dacă folosești uv, creează mai întâi un mediu virtual cu uv venv && source .venv/bin/activate. Este vizibil mai rapid decât pip obișnuit pentru rezolvarea dependențelor.

Construirea Primului Tău Agent Google ADK

Primul tău agent ADK are nevoie doar de trei lucruri: un nume, un model (cum ar fi gemini-2.0-flash) și un șir de instrucțiuni. Definește-l în agent.py, plasează-l într-un folder cu un fișier __init__.py și rulează adk web pentru a discuta cu el într-o interfață din browser. Întreaga configurare necesită aproximativ 10 linii de Python.

Creează un folder numit my_agent și adaugă două fișiere. Mai întâi, definiția agentului:

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

Apoi fișierul init care exportă agentul tău:

# my_agent/__init__.py
from .agent import root_agent

Numele acelei variabile contează, ADK caută specific root_agent. Dacă omiți acest lucru, vei primi o eroare „agent not found” care nu explică de ce.

Acum rulează-l. Ai două opțiuni:

# CLI mode -- chat in your terminal
adk run my_agent

# Web UI mode -- opens a browser interface
adk web my_agent

Interfața adk web este genuinely utilă. Îți arată întreaga urmă a conversației, ce instrumente a apelat agentul, ce a primit modelul și ce a returnat. Gândește-te la ea ca la Chrome DevTools pentru agentul tău. Când vei începe să construiești sisteme multi-agent mai târziu, aceasta devine esențială pentru înțelegerea fluxului de delegare.

Încearcă să modifici instrucțiunea pentru a vedea cum se schimbă comportamentul. Transformă-l într-un pirat. Fă-l să răspundă doar în haiku. A te familiariza cu modul în care instrucțiunile modelează comportamentul este fundamentul pentru tot restul din acest tutorial.

Adăugarea Instrumentelor Personalizate Agentului Tău Google ADK

Agenții ADK devin utili când le oferi instrumente. Definește o funcție Python cu un docstring clar, iar ADK o convertește automat într-un instrument pe care agentul îl poate apela. Docstring-ul este critic; acesta îi spune modelului ce face instrumentul și când să îl folosească. ADK vine, de asemenea, cu instrumente integrate precum Căutarea Google și executarea codului.

Instrumentele sunt mâinile unui agent. Fără ele, agentul tău poate doar să vorbească. Cu ele, poate verifica baze de date, apela API-uri, rula calcule și interacționa cu sisteme externe. Dacă vrei să înțelegi cum funcționează apelarea funcțiilor în spatele scenei, avem un ghid separat aprofundat despre asta.

Instrumente Funcționale Personalizate

Iată un exemplu practic, un instrument care caută prețurile acțiunilor:

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

Observă indicațiile de tip (type hints) și docstring-ul. Acestea nu sunt detalii opționale; ADK le folosește pentru a genera schema instrumentului pe care o vede modelul. Omite docstring-ul și modelul nu va ști când să apeleze funcția ta. Omite indicațiile de tip și vei primi o eroare de semnătură.

Instrumente Integrate (Căutare Google, Executare Cod)

ADK vine cu instrumente pe care le poți integra fără a scrie niciun cod:

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 agentului să interogheze web-ul în timp real. code_execution îi oferă un mediu Python izolat pentru a rula calcule. Aceste două alone acoperă un număr surprinzător de cazuri de utilizare.

Sisteme Multi-Agent: Cum Deleghează Lucrul Agenții Google ADK

Sistemul multi-agent al ADK folosește un agent rădăcină care deleghează sarcini către sub-agenți specializați. Fiecare sub-agent gestionează un domeniu: cercetare, scriere, codare. Agentul rădăcină decide care sub-agent să fie apelat în funcție de cererea utilizatorului. Poți folosi, de asemenea, modelul agent-ca-instrument, unde un agent apelează altul ca și cum ar fi o funcție. Blogul oficial Google despre sistemele multi-agent aprofundează tiparele arhitecturale.

Gândește-te la asta ca la un manager de proiect care deleghează către specialiști. Agentul rădăcină citește cererea utilizatorului, își dă seama care specialist ar trebui să o gestioneze și rutează corespunzător. Specialiștii nu știu unii de alții; ei își fac doar treaba și raportează înapoi.

Modelul Agent Rădăcină + Sub-Agenți

Iată un exemplu funcțional cu un agent rădăcină care deleghează către un agent de cercetare și unul de scriere:

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

# Sub-agent 1: handles research
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-agent 2: handles writing
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"
)

# Root agent: delegates to the right sub-agent
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"
)

Câmpul description de pe fiecare sub-agent este modul în care agentul rădăcină înțelege ce pot face aceștia. Scrie descrieri clare; cele vagi duc la decizii proaste de rutare.

Modelul Agent-ca-Instrument

Uneori dorești mai mult control asupra modului în care un agent îl apelează pe altul. Modelul agent-ca-instrument împachetează un sub-agent ca un instrument apelabil:

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

Folosește sub-agenți când vrei ca agentul rădăcină să delegheze complet controlul. Folosește agent-ca-instrument când vrei ca agentul apelant să rămână la cârmă și să folosească doar output-ul sub-agentului ca input. Dacă construiești sisteme în care agenții au nevoie de context partajat, vezi ghidul nostru cuprinzător despre arhitecturile de memorie ale agenților.

Agenți de Flux de Lucru: Secvențiali, Paraleli și Buclă

Dincolo de delegarea condusă de LLM, ADK oferă trei tipuri de agenți de flux de lucru pentru orchestrare deterministă: SequentialAgent rulează sub-agenții unul după altul, ParallelAgent îi rulează simultan, iar LoopAgent repetă o secvență până când o condiție este îndeplinită. Acestea sunt utile când ai nevoie de o ordine de execuție predictibilă, în loc să lași LLM-ul să decidă.

Distincția contează. Delegarea condusă de LLM (modelul sub_agents de mai sus) permite modelului să aleagă pe cine să apeleze. Agenții de flux de lucru îți oferă control programatic. Folosește agenții de flux de lucru când ordinea de execuție este cunoscută de la început.

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

# Three agents that must run in order
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: research -> draft -> review
content_pipeline = SequentialAgent(
    name="content_pipeline",
    sub_agents=[research_agent, draft_agent, review_agent],
    description="Runs a complete content creation pipeline"
)

Pentru sarcini independente care pot rula în același timp, ParallelAgent economisește timp real:

# Three data fetchers that run concurrently
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"
)

Gestionarea Stării și Memoriei

ADK gestionează starea agentului la două niveluri: starea sesiunii (date într-o conversație, cum ar fi preferințele utilizatorului colectate în mijlocul chat-ului) și serviciile de memorie (date care persistă între conversații). Starea sesiunii este un magazin simplu key-value accesat prin context.state. Memoria folosește servicii precum InMemoryMemoryService sau VertexAIMemoryBankService pentru producție.

Starea sesiunii este cea mai simplă. Este un dicționar atașat fiecărei conversații:

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

Pentru memoria între conversații, tipul în care agentul tău își amintește un utilizator de marțea trecută, ai nevoie de un serviciu de memorie:

from google.adk.memory import InMemoryMemoryService

# For development (data lost on restart)
memory_service = InMemoryMemoryService()

# For production, use VertexAIMemoryBankService
# memory_service = VertexAIMemoryBankService(project="your-project")

Când ai nevoie de memorie vs. stare de sesiune? Dacă este într-o singură conversație (coș de cumpărături, contextul sarcinii curente), folosește starea sesiunii. Dacă trebuie să supraviețuiască între conversații (preferințele utilizatorului, interacțiuni trecute), folosește un serviciu de memorie. Consultă ghidul nostru cuprinzător despre arhitecturile de memorie ale agenților pentru tipare de producție.

Callback-uri: Controlarea Comportamentului Agentului

Callback-urile ADK îți permit să interceptezi și să modifici comportamentul agentului în patru puncte: before_model_callback (înainte de apelul LLM), after_model_callback (după răspunsul LLM), before_tool_callback (înainte de executarea instrumentului) și after_tool_callback (după rezultatul instrumentului). Folosește-le pentru validarea inputului, filtrarea de siguranță, logging sau modificarea răspunsurilor înainte ca acestea să ajungă la utilizator.

Callback-urile sunt locul unde adaugi garduri de protecție (guardrails). Gândește-te la ele ca la middleware pentru agentul tău; fiecare cerere și răspuns trece prin ele, și poți inspecta, modifica sau bloca orice.

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

before_model_callback este cel mai important pentru producție. Rulează înainte de fiecare apel LLM, oferindu-ți șansa de a bloca injecțiile de prompt, valida inputurile sau adăuga context de sistem. Dacă returnezi un obiect de răspuns, ADK sare complet peste model. Returnează None pentru a lăsa cererea să treacă. Pentru mai multe tipare, vezi tipare mai profunde pentru gardurile de siguranță LLM.

Testarea și Evaluarea Agenților Tăi ADK

ADK include un framework de evaluare integrat cu două tipuri de evaluatori: ResponseEvaluator verifică dacă răspunsul final al agentului este corect, iar TrajectoryEvaluator verifică dacă agentul a făcut pașii corecți, a apelat instrumentele potrivite în ordinea corectă. Scrie cazurile de test ca fișiere JSON și rulează-le cu pytest pentru a prinde regresii înainte de implementare.

De ce să te deranjezi să testezi agenții? Pentru că sunt non-determiniști. Același input poate produce output-uri diferite, iar o mică schimbare în instrucțiunea ta poate strica apelarea instrumentelor în moduri subtile. În experiența noastră, agenții care trec evaluarea traiectoriei sunt mult mai fiabili în producție decât cei testați doar pe calitatea output-ului final. Pentru strategii de evaluare mai largi, vezi ghidul nostru despre strategiile de evaluare LLM.

Cazurile tale de test merg într-un fișier 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"}}
    ]
  }
]

Apoi rulează evaluările cu pytest. Depozitul Python ADK are referința completă a API-ului de evaluare:

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

Rulează cu pytest test_agent.py -v. Setează pragurile tale în funcție de criticitate -- 80% acuratețe a răspunsului ar putea fi suficient pentru un agent de scriere creativă, dar ai vrea 95%+ pentru orice manipulează date financiare.

Implementarea Agentului Tău Google ADK în Producție

Implementează agentul tău ADK pe Google Cloud Run cu o singură comandă: adk deploy cloud_run --project YOUR_PROJECT --region us-central1. ADK împachetează codul tău, construiește un container și lansează un endpoint serverless. Pentru găzduire gestionată, folosește Vertex AI Agent Engine. Pentru infrastructură personalizată, ADK suportă și containerizarea Docker.

Am implementat agenți ADK pe Cloud Run pentru instrumente interne, iar timpii de pornire la rece (cold start) sunt surprinzător de rapizi, sub 3 secunde pentru un agent de bază. Pentru sisteme de producție, ia în considerare asocierea implementării tale cu instrumente de monitorizare pentru agenții de producție.

Implementare pe Cloud Run (Recomandat pentru Majoritatea)

Cloud Run este cea mai simplă cale. O comandă, iar agentul tău este live cu un endpoint HTTPS:

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

Flag-ul --with_ui implementează interfața Web ADK alături de agentul tău, astfel încât primești un chat bazat pe browser pentru testare în producție. În spate, ADK construiește o imagine de container, o împinge în Google Artifact Registry și creează un serviciu Cloud Run. Fluxul complet de implementare este documentat în ghidul rapid Cloud Run de la Google pentru ADK.

Pentru infrastructură personalizată, iată un Dockerfile minimal:

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

Alternativă: Vertex AI Agent Engine

Pentru echipe enterprise care au nevoie de scalare gestionată, monitorizare și versionare, Vertex AI Agent Engine gestionează infrastructura complet. Schimbi flexibilitatea pentru conveniență: fără containere de gestionat, scalare automată, analitică integrată.

Considerații de Cost

Numere reale pe care ar trebui să le știi:

• Nivel gratuit API Gemini: 15 cereri pe minut, 1 milion de tokeni/zi. Suficient pentru dezvoltare și demo-uri ușoare.
• Gemini 2.0 Flash (plătit): $0.10 per milion tokeni de input, $0.40 per milion tokeni de output. Destul de ieftin pentru producție.
• Nivel gratuit Cloud Run: 2 milioane de cereri/lună, 360.000 GB-secunde de calcul. Un agent de bază care gestionează 1.000 de cereri/zi rămâne bine în interiorul nivelului gratuit.
• Sfat de optimizare: Folosește gemini-2.0-flash (nu gemini-2.0-pro) pentru sub-agenții care fac rutare simplă sau formatare. Rezervă modelele mai capabile pentru agenții care fac raționamente complexe.

Cum Abordează Techsy Dezvoltarea Agenților AI

La Techsy, am construit sisteme multi-agent pentru clienți folosind ADK, LangGraph și CrewAI. Alegerea framework-ului depinde de stack-ul tău: dacă ești deja pe Google Cloud, ADK elimină o mulțime de frecare de integrare. Dacă ai nevoie de suport LLM multi-provider din prima zi, LangGraph îți oferă mai multă flexibilitate.

Angajamentul nostru tipic începe cu consultanță de arhitectură, maparea cazului tău de utilizare la tiparele de agenți potrivite, urmată de dezvoltarea prototipului și implementarea pe Cloud Run. Am descoperit că echipele economisesc 2-3 săptămâni obținând arhitectura corectă de la început, în loc să refactoreze mai târziu.

Construiești agenți AI pentru echipa ta? Obține o consultație gratuită, te vom ajuta să alegi framework-ul și strategia de implementare potrivite.

Erori Comune și Depanare

Acestea sunt erorile pe care le întâlnim cel mai des când începem cu ADK. Economisește-ți timpul de depanare:

Sfat de depanare: adk web este cel mai bun prieten al tău aici. Arată întreaga urmă a conversației, fiecare apel de model, invocare de instrument și delegare de agent, în timp real. Când ceva nu merge bine într-un sistem multi-agent, interfața web îți arată exact unde s-a rupt lanțul.

Întrebări Frecvente (FAQ)

Ce este Google ADK?

Agent Development Kit (ADK) de la Google este un framework Python open-source pentru construirea, evaluarea și implementarea agenților AI. Este optimizat pentru modelele Google Gemini, dar suportă peste 100 de LLM-uri prin integrarea LiteLLM. Punctul forte al ADK este orchestrarea nativă multi-agent cu instrumente integrate, o interfață de dezvoltare și implementare pe Cloud Run printr-o singură comandă.

Este Google ADK gratuit de utilizat?

Da. ADK în sine este open-source sub licența Apache 2.0. Ai nevoie de o cheie API Gemini, care are un nivel gratuit oferind 15 cereri pe minut și 1 milion de tokeni pe zi. Costurile de implementare pe cloud depind de alegerea ta de găzduire; nivelul gratuit Cloud Run acoperă 2 milioane de cereri pe lună.

Care este diferența dintre Google ADK și LangChain?

ADK este framework-ul opinat al Google optimizat pentru Gemini, cu orchestrare multi-agent nativă și instrumente de implementare integrate. LangChain este agnostic față de model, cu integrări terțe mai largi, dar cu o complexitate semnificativ mai mare. ADK este mai bun pentru echipele „Gemini-first” care doresc implementare rapidă; LangChain se potrivește configurațiilor multi-provider care necesită flexibilitate maximă.

Suportă Google ADK sisteme multi-agent?

Da, și aceasta este caracteristica principală a ADK. Creezi un agent rădăcină care deleghează către sub-agenți specializați în funcție de cererile utilizatorului. ADK oferă, de asemenea, SequentialAgent, ParallelAgent și LoopAgent pentru orchestrarea deterministă a fluxului de lucru. Modelul agent-ca-instrument permite agenților să apeleze alți agenți ca funcții apelabile.

Cum implementez un agent Google ADK?

Rulează adk deploy cloud_run --project YOUR_PROJECT --region us-central1 pentru implementare serverless pe Google Cloud Run. Adaugă --with_ui pentru a include interfața de chat bazată pe browser. Poți implementa și pe Vertex AI Agent Engine pentru găzduire gestionată sau construi un container Docker pentru infrastructură personalizată.

Poate Google ADK utiliza alte modele decât Gemini?

Da. ADK suportă peste 100 de modele prin integrarea LiteLLM, inclusiv Anthropic Claude, OpenAI GPT-4, Meta Llama și Mistral. Setează parametrul model la șirul modelului LiteLLM, de exemplu, litellm/anthropic/claude-3-sonnet sau litellm/openai/gpt-4o. Modelele Gemini funcționează nativ fără prefixul LiteLLM.

Ce este interfața Web ADK?

O interfață de depanare bazată pe browser lansată cu adk web your_agent_folder. Afișează urmele conversației în timp real, apelurile de instrumente, lanțurile de delegare a agenților și schimbările de stare pe măsură ce acestea au loc. Interfața Web este esențială pentru depanarea sistemelor multi-agent deoarece arată exact care sub-agent a gestionat fiecare cerere.

Suportă Google ADK MCP (Model Context Protocol)?

Da. ADK are suport nativ pentru Model Context Protocol, permițând agenților să se conecteze la orice server de instrumente compatibil cu MCP pentru instrumente externe și surse de date. Acest lucru face ca agenții ADK să fie interoperabili cu ecosistemul MCP în creștere. Pentru contexte despre protocol, vezi ghidul nostru MCP.

Cum testez agenții ADK?

ADK vine cu evaluatori integri: ResponseEvaluator pentru verificarea calității output-ului față de răspunsurile așteptate și TrajectoryEvaluator pentru verificarea faptului că agentul a apelat instrumentele corecte în ordinea corectă. Scrie cazurile de test ca fișiere JSON definind inputurile, output-urile așteptate și secvențele de apelare a instrumentelor așteptate, apoi rulează-le cu pytest.

Ce versiune de Python necesită Google ADK?

ADK necesită Python 3.9 sau mai mare. Se recomandă Python 3.10+ pentru suport complet de type hinting, ceea contează deoarece ADK folosește type hints pentru a genera schemele instrumentelor. Python 3.11 sau 3.12 oferă, de asemenea, îmbunătățiri semnificative de performanță pentru sarcinile de lucru ale agenților. Instalează cu pip install google-adk.