Посібник Google ADK: Створення ШІ-агентів від нуля до продакшену

Посібник Google ADK: Створення ШІ-агентів від нуля до продакшену

Agent Development Kit (ADK) від Google — це фреймворк, який нарешті робить мультиагентні системи зрозумілими та доступними. Якщо ви створювали ШІ-агентів за допомогою LangChain або CrewAI і відчували, що більше боретеся з фреймворком, ніж працюєте з ним, цей посібник із Google ADK проведе вас через усі етапи: від вашого першого агента до його розгортання в Cloud Run.

Що таке Google ADK (і чому вам варто звернути на нього увагу)?

Agent Development Kit (ADK) від Google — це фреймворк з відкритим кодом на Python для створення, оцінки та розгортання ШІ-агентів. Випущений у 2025 році, він оптимізований для Gemini, але підтримує понад 100 моделей через LiteLLM. Ключова особливість ADK — нативна оркестрація мультиагентних систем, де агенти можуть делегувати завдання іншим агентам без зайвого «клею» у вигляді додаткового коду.

Після роботи з агентами в LangChain, CrewAI та тепер в ADK, ось що виділяється: ADK має чітку думку там, де це потрібно. Він надає вам структуру проекту, вбудований інтерфейс для розробки та команду для розгортання. Вам не потрібно зшивати п’ять різних бібліотек, щоб запустити базового агента.

Якщо LangChain — це універсальний швейцарський ніж, то ADK — це спеціалізований набір інструментів від Google для мультиагентних робочих процесів. CrewAI ближчий за філософією до рольових агентів, які співпрацюють, але ADK йде далі, пропонуючи вбудовану оцінку, нативну оптимізацію для Gemini та розгортання в Cloud Run однією командою. Для глибшого аналізу ознайомтеся з нашим детальним порівнянням фреймворків для агентів.

Для кого призначений ADK? Для Python-розробників, які хочуть структуровані мультиагентні системи. Для команд, які вже використовують Google Cloud або Gemini. Для всіх, хто втомився писати шаблонний код для оркестрації.

Ось як ці фреймворки співвідносяться один з одним:

Коротко кажучи: якщо ви шукаєте найшвидший шлях від «ідеї» до «розгорнутої мультиагентної системи», ADK зараз важко перевершити.

Передумови та встановлення Google ADK

Щоб почати роботу з Google ADK, вам потрібен Python 3.9+, ключ API Gemini (безкоштовний рівень доступний у Google AI Studio) та пакет google-adk. Встановіть його через pip install google-adk, налаштуйте ключ API як змінну середовища, і ви готові створити свого першого агента менш ніж за 5 хвилин.

Ось ваш контрольний список для налаштування:

• Python 3.9+ (рекомендовано 3.10+ для повної підтримки анотацій типів)
• Ключ API Gemini, отримайте його безкоштовно на aistudio.google.com. Безкоштовний рівень надає 15 запитів на хвилину, чого цілком достатньо для розробки.
• pip (або uv, якщо ви цінуєте швидкість; uv pip install google-adk також працює)

Встановіть пакет і налаштуйте свій ключ:

pip install google-adk

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

ADK очікує певної структури папок. Кожен агент живе у власному каталозі пакета:

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

Назва папки стає назвою пакета вашого агента, тому обирайте щось описове. Не називайте її test або agent, це заплутає систему імпорту Python.

Порада професіонала: Якщо ви використовуєте uv, спочатку створіть віртуальне середовище за допомогою uv venv && source .venv/bin/activate. Це помітно швидше за звичайний pip для вирішення залежностей.

Створення вашого першого агента Google ADK

Вашому першому агенту ADK потрібно всього три речі: ім’я, модель (наприклад, gemini-2.0-flash) та рядок інструкцій. Визначте його у файлі agent.py, розмістіть його всередині папки з файлом __init__.py і запустіть adk web, щоб спілкуватися з ним через браузерний інтерфейс. Усе налаштування займає близько 10 рядків коду на Python.

Створіть папку з назвою my_agent і додайте два файли. По-перше, визначення агента:

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

Потім файл ініціалізації, який експортує вашого агента:

# my_agent/__init__.py
from .agent import root_agent

Ця назва змінної має значення, ADK шукає саме root_agent. Якщо ви пропустите цей момент, отримаєте помилку «agent not found», яка не пояснює причини.

Тепер запустіть його. У вас є два варіанти:

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

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

Інтерфейс adk web дійсно корисний. Він показує повний слід розмови, які інструменти викликав агент, що отримала модель і що вона повернула. Вважайте це Chrome DevTools для вашого агента. Коли ви почнете створювати мультиагентні системи пізніше, це стане необхідним для розуміння потоку делегування.

Спробуйте змінити інструкцію, щоб побачити, як змінюється поведінка. Зробіть його піратом. Змусьте його відповідати лише хайку. Відчуття того, як інструкції формують поведінку, є фундаментом для всього іншого в цьому посібнику.

Додавання власних інструментів до вашого агента Google ADK

Агенти ADK стають корисними, коли ви надаєте їм інструменти. Визначте функцію Python з чітким docstring, і ADK автоматично перетворить її на інструмент, який може викликати агент. Docstring має критичне значення: він повідомляє моделі, що робить інструмент і коли його використовувати. ADK також постачається з вбудованими інструментами, такими як Google Search та виконання коду.

Інструменти — це руки агента. Без них ваш агент може лише говорити. З ними він може перевіряти бази даних, викликати API, проводити обчислення та взаємодіяти із зовнішніми системами. Якщо ви хочете зрозуміти, як працює виклик функцій під капотом, у нас є окреме детальне дослідження на цю тему.

Користувацькі функціональні інструменти

Ось практичний приклад — інструмент для перевірки цін на акції:

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

Зверніть увагу на анотації типів та docstring. Це не просто необов’язкові прикраси; ADK використовує їх для генерації схеми інструменту, яку бачить модель. Пропустіть docstring, і модель не знатиме, коли викликати вашу функцію. Пропустіть анотації типів, і ви отримаєте помилку сигнатури.

Вбудовані інструменти (Google Search, виконання коду)

ADK постачається з інструментами, які можна використовувати без написання будь-якого коду:

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 дозволяє агенту робити запити в Інтернеті в реальному часі. code_execution надає йому ізольоване середовище Python для виконання обчислень. Цих двох інструментів уже достатньо для багатьох випадків використання.

Мультиагентні системи: Як агенти Google ADK делегують роботу

Мультиагентна система ADK використовує кореневий агент, який делегує завдання спеціалізованим субагентам. Кожен субагент відповідає за одну область: дослідження, написання текстів, кодування. Кореневий агент вирішує, якого субагента викликати, виходячи з запиту користувача. Ви також можете використовувати патерн «агент як інструмент», де один агент викликає інший так, ніби це функція. Офіційний блог Google про мультиагентні системи глибше розглядає архітектурні патерни.

Уявіть це як менеджера проекту, який делегує завдання фахівцям. Кореневий агент читає запит користувача, визначає, який фахівець повинен його обробити, і маршрутизує запит відповідно. Фахівці не знають один про одного; вони просто виконують свою роботу і звітують назад.

Патерн «Кореневий агент + Субагенти»

Ось робочий приклад із кореневим агентом, який делегує завдання агенту досліджень та агенту написання текстів:

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

Поле description для кожного субагента — це те, як кореневий агент розуміє, що вони можуть робити. Пишіть чіткі описи; нечіткі описи призводять до неправильних рішень щодо маршрутизації.

Патерн «Агент як інструмент»

Іноді вам потрібен більший контроль над тим, як один агент викликає інший. Патерн «агент як інструмент» обгортає субагент у вигляді викликаного інструменту:

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

Використовуйте субагентів, коли хочете, щоб кореневий агент повністю делегував контроль. Використовуйте патерн «агент як інструмент», коли хочете, щоб агент, що викликає, залишався керуючим і просто використовував вивід субагента як вхідні дані. Якщо ви будуєте системи, де агентам потрібен спільний контекст, перегляньте наш комплексний посібник з архітектури пам’яті агентів.

Агенти робочих процесів: Послідовні, Паралельні та Циклічні

Окрім делегування на основі LLM, ADK пропонує три типи агентів робочих процесів для детермінованої оркестрації: SequentialAgent запускає субагентів один за одним, ParallelAgent запускає їх одночасно, а LoopAgent повторює послідовність, доки не буде виконана умова. Вони корисні, коли вам потрібен передбачуваний порядок виконання, а не рішення LLM.

Ця відмінність має значення. Делегування на основі LLM (патерн sub_agents, описаний вище) дозволяє моделі обирати, кого викликати. Агенти робочих процесів дають вам програмний контроль. Використовуйте агенти робочих процесів, коли порядок виконання відомий заздалегідь.

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

Для незалежних завдань, які можна виконувати одночасно, ParallelAgent економить реальний час:

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

Управління станом та пам’яттю

ADK керує станом агента на двох рівнях: стан сеансу (дані в межах однієї розмови, наприклад, уподобання користувача, зібрані під час чату) та сервіси пам’яті (дані, які зберігаються між розмовами). Стан сеансу — це просте сховище ключ-значення, доступ до якого здійснюється через context.state. Пам’ять використовує такі сервіси, як InMemoryMemoryService або VertexAIMemoryBankService для продакшену.

Стан сеансу є простішим. Це словник, прив’язаний до кожної розмови:

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

Для пам’яті між розмовами, коли ваш агент пам’ятає користувача з минулого вівторка, вам потрібен сервіс пам’яті:

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

Коли потрібна пам’ять, а коли стан сеансу? Якщо це в межах однієї розмови (кошик покупок, поточний контекст завдання), використовуйте стан сеансу. Якщо дані мають зберігатися між розмовами (уподобання користувача, минулі взаємодії), використовуйте сервіс пам’яті. Ознайомтеся з нашим комплексним посібником з архітектури пам’яті агентів для виробничих патернів.

Зворотні виклики: Контроль поведінки агента

Зворотні виклики (callbacks) в ADK дозволяють перехоплювати та змінювати поведінку агента в чотирьох точках: before_model_callback (перед викликом LLM), after_model_callback (після відповіді LLM), before_tool_callback (перед виконанням інструменту) та after_tool_callback (після результату інструменту). Використовуйте їх для валідації вхідних даних, фільтрації безпеки, логування або зміни відповідей перед тим, як вони дійдуть до користувача.

Зворотні виклики — це місце, де ви додаєте обмежувачі. Вважайте їх проміжним програмним забезпеченням (middleware) для вашого агента: кожен запит і відповідь проходять через них, і ви можете перевіряти, змінювати або блокувати будь-що.

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 є найважливішим для продакшену. Він запускається перед кожним викликом LLM, даючи вам можливість блокувати ін’єкції промптів, валідувати вхідні дані або додавати системний контекст. Якщо ви повертаєте об’єкт відповіді, ADK повністю пропускає модель. Поверніть None, щоб пропустити запит. Більше патернів дивіться в статті глибші патерни для обмежувачів безпеки LLM.

Тестування та оцінка ваших агентів ADK

ADK включає вбудований фреймворк оцінки з двома типами оцінювачів: ResponseEvaluator перевіряє, чи правильна остаточна відповідь агента, а TrajectoryEvaluator перевіряє, чи агент зробив правильні кроки, викликав правильні інструменти в правильному порядку. Напишіть тестові випадки у вигляді JSON-файлів і запустіть їх за допомогою pytest, щоб виявити регресії перед розгортанням.

Навіщо тестувати агентів? Тому що вони недетерміновані. Один і той самий вхід може давати різні виходи, а невелика зміна в інструкції може тонко зламати виклик інструментів. За нашим досвідом, агенти, які проходять оцінку траєкторії, набагато надійніші в продакшені, ніж ті, що тестуються лише на якість кінцевого виводу. Для ширших стратегій оцінки дивіться наш посібник зі стратегій оцінки LLM.

Ваші тестові випадки розміщуються у 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"}}
    ]
  }
]

Потім запустіть оцінку за допомогою pytest. Репозиторій ADK Python містить повну довідку API оцінки:

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

Запустіть через pytest test_agent.py -v. Встановіть свої пороги залежно від критичності: 80% точності відповідей може бути достатньо для агента креативного письма, але для всього, що працює з фінансовими даними, ви захочете 95%+.

Розгортання вашого агента Google ADK у продакшен

Розгорніть свого агента ADK у Google Cloud Run однією командою: adk deploy cloud_run --project YOUR_PROJECT --region us-central1. ADK пакує ваш код, будує контейнер і запускає серверless endpoint. Для керованого хостингу використовуйте Vertex AI Agent Engine. Для_CUSTOM_ інфраструктури ADK також підтримує контейнеризацію Docker.

Ми розгортали агентів ADK у Cloud Run для внутрішніх інструментів, і час холодного старту виявився напрочуд швидким — менше 3 секунд для базового агента. Для виробничих систем розгляньте можливість поєднання вашого розгортання з інструментами моніторингу для продакшен-агентів.

Розгортання в Cloud Run (Рекомендовано для більшості)

Cloud Run — це найпростіший шлях. Одна команда, і ваш агент онлайн з HTTPS endpoint:

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

Прапорець --with_ui розгортає веб-інтерфейс ADK разом із вашим агентом, тож ви отримуєте браузерний чат для тестування в продакшені. За лаштунками ADK будує образ контейнера, відправляє його в Google Artifact Registry та створює службу Cloud Run. Повний процес розгортання документований у швидкому старті Google Cloud Run для ADK.

Для_custom_ інфраструктури ось мінімальний 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"]

Альтернатива: Vertex AI Agent Engine

Для корпоративних команд, яким потрібне кероване масштабування, моніторинг та версіонування, Vertex AI Agent Engine повністю бере на себе інфраструктуру. Ви жертвуєте гнучкістю заради зручності: немає контейнерів для управління, автоматичне масштабування, вбудована аналітика.

Міркування щодо вартості

Реальні цифри, які вам слід знати:

• Безкоштовний рівень Gemini API: 15 запитів на хвилину, 1 мільйон токенів/день. Достатньо для розробки та легких демо.
• Gemini 2.0 Flash (платний): $0.10 за мільйон вхідних токенів, $0.40 за мільйон вихідних токенів. Достатньо дешево для продакшену.
• Безкоштовний рівень Cloud Run: 2 мільйони запитів/місяць, 360 000 ГБ-секунд обчислень. Базовий агент, що обробляє 1000 запитів/день, залишається добре в межах безкоштовного ліміту.
• Порада з оптимізації: Використовуйте gemini-2.0-flash (не gemini-2.0-pro) для субагентів, які виконують просте маршрутизування або форматування. Залиште більш потужні моделі для агентів, які виконують складні міркування.

Як Techsy підходить до розробки ШІ-агентів

У Techsy ми створювали мультиагентні системи для клієнтів, використовуючи ADK, LangGraph та CrewAI. Вибір фреймворку залежить від вашого стеку: якщо ви вже в Google Cloud, ADK усуває багато проблем із інтеграцією. Якщо вам потрібна підтримка LLM від кількох провайдерів з першого дня, LangGraph дає більше гнучкості.

Наша типова співпраця починається з консультацій щодо архітектури, зіставлення вашого випадку використання з правильними патернами агентів, за якими слідує розробка прототипу та розгортання в Cloud Run. Ми виявили, що команди економлять 2-3 тижні, правильно визначивши архітектуру на початку, замість того щоб переробляти її пізніше.

Створюєте ШІ-агентів для своєї команди? Отримайте безкоштовну консультацію, ми допоможемо вам обрати правильний фреймворк та стратегію розгортання.

Поширені помилки та усунення неполадок

Це помилки, з якими ми стикаємося найчастіше під час початку роботи з ADK. Заощадьте собі час на налагодженні:

Порада з налагодження: adk web — ваш найкращий друг тут. Він показує повний слід розмови, кожен виклик моделі, виклик інструменту та делегування агентів у реальному часі. Коли щось йде не так у мультиагентній системі, веб-інтерфейс показує вам точно, де перервався ланцюжок.

FAQ

Що таке Google ADK?

Agent Development Kit (ADK) від Google — це фреймворк з відкритим кодом на Python для створення, оцінки та розгортання ШІ-агентів. Він оптимізований для моделей Google Gemini, але підтримує понад 100 LLM через інтеграцію з LiteLLM. Основною силою ADK є нативна оркестрація мультиагентних систем із вбудованими інструментами, інтерфейсом для розробки та розгортанням у Cloud Run однією командою.

Чи безкоштовно використовувати Google ADK?

Так. Сам ADK має відкритий код під ліцензією Apache 2.0. Вам потрібен ключ API Gemini, який має безкоштовний рівень, що пропонує 15 запитів на хвилину та 1 мільйон токенів на день. Вартість розгортання в хмарі залежить від вашого вибору хостингу; безкоштовний рівень Cloud Run покриває 2 мільйони запитів на місяць.

Яка різниця між Google ADK та LangChain?

ADK — це думковий фреймворк від Google, оптимізований для Gemini, з нативною оркестрацією мультиагентних систем та вбудованими інструментами розгортання. LangChain не залежить від моделі, має ширші інтеграції з третіми сторонами, але значно складніший. ADK краще підходить для команд, орієнтованих на Gemini, які хочуть швидкого розгортання; LangChain підходить для налаштувань з кількома провайдерами, де потрібна максимальна гнучкість.

Чи підтримує Google ADK мультиагентні системи?

Так, і це флагманська функція ADK. Ви створюєте кореневий агент, який делегує завдання спеціалізованим субагентам на основі запитів користувачів. ADK також пропонує SequentialAgent, ParallelAgent та LoopAgent для детермінованої оркестрації робочих процесів. Патерн «агент як інструмент» дозволяє агентам викликати інших агентів як викликані функції.

Як розгорнути агента Google ADK?

Запустіть adk deploy cloud_run --project YOUR_PROJECT --region us-central1 для серверless розгортання в Google Cloud Run. Додайте --with_ui, щоб включити браузерний інтерфейс чату. Ви також можете розгорнути в Vertex AI Agent Engine для керованого хостингу або створити контейнер Docker для_custom_ інфраструктури.

Чи може Google ADK використовувати моделі, відмінні від Gemini?

Так. ADK підтримує понад 100 моделей через інтеграцію з LiteLLM, включаючи Anthropic Claude, OpenAI GPT-4, Meta Llama та Mistral. Встановіть параметр моделі на рядок моделі LiteLLM, наприклад, litellm/anthropic/claude-3-sonnet або litellm/openai/gpt-4o. Моделі Gemini працюють нативно без префікса LiteLLM.

Що таке ADK Web UI?

Це браузерний інтерфейс для налагодження, який запускається командою adk web your_agent_folder. Він відображає следами розмов у реальному часі, виклики інструментів, ланцюжки делегування агентів та зміни стану в міру їх відбування. Веб-інтерфейс є необхідним для налагодження мультиагентних систем, оскільки він показує, який саме субагент обробив кожен запит.

Чи підтримує Google ADK MCP (Model Context Protocol)?

Так. ADK має нативну підтримку Model Context Protocol, що дозволяє агентам підключатися до будь-якого сервера інструментів, сумісного з MCP, для зовнішніх інструментів та джерел даних. Це робить агентів ADK сумісними зі зростаючою екосистемою MCP. Для довідкової інформації про протокол дивіться наш посібник з MCP.

Як тестувати агентів ADK?

ADK постачається з вбудованими оцінювачами: ResponseEvaluator для перевірки якості виводу проти очікуваних відповідей та TrajectoryEvaluator для перевірки того, чи агент викликав правильні інструменти в правильному порядку. Напишіть тестові випадки у вигляді JSON-файлів, визначаючи вхідні дані, очікувані вихідні дані та очікувані послідовності викликів інструментів, а потім запустіть їх за допомогою pytest.

Яка версія Python потрібна для Google ADK?

ADK вимагає Python 3.9 або вище. Рекомендується Python 3.10+ для повної підтримки анотацій типів, що має значення, оскільки ADK використовує анотації типів для генерації схем інструментів. Python 3.11 або 3.12 також пропонують значні покращення продуктивності для робочих навантажень агентів. Встановіть через pip install google-adk.