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 bangun

Asisten Papan Lowongan Pintar untuk "TechJobs" — agen ADK yang didukung Gemini yang membantu developer menjelajahi daftar lowongan di bidang teknologi menggunakan filter standar (peran, stack teknologi) dan menemukan pekerjaan melalui deskripsi bahasa alami seperti "Saya ingin pekerjaan jarak jauh yang mengerjakan chatbot AI." 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) menstandardisasi akses alat untuk agen AI, dan cara MCP Toolbox untuk Database menerapkan hal ini pada operasi database
Menyiapkan MCP Toolbox untuk Database 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
Gunakan 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 project ID 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 berwarna 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=techjobs-pwd" >> .env
echo "DB_INSTANCE=jobs-instance" >> .env
echo "DB_NAME=jobs_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_jobs_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 seeding scripts/setup_jobs_db.py menggunakan perintah di bawah

cloudshell edit scripts/setup_jobs_db.py

Kemudian, salin kode berikut ke dalam file scripts/setup_jobs_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)

# Job listings data (fictional, for tutorial purposes only)
JOBS = [
    ("Senior Backend Engineer", "Stripe", "Backend", "Go, PostgreSQL, gRPC, Kubernetes", "$180-250K/year", "San Francisco, Hybrid", 3,
     "Design and build high-throughput microservices powering payment infrastructure for millions of businesses. Optimize Go services for sub-100ms latency at scale, work with PostgreSQL and Redis for data persistence, and deploy on Kubernetes clusters handling billions of API calls."),
    ("Machine Learning Engineer", "Spotify", "Data/AI", "Python, TensorFlow, BigQuery, Vertex AI", "$170-230K/year", "Stockholm, Remote", 2,
     "Build and deploy ML models for music recommendation and personalization systems serving hundreds of millions of listeners. Design feature pipelines in BigQuery, train models using distributed computing, and serve predictions through real-time APIs processing thousands of requests per second."),
    ("Frontend Engineer", "Vercel", "Frontend", "React, TypeScript, Next.js", "$140-190K/year", "Remote", 4,
     "Build developer-facing dashboard interfaces and deployment tools used by millions of developers worldwide. Create responsive, accessible React components for project management, analytics, and real-time deployment monitoring with a focus on developer experience."),
    ("DevOps Engineer", "Datadog", "DevOps", "Terraform, GCP, Docker, Kubernetes, ArgoCD", "$160-220K/year", "New York, Hybrid", 2,
     "Manage cloud infrastructure powering an observability platform used by thousands of engineering teams. Automate deployment pipelines with ArgoCD, manage multi-cloud Kubernetes clusters, and implement infrastructure-as-code with Terraform across production environments."),
    ("Mobile Engineer (Android)", "Grab", "Mobile", "Kotlin, Jetpack Compose, GraphQL", "$120-170K/year", "Singapore, Hybrid", 3,
     "Develop features for a super-app serving millions of users across Southeast Asia. Build modern Android UIs with Jetpack Compose, integrate GraphQL APIs, and optimize app performance for diverse device capabilities and network conditions."),
    ("Data Engineer", "Airbnb", "Data", "Python, Apache Spark, Airflow, BigQuery", "$160-210K/year", "San Francisco, Hybrid", 2,
     "Build data pipelines that process booking, search, and pricing data for a global travel marketplace. Design ETL workflows with Apache Spark and Airflow, maintain data warehouses in BigQuery, and ensure data quality for analytics and machine learning teams."),
    ("Full Stack Engineer", "Revolut", "Full Stack", "TypeScript, Node.js, React, PostgreSQL", "$130-180K/year", "London, Remote", 5,
     "Build the next generation of financial products making banking accessible to millions of users across 35 countries. Develop real-time trading interfaces with React and WebSockets, build Node.js APIs handling market data streams, and design PostgreSQL schemas for financial transactions."),
    ("Site Reliability Engineer", "Cloudflare", "SRE", "Go, Prometheus, Grafana, GCP, Terraform", "$170-230K/year", "Austin, Hybrid", 2,
     "Ensure 99.99% uptime for a global network handling millions of requests per second. Define SLOs, build monitoring dashboards with Prometheus and Grafana, manage incident response, and automate infrastructure scaling across 300+ data centers worldwide."),
    ("Cloud Architect", "Google Cloud", "Cloud", "GCP, Terraform, Kubernetes, Python", "$200-280K/year", "Seattle, Hybrid", 1,
     "Help enterprises modernize their infrastructure on Google Cloud. Design multi-region architectures, lead migration projects from on-premises to GKE, and build reference implementations using Terraform and Cloud Foundation Toolkit."),
    ("Backend Engineer (Payments)", "Square", "Backend", "Java, Spring Boot, PostgreSQL, Kafka", "$160-220K/year", "San Francisco, Hybrid", 3,
     "Build payment processing systems handling millions of transactions for businesses of all sizes. Design event-driven architectures using Kafka, implement idempotent payment flows with Spring Boot, and ensure PCI-DSS compliance across all services."),
    ("AI Engineer", "Hugging Face", "Data/AI", "Python, LangChain, Vertex AI, FastAPI, PostgreSQL", "$150-210K/year", "Paris, Remote", 2,
     "Build AI-powered tools for the largest open-source ML community. Develop RAG pipelines that index and search model documentation, create conversational agents using LangChain, and deploy AI services with FastAPI on cloud infrastructure."),
    ("Platform Engineer", "Coinbase", "Platform", "Rust, Kubernetes, AWS, Terraform", "$180-250K/year", "Remote", 0,
     "Build the infrastructure platform for a leading cryptocurrency exchange. Develop high-performance matching engines in Rust, manage Kubernetes clusters for microservices, and design CI/CD pipelines that enable rapid feature deployment with zero downtime."),
    ("QA Automation Engineer", "Shopify", "QA", "Python, Selenium, Cypress, Jenkins", "$110-160K/year", "Toronto, Hybrid", 3,
     "Design and maintain automated test suites for a commerce platform powering millions of merchants. Build end-to-end test frameworks with Cypress and Selenium, integrate tests into Jenkins CI pipelines, and establish quality gates that prevent regressions in checkout and payment flows."),
    ("Security Engineer", "CrowdStrike", "Security", "Python, SIEM, Kubernetes, Penetration Testing", "$170-240K/year", "Austin, On-site", 1,
     "Protect enterprise customers from cyber threats on a leading endpoint security platform. Conduct penetration testing, design security monitoring with SIEM tools, implement zero-trust networking in Kubernetes environments, and lead incident response for security events."),
    ("Product Engineer", "GitLab", "Full Stack", "Go, React, PostgreSQL, Redis, GCP", "$140-200K/year", "Remote", 4,
     "Own features end-to-end for an all-in-one DevSecOps platform used by millions of developers. Build Go microservices for CI/CD pipelines, create React frontends for code review and project management, and collaborate with product managers to iterate on user-facing features using data-driven development."),
]


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 jobs 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 jobs (
            id SERIAL PRIMARY KEY,
            title VARCHAR NOT NULL,
            company VARCHAR NOT NULL,
            role VARCHAR NOT NULL,
            tech_stack VARCHAR NOT NULL,
            salary_range VARCHAR NOT NULL,
            location VARCHAR NOT NULL,
            openings INTEGER NOT NULL,
            description TEXT NOT NULL,
            description_embedding vector(3072)
        )
    """)


def seed_jobs(cursor, conn):
    """Insert job listings."""
    cursor.execute("SELECT COUNT(*) FROM jobs")
    existing_count = cursor.fetchone()[0]

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

    cursor.executemany("""
        INSERT INTO jobs (title, company, role, tech_stack, salary_range, location, openings, description)
        VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
    """, JOBS)
    conn.commit()
    return len(JOBS)


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

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

    cursor.execute(f"""
        UPDATE jobs
        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_jobs(cursor, conn)
        if seeded > 0:
            print(f"      ✓ Inserted {seeded} jobs")

        # 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 cepat yang 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 menginisialisasi 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 biner bawaan yang siap digunakan di lingkungan Linux. Sekarang, mari kita download di latar belakang karena prosesnya cukup lama. Jalankan perintah berikut untuk mendownload 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.0.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 kita konfigurasi sebelumnya. Proses ini melakukan hal berikut

Perintah pertama yang kita jalankan di sana adalah perintah gcloud sql instances create dengan flag 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 core 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
Beri 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_jobs_db.py

Memahami skrip pengurutan `scripts/setup_jobs_db.py`

Sekarang, beralih ke skrip seeding, 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 jobs_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 tugas 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 sematan 3072 dimensi per deskripsi pekerjaan.

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

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 menstandardisasi 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 tidak terikat dengan agen — perbarui kueri dengan mengedit tools.yaml dan memulai ulang Toolbox, tanpa menyentuh kode agen. Alat yang sama dapat digunakan 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: jobs-db
type: cloud-sql-postgres
project: ${GOOGLE_CLOUD_PROJECT}
region: ${REGION}
instance: ${DB_INSTANCE}
database: ${DB_NAME}
user: postgres
password: ${DB_PASSWORD}

---