Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Database sebagai Alat: RAG Agentic dengan ADK, MCP Toolbox, dan Cloud SQL

1. Pengantar

Kualitas agen AI bergantung pada kualitas data yang dapat diaksesnya. Sebagian besar data dunia nyata berada di database — dan menghubungkan agen ke database biasanya berarti menulis pengelolaan koneksi, logika kueri, dan menyematkan pipeline di dalam kode agen Anda. Setiap agen yang memerlukan akses database mengulangi pekerjaan ini, dan setiap perubahan kueri memerlukan deployment ulang agen.

Codelab ini menunjukkan pendekatan yang berbeda. Anda mendeklarasikan alat database dalam file YAML — kueri SQL standar, penelusuran kemiripan vektor, bahkan pembuatan embedding otomatis — dan MCP Toolbox for Databases menangani semua operasi database sebagai server MCP. Kode agen Anda tetap minimal: muat alat, biarkan Gemini memutuskan alat mana yang akan dipanggil.

Yang akan Anda build

Restaurant Concierge untuk "Foodie Finds" — agen ADK yang didukung oleh Gemini yang membantu pengunjung menjelajahi menu restoran menggunakan filter standar (kategori, jenis masakan) dan menemukan hidangan melalui deskripsi bahasa alami seperti "Saya ingin sesuatu yang pedas dan vegetarian". Agen membaca dan menulis ke database Cloud SQL PostgreSQL sepenuhnya melalui MCP Toolbox for Databases, yang menangani semua akses database — termasuk pembuatan embedding otomatis untuk penelusuran vektor. Pada akhirnya, Toolbox dan agen akan berjalan di Cloud Run.

Yang akan Anda pelajari

Cara MCP (Model Context Protocol) menstandarkan akses alat untuk agen AI, dan cara MCP Toolbox for Databases menerapkan hal ini pada operasi database
Menyiapkan MCP Toolbox for Databases sebagai middleware antara agen ADK dan Cloud SQL PostgreSQL
Tentukan alat database secara deklaratif di tools.yaml — tidak ada kode database di agen Anda
Membangun agen ADK yang memuat alat dari server Toolbox yang sedang berjalan menggunakan ToolboxToolset
Buat embedding vektor menggunakan fungsi embedding() bawaan Cloud SQL dan aktifkan penelusuran semantik dengan pgvector
Menggunakan fitur valueFromParam untuk penyerapan vektor otomatis pada operasi tulis
Men-deploy server Toolbox dan agen ADK ke Cloud Run

Prasyarat

Akun Google Cloud dengan akun penagihan uji coba
Pemahaman dasar tentang Python dan SQL
Pengalaman sebelumnya dengan Cloud Database dan ADK akan sangat membantu

2. Menyiapkan Lingkungan Anda

Langkah ini menyiapkan lingkungan Cloud Shell, mengonfigurasi project Google Cloud, dan meng-clone repositori referensi.

Buka Cloud Shell

Buka Cloud Shell di browser Anda. Cloud Shell menyediakan lingkungan yang telah dikonfigurasi sebelumnya dengan semua alat yang Anda perlukan untuk codelab ini. Klik Authorize saat diminta untuk

Kemudian, klik "View" -> "Terminal" untuk membuka terminal.Antarmuka Anda akan terlihat mirip dengan ini

Ini akan menjadi antarmuka utama kita, IDE di atas, terminal di bawah

Menyiapkan direktori kerja Anda

Buat direktori kerja Anda. Semua kode yang Anda tulis dalam codelab ini ada di sini:

mkdir -p ~/build-agent-adk-toolbox-cloudsql
cloudshell workspace ~/build-agent-adk-toolbox-cloudsql && cd ~/build-agent-adk-toolbox-cloudsql

Setelah itu, siapkan beberapa direktori untuk mengelola hal-hal seperti skrip dan log seeding

mkdir -p ~/build-agent-adk-toolbox-cloudsql/scripts
mkdir -p ~/build-agent-adk-toolbox-cloudsql/logs

Menyiapkan project Google Cloud

Buat file .env dengan variabel lokasi:

# For Vertex AI / Gemini API calls
echo "GOOGLE_CLOUD_LOCATION=global" > .env
# For Cloud SQL, Cloud Run, Artifact Registry
echo "REGION=us-central1" >> .env

Untuk menyederhanakan penyiapan project di terminal, download skrip penyiapan project ini ke direktori kerja Anda:

curl -sL https://raw.githubusercontent.com/alphinside/cloud-trial-project-setup/main/setup_verify_trial_project.sh -o setup_verify_trial_project.sh

Jalankan skrip. Skrip ini memverifikasi akun penagihan uji coba Anda, membuat project baru (atau memvalidasi project yang ada), menyimpan ID project Anda ke file .env di direktori saat ini, dan menetapkan project aktif di gcloud.

bash setup_verify_trial_project.sh && source .env

Skrip akan:

Pastikan Anda memiliki akun penagihan uji coba yang aktif
Periksa project yang ada di .env (jika ada)
Buat project baru atau gunakan kembali project yang sudah ada
Menautkan akun penagihan uji coba ke project Anda
Simpan project ID ke .env
Menetapkan project sebagai project gcloud yang aktif

Pastikan project disetel dengan benar dengan memeriksa teks kuning di samping direktori kerja Anda di perintah terminal Cloud Shell. Project ID Anda akan ditampilkan.

Aktifkan API yang Diperlukan

Selanjutnya, kita perlu mengaktifkan beberapa API untuk produk yang akan kita gunakan:

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

Vertex AI API (aiplatform.googleapis.com) — agen Anda menggunakan model Gemini, dan Toolbox menggunakan embedding API untuk penelusuran vektor.
Cloud SQL Admin API (sqladmin.googleapis.com) — Anda menyediakan dan mengelola instance PostgreSQL.
Compute Engine API (compute.googleapis.com) — diperlukan untuk membuat instance Cloud SQL.
Cloud Run, Cloud Build, Artifact Registry — digunakan dalam langkah deployment nanti di codelab ini

3. Menyiapkan Skrip untuk Inisialisasi Database

Langkah ini memulai pembuatan instance Cloud SQL dan menjalankan skrip penyiapan otomatis yang menunggu hingga instance siap, lalu membuat database, mengisinya dengan listingan pekerjaan, dan membuat penyematan — semuanya dalam satu operasi.

Pertama, tambahkan sandi database ke file .env dan muat ulang:

echo "DB_PASSWORD=restaurant-pwd" >> .env
echo "DB_INSTANCE=restaurant-instance" >> .env
echo "DB_NAME=restaurant_db" >> .env
source .env

Membuat skrip Bash untuk pembuatan instance dan database

Kemudian, buat skrip scripts/setup_database.sh dengan perintah berikut

mkdir -p ~/build-agent-adk-toolbox-cloudsql/scripts
cloudshell edit scripts/setup_database.sh

Kemudian, salin kode berikut ke dalam file scripts/setup_database.sh

#!/bin/bash
set -e
source .env

echo "================================================"
echo "Database Setup"
echo "================================================"
echo ""

# Step 1: Create Cloud SQL instance
echo "[1/5] Creating Cloud SQL instance..."

# Check if instance already exists
if gcloud sql instances describe "$DB_INSTANCE" --quiet >/dev/null 2>&1; then
    echo "      Instance already exists"
else
    echo "      Creating instance (takes 5-10 minutes)..."
    gcloud sql instances create "$DB_INSTANCE" \
        --database-version=POSTGRES_17 \
        --tier=db-custom-1-3840 \
        --edition=ENTERPRISE \
        --region="$REGION" \
        --root-password="$DB_PASSWORD" \
        --enable-google-ml-integration \
        --database-flags cloudsql.enable_google_ml_integration=on \
        --quiet
fi
echo "      ✓ Instance ready"
echo ""

# Step 2: Verify instance is ready
echo "[2/5] Verifying instance state..."

STATE=$(gcloud sql instances describe "$DB_INSTANCE" --format='value(state)')

if [ "$STATE" != "RUNNABLE" ]; then
    echo "ERROR: Instance not ready (state: $STATE)"
    exit 1
fi
echo "      ✓ Instance is RUNNABLE"
echo ""

# Step 3: Grant IAM permissions
echo "[3/5] Granting Vertex AI permissions..."

SERVICE_ACCOUNT=$(gcloud sql instances describe "$DB_INSTANCE" \
    --format='value(serviceAccountEmailAddress)')

if [ -z "$SERVICE_ACCOUNT" ]; then
    echo "ERROR: Could not retrieve service account"
    exit 1
fi

gcloud projects add-iam-policy-binding "$GOOGLE_CLOUD_PROJECT" \
    --member="serviceAccount:$SERVICE_ACCOUNT" \
    --role="roles/aiplatform.user" \
    --quiet

echo "      ✓ Permissions granted"
echo ""

# Step 4: Create database
echo "[4/5] Creating database..."

# Check if database already exists
if gcloud sql databases describe "$DB_NAME" \
    --instance="$DB_INSTANCE" --quiet >/dev/null 2>&1; then
    echo "      Database already exists"
else
    gcloud sql databases create "$DB_NAME" \
        --instance="$DB_INSTANCE" \
        --quiet
fi

echo "      ✓ Database '$DB_NAME' ready"
echo ""

# Step 5: Seed database and generate embeddings
echo "[5/5] Seeding database and generating embeddings..."

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
SETUP_SCRIPT="${SCRIPT_DIR}/setup_restaurant_db.py"

if [ ! -f "$SETUP_SCRIPT" ]; then
    echo "ERROR: Setup script not found: $SETUP_SCRIPT"
    exit 1
fi

uv run "$SETUP_SCRIPT"

echo ""
echo "================================================"
echo "Setup complete!"
echo "================================================"
echo ""

Membuat skrip Python untuk pengisian data

Setelah itu, buat file python skrip pengisian data scripts/setup_restaurant_db.py menggunakan perintah di bawah

cloudshell edit scripts/setup_restaurant_db.py

Kemudian, salin kode berikut ke dalam file scripts/setup_restaurant_db.py

import os
import sys
from pathlib import Path
from dotenv import load_dotenv
from google.cloud.sql.connector import Connector
import pg8000
import time

# Load environment variables from .env file
env_path = Path(__file__).parent.parent / '.env'
load_dotenv(env_path)
EMBEDDING_MODEL='gemini-embedding-001'

# Verify required environment variables
required_vars = ['GOOGLE_CLOUD_PROJECT', 'REGION', 'DB_PASSWORD']
missing_vars = [var for var in required_vars if not os.environ.get(var)]

if missing_vars:
    print(f"ERROR: Missing required environment variables: {', '.join(missing_vars)}", file=sys.stderr)
    print(f"", file=sys.stderr)
    print(f"Expected .env file location: {env_path}", file=sys.stderr)
    if not env_path.exists():
        print(f"✗ File not found at that location", file=sys.stderr)
    else:
        print(f"✓ File exists but is missing the variables above", file=sys.stderr)
    print(f"", file=sys.stderr)
    print(f"Make sure your .env file contains:", file=sys.stderr)
    for var in missing_vars:
        print(f"  {var}=<value>", file=sys.stderr)
    sys.exit(1)

# Menu items data
MENU_ITEMS = [
    ("Truffle Mushroom Risotto", "Italian", "Main Course",
     "Arborio rice, truffle oil, porcini mushrooms, parmesan, white wine",
     "$28", "Vegetarian, Gluten-Free", True,
     "A creamy, luxurious risotto made with arborio rice slow-cooked in white wine and mushroom broth, finished with shaved black truffle and aged parmesan. The porcini mushrooms add a deep, earthy flavor that pairs beautifully with the delicate truffle oil drizzled on top."),
    ("Spicy Tuna Tartare", "Japanese", "Appetizer",
     "Ahi tuna, sriracha, sesame oil, avocado, crispy wonton",
     "$22", "Gluten-Free, Dairy-Free", True,
     "Fresh ahi tuna diced and tossed with sriracha aioli, toasted sesame oil, and lime juice, served atop creamy avocado slices with crispy wonton chips. A perfect balance of heat, richness, and crunch inspired by modern Japanese fusion cuisine."),
    ("Lamb Kofta Kebab", "Middle Eastern", "Main Course",
     "Ground lamb, cumin, coriander, yogurt sauce, flatbread",
     "$24", "Halal", True,
     "Hand-formed spiced lamb kebabs grilled over charcoal, seasoned with cumin, coriander, and sumac. Served with warm flatbread, tangy yogurt-cucumber sauce, and a fresh herb salad. A classic Middle Eastern street food elevated with premium ingredients."),
    ("Pad Thai", "Thai", "Main Course",
     "Rice noodles, shrimp, tamarind, peanuts, bean sprouts, lime",
     "$19", "Gluten-Free, Dairy-Free", True,
     "Stir-fried rice noodles with tiger shrimp, scrambled egg, and a sweet-sour tamarind sauce, topped with crushed peanuts, fresh bean sprouts, and a squeeze of lime. This classic Thai street food dish balances sweet, sour, salty, and umami in every bite."),
    ("Margherita Pizza", "Italian", "Main Course",
     "San Marzano tomatoes, fresh mozzarella, basil, olive oil",
     "$18", "Vegetarian", True,
     "A Neapolitan-style pizza with a thin, charred crust topped with crushed San Marzano tomatoes, creamy buffalo mozzarella, fresh basil leaves, and a drizzle of extra virgin olive oil. Simple, classic, and made with imported Italian ingredients."),
    ("Miso Glazed Black Cod", "Japanese", "Main Course",
     "Black cod, white miso, mirin, sake, pickled ginger",
     "$36", "Gluten-Free, Dairy-Free", True,
     "Buttery black cod marinated for 72 hours in a sweet white miso glaze with mirin and sake, then broiled until caramelized. Served with pickled ginger and steamed bok choy. A signature dish inspired by Nobu's iconic preparation."),
    ("Caesar Salad", "American", "Appetizer",
     "Romaine lettuce, parmesan, croutons, anchovy dressing",
     "$14", "Contains Gluten", True,
     "Crisp romaine hearts tossed with a house-made anchovy-garlic dressing, shaved parmesan, and golden sourdough croutons. A timeless salad that serves as the perfect light starter or side dish with grilled proteins."),
    ("Chicken Tikka Masala", "Indian", "Main Course",
     "Chicken thigh, tomato cream sauce, garam masala, basmati rice",
     "$21", "Gluten-Free", True,
     "Tender chunks of tandoori-marinated chicken simmered in a rich, creamy tomato sauce spiced with garam masala, cumin, and fenugreek. Served over fragrant basmati rice with warm garlic naan on the side."),
    ("Chocolate Lava Cake", "French", "Dessert",
     "Dark chocolate, butter, eggs, vanilla, powdered sugar",
     "$15", "Vegetarian", True,
     "A warm, individual-sized chocolate cake with a molten dark chocolate center that flows when you break through the delicate outer shell. Made with 70% Belgian dark chocolate and served with a scoop of vanilla bean ice cream."),
    ("Pho Bo", "Vietnamese", "Main Course",
     "Rice noodles, beef brisket, star anise, cinnamon, bean sprouts, Thai basil",
     "$17", "Gluten-Free, Dairy-Free", True,
     "A deeply aromatic beef broth simmered for 12 hours with star anise, cinnamon, and charred ginger, ladled over rice noodles and thinly sliced beef brisket. Served with fresh Thai basil, bean sprouts, jalapeño, and lime for the table to customize."),
    ("Lobster Bisque", "French", "Appetizer",
     "Lobster, heavy cream, cognac, tarragon, cayenne",
     "$19", "Gluten-Free", True,
     "A velvety smooth soup made from roasted lobster shells, finished with heavy cream, a splash of cognac, and fresh tarragon. Each bowl is garnished with tender lobster meat and a pinch of cayenne for subtle warmth."),
    ("Falafel Plate", "Middle Eastern", "Main Course",
     "Chickpeas, herbs, tahini, pickled vegetables, hummus",
     "$16", "Vegan, Gluten-Free", True,
     "Crispy-on-the-outside, fluffy-on-the-inside chickpea fritters seasoned with fresh parsley, cilantro, and cumin. Served with creamy tahini sauce, house-made hummus, pickled turnips, and warm pita bread."),
    ("Crème Brûlée", "French", "Dessert",
     "Heavy cream, vanilla bean, egg yolks, caramelized sugar",
     "$13", "Vegetarian, Gluten-Free", True,
     "A classic French custard made with Madagascar vanilla bean and farm-fresh egg yolks, topped with a perfectly torched layer of caramelized sugar that cracks with a satisfying snap. Rich, creamy, and elegantly simple."),
    ("Korean BBQ Short Ribs", "Korean", "Main Course",
     "Beef short ribs, soy sauce, sesame, garlic, pear marinade",
     "$32", "Dairy-Free", False,
     "Premium beef short ribs marinated overnight in a sweet and savory blend of soy sauce, Asian pear, garlic, and toasted sesame. Grilled tableside over charcoal and served with lettuce wraps, pickled daikon, and gochujang dipping sauce."),
    ("Tiramisu", "Italian", "Dessert",
     "Mascarpone, espresso, ladyfingers, cocoa, Marsala wine",
     "$14", "Vegetarian, Contains Gluten", True,
     "Layers of espresso-soaked ladyfingers and whipped mascarpone cream flavored with Marsala wine, dusted with premium Dutch cocoa powder. Made fresh daily and chilled for 24 hours to develop rich, complex flavors."),
]


def get_connection():
    """Create a connection to Cloud SQL using the connector."""
    project = os.environ['GOOGLE_CLOUD_PROJECT']
    region = os.environ['REGION']
    password = os.environ['DB_PASSWORD']
    instance = os.environ['DB_INSTANCE']
    database = os.environ['DB_NAME']

    connector = Connector()
    conn = connector.connect(
        f"{project}:{region}:{instance}",
        "pg8000",
        user="postgres",
        password=password,
        db=database
    )
    return conn, connector


def create_schema(cursor):
    """Create extensions and menu_items table."""
    cursor.execute("CREATE EXTENSION IF NOT EXISTS google_ml_integration")
    cursor.execute("CREATE EXTENSION IF NOT EXISTS vector")
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS menu_items (
            id SERIAL PRIMARY KEY,
            name VARCHAR NOT NULL,
            cuisine_type VARCHAR NOT NULL,
            category VARCHAR NOT NULL,
            ingredients VARCHAR NOT NULL,
            price VARCHAR NOT NULL,
            dietary_tags VARCHAR NOT NULL,
            available BOOLEAN NOT NULL DEFAULT TRUE,
            description TEXT NOT NULL,
            description_embedding vector(3072)
        )
    """)


def seed_menu_items(cursor, conn):
    """Insert menu items."""
    cursor.execute("SELECT COUNT(*) FROM menu_items")
    existing_count = cursor.fetchone()[0]

    if existing_count > 0:
        print(f"      {existing_count} menu items already exist, skipping seed")
        return 0

    cursor.executemany("""
        INSERT INTO menu_items (name, cuisine_type, category, ingredients, price, dietary_tags, available, description)
        VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
    """, MENU_ITEMS)
    conn.commit()
    return len(MENU_ITEMS)


def generate_embeddings(cursor, conn):
    """Generate embeddings using Cloud SQL's embedding() function."""
    cursor.execute("SELECT COUNT(*) FROM menu_items WHERE description_embedding IS NULL")
    null_count = cursor.fetchone()[0]

    if null_count == 0:
        print("      All menu items already have embeddings")
        return 0

    cursor.execute(f"""
        UPDATE menu_items
        SET description_embedding = embedding('{EMBEDDING_MODEL}', description)::vector
        WHERE description_embedding IS NULL
    """)
    rows_updated = cursor.rowcount
    conn.commit()
    return rows_updated


def main():
    conn, connector = get_connection()
    cursor = conn.cursor()

    try:
        create_schema(cursor)
        conn.commit()

        seeded = seed_menu_items(cursor, conn)
        if seeded > 0:
            print(f"      ✓ Inserted {seeded} menu items")

        # Waiting for vertex role propagation
        time.sleep(60)
        embedded = generate_embeddings(cursor, conn)
        if embedded > 0:
            print(f"      ✓ Generated {embedded} embeddings")

    except Exception as e:
        print(f"ERROR: {e}", file=sys.stderr)
        sys.exit(1)
    finally:
        cursor.close()
        conn.close()
        connector.close()


if __name__ == "__main__":
    main()

Sekarang, mari kita lanjutkan ke langkah berikutnya

4. Membuat dan Menginisialisasi Database

Sekarang skrip kita siap dieksekusi. Kita akan memerlukan Python untuk mengeksekusi skrip yang sudah disiapkan, jadi mari kita siapkan terlebih dahulu

Menyiapkan project Python

uv adalah pengelola project dan paket Python yang cepat dan ditulis dalam Rust ( dokumentasi uv ). Codelab ini menggunakannya untuk kecepatan dan kesederhanaan dalam memelihara project Python

Inisialisasi project Python dan tambahkan dependensi yang diperlukan:

uv init
uv add cloud-sql-python-connector --extra pg8000
uv add python-dotenv

Perhatikan bahwa kita menggunakan cloud-sql-python-connector Python SDK di sini untuk melakukan inisialisasi koneksi yang aman dengan instance database yang diautentikasi menggunakan Kredensial Default Aplikasi.

Jalankan skrip penyiapan

Sekarang, kita dapat menjalankan skrip penyiapan di latar belakang dan memeriksa output konsol yang akan ditulis ke file logs/atabase_setup.log menggunakan perintah berikut. Anda dapat melanjutkan ke bagian berikutnya sambil menunggu proses ini selesai

mkdir -p ~/build-agent-adk-toolbox-cloudsql/logs
bash scripts/setup_database.sh > logs/database_setup.log 2>&1 &

Download biner Toolbox

Kita akan menggunakan MCP Toolbox dalam tutorial ini. Untungnya, MCP Toolbox dilengkapi dengan program biner yang telah dibuat sebelumnya dan siap digunakan di lingkungan Linux. Sekarang, mari kita download di latar belakang karena prosesnya akan memakan waktu cukup lama. Jalankan perintah berikut untuk mendownload program biner dan memeriksa log output di logs/toolbox_dl.log. Anda dapat melanjutkan ke bagian berikutnya sambil menunggu proses ini selesai

cd ~/build-agent-adk-toolbox-cloudsql
curl -O https://storage.googleapis.com/mcp-toolbox-for-databases/v1.1.0/linux/amd64/toolbox > logs/toolbox_dl.log 2>&1 &

Memahami skrip penyiapan `scripts/setup_database.sh`

Sekarang, mari kita coba memahami skrip penyiapan yang sebelumnya kita konfigurasi. Proses ini melakukan hal berikut

Perintah pertama yang kita jalankan di sana adalah perintah gcloud sql instances create dengan tanda berikut

db-custom-1-3840 adalah tingkat Cloud SQL dengan core khusus terkecil (1 vCPU, RAM 3,75 GB) dalam edisi ENTERPRISE. Anda dapat membaca detail selengkapnya di sini. Core khusus diperlukan untuk integrasi ML Vertex AI — tingkat inti bersama (db-f1-micro, db-g1-small) tidak mendukungnya.
--root-password menyetel sandi untuk pengguna postgres default.
--enable-google-ml-integration memungkinkan integrasi bawaan Cloud SQL dengan Vertex AI, yang memungkinkan Anda memanggil model embedding langsung dari SQL menggunakan fungsi embedding().

Verifikasi apakah instance sudah dalam status RUNNABLE
Berikan izin akun layanan instance Cloud SQL untuk memanggil Vertex AI menggunakan perintah gcloud projects add-iam-policy-binding. Hal ini diperlukan untuk fungsi embedding() bawaan yang akan kita gunakan saat mengisi database
Membuat database
Mengeksekusi skrip pengisian data setup_restaurant_db.py

Memahami skrip awal `scripts/setup_restaurant_db.py`

Sekarang, beralih ke skrip pengisian data, skrip ini melakukan hal berikut:

Melakukan inisialisasi koneksi ke instance database
Menginstal dua ekstensi PostgreSQL:

google_ml_integration — menyediakan fungsi SQL embedding(), yang memanggil model embedding Vertex AI langsung dari SQL. Ini adalah ekstensi tingkat database yang membuat fungsi ML tersedia di dalam restaurant_db. Flag tingkat instance (--enable-google-ml-integration) yang Anda tetapkan selama pembuatan instance memungkinkan VM Cloud SQL menjangkau Vertex AI — ekstensi ini membuat fungsi SQL tersedia dalam database tertentu ini.
vector (pgvector) — menambahkan jenis data vector dan operator jarak untuk menyimpan dan membuat kueri penyematan.

Buat tabel, perhatikan bahwa kolom description_embedding adalah vector(3072) — kolom pgvector yang menyimpan vektor 3072 dimensi.
Menambahkan data item menu awal
Buat data embedding dari kolom description dan isi description_embedding menggunakan integrasi Vertex bawaan melalui fungsi embedding()

embedding('gemini-embedding-001', description) — memanggil model embedding Gemini Vertex AI langsung dari SQL, dengan meneruskan teks description setiap tugas. Ini adalah ekstensi google_ml_integration yang Anda instal dalam skrip awal.
::vector — mentransmisikan array float yang ditampilkan ke jenis vector pgvector sehingga dapat disimpan dan dikueri dengan operator jarak.
UPDATE berjalan di semua 15 baris, menghasilkan satu penyematan 3072 dimensi per deskripsi pekerjaan.

Tindakan ini akan menyiapkan data awal yang akan diakses oleh agen kita

5. Mengonfigurasi MCP Toolbox for Databases

Langkah ini memperkenalkan MCP Toolbox for Databases, mengonfigurasinya untuk terhubung ke instance Cloud SQL Anda, dan menentukan dua alat kueri SQL standar.

Apa itu MCP dan mengapa menggunakan Toolbox?

MCP (Model Context Protocol) adalah protokol terbuka yang menstandarkan cara agen AI menemukan dan berinteraksi dengan alat eksternal. Model ini menentukan model klien-server: agen menghosting klien MCP, dan alat diekspos oleh server MCP. Klien yang kompatibel dengan MCP dapat menggunakan server yang kompatibel dengan MCP — agen tidak memerlukan kode integrasi kustom untuk setiap alat.

MCP Toolbox for Databases adalah server MCP open source yang dibuat khusus untuk akses database. Tanpa itu, Anda akan menulis fungsi Python yang membuka koneksi database, mengelola kumpulan koneksi, membuat kueri berparameter untuk mencegah injeksi SQL, menangani error, dan menyematkan semua kode tersebut di dalam agen Anda. Setiap agen yang memerlukan akses database mengulangi pekerjaan ini. Mengubah kueri berarti men-deploy ulang agen.

Dengan Toolbox, Anda menulis file YAML. Setiap alat dipetakan ke pernyataan SQL berparameter. Toolbox menangani penggabungan koneksi, kueri berparameter, autentikasi, dan kemampuan observasi. Alat dipisahkan dari agen — perbarui kueri dengan mengedit tools.yaml dan memulai ulang Toolbox, tanpa menyentuh kode agen. Alat yang sama berfungsi di ADK, LangGraph, LlamaIndex, atau framework yang kompatibel dengan MCP.

Menulis konfigurasi alat

Sekarang, kita perlu membuat file bernama tools.yaml di Cloud Shell Editor untuk menyiapkan konfigurasi alat

cloudshell edit tools.yaml

File menggunakan YAML multi-dokumen — setiap blok yang dipisahkan oleh --- adalah resource mandiri. Setiap resource memiliki kind yang menyatakan apa resource tersebut (sources untuk koneksi database, tools untuk tindakan yang dapat dipanggil agen) dan type yang menentukan backend (cloud-sql-postgres untuk sumber, postgres-sql untuk alat berbasis SQL). Alat mereferensikan sumbernya berdasarkan name, sehingga Toolbox mengetahui kumpulan koneksi mana yang akan dijalankan. Variabel lingkungan menggunakan sintaksis ${VAR_NAME} dan diselesaikan saat startup.

Sekarang, salin skrip berikut terlebih dahulu ke dalam file tools.yaml

# tools.yaml

# --- Data Source ---
kind: source
name: restaurant-db
type: cloud-sql-postgres
project: ${GOOGLE_CLOUD_PROJECT}
region: ${REGION}
instance: ${DB_INSTANCE}
database: ${DB_NAME}
user: postgres
password: ${DB_PASSWORD}

---