Samouczek Google ADK: Buduj agentów AI od zera do produkcji

Samouczek Google ADK: Buduj agentów AI od zera do produkcji

Agent Development Kit (ADK) od Google to framework, który w końcu sprawia, że systemy wieloagentowe stają się przystępne. Jeśli budowałeś agentów AI za pomocą LangChain lub CrewAI i miałeś wrażenie, że walczysz z frameworkiem bardziej niż z nim pracujesz, ten samouczek Google ADK przeprowadzi Cię przez wszystko – od stworzenia pierwszego agenta po wdrożenie go w Cloud Run.

Czym jest Google ADK (i dlaczego warto się tym zainteresować)?

Agent Development Kit (ADK) od Google to open-source'owy framework Pythona do budowania, ewaluacji i wdrażania agentów AI. Wydany w 2025 roku, został zoptymalizowany pod kątem modelu Gemini, ale obsługuje ponad 100 modeli poprzez LiteLLM. Najważniejszą cechą ADK jest natywna orkiestracja wieloagentowa – agenci delegują zadania innym agentom bez konieczności pisania kodu klejącego.

Po zbudowaniu agentów przy użyciu LangChain, CrewAI, a teraz ADK, oto co rzuca się w oczy: ADK ma słusznie narzucone opinie w kluczowych miejscach. Daje Ci strukturę projektu, wbudowany interfejs deweloperski oraz polecenie do wdrażania. Nie musisz łączyć pięciu bibliotek, aby uruchomić podstawowego agenta.

Jeśli LangChain jest uniwersalnym scyzorykiem, ADK to zestaw narzędzi Google zaprojektowany specjalnie do przepływów pracy wieloagentowych. CrewAI jest bliższe filozoficznie dzięki agentom opartym na rolach, które współpracują ze sobą, ale ADK idzie dalej, oferując wbudowaną ewaluację, natywną optymalizację dla Gemini oraz wdrożenie w Cloud Run jednym poleceniem. Aby uzyskać głębszą analizę, sprawdź nasze szczegółowe porównanie frameworków agentowych.

Dla kogo jest ADK? Dla programistów Pythona, którzy chcą uporządkowanych systemów wieloagentowych. Dla zespołów już korzystających z Google Cloud lub Gemini. Dla każdego, kto ma dość pisania szablonowego kodu orkiestracji.

Oto jak prezentują się frameworki w skrócie:

W skrócie: jeśli szukasz najszybszej drogi od „pomysłu” do „wdrożonego systemu wieloagentowego”, ADK jest obecnie trudny do pobicia.

Wymagania wstępne i instalacja Google ADK

Aby rozpocząć pracę z Google ADK, potrzebujesz Pythona 3.9+, klucza API Gemini (darmowa warstwa dostępna w Google AI Studio) oraz pakietu google-adk. Zainstaluj go poleceniem pip install google-adk, ustaw swój klucz API jako zmienną środowiskową i jesteś gotowy do zbudowania pierwszego agenta w mniej niż 5 minut.

Oto lista kontrolna konfiguracji:

• Python 3.9+ (zalecany 3.10+ dla pełnej obsługi hintów typów)
• Klucz API Gemini, zdobądź go za darmo na aistudio.google.com. Darmowa warstwa oferuje 15 żądań na minutę, co wystarcza do celów deweloperskich.
• pip (lub uv, jeśli preferujesz szybkość, uv pip install google-adk również działa)

Zainstaluj pakiet i ustaw swój klucz:

pip install google-adk

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

ADK oczekuje określonej struktury folderów. Każdy agent znajduje się we własnym katalogu pakietu:

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

Nazwa folderu staje się nazwą pakietu Twojego agenta, więc wybierz coś opisowego. Nie nazywaj go test ani agent, ponieważ wprowadzisz zamieszanie w systemie importowania Pythona.

Wskazówka: Jeśli używasz uv, najpierw utwórz wirtualne środowisko poleceniem uv venv && source .venv/bin/activate. Jest zauważalnie szybsze niż zwykły pip przy rozwiązywaniu zależności.

Budowanie Twojego pierwszego agenta Google ADK

Twój pierwszy agent ADK potrzebuje tylko trzech rzeczy: nazwy, modelu (np. gemini-2.0-flash) oraz ciągu instrukcji. Zdefiniuj go w pliku agent.py, umieść w folderze z plikiem __init__.py i uruchom adk web, aby rozmawiać z nim w interfejsie przeglądarki. Cała konfiguracja zajmuje około 10 linii kodu Python.

Utwórz folder o nazwie my_agent i dodaj dwa pliki. Po pierwsze, definicję agenta:

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

Następnie plik init, który eksportuje Twojego agenta:

# my_agent/__init__.py
from .agent import root_agent

Ta nazwa zmiennej ma znaczenie, ADK szuka konkretnie root_agent. Jeśli to pominiesz, otrzymasz błąd „agent not found”, który nie wyjaśnia przyczyny.

Teraz uruchom go. Masz dwie opcje:

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

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

Interfejs adk web jest naprawdę przydatny. Pokazuje pełny ślad konwersacji, jakie narzędzia wywołał agent, co otrzymał model i co zwrócił. Traktuj to jak Chrome DevTools dla Twojego agenta. Gdy zaczniesz później budować systemy wieloagentowe, stanie się to niezbędne do zrozumienia przepływu delegacji.

Spróbuj zmodyfikować instrukcje, aby zobaczyć, jak zmienia się zachowanie. Spraw, by był piratem. Spraw, by odpowiadał tylko haiku. Zrozumienie, jak instrukcje kształtują zachowanie, jest fundamentem wszystkiego innego w tym samouczku.

Dodawanie niestandardowych narzędzi do agenta Google ADK

Agenci ADK stają się użyteczni, gdy dasz im narzędzia. Zdefiniuj funkcję Pythona z jasnym docstringiem, a ADK automatycznie przekształci ją w narzędzie, które agent może wywołać. Docstring jest kluczowy – mówi modelowi, co robi narzędzie i kiedy go używać. ADK dostarcza również wbudowane narzędzia, takie jak Wyszukiwarka Google i wykonanie kodu.

Narzędzia to ręce agenta. Bez nich Twój agent może tylko rozmawiać. Dzięki nim może sprawdzać bazy danych, wywoływać API, przeprowadzać obliczenia i interagować z systemami zewnętrznymi. Jeśli chcesz zrozumieć, jak działa wywoływanie funkcji pod maską, mamy osobny artykuł poświęcony temu tematowi.

Niestandardowe narzędzia funkcyjne

Oto praktyczny przykład – narzędzie wyszukujące ceny akcji:

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

Zwróć uwagę na hinty typów i docstring. Nie są to opcjonalne uprzejmości, ADK używa ich do generowania schematu narzędzia, który widzi model. Pomiń docstring, a model nie będzie wiedział, kiedy wywołać Twoją funkcję. Pomiń hinty typów, a otrzymasz błąd sygnatury.

Wbudowane narzędzia (Wyszukiwarka Google, Wykonywanie kodu)

ADK dostarcza narzędzia, które możesz dodać bez pisania żadnego kodu:

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 pozwala agentowi wyszukiwać informacje w sieci w czasie rzeczywistym. code_execution daje mu piaskownicę Pythona do przeprowadzania obliczeń. Te dwa narzędzia same w sobie pokrywają zaskakująco wiele przypadków użycia.

Systemy wieloagentowe: Jak agenci Google ADK delegują pracę

System wieloagentowy ADK wykorzystuje agenta głównego (root), który deleguje zadania do wyspecjalizowanych pod-agentów. Każdy pod-agent zajmuje się jedną domeną: badaniami, pisaniem, kodowaniem. Agent główny decyduje, którego pod-agenta wywołać na podstawie żądania użytkownika. Możesz również użyć wzorca „agent jako narzędzie”, gdzie jeden agent wywołuje inny tak, jakby był funkcją. Oficjalny blog Google na temat systemów wieloagentowych zagłębia się bardziej w wzorce architektoniczne.

Myśl o tym jak o menedżerze projektu delegującym zadania do specjalistów. Agent główny czyta żądanie użytkownika, ustala, który specjalista powinien się nim zająć, i odpowiednio kieruje ruch. Specjaliści nie wiedzą o sobie nawzajem, po prostu wykonują swoją pracę i raportują zwrotnie.

Wzorzec Agent Główny + Pod-agenci

Oto działający przykład z agentem głównym, który deleguje zadania do agenta badawczego i pisarskiego:

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

Pole description przy każdym pod-agencie informuje agenta głównego, co potrafią robić. Pisząc wyraźne opisy, unikniesz błędnych decyzji routingu.

Wzorzec Agent-jako-Narzędzie

Czasami chcesz mieć większą kontrolę nad tym, jak jeden agent wywołuje inny. Wzorzec agent-jako-narzędzie opakowuje pod-agenta jako wywoływalne narzędzie:

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

Używaj pod-agentów, gdy chcesz, aby agent główny całkowicie przekazał kontrolę. Używaj wzorca agent-jako-narzędzie, gdy chcesz, aby wywołujący agent pozostał sterownikiem i używał wyniku pod-agenta jedynie jako danych wejściowych. Jeśli budujesz systemy, w których agenci potrzebują współdzielonego kontekstu, zobacz nasz kompleksowy przewodnik po architekturach pamięci agentów.

Agenci przepływu pracy: Sekwencyjni, Równolegli i Pętlowi

Poza delegacją sterowaną przez LLM, ADK oferuje trzy typy agentów przepływu pracy do deterministycznej orkiestracji: SequentialAgent uruchamia pod-agentów jeden po drugim, ParallelAgent uruchamia ich jednocześnie, a LoopAgent powtarza sekwencję, dopóki nie zostanie spełniony warunek. Są one przydatne, gdy potrzebujesz przewidywalnej kolejności wykonywania, zamiast pozostawiać decyzję modelowi LLM.

To rozróżnienie ma znaczenie. Delegacja sterowana przez LLM (wzorzec sub_agents powyżej) pozwala modelowi wybrać, kogo wywołać. Agenci przepływu pracy dają Ci kontrolę programistyczną. Używaj agentów przepływu pracy, gdy kolejność wykonywania jest znana z góry.

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

Dla niezależnych zadań, które mogą być uruchamiane jednocześnie, ParallelAgent oszczędza realny czas:

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

Zarządzanie stanem i pamięcią

ADK zarządza stanem agenta na dwóch poziomach: stan sesji (dane w ramach jednej rozmowy, np. preferencje użytkownika zebrane w trakcie czatu) oraz usługi pamięci (dane utrzymywane między rozmowami). Stan sesji to prosty magazyn klucz-wartość dostępny przez context.state. Pamięć wykorzystuje usługi takie jak InMemoryMemoryService lub VertexAIMemoryBankService do zastosowań produkcyjnych.

Stan sesji jest prostszy. To słownik dołączony do każdej rozmowy:

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

Dla pamięci między rozmowami, takiej, w której Twój agent pamięta użytkownika z ostatniego wtorku, potrzebujesz usługi pamięci:

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

Kiedy potrzebujesz pamięci, a kiedy stanu sesji? Jeśli dotyczy to pojedynczej rozmowy (koszyk zakupowy, bieżący kontekst zadania), użyj stanu sesji. Jeśli musi przetrwać między rozmowami (preferencje użytkownika, przeszłe interakcje), użyj usługi pamięci. Sprawdź nasz kompleksowy przewodnik po architekturach pamięci agentów, aby poznać wzorce produkcyjne.

Callbacki: Kontrolowanie zachowania agenta

Callbacki ADK pozwalają przechwytywać i modyfikować zachowanie agenta w czterech punktach: before_model_callback (przed wywołaniem LLM), after_model_callback (po odpowiedzi LLM), before_tool_callback (przed wykonaniem narzędzia) oraz after_tool_callback (po wyniku narzędzia). Używaj ich do walidacji danych wejściowych, filtrowania bezpieczeństwa, logowania lub modyfikowania odpowiedzi przed dotarciem do użytkownika.

Callbacki to miejsce, w którym dodajesz barierki ochronne. Traktuj je jak middleware dla Twojego agenta – każde żądanie i odpowiedź przechodzi przez nie, a Ty możesz inspectować, modyfikować lub blokować cokolwiek.

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 jest najważniejszy w środowisku produkcyjnym. Uruchamia się przed każdym wywołaniem LLM, dając Ci szansę na zablokowanie wstrzykiwania promptów, walidację danych wejściowych lub dodanie kontekstu systemowego. Jeśli zwrócisz obiekt odpowiedzi, ADK całkowicie pomija model. Zwróć None, aby przepuścić żądanie. Więcej wzorców znajdziesz w artykule głębsze wzorce dla barier bezpieczeństwa LLM.

Testowanie i ewaluacja Twoich agentów ADK

ADK zawiera wbudowany framework ewaluacyjny z dwoma typami ewaluatorów: ResponseEvaluator sprawdza, czy ostateczna odpowiedź agenta jest poprawna, a TrajectoryEvaluator weryfikuje, czy agent podjął właściwe kroki i wywołał odpowiednie narzędzia we właściwej kolejności. Zapisz przypadki testowe jako pliki JSON i uruchom je za pomocą pytest, aby wychwycić regresje przed wdrożeniem.

Dlaczego warto testować agentów? Ponieważ są niedeterministyczne. To samo dane wejściowe mogą generować różne wyniki, a drobna zmiana w instrukcji może subtelnie zaburzyć wywoływanie narzędzi. Z naszego doświadczenia wynika, że agenci, którzy przechodzą ewaluację trajektorii, są znacznie bardziej niezawodni w produkcji niż ci testowani tylko pod kątem jakości końcowego wyniku. Szersze strategie ewaluacji znajdziesz w naszym przewodniku po strategiach ewaluacji LLM.

Twoje przypadki testowe trafiają do pliku 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"}}
    ]
  }
]

Następnie uruchom ewaluacje za pomocą pytest. Repozytorium Pythona ADK zawiera pełną dokumentację API ewaluacji:

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

Uruchom poleceniem pytest test_agent.py -v. Ustaw progi w zależności od krytyczności – 80% dokładności odpowiedzi może być wystarczające dla agenta do kreatywnego pisania, ale dla czegoś obsługującego dane finansowe chciałbyś 95%+.

Wdrażanie agenta Google ADK do produkcji

Wdróż swojego agenta ADK w Google Cloud Run jednym poleceniem: adk deploy cloud_run --project TWOJ_PROJEKT --region us-central1. ADK spakuje Twój kod, zbuduje kontener i uruchomi endpoint serverless. Do hostingu zarządzanego użyj Vertex AI Agent Engine. Do niestandardowej infrastruktury ADK obsługuje również konteneryzację Docker.

Wdrażaliśmy agentów ADK w Cloud Run do narzędzi wewnętrznych, a czasy zimnego startu są zaskakująco szybkie – poniżej 3 sekund dla podstawowego agenta. W systemach produkcyjnych rozważ połączenie wdrożenia z narzędziami monitoringu dla agentów produkcyjnych.

Wdrożenie w Cloud Run (Zalecane dla większości)

Cloud Run to najprostsza droga. Jedno polecenie i Twój agent jest online z endpointem HTTPS:

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

Flaga --with_ui wdraża interfejs internetowy ADK obok Twojego agenta, dzięki czemu otrzymujesz czat w przeglądarce do testowania w środowisku produkcyjnym. Za kulisami ADK buduje obraz kontenera, wypycha go do Google Artifact Registry i tworzy usługę Cloud Run. Pełny proces wdrażania jest opisany w szybkim starcie Google Cloud Run dla ADK.

Dla niestandardowej infrastruktury oto minimalny Dockerfile:

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

Alternatywa: Vertex AI Agent Engine

Dla zespołów enterprise, które potrzebują zarządzanego skalowania, monitoringu i wersjonowania, Vertex AI Agent Engine zajmuje się infrastrukturą całkowicie. Zrezygnujesz z elastyczności na rzecz wygody – brak kontenerów do zarządzania, automatyczne skalowanie, wbudowana analityka.

Kwestie kosztów

Realne liczby, które powinieneś znać:

• Darmowa warstwa API Gemini: 15 żądań na minutę, 1 milion tokenów/dzień. Wystarczające do rozwoju i lekkich demonstracji.
• Gemini 2.0 Flash (płatny): 0,10 USD za milion tokenów wejściowych, 0,40 USD za milion tokenów wyjściowych. Wystarczająco tanie do produkcji.
• Darmowa warstwa Cloud Run: 2 miliony żądań/miesiąc, 360 000 GB-sekund obliczeniowych. Podstawowy agent obsługujący 1000 żądań dziennie mieści się dobrze w darmowej warstwie.
• Wskazówka optymalizacyjna: Używaj gemini-2.0-flash (nie gemini-2.0-pro) dla pod-agentów wykonujących proste routowanie lub formatowanie. Zarezerwuj bardziej zaawansowane modele dla agentów wykonujących złożone rozumowanie.

Jak Techsy podchodzi do rozwoju agentów AI

W Techsy budowaliśmy systemy wieloagentowe dla klientów przy użyciu ADK, LangGraph i CrewAI. Wybór frameworka zależy od Twojego stosu technologicznego: jeśli jesteś już w Google Cloud, ADK eliminuje wiele tarcia integracyjnego. Jeśli od pierwszego dnia potrzebujesz obsługi LLM od wielu dostawców, LangGraph daje większą elastyczność.

Nasze typowe zaangażowanie zaczyna się od konsultacji architektonicznych, mapowania przypadku użycia do odpowiednich wzorców agentowych, a następnie rozwoju prototypu i wdrożenia w Cloud Run. Odkryliśmy, że zespoły oszczędzają 2-3 tygodnie, uzyskując prawidłową architekturę na początku, zamiast refaktoryzować ją później.

Budujesz agentów AI dla swojego zespołu? Umów bezpłatną konsultację, pomożemy Ci wybrać odpowiedni framework i strategię wdrożenia.

Częste błędy i rozwiązywanie problemów

Oto błędy, które najczęściej napotykamy podczas rozpoczynania pracy z ADK. Oszczędź sobie czasu na debugowanie:

Wskazówka debugowania: adk web jest tutaj Twoim najlepszym przyjacielem. Pokazuje pełny ślad konwersacji, każde wywołanie modelu, wywołanie narzędzia i delegację agenta w czasie rzeczywistym. Gdy coś pójdzie nie tak w systemie wieloagentowym, interfejs webowy pokaże Ci dokładnie, gdzie zerwał się łańcuch.

FAQ

Czym jest Google ADK?

Agent Development Kit (ADK) od Google to open-source'owy framework Pythona do budowania, ewaluacji i wdrażania agentów AI. Jest zoptymalizowany pod kątem modeli Google Gemini, ale obsługuje ponad 100 LLM poprzez integrację z LiteLLM. Główną siłą ADK jest natywna orkiestracja wieloagentowa z wbudowanymi narzędziami, interfejsem deweloperskim i wdrożeniem w Cloud Run jednym poleceniem.

Czy Google ADK jest darmowy?

Tak. Samo ADK jest open-source'em na licencji Apache 2.0. Potrzebujesz klucza API Gemini, który posiada darmową warstwę oferującą 15 żądań na minutę i 1 milion tokenów dziennie. Koszty wdrożenia w chmurze zależą od wybranego hostingu – darmowa warstwa Cloud Run pokrywa 2 miliony żądań miesięcznie.

Jaka jest różnica między Google ADK a LangChain?

ADK to framework Google z narzuconymi opiniami, zoptymalizowany pod kątem Gemini, z natywną orkiestracją wieloagentową i wbudowanymi narzędziami wdrożeniowymi. LangChain jest niezależny od modelu, z szerszymi integracjami zewnętrznymi, ale znacznie większą złożonością. ADK jest lepszy dla zespołów stawiających na Gemini, chcących szybkiego wdrożenia; LangChain pasuje do setupów wielodostawcowych wymagających maksymalnej elastyczności.

Czy Google ADK obsługuje systemy wieloagentowe?

Tak, i jest to flagowa cecha ADK. Tworzysz agenta głównego, który deleguje zadania do wyspecjalizowanych pod-agentów na podstawie żądań użytkownika. ADK oferuje również SequentialAgent, ParallelAgent i LoopAgent do deterministycznej orkiestracji przepływu pracy. Wzorzec agent-jako-narzędzie pozwala agentom wywoływać inne agenty jako funkcje.

Jak wdrożyć agenta Google ADK?

Uruchom adk deploy cloud_run --project TWOJ_PROJEKT --region us-central1 dla wdrożenia serverless w Google Cloud Run. Dodaj --with_ui, aby dołączyć interfejs czatu w przeglądarce. Możesz również wdrożyć w Vertex AI Agent Engine dla hostingu zarządzanego lub zbudować kontener Docker dla niestandardowej infrastruktury.

Czy Google ADK może używać modeli innych niż Gemini?

Tak. ADK obsługuje ponad 100 modeli poprzez integrację z LiteLLM, w tym Anthropic Claude, OpenAI GPT-4, Meta Llama i Mistral. Ustaw parametr modelu na ciąg LiteLLM, na przykład litellm/anthropic/claude-3-sonnet lub litellm/openai/gpt-4o. Modele Gemini działają natywnie bez prefiksu LiteLLM.

Czym jest ADK Web UI?

To interfejs debugowania w przeglądarce, uruchamiany poleceniem adk web twoj_folder_agenta. Wyświetla ślady konwersacji w czasie rzeczywistym, wywołania narzędzi, łańcuchy delegacji agentów i zmiany stanu w miarę ich występowania. Interfejs Web UI jest niezbędny do debugowania systemów wieloagentowych, ponieważ pokazuje dokładnie, który pod-agent obsłużył każde żądanie.

Czy Google ADK obsługuje MCP (Model Context Protocol)?

Tak. ADK ma natywne wsparcie dla Model Context Protocol, umożliwiając agentom łączenie się z dowolnym serwerem narzędzi kompatybilnym z MCP w celu uzyskania zewnętrznych narzędzi i źródeł danych. To sprawia, że agenci ADK są interoperacyjni z rozwijającym się ekosystemem MCP. Tło dotyczące protokołu znajdziesz w naszym przewodniku po MCP.

Jak testować agentów ADK?

ADK dostarcza wbudowane ewaluatory: ResponseEvaluator do sprawdzania jakości wyjścia względem oczekiwanych odpowiedzi oraz TrajectoryEvaluator do weryfikacji, czy agent wywołał właściwe narzędzia we właściwej kolejności. Zapisz przypadki testowe jako pliki JSON definiujące dane wejściowe, oczekiwane wyniki i oczekiwaną sekwencję wywołań narzędzi, a następnie uruchom je za pomocą pytest.

Jakiej wersji Pythona wymaga Google ADK?

ADK wymaga Pythona 3.9 lub nowszego. Zalecany jest Python 3.10+ dla pełnej obsługi hintów typów, co ma znaczenie, ponieważ ADK używa hintów typów do generowania schematów narzędzi. Python 3.11 lub 3.12 oferuje również znaczące poprawy wydajności dla obciążeń agentowych. Zainstaluj poleceniem pip install google-adk.