Tutorial Google ADK: Bangun Agen AI dari Nol hingga Produksi

Tutorial Google ADK: Bangun Agen AI dari Nol hingga Produksi

Agent Development Kit (ADK) dari Google adalah kerangka kerja yang akhirnya membuat sistem multi-agen terasa mudah didekati. Jika Anda telah membangun agen AI dengan LangChain atau CrewAI dan merasa lebih banyak bertarung melawan kerangka kerja daripada membangun dengannya, tutorial Google ADK ini akan menuntun Anda melalui semuanya, mulai dari agen pertama Anda hingga menerapkannya di Cloud Run.

Apa Itu Google ADK (Dan Mengapa Anda Harus Peduli)?

Agent Development Kit (ADK) dari Google adalah kerangka kerja Python open-source untuk membangun, mengevaluasi, dan menerapkan agen AI. Diluncurkan pada tahun 2025, ADK dioptimalkan untuk Gemini tetapi mendukung 100+ model melalui LiteLLM. Fitur unggulan ADK adalah orkestrasi multi-agen asli, di mana agen dapat mendelegasikan tugas ke agen lain tanpa perlu kode perekat.

Setelah membangun agen dengan LangChain, CrewAI, dan sekarang ADK, inilah yang paling menonjol: ADK memiliki opini yang tepat di tempat yang tepat. ADK memberikan struktur proyek, UI pengembangan bawaan, dan perintah penerapan. Anda tidak perlu menyatukan lima pustaka berbeda hanya untuk menjalankan agen dasar.

Jika LangChain adalah pisau lipat serbaguna, maka ADK adalah kotak alat khusus buatan Google untuk alur kerja multi-agen. CrewAI memiliki filosofi yang lebih dekat, yaitu agen berbasis peran yang berkolaborasi, namun ADK melangkah lebih jauh dengan evaluasi bawaan, optimasi Gemini asli, dan penerapan Cloud Run satu perintah. Untuk uraian yang lebih mendalam, lihat perbandingan mendalam kami tentang kerangka kerja agen.

Untuk siapa ADK ini? Pengembang Python yang menginginkan sistem multi-agen yang terstruktur. Tim yang sudah menggunakan Google Cloud atau Gemini. Siapa pun yang lelah menulis logika orkestrasi standar.

Berikut adalah perbandingan singkat antar kerangka kerja:

Versi singkatnya: jika Anda menginginkan jalur tercepat dari "ide" menjadi "sistem multi-agen yang diterapkan," ADK sulit dikalahkan saat ini.

Prasyarat dan Instalasi Google ADK

Untuk memulai dengan Google ADK, Anda memerlukan Python 3.9+, kunci API Gemini (tier gratis tersedia di Google AI Studio), dan paket google-adk. Instal dengan pip install google-adk, atur kunci API Anda sebagai variabel lingkungan, dan Anda siap membangun agen pertama Anda dalam waktu kurang dari 5 menit.

Berikut adalah daftar periksa pengaturan Anda:

• Python 3.9+ (3.10+ direkomendasikan untuk dukungan type hint penuh)
• Kunci API Gemini, dapatkan secara gratis di aistudio.google.com. Tier gratis memberi Anda 15 permintaan per menit, yang cukup untuk pengembangan.
• pip (atau uv jika Anda mengutamakan kecepatan, uv pip install google-adk juga berfungsi)

Instal paket dan atur kunci Anda:

pip install google-adk

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

ADK mengharapkan struktur folder tertentu. Setiap agen berada di direktori paketnya sendiri:

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

Nama folder menjadi nama paket agen Anda, jadi pilihlah nama yang deskriptif. Jangan menyebutnya test atau agent, karena Anda akan membingungkan sistem impor Python.

Tips pro: Jika Anda menggunakan uv, buat virtual environment terlebih dahulu dengan uv venv && source .venv/bin/activate. Proses resolusi dependensinya noticeably lebih cepat daripada pip biasa.

Membangun Agen Google ADK Pertama Anda

Agen ADK pertama Anda hanya membutuhkan tiga hal: nama, model (seperti gemini-2.0-flash), dan string instruksi. Definisikan di agent.py, letakkan di dalam folder dengan __init__.py, dan jalankan adk web untuk mengobrol dengannya di UI browser. Seluruh penyiapan hanya memakan sekitar 10 baris kode Python.

Buat folder bernama my_agent dan tambahkan dua file. Pertama, definisi agen:

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

Kemudian file init yang mengekspor agen Anda:

# my_agent/__init__.py
from .agent import root_agent

Nama variabel tersebut penting, ADK secara khusus mencari root_agent. Jika melewatkannya, Anda akan mendapatkan error "agent not found" yang tidak menjelaskan alasannya.

Sekarang jalankan. Anda memiliki dua opsi:

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

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

Antarmuka adk web sangat berguna. Ini menunjukkan jejak percakapan lengkap, alat apa yang dipanggil agen, apa yang diterima model, dan apa yang dikembalikan. Anggap saja sebagai Chrome DevTools untuk agen Anda. Saat Anda mulai membangun sistem multi-agen nanti, ini menjadi penting untuk memahami alur delegasi.

Coba modifikasi instruksi untuk melihat bagaimana perilaku berubah. Jadikan dia bajak laut. Buat agar dia hanya merespons dalam bentuk haiku. Memahami bagaimana instruksi membentuk perilaku adalah fondasi untuk segala hal lainnya dalam tutorial ini.

Menambahkan Alat Kustom ke Agen Google ADK Anda

Agen ADK menjadi berguna ketika Anda memberikannya alat. Definisikan fungsi Python dengan docstring yang jelas, dan ADK secara otomatis mengubahnya menjadi alat yang dapat dipanggil agen. Docstring sangat kritis karena memberitahu model apa fungsi alat tersebut dan kapan harus menggunakannya. ADK juga dilengkapi dengan alat bawaan seperti Pencarian Google dan eksekusi kode.

Alat adalah tangan bagi sebuah agen. Tanpanya, agen Anda hanya bisa berbicara. Dengan alat, agen dapat memeriksa basis data, memanggil API, menjalankan perhitungan, dan berinteraksi dengan sistem eksternal. Jika Anda ingin memahami cara kerja function calling di balik layar, kami memiliki uraian mendalam terpisah tentang hal itu.

Alat Fungsi Kustom

Berikut adalah contoh praktis, alat yang mencari harga saham:

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

Perhatikan type hints dan docstring. Ini bukan sekadar hiasan opsional, ADK menggunakannya untuk menghasilkan skema alat yang dilihat model. Lewatkan docstring dan model tidak akan tahu kapan harus memanggil fungsi Anda. Lewatkan type hints dan Anda akan mendapatkan error tanda tangan.

Alat Bawaan (Pencarian Google, Eksekusi Kode)

ADK dilengkapi dengan alat yang dapat Anda gunakan tanpa menulis kode apa pun:

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 memungkinkan agen melakukan kueri web secara real time. code_execution memberikannya lingkungan Python terisolasi untuk menjalankan perhitungan. Kedua alat ini saja mencakup jumlah kasus penggunaan yang mengejutkan.

Sistem Multi-Agen: Cara Agen Google ADK Mendelegasikan Pekerjaan

Sistem multi-agen ADK menggunakan agen root yang mendelegasikan tugas ke sub-agen khusus. Setiap sub-agen menangani satu domain, seperti penelitian, penulisan, atau pengkodean. Agen root memutuskan sub-agen mana yang akan dipanggil berdasarkan permintaan pengguna. Anda juga dapat menggunakan pola agen-sebagai-alat, di mana satu agen memanggil agen lain seolah-olah itu adalah fungsi. Blog resmi Google tentang sistem multi-agen membahas lebih dalam pola arsitekturalnya.

Bayangkan seperti manajer proyek yang mendelegasikan tugas kepada spesialis. Agen root membaca permintaan pengguna, mencari tahu spesialis mana yang harus menanganinya, dan mengarahkannya sesuai. Para spesialis tidak saling mengenal, mereka hanya melakukan pekerjaan mereka dan melaporkan kembali.

Pola Agen Root + Sub-Agen

Berikut adalah contoh yang berfungsi dengan agen root yang mendelegasikan ke agen peneliti dan agen penulis:

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

Bidang description pada setiap sub-agen adalah cara agen root memahami apa yang dapat mereka lakukan. Tulis deskripsi yang jelas, deskripsi yang samar akan menyebabkan keputusan perutean yang buruk.

Pola Agen-sebagai-Alat

Terkadang Anda menginginkan kontrol lebih besar atas bagaimana satu agen memanggil agen lain. Pola agen-sebagai-alat membungkus sub-agen sebagai alat yang dapat dipanggil:

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

Gunakan sub-agen ketika Anda ingin agen root sepenuhnya mendelegasikan kontrol. Gunakan agen-sebagai-alat ketika Anda ingin agen pemanggil tetap memegang kendali dan hanya menggunakan output sub-agen sebagai input. Jika Anda membangun sistem di mana agen memerlukan konteks bersama, lihat panduan komprehensif kami tentang arsitektur memori agen.

Agen Alur Kerja: Sekuensial, Paralel, dan Loop

Selain delegasi yang digerakkan oleh LLM, ADK menawarkan tiga jenis agen alur kerja untuk orkestrasi deterministik: SequentialAgent menjalankan sub-agen satu per satu, ParallelAgent menjalankannya secara bersamaan, dan LoopAgent mengulang urutan hingga kondisi terpenuhi. Ini berguna ketika Anda memerlukan urutan eksekusi yang dapat diprediksi daripada membiarkan LLM memutuskan.

Perbedaannya penting. Delegasi yang digerakkan LLM (pola sub_agents di atas) membiarkan model memilih siapa yang akan dipanggil. Agen alur kerja memberi Anda kontrol programatik. Gunakan agen alur kerja ketika urutan eksekusi sudah diketahui sebelumnya.

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

Untuk tugas independen yang dapat berjalan secara bersamaan, ParallelAgent menghemat waktu nyata:

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

Mengelola State dan Memori

ADK mengelola state agen di dua tingkat: state sesi (data dalam satu percakapan, seperti preferensi pengguna yang dikumpulkan di tengah obrolan) dan layanan memori (data yang bertahan lintas percakapan). State sesi adalah penyimpanan key-value sederhana yang diakses melalui context.state. Memori menggunakan layanan seperti InMemoryMemoryService atau VertexAIMemoryBankService untuk produksi.

State sesi adalah yang lebih sederhana. Ini adalah kamus yang melekat pada setiap percakapan:

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

Untuk memori lintas percakapan, jenis di mana agen Anda mengingat pengguna dari hari Selasa lalu, Anda memerlukan layanan memori:

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

Kapan Anda memerlukan memori vs state sesi? Jika itu dalam satu percakapan (keranjang belanja, konteks tugas saat ini), gunakan state sesi. Jika itu perlu bertahan antar percakapan (preferensi pengguna, interaksi masa lalu), gunakan layanan memori. Lihat panduan komprehensif kami tentang arsitektur memori agen untuk pola produksi.

Callback: Mengontrol Perilaku Agen

Callback ADK memungkinkan Anda menyadap dan memodifikasi perilaku agen di empat titik: before_model_callback (sebelum panggilan LLM), after_model_callback (setelah respons LLM), before_tool_callback (sebelum eksekusi alat), dan after_tool_callback (setelah hasil alat). Gunakan ini untuk validasi input, penyaringan keamanan, pencatatan log, atau memodifikasi respons sebelum mencapai pengguna.

Callback adalah tempat Anda menambahkan pagar pembatas. Anggap saja sebagai middleware untuk agen Anda, setiap permintaan dan respons melewatinya, dan Anda dapat memeriksa, memodifikasi, atau memblokir apa pun.

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 adalah yang paling penting untuk produksi. Ini berjalan sebelum setiap panggilan LLM, memberi Anda kesempatan untuk memblokir injeksi prompt, memvalidasi input, atau menambahkan konteks sistem. Jika Anda mengembalikan objek respons, ADK akan melewatkan model sepenuhnya. Kembalikan None untuk membiarkan permintaan lolos. Untuk pola lebih lanjut, lihat pola yang lebih dalam untuk pagar pembatas keamanan LLM.

Menguji dan Mengevaluasi Agen ADK Anda

ADK mencakup kerangka evaluasi bawaan dengan dua jenis evaluator: ResponseEvaluator memeriksa apakah jawaban akhir agen benar, dan TrajectoryEvaluator memverifikasi apakah agen mengambil langkah yang tepat, memanggil alat yang tepat dalam urutan yang tepat. Tulis kasus uji sebagai file JSON dan jalankan dengan pytest untuk menangkap regresi sebelum penerapan.

Mengapa repot-repot menguji agen? Karena agen bersifat non-deterministik. Input yang sama dapat menghasilkan output yang berbeda, dan perubahan kecil pada instruksi Anda dapat merusak pemanggilan alat dengan cara yang halus. Dalam pengalaman kami, agen yang lulus evaluasi trajektori jauh lebih andal dalam produksi daripada yang hanya diuji pada kualitas output akhir. Untuk strategi evaluasi yang lebih luas, lihat panduan kami tentang strategi evaluasi LLM.

Kasus uji Anda masuk ke dalam 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"}}
    ]
  }
]

Kemudian jalankan evaluasi dengan pytest. Repositori Python ADK memiliki referensi API evaluasi lengkap:

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

Jalankan dengan pytest test_agent.py -v. Atur ambang batas Anda berdasarkan tingkat kritisitas -- akurasi respons 80% mungkin baik-baik saja untuk agen penulisan kreatif, tetapi Anda akan menginginkan 95%+ untuk apa pun yang menangani data keuangan.

Menerapkan Agen Google ADK Anda ke Produksi

Terapkan agen ADK Anda ke Google Cloud Run dengan satu perintah: adk deploy cloud_run --project YOUR_PROJECT --region us-central1. ADK mengemas kode Anda, membangun kontainer, dan meluncurkan endpoint serverless. Untuk hosting terkelola, gunakan Vertex AI Agent Engine. Untuk infrastruktur kustom, ADK juga mendukung kontainerisasi Docker.

Kami telah menerapkan agen ADK di Cloud Run untuk alat internal, dan waktu cold start-nya surprisingly cepat, di bawah 3 detik untuk agen dasar. Untuk sistem produksi, pertimbangkan untuk memasangkan penerapan Anda dengan alat pemantauan untuk agen produksi.

Terapkan ke Cloud Run (Direkomendasikan untuk Sebagian Besar)

Cloud Run adalah jalur termudah. Satu perintah, dan agen Anda aktif dengan endpoint HTTPS:

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

Flag --with_ui menerapkan antarmuka Web ADK bersama dengan agen Anda, sehingga Anda mendapatkan obrolan berbasis browser untuk pengujian di produksi. Di balik layar, ADK membangun image kontainer, mendorongnya ke Google Artifact Registry, dan membuat layanan Cloud Run. Alur penerapan lengkap didokumentasikan dalam quickstart Cloud Run Google untuk ADK.

Untuk infrastruktur kustom, berikut adalah 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"]

Alternatif: Vertex AI Agent Engine

Untuk tim perusahaan yang membutuhkan penskalaan terkelola, pemantauan, dan versioning, Vertex AI Agent Engine menangani infrastruktur sepenuhnya. Anda menukar fleksibilitas dengan kenyamanan, tidak ada kontainer yang perlu dikelola, penskalaan otomatis, analitik bawaan.

Pertimbangan Biaya

Angka nyata yang harus Anda ketahui:

• Tier gratis API Gemini: 15 permintaan per menit, 1 juta token/hari. Cukup untuk pengembangan dan demo ringan.
• Gemini 2.0 Flash (berbayar): $0,10 per juta token input, $0,40 per juta token output. Cukup murah untuk produksi.
• Tier gratis Cloud Run: 2 juta permintaan/bulan, 360.000 GB-detik komputasi. Agen dasar yang menangani 1.000 permintaan/hari tetap well within tier gratis.
• Tips optimasi: Gunakan gemini-2.0-flash (bukan gemini-2.0-pro) untuk sub-agen yang melakukan perutean atau pemformatan sederhana. Simpan model yang lebih capable untuk agen yang melakukan penalaran kompleks.

Bagaimana Techsy Mendekati Pengembangan Agen AI

Di Techsy, kami telah membangun sistem multi-agen untuk klien menggunakan ADK, LangGraph, dan CrewAI. Pilihan kerangka kerja tergantung pada tumpukan teknologi Anda: jika Anda sudah berada di Google Cloud, ADK menghilangkan banyak friksi integrasi. Jika Anda memerlukan dukungan LLM multi-provider sejak hari pertama, LangGraph memberi Anda lebih banyak fleksibilitas.

Keterlibatan khas kami dimulai dengan konsultasi arsitektur, memetakan kasus penggunaan Anda ke pola agen yang tepat, diikuti oleh pengembangan prototipe dan penerapan Cloud Run. Kami menemukan bahwa tim menghemat 2-3 minggu dengan mendapatkan arsitektur yang benar di awal daripada melakukan refactoring nanti.

Membangun agen AI untuk tim Anda? Dapatkan konsultasi gratis, kami akan membantu Anda memilih kerangka kerja dan strategi penerapan yang tepat.

Error Umum dan Pemecahan Masalah

Ini adalah error yang paling sering kami temui saat mulai menggunakan ADK. Hemat waktu debugging Anda:

Tips debugging: adk web adalah sahabat terbaik Anda di sini. Ini menunjukkan jejak percakapan lengkap, setiap panggilan model, pemanggilan alat, dan delegasi agen, secara real time. Ketika sesuatu salah dalam sistem multi-agen, UI web menunjukkan tepat di mana rantai tersebut putus.

FAQ

Apa itu Google ADK?

Agent Development Kit (ADK) dari Google adalah kerangka kerja Python open-source untuk membangun, mengevaluasi, dan menerapkan agen AI. ADK dioptimalkan untuk model Google Gemini tetapi mendukung 100+ LLM melalui integrasi LiteLLM. Kekuatan inti ADK adalah orkestrasi multi-agen asli dengan alat bawaan, UI pengembangan, dan penerapan Cloud Run satu perintah.

Apakah Google ADK gratis digunakan?

Ya. ADK itu sendiri adalah open-source di bawah lisensi Apache 2.0. Anda memerlukan kunci API Gemini, yang memiliki tier gratis menawarkan 15 permintaan per menit dan 1 juta token per hari. Biaya penerapan cloud tergantung pada pilihan hosting Anda, tier gratis Cloud Run mencakup 2 juta permintaan per bulan.

Apa perbedaan antara Google ADK dan LangChain?

ADK adalah kerangka kerja opini Google yang dioptimalkan untuk Gemini dengan orkestrasi multi-agen asli dan alat penerapan bawaan. LangChain agnostik terhadap model dengan integrasi pihak ketiga yang lebih luas tetapi kompleksitas yang jauh lebih tinggi. ADK lebih baik untuk tim yang mengutamakan Gemini dan menginginkan penerapan cepat; LangChain cocok untuk setup multi-provider yang membutuhkan fleksibilitas maksimal.

Apakah Google ADK mendukung sistem multi-agen?

Ya, dan itu adalah fitur unggulan ADK. Anda membuat agen root yang mendelegasikan ke sub-agen khusus berdasarkan permintaan pengguna. ADK juga menawarkan SequentialAgent, ParallelAgent, dan LoopAgent untuk orkestrasi alur kerja deterministik. Pola agen-sebagai-alat memungkinkan agen memanggil agen lain sebagai fungsi yang dapat dipanggil.

Bagaimana cara menerapkan agen Google ADK?

Jalankan adk deploy cloud_run --project YOUR_PROJECT --region us-central1 untuk penerapan serverless ke Google Cloud Run. Tambahkan --with_ui untuk menyertakan antarmuka obrolan berbasis browser. Anda juga dapat menerapkan ke Vertex AI Agent Engine untuk hosting terkelola, atau membangun kontainer Docker untuk infrastruktur kustom.

Bisakah Google ADK menggunakan model selain Gemini?

Ya. ADK mendukung 100+ model melalui integrasi LiteLLM, termasuk Anthropic Claude, OpenAI GPT-4, Meta Llama, dan Mistral. Atur parameter model ke string model LiteLLM, misalnya, litellm/anthropic/claude-3-sonnet atau litellm/openai/gpt-4o. Model Gemini bekerja secara native tanpa awalan LiteLLM.

Apa itu ADK Web UI?

Antarmuka debugging berbasis browser yang diluncurkan dengan adk web your_agent_folder. Ini menampilkan jejak percakapan real time, panggilan alat, rantai delegasi agen, dan perubahan state saat terjadi. Web UI sangat penting untuk debugging sistem multi-agen karena menunjukkan sub-agen mana yang menangani setiap permintaan.

Apakah Google ADK mendukung MCP (Model Context Protocol)?

Ya. ADK memiliki dukungan native Model Context Protocol, memungkinkan agen terhubung ke server alat apa pun yang kompatibel dengan MCP untuk alat eksternal dan sumber data. Ini membuat agen ADK dapat dioperasikan dengan ekosistem MCP yang berkembang. Untuk latar belakang tentang protokol tersebut, lihat panduan MCP kami.

Bagaimana cara menguji agen ADK?

ADK dilengkapi dengan evaluator bawaan: ResponseEvaluator untuk memeriksa kualitas output terhadap jawaban yang diharapkan, dan TrajectoryEvaluator untuk memverifikasi apakah agen memanggil alat yang tepat dalam urutan yang tepat. Tulis kasus uji sebagai file JSON yang mendefinisikan input, output yang diharapkan, dan urutan panggilan alat yang diharapkan, lalu jalankan dengan pytest.

Versi Python apa yang diperlukan Google ADK?

ADK memerlukan Python 3.9 atau lebih tinggi. Python 3.10+ direkomendasikan untuk dukungan type hinting penuh, yang penting karena ADK menggunakan type hints untuk menghasilkan skema alat. Python 3.11 atau 3.12 juga menawarkan peningkatan kinerja yang berarti untuk beban kerja agen. Instal dengan pip install google-adk.