Google menggunakan teknologi AI untuk menerjemahkan konten ke dalam bahasa pilihan Anda. Terjemahan AI mungkin mengandung kesalahan.

Membangun Sistem Multiagen

1. Pengantar

Ringkasan

Dalam lab ini, Anda akan melampaui chatbot sederhana dan membangun sistem multi-agen terdistribusi.

Meskipun satu LLM dapat menjawab pertanyaan, kompleksitas dunia nyata sering kali memerlukan peran khusus. Anda tidak meminta engineer backend untuk mendesain UI, dan Anda tidak meminta desainer untuk mengoptimalkan kueri database. Demikian pula, kita dapat membuat agen AI khusus yang berfokus pada satu tugas dan berkoordinasi satu sama lain untuk memecahkan masalah yang kompleks.

Anda akan membangun Sistem Pembuatan Kursus yang terdiri dari:

Agen Peneliti: Menggunakan google_search untuk menemukan informasi terbaru.
Agen Penilai: Mengevaluasi kualitas dan kelengkapan riset.
Agen Pembuat Konten: Mengubah riset menjadi kursus terstruktur.
Agen Pengelola: Mengelola alur kerja dan komunikasi antara spesialis ini.

Prasyarat

Pengetahuan Python dasar.
Memiliki pengetahuan tentang Konsol Google Cloud.

Yang akan Anda lakukan

Tentukan agen pengguna alat (researcher) yang dapat menelusuri web.
Implementasikan output terstruktur dengan Pydantic untuk judge.
Terhubung ke agen jarak jauh menggunakan protokol Agent-to-Agent (A2A).
Buatlah LoopAgent untuk menciptakan lingkaran umpan balik antara peneliti dan hakim.
Jalankan sistem terdistribusi secara lokal menggunakan ADK.
Sebarkan sistem multi-agen ke Google Cloud Run.

Prinsip Arsitektur & Orkestrasi

Sebelum kita menulis kode, mari kita pahami bagaimana agen-agen ini bekerja sama. Kami sedang membangun Pipeline Pembuatan Kursus.

Desain Sistem

Diagram Arsitektur

Mengorkestrasi dengan Agen

Agen standar (seperti Peneliti) berfungsi. Agen Pengelola (seperti LoopAgent atau SequentialAgent) mengelola agen lain. Mereka tidak memiliki alat sendiri; "alat" mereka adalah pendelegasian.

LoopAgent: Ini berfungsi seperti loop while dalam kode. Agen ini menjalankan urutan agen berulang kali hingga suatu kondisi terpenuhi (atau iterasi maksimum tercapai). Kami menggunakannya untuk Research Loop:
- Peneliti menemukan informasi.
- Hakim mengkritiknya.
- Jika Judge menampilkan "Fail", EscalationChecker akan membiarkan loop berlanjut.
- Jika Judge mengatakan "Pass", EscalationChecker akan menghentikan loop.
SequentialAgentIni berfungsi seperti eksekusi skrip standar. Agen ini menjalankan agen satu per satu. Kita menggunakannya untuk Pipeline Tingkat Tinggi:
- Pertama, jalankan Research Loop (hingga selesai dengan data yang baik).
- Kemudian, jalankan Content Builder (untuk menulis kursus).

Dengan menggabungkan hal-hal tersebut, kita menciptakan sistem yang tangguh yang dapat melakukan koreksi diri sebelum menghasilkan keluaran akhir.

2. Penyiapan

Penyiapan Lingkungan

Buka Cloud Shell: Klik ikon Activate Cloud Shell di kanan atas Konsol Google Cloud.

Mendapatkan Kode Awal

Buat clone repositori awal ke direktori utama Anda:

cd ~
git clone --depth 1 --filter=blob:none --sparse https://github.com/GoogleCloudPlatform/devrel-demos.git temp-repo && cd temp-repo && git sparse-checkout set agents/build-with-ai/production-ready-ai/prai-roadshow-lab-1-starter && cd .. && mv temp-repo/agents/build-with-ai/production-ready-ai/prai-roadshow-lab-1-starter . && rm -rf temp-repo
cd prai-roadshow-lab-1-starter

Aktifkan API: Jalankan perintah berikut untuk mengaktifkan layanan Google Cloud yang diperlukan:

gcloud services enable \
    run.googleapis.com \
    artifactregistry.googleapis.com \
    cloudbuild.googleapis.com \
    aiplatform.googleapis.com \
    compute.googleapis.com

Buka folder ini di editor Anda.

Instal Dependensi

Kita menggunakan uv untuk pengelolaan dependensi yang cepat.

Instal dependensi project:

# Ensure you have uv installed: pip install uv
uv sync

Siapkan variabel lingkungan.
- Tips: Anda dapat menemukan Project ID di dasbor Konsol Cloud, atau dengan menjalankan gcloud config get-value project.
Kita akan membuat file .env untuk menyimpan variabel ini sehingga Anda dapat memuat ulang variabel tersebut dengan mudah jika sesi Anda terputus.
```
cat <<EOF > .env
export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=true
EOF
```
Sumber variabel lingkungan:
```
source .env
```
Peringatan: Variabel lingkungan tidak dipertahankan di seluruh sesi terminal baru. Jika Anda membuka tab terminal baru, jalankan source .env untuk memulihkannya.

3. 🕵️ Agen Peneliti

Agen Peneliti

Peneliti adalah seorang spesialis. Tugasnya hanya untuk menemukan informasi. Untuk melakukannya, alat ini memerlukan akses ke alat: Google Penelusuran.

Mengapa harus memisahkan Peneliti?

Analisis Mendalam: Mengapa tidak menggunakan satu agen saja untuk melakukan semuanya?

Agen yang kecil dan terfokus lebih mudah untuk dievaluasi dan di-debug. Jika hasil riset buruk, Anda dapat mengulangi perintah Peneliti. Jika format kursusnya buruk, Anda perlu melakukan iterasi pada Content Builder. Dalam perintah "lakukan semuanya" yang monolitik, memperbaiki satu hal sering kali merusak hal lain.

Jika Anda bekerja di Cloud Shell, jalankan perintah berikut untuk membuka editor Cloud Shell:
```
cloudshell workspace .
```
Jika Anda bekerja di lingkungan lokal, buka IDE favorit Anda.
Buka agents/researcher/agent.py.
Anda akan melihat kerangka dengan TODO.

Tambahkan kode berikut untuk mendefinisikan agen researcher:

# ... existing imports ...

# Define the Researcher Agent
researcher = Agent(
    name="researcher",
    model=MODEL,
    description="Gathers information on a topic using Google Search.",
    instruction="""
    You are an expert researcher. Your goal is to find comprehensive and accurate information on the user's topic.
    Summarize your findings clearly.
    If you receive feedback that your research is insufficient, use the feedback to refine your next search.
    DO NOT output any function calls. Provide your research directly as text.
    """,
)

root_agent = researcher

Konsep Utama: Penggunaan Alat

Saat menggunakan Gemini 3, alat Google Penelusuran otomatis tersedia. Jika Anda menggunakan model lain, misalnya Gemini 2.5, Anda harus meneruskan tools=[google_search] sebagai parameter tambahan ke konstruktor Agent(). ADK menangani kompleksitas dalam mendeskripsikan alat ini ke LLM. Saat model memutuskan bahwa model memerlukan informasi, model akan membuat panggilan alat terstruktur, ADK menjalankan fungsi Python google_search, dan mengembalikan hasilnya ke model.

4. ⚖️ Agen Hakim

Agen Penilaian

Peneliti bekerja keras, tetapi para pemegang gelar LLM bisa jadi malas. Kami memerlukan Penilai untuk meninjau pekerjaan tersebut. Agen Penilai menerima riset dan menampilkan penilaian Lulus/Gagal terstruktur.

Output Terstruktur

Penjelasan Mendalam: Untuk mengotomatiskan alur kerja, kita membutuhkan keluaran yang dapat diprediksi. Ulasan teks yang bertele-tele sulit diuraikan secara terprogram. Dengan menerapkan skema JSON (menggunakan Pydantic), kami memastikan bahwa Judge mengembalikan nilai boolean pass atau fail yang dapat diandalkan oleh kode kami.

Buka agents/judge/agent.py.

Tentukan skema JudgeFeedback dan agen judge.

# 1. Define the Schema
class JudgeFeedback(BaseModel):
    """Structured feedback from the Judge agent."""
    status: Literal["pass", "fail"] = Field(
        description="Whether the research is sufficient ('pass') or needs more work ('fail')."
    )
    feedback: str = Field(
        description="Detailed feedback on what is missing. If 'pass', a brief confirmation."
    )

# 2. Define the Agent
judge = Agent(
    name="judge",
    model=MODEL,
    description="Evaluates research findings for completeness and accuracy.",
    instruction="""
    You are a strict editor.
    Evaluate the 'research_findings' against the user's original request.
    If the findings are missing key info, return status='fail'.
    If they are comprehensive, return status='pass'.
    """,
    output_schema=JudgeFeedback,
    # Disallow delegation because it should only output the schema
    disallow_transfer_to_parent=True,
    disallow_transfer_to_peers=True,
)

root_agent = judge

Konsep Utama: Membatasi Perilaku Agen

Kami menetapkan disallow_transfer_to_parent=True dan disallow_transfer_to_peers=True. Hal ini memaksa Hakim untuk hanya menampilkan JudgeFeedback terstruktur. Agen ini tidak dapat memutuskan untuk "melakukan chat" dengan pengguna atau mendelegasikan tugas kepada agen lain. Hal ini menjadikannya komponen deterministik dalam alur logika kita.

5. 🧪 Pengujian secara Terpisah

Sebelum menghubungkannya, kita dapat memverifikasi bahwa setiap agen berfungsi. ADK memungkinkan Anda menjalankan agen secara individual.

Konsep Utama: Runtime Interaktif

adk run menjalankan lingkungan ringan di mana Anda adalah "pengguna". Hal ini memungkinkan Anda menguji petunjuk agen dan penggunaan alat secara terpisah. Jika agen gagal di sini (misalnya, tidak dapat menggunakan Google Penelusuran), agen pasti akan gagal dalam orkestrasi.

Jalankan Researcher secara interaktif. Perhatikan bahwa kita mengarah ke direktori agen tertentu:
```
# This runs the researcher agent in interactive mode
uv run adk run agents/researcher
```
Pada kolom obrolan, ketik:
```
Find the population of Tokyo in 2020
```
Model harus menggunakan alat Google Penelusuran dan menampilkan jawabannya.Catatan: Jika Anda melihat error yang menunjukkan bahwa project, lokasi, dan penggunaan Vertex belum ditetapkan, pastikan project ID Anda telah ditetapkan dan jalankan perintah berikut:
```
export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=true
```
Keluar dari chat (Ctrl+C).
Jalankan Judge secara interaktif:
```
uv run adk run agents/judge
```
Pada kolom obrolan, simulasikan input berikut:
```
Topic: Tokyo. Findings: Tokyo is a city.
```
Hal ini akan menampilkan status='fail' karena temuan terlalu singkat.

6. ✍️ Agen Pembuat Konten

Pembuat Konten

Content Builder adalah penulis kreatif. Tim ini akan mengambil riset yang telah disetujui dan mengubahnya menjadi kursus.

Buka agents/content_builder/agent.py.

Tentukan agen content_builder.

content_builder = Agent(
    name="content_builder",
    model=MODEL,
    description="Transforms research findings into a structured course.",
    instruction="""
    You are an expert course creator.
    Take the approved 'research_findings' and transform them into a well-structured, engaging course module.

    **Formatting Rules:**
    1. Start with a main title using a single `#` (H1).
    2. Use `##` (H2) for main section headings.
    3. Use bullet points and clear paragraphs.
    4. Maintain a professional but engaging tone.

    Ensure the content directly addresses the user's original request.
    """,
)
root_agent = content_builder

Konsep Utama: Penyebaran Konteks

Anda mungkin bertanya: "Bagaimana Pembuat Konten mengetahui apa yang ditemukan Peneliti?" Di ADK, agen dalam pipeline berbagi session.state. Nanti, di Orchestrator, kita akan mengonfigurasi Peneliti dan Penilai untuk menyimpan outputnya ke status bersama ini. Prompt Content Builder secara efektif memiliki akses ke riwayat ini.

7. 🎻 Sang Pengatur Orkestra

Agen Orchestrator

Orchestrator adalah pengelola tim multi-agen kami. Tidak seperti agen spesialis (Peneliti, Penilai, Pembuat Konten) yang melakukan tugas tertentu, tugas Pengorkestrasi adalah mengoordinasikan alur kerja dan memastikan informasi mengalir dengan benar di antara mereka.

🌐 Arsitektur: Agent-to-Agent (A2A)

Arsitektur A2A

Di lab ini, kita akan membangun sistem terdistribusi. Daripada menjalankan semua agen dalam satu proses Python, kami men-deploy-nya sebagai microservice independen. Hal ini memungkinkan setiap agen diskalakan secara independen dan gagal tanpa membuat seluruh sistem error.

Untuk mewujudkannya, kami menggunakan protokol Agent-to-Agent (A2A).

Protokol A2A

Pembahasan Mendalam: Dalam sistem produksi, agen berjalan di server yang berbeda (atau bahkan cloud yang berbeda). Protokol A2A menciptakan cara standar bagi agen untuk saling menemukan dan berkomunikasi melalui HTTP. RemoteA2aAgent adalah klien ADK untuk protokol ini.

Buka agents/orchestrator/agent.py.
Cari komentar # TODO: Define connections to remote agents atau bagian untuk definisi agen jarak jauh.

Tambahkan kode berikut untuk menentukan koneksi. Pastikan untuk menempatkan setelah impor dan sebelum definisi agen lainnya.

# ... existing code ...

# Connect to the Researcher (Localhost port 8001)
researcher_url = os.environ.get("RESEARCHER_AGENT_CARD_URL", "http://localhost:8001/a2a/agent/.well-known/agent-card.json")
researcher = RemoteA2aAgent(
    name="researcher",
    agent_card=researcher_url,
    description="Gathers information using Google Search.",
    # IMPORTANT: Save the output to state for the Judge to see
    after_agent_callback=create_save_output_callback("research_findings"),
    # IMPORTANT: Use authenticated client for communication
    httpx_client=create_authenticated_client(researcher_url)
)

# Connect to the Judge (Localhost port 8002)
judge_url = os.environ.get("JUDGE_AGENT_CARD_URL", "http://localhost:8002/a2a/agent/.well-known/agent-card.json")
judge = RemoteA2aAgent(
    name="judge",
    agent_card=judge_url,
    description="Evaluates research.",
    after_agent_callback=create_save_output_callback("judge_feedback"),
    httpx_client=create_authenticated_client(judge_url)
)

# Content Builder (Localhost port 8003)
content_builder_url = os.environ.get("CONTENT_BUILDER_AGENT_CARD_URL", "http://localhost:8003/a2a/agent/.well-known/agent-card.json")
content_builder = RemoteA2aAgent(
    name="content_builder",
    agent_card=content_builder_url,
    description="Builds the course.",
    httpx_client=create_authenticated_client(content_builder_url)
)

8. 🛑 Pemeriksa Eskalasi

Loop memerlukan cara untuk berhenti. Jika Hakim mengatakan "Lulus", kita harus segera keluar dari loop dan beralih ke Pembuat Konten.

Logika Kustom dengan BaseAgent

Pembahasan Mendalam: Tidak semua agen menggunakan LLM. Terkadang Anda memerlukan logika Python sederhana. BaseAgent memungkinkan Anda menentukan agen yang hanya menjalankan kode. Dalam hal ini, kita memeriksa status sesi dan menggunakan EventActions(escalate=True) untuk memberi sinyal agar LoopAgent berhenti.

Masih di agents/orchestrator/agent.py.
Temukan placeholder EscalationChecker TODO.

Ganti dengan implementasi berikut:

class EscalationChecker(BaseAgent):
    """Checks the judge's feedback and escalates (breaks the loop) if it passed."""

    async def _run_async_impl(
        self, ctx: InvocationContext
    ) -> AsyncGenerator[Event, None]:
        # Retrieve the feedback saved by the Judge
        feedback = ctx.session.state.get("judge_feedback")
        print(f"[EscalationChecker] Feedback: {feedback}")

        # Check for 'pass' status
        is_pass = False
        if isinstance(feedback, dict) and feedback.get("status") == "pass":
            is_pass = True
        # Handle string fallback if JSON parsing failed
        elif isinstance(feedback, str) and '"status": "pass"' in feedback:
            is_pass = True

        if is_pass:
            # 'escalate=True' tells the parent LoopAgent to stop looping
            yield Event(author=self.name, actions=EventActions(escalate=True))
        else:
            # Continue the loop
            yield Event(author=self.name)

escalation_checker = EscalationChecker(name="escalation_checker")

Konsep Utama: Alur Kontrol melalui Peristiwa

Agen berkomunikasi tidak hanya dengan teks, tetapi juga dengan Peristiwa. Dengan menghasilkan suatu kejadian dengan escalate=True, agen ini mengirimkan sinyal ke induknya (yaitu LoopAgent). LoopAgent diprogram untuk menangkap sinyal ini dan mengakhiri perulangan.

9. 🔁 Siklus Riset

Loop Riset

Kita memerlukan feedback loop: Riset -> Menilai -> (Gagal) -> Riset -> ...

Masih di agents/orchestrator/agent.py.

Tambahkan definisi research_loop. Tempatkan ini setelah kelas EscalationChecker dan instance escalation_checker.

research_loop = LoopAgent(
    name="research_loop",
    description="Iteratively researches and judges until quality standards are met.",
    sub_agents=[researcher, judge, escalation_checker],
    max_iterations=3,
)

Konsep Utama: LoopAgent

LoopAgent berganti-ganti sub_agents secara berurutan.

researcher: Menemukan data.
judge: Mengevaluasi data.
escalation_checker: Menentukan apakah akan yield Event(escalate=True). Jika escalate=True terjadi, loop akan berhenti lebih awal. Jika tidak, proses akan dimulai ulang di peneliti (hingga max_iterations).

10. 🔗 Pipeline Akhir

Saluran Pipa Akhir

Terakhir, jahit semuanya menjadi satu.

Masih di agents/orchestrator/agent.py.

Definisikan root_agent di bagian bawah file. Pastikan ini menggantikan placeholder root_agent = None yang sudah ada.

root_agent = SequentialAgent(
    name="course_creation_pipeline",
    description="A pipeline that researches a topic and then builds a course from it.",
    sub_agents=[research_loop, content_builder],
)

Konsep Utama: Komposisi Hierarkis

Perhatikan bahwa research_loop itu sendiri adalah agen (sebuah LoopAgent). Kita memperlakukannya sama seperti sub-agen lainnya dalam SequentialAgent. Kemampuan untuk menggabungkan ini memungkinkan Anda membangun logika kompleks dengan menyusun pola-pola sederhana (loop di dalam sequence, sequence di dalam router, dll.).

11. 💻 Jalankan Secara Lokal

Sebelum menjalankan semuanya, mari kita lihat cara ADK menyimulasikan lingkungan terdistribusi secara lokal.

Analisis Mendalam: Bagaimana Pembangunan Lokal Bekerja

Dalam arsitektur microservice, setiap agen berjalan sebagai servernya sendiri. Saat Anda melakukan deployment, Anda akan memiliki 4 layanan Cloud Run yang berbeda. Mensimulasikan hal ini secara lokal bisa merepotkan jika Anda harus membuka 4 tab terminal dan menjalankan 4 perintah.

Skrip ini memulai proses uvicorn untuk Peneliti (port 8001), Hakim (8002), dan Pembuat Konten (8003). Ini mengatur variabel lingkungan seperti RESEARCHER_AGENT_CARD_URL dan meneruskannya ke Orchestrator (port 8004). Inilah cara kita akan mengonfigurasinya di cloud nanti.

Aplikasi Berjalan

Jalankan skrip orkestrasi:

perl -pi -e 's/us-central1/global/g' run_local.sh
./run_local.sh

Ini akan memulai 4 proses terpisah.

Mengujinya:
- Jika menggunakan Cloud Shell: Klik tombol Web Preview (kanan atas terminal) -> Preview on port 8080 -> Change port ke 8000.
- Jika dijalankan secara lokal: Buka http://localhost:8000 di browser Anda.
- Prompt: "Buatlah kursus tentang sejarah kopi."
- Mengamati: Orchestrator akan memanggil Peneliti. Output diteruskan ke Hakim. Jika Hakim gagal, loop akan berlanjut.
Penyelesaian Masalah:
- "Internal Server Error" / Error Autentikasi: Jika Anda melihat error autentikasi (misalnya, terkait dengan google-auth), pastikan Anda telah menjalankan gcloud auth application-default login jika berjalan di mesin lokal. Di Cloud Shell, pastikan variabel lingkungan GOOGLE_CLOUD_PROJECT Anda diatur dengan benar.
- Kesalahan Terminal: Jika perintah gagal di jendela terminal baru, ingat untuk mengekspor ulang variabel lingkungan Anda (GOOGLE_CLOUD_PROJECT, dll.).

Menguji Agen Secara Terisolasi: Bahkan ketika sistem lengkap sedang berjalan, Anda dapat menguji agen tertentu dengan menargetkan portnya secara langsung. Ini berguna untuk men-debug komponen tertentu tanpa memicu seluruh rantai.Catatan: Ini adalah endpoint API, bukan halaman web. Anda tidak dapat mengaksesnya melalui peramban. Sebaliknya, gunakan curl untuk memverifikasi bahwa mereka sedang berjalan (misalnya, dengan mengambil kartu agen mereka).

Khusus Peneliti (Port 8001):

Periksa status (dan temukan endpoint url):

curl http://localhost:8001/a2a/agent/.well-known/agent-card.json

Mengirim kueri (menggunakan protokol JSON-RPC A2A):

curl -X POST http://localhost:8001/a2a/agent \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "message/send",
    "id": 1,
    "params": {
      "message": {
        "message_id": "test-1",
        "role": "user",
        "parts": [
          {
            "text": "What is the capital of France?",
            "kind": "text"
          }
        ]
      }
    }
  }'

Judge Only (Port 8002):

Periksa status:

curl http://localhost:8002/a2a/agent/.well-known/agent-card.json

Mengirim kueri:

curl -X POST http://localhost:8002/a2a/agent \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "message/send",
    "id": 1,
    "params": {
      "message": {
        "message_id": "test-2",
        "role": "user",
        "parts": [
          {
            "text": "Topic: Tokyo. Findings: Tokyo is the capital of Japan.",
            "kind": "text"
          }
        ]
      }
    }
  }'

Content Builder Only (Port 8003):

curl http://localhost:8003/a2a/agent/.well-known/agent-card.json

Orchestrator (Port 8004):

curl http://localhost:8004/a2a/agent/.well-known/agent-card.json

12. 🚀 Deploy ke Cloud Run

Validasi utama berjalan di cloud. Kita akan men-deploy setiap agen sebagai layanan terpisah.

Memahami Konfigurasi Penyebaran

Saat men-deploy agen ke Cloud Run, kami meneruskan beberapa variabel lingkungan untuk mengonfigurasi perilaku dan konektivitasnya:

GOOGLE_CLOUD_PROJECT: Memastikan agen menggunakan project Google Cloud yang benar untuk panggilan logging dan Vertex AI.
GOOGLE_GENAI_USE_VERTEXAI: Memberi tahu framework agen (ADK) untuk menggunakan Vertex AI untuk inferensi model, bukan memanggil Gemini API secara langsung.
GOOGLE_CLOUD_LOCATION: Memberi tahu framework agen (ADK) endpoint mana yang akan digunakan.
[AGENT]_AGENT_CARD_URL: Hal ini sangat penting untuk Orchestrator. Petunjuk ini memberi tahu Orchestrator tempat menemukan agen jarak jauh. Dengan menyetel ini ke URL Cloud Run yang di-deploy (khususnya jalur kartu agen), kita memungkinkan Orchestrator menemukan dan berkomunikasi dengan Peneliti, Penilai, dan Pembuat Konten melalui internet.

Deploy Sub-Agen (Paralel):Untuk menghemat waktu, kita akan men-deploy Peneliti, Penilai, dan Pembuat Konten secara bersamaan.Buka tiga tab terminal baru. Di setiap tab baru, jalankan perintah berikut untuk menyiapkan lingkungan Anda:

cd ~/prai-roadshow-lab-1-starter
source .env

Tab 1: Jalankan penyebaran Peneliti:

gcloud run deploy researcher \
  --source agents/researcher/ \
  --region us-west1 \
  --allow-unauthenticated \
  --labels dev-tutorial=prod-ready-1 \
  --set-env-vars GOOGLE_CLOUD_PROJECT=$GOOGLE_CLOUD_PROJECT \
  --set-env-vars GOOGLE_CLOUD_LOCATION=$GOOGLE_CLOUD_LOCATION \
  --set-env-vars GOOGLE_GENAI_USE_VERTEXAI="true"

Tab 2: Jalankan deployment Judge:

gcloud run deploy judge \
  --source agents/judge/ \
  --region us-west1 \
  --allow-unauthenticated \
  --labels dev-tutorial=prod-ready-1 \
  --set-env-vars GOOGLE_CLOUD_PROJECT=$GOOGLE_CLOUD_PROJECT \
  --set-env-vars GOOGLE_CLOUD_LOCATION=$GOOGLE_CLOUD_LOCATION \
  --set-env-vars GOOGLE_GENAI_USE_VERTEXAI="true"

Tab 3: Jalankan deployment Content Builder:

gcloud run deploy content-builder \
  --source agents/content_builder/ \
  --region us-west1 \
  --allow-unauthenticated \
  --labels dev-tutorial=prod-ready-1 \
  --set-env-vars GOOGLE_CLOUD_PROJECT=$GOOGLE_CLOUD_PROJECT \
  --set-env-vars GOOGLE_CLOUD_LOCATION=$GOOGLE_CLOUD_LOCATION \
  --set-env-vars GOOGLE_GENAI_USE_VERTEXAI="true"

Ambil URL: Setelah ketiga deployment selesai, kembali ke terminal asli (tempat Anda akan men-deploy Orchestrator). Jalankan perintah berikut untuk mengambil URL layanan:

RESEARCHER_URL=$(gcloud run services describe researcher --region us-west1 --format='value(status.url)')
JUDGE_URL=$(gcloud run services describe judge --region us-west1 --format='value(status.url)')
CONTENT_BUILDER_URL=$(gcloud run services describe content-builder --region us-west1 --format='value(status.url)')

echo "Researcher: $RESEARCHER_URL"
echo "Judge: $JUDGE_URL"
echo "Content Builder: $CONTENT_BUILDER_URL"

Deploy Orchestrator: Gunakan variabel lingkungan yang diambil untuk mengonfigurasi Orchestrator.

gcloud run deploy orchestrator \
  --source agents/orchestrator/ \
  --region us-west1 \
  --allow-unauthenticated \
  --labels dev-tutorial=prod-ready-1 \
  --set-env-vars RESEARCHER_AGENT_CARD_URL=$RESEARCHER_URL/a2a/agent/.well-known/agent-card.json \
  --set-env-vars JUDGE_AGENT_CARD_URL=$JUDGE_URL/a2a/agent/.well-known/agent-card.json \
  --set-env-vars CONTENT_BUILDER_AGENT_CARD_URL=$CONTENT_BUILDER_URL/a2a/agent/.well-known/agent-card.json \
  --set-env-vars GOOGLE_CLOUD_PROJECT=$GOOGLE_CLOUD_PROJECT \
  --set-env-vars GOOGLE_CLOUD_LOCATION=$GOOGLE_CLOUD_LOCATION \
  --set-env-vars GOOGLE_GENAI_USE_VERTEXAI="true"

Ambil URL:

ORCHESTRATOR_URL=$(gcloud run services describe orchestrator --region us-west1 --format='value(status.url)')
echo $ORCHESTRATOR_URL

Deploy Frontend:

gcloud run deploy course-creator \
    --source app \
    --region us-west1 \
    --allow-unauthenticated \
    --labels dev-tutorial=prod-ready-1 \
    --set-env-vars AGENT_SERVER_URL=$ORCHESTRATOR_URL \
    --set-env-vars GOOGLE_CLOUD_PROJECT=$GOOGLE_CLOUD_PROJECT

Uji Deployment Jarak Jauh: Buka URL Orchestrator yang di-deploy. Sekarang aplikasi berjalan sepenuhnya di cloud, memanfaatkan infrastruktur serverless Google untuk menskalakan agen Anda.Petunjuk: Anda akan menemukan semua layanan mikro dan URL-nya di antarmuka Cloud Run

13. Ringkasan

Selamat! Anda telah berhasil membangun dan menerapkan sistem multi-agen terdistribusi yang siap produksi.

Apa yang telah kita capai

Menguraikan Tugas Kompleks: Alih-alih satu tugas besar, kami membagi pekerjaan ke dalam peran-peran khusus (Peneliti, Juri, Pembuat Konten).
Kendali Mutu yang Diterapkan: Kami menggunakan LoopAgent dan Judge terstruktur untuk memastikan hanya informasi berkualitas tinggi yang mencapai langkah akhir.
Dibangun untuk Produksi: Dengan menggunakan protokol Agent-to-Agent (A2A) dan Cloud Run, kami menciptakan sistem di mana setiap agen merupakan layanan mikro yang independen dan dapat diskalakan. Cara ini jauh lebih andal daripada menjalankan semuanya dalam satu skrip Python.
Orkestrasi: Kami menggunakan SequentialAgent dan LoopAgent untuk menentukan pola alur kontrol yang jelas.

Langkah Berikutnya

Setelah Anda memiliki fondasinya, Anda dapat memperluas sistem ini:

Tambahkan lebih banyak alat: Berikan akses kepada Peneliti ke dokumen internal atau API.
Tingkatkan Sistem Penilaian: Tambahkan kriteria yang lebih spesifik atau bahkan langkah "Manusia dalam Proses".
Tukar Model: Cobalah menggunakan model yang berbeda untuk agen yang berbeda (misalnya, model yang lebih cepat untuk Hakim, model yang lebih kuat untuk Penulis Konten).

Sekarang Anda siap membangun alur kerja agentic yang kompleks dan andal di Google Cloud.