สร้างและติดตั้งใช้งาน AI Agent ด้วย Gemma 4 และเซิร์ฟเวอร์ MCP ของ BigQuery ใน Cloud Run

1. บทนำ

ภาพรวม

สิ่งที่คุณจะได้เรียนรู้

  • วิธีติดตั้งใช้งานโมเดล Gemma 4 บน Cloud Run GPU ของ RTX 6000 Pro ด้วย vLLM
  • วิธีสร้าง AI Agent โดยใช้ Agent Development Kit (ADK) และใช้ Gemma 4 กับ AI Agent
  • วิธีให้สิทธิ์เข้าถึง Structured Data ใน BigQuery แก่ AI Agent โดยใช้ เซิร์ฟเวอร์ BigQuery MCP

Gemma 4 เป็นกลุ่มผลิตภัณฑ์โมเดลแบบเปิดที่มีน้ำหนักเบาและได้รับอนุญาตภายใต้ Apache 2 จาก Google DeepMind โมเดลนี้เป็นแบบหลายรูปแบบ หลายภาษา มีความสามารถในการให้เหตุผล และมีสถาปัตยกรรมที่มีประสิทธิภาพ

Cloud Run เป็นสภาพแวดล้อมแบบ Serverless สำหรับคอนเทนเนอร์ที่รองรับ GPU

Agent Development Kit (ADK) เป็นเฟรมเวิร์กการพัฒนา Agent แบบโอเพนซอร์สที่ช่วยให้คุณสร้าง แก้ไขข้อบกพร่อง และติดตั้งใช้งาน AI Agent ที่เชื่อถือได้ในระดับองค์กร

BigQuery เป็นคลังข้อมูลสำหรับองค์กรแบบ Serverless ที่มีการจัดการครบวงจร ซึ่งช่วยให้คุณจัดเก็บ ค้นหา และวิเคราะห์ชุดข้อมูลขนาดใหญ่ได้

Model Context Protocol (MCP) กำหนดมาตรฐานวิธีที่โมเดลภาษาขนาดใหญ่ (LLM) และแอปพลิเคชันหรือ Agent AI เชื่อมต่อกับแหล่งข้อมูลภายนอก เซิร์ฟเวอร์ MCP ช่วยให้คุณใช้เครื่องมือ ทรัพยากร และพรอมต์เพื่อดำเนินการและรับข้อมูลที่อัปเดตจากบริการแบ็กเอนด์ได้ เซิร์ฟเวอร์ BigQuery MCP ช่วยให้ AI Agent วิเคราะห์ข้อมูลใน BigQuery ได้โดยตรงและปลอดภัย เซิร์ฟเวอร์ MCP ที่มีการจัดการครบวงจรนี้ช่วยลดภาระในการจัดการ ทำให้คุณมุ่งเน้นไปที่การพัฒนา Agent อัจฉริยะได้

2. การตั้งค่าและข้อกำหนด

เริ่มต้นจากการตั้งค่าโปรเจ็กต์เริ่มต้นและภูมิภาค Cloud Run ดังนี้

# set the project
gcloud config set project YOUR_PROJECT_ID

แทนที่ YOUR_PROJECT_ID ด้วยรหัสโปรเจ็กต์ Google Cloud

# set Cloud Run region
REGION="CLOUD-RUN-REGION"; gcloud config set run/region $REGION && echo $REGION > lab2rgn.txt

แทนที่ CLOUD-RUN-REGION ด้วยภูมิภาค Cloud อย่างใดอย่างหนึ่งต่อไปนี้

  • us-central1
  • asia-southeast1

ต่อไปนี้คือตัวแปรสภาพแวดล้อมที่จะใช้ตลอด Codelab นี้ คุณสามารถบันทึกตัวแปรเหล่านี้ในไฟล์สภาพแวดล้อมและ "source" ตัวแปรเหล่านั้นได้ ตรวจสอบว่าได้ตั้งค่ารหัสโปรเจ็กต์และภูมิภาค (ไม่บังคับ) อย่างถูกต้อง

# Model name on HuggingFace Hub
export MODEL_NAME="google/gemma-4-31B-it"

# Cloud Run Service name
export SERVICE_NAME="gemma4-rtx-vllm-codelab"

# Cloud Project and Region for Cloud Run
export GOOGLE_CLOUD_PROJECT=$(gcloud config get project -q)
export GOOGLE_CLOUD_REGION=$(cat lab2rgn.txt 2> /dev/null || gcloud config get run/region -q)

# Service account for Cloud Run service
export SERVICE_ACCOUNT="vllm-service-sa"
export SERVICE_ACCOUNT_EMAIL="${SERVICE_ACCOUNT}@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com"

# GCS Bucket for the model cache.
export MODEL_CACHE_BUCKET="${GOOGLE_CLOUD_PROJECT}-${GOOGLE_CLOUD_REGION}-hf-model-cache"
# Model cache location in GSC bucket
export GCS_MODEL_LOCATION="gs://${MODEL_CACHE_BUCKET}/model-cache/${MODEL_NAME}"
# Uncomment next line if loading gemma-4-31B-it directly from the public cache bucket
# export GCS_MODEL_LOCATION="gs://vertex-model-garden-public-us/gemma4/gemma-4-31B-it"

# VPC Network for Direct VPC Egress
export VPC_NETWORK="vllm-${GOOGLE_CLOUD_REGION}-net"
export VPC_SUBNET="vllm-${GOOGLE_CLOUD_REGION}-subnet"
export SUBNET_RANGE="10.8.0.0/26"

เปิดใช้ API ที่จำเป็นสำหรับ Codelab นี้ การเปลี่ยนแปลง API อาจใช้เวลา 2-3 นาทีจึงจะมีผล

gcloud services enable --project "${GOOGLE_CLOUD_PROJECT}" \
    run.googleapis.com \
    cloudbuild.googleapis.com \
    artifactregistry.googleapis.com \
    iam.googleapis.com \
    compute.googleapis.com \
    vpcaccess.googleapis.com \
    storage.googleapis.com \
    bigquery.googleapis.com \
    aiplatform.googleapis.com

3. สร้างบัญชีบริการ

หากคุณไม่ได้ระบุบัญชีบริการเมื่อสร้างบริการหรือ Job ของ Cloud Run ระบบจะใช้บัญชีบริการเริ่มต้นของ Compute Engine เราขอแนะนำให้ใช้บัญชีบริการแยกต่างหากสำหรับบริการ Cloud Run เพื่อหลีกเลี่ยงการเรียกใช้บริการด้วยสิทธิ์ที่มากเกินไป

สร้างบัญชีบริการสำหรับบริการ Cloud Run

gcloud iam service-accounts create ${SERVICE_ACCOUNT} \
  --project "${GOOGLE_CLOUD_PROJECT}" \
  --display-name "vLLM Service Account"

4. ตั้งค่า Cloud Storage

สร้าง Bucket ของ Cloud Storage เพื่อจัดเก็บน้ำหนักของโมเดล ซึ่งจะช่วยให้ใช้ Direct VPC Egress เพื่อดาวน์โหลดน้ำหนักของโมเดลได้เร็วขึ้นทุกครั้งที่ Cloud Run เริ่มอินสแตนซ์บริการ

เมื่อใช้ร่วมกับฟีเจอร์ Run:ai Model Streamer ใน vLLM จะช่วยลดเวลาในการโหลดโมเดลได้อย่างมาก

สร้างที่เก็บข้อมูล

ตรวจสอบว่าที่เก็บข้อมูลเป็นที่เก็บข้อมูลแบบภูมิภาคเดียวที่อยู่ในตำแหน่งเดียวกันกับบริการ Cloud Run

gcloud storage buckets create "gs://${MODEL_CACHE_BUCKET}" \
    --uniform-bucket-level-access --public-access-prevention \
    --project "${GOOGLE_CLOUD_PROJECT}" --location "${GOOGLE_CLOUD_REGION}"

5. ดึงและแคชน้ำหนักของโมเดล

จากนั้นดาวน์โหลดโมเดล Gemma 4 ลงใน Bucket ของ Cloud Storage น้ำหนักของโมเดลมีขนาดหลายสิบกิกะไบต์ และการดาวน์โหลดลงในเครื่องของคุณหรือ Cloud Shell ก่อนอาจทำไม่ได้ ให้ใช้ Cloud Build ที่มีพื้นที่เก็บข้อมูลเพียงพอสำหรับเก็บน้ำหนักของโมเดลแทน

คัดลอกน้ำหนักของโมเดลจาก Bucket ของ Cloud Storage ที่แชร์

Google Cloud มี Bucket ของ Cloud Storage ที่เข้าถึงได้แบบสาธารณะซึ่งมีน้ำหนักของโมเดล Gemma 4

หากต้องการคัดลอกน้ำหนักของโมเดลไปยัง Bucket ของพื้นที่เก็บข้อมูล ให้เรียกใช้คำสั่งต่อไปนี้

gcloud builds submit --project="${GOOGLE_CLOUD_PROJECT}" --region="${GOOGLE_CLOUD_REGION}" --no-source \
    --substitutions="_MODEL_NAME=${MODEL_NAME},_GCS_MODEL_LOCATION=${GCS_MODEL_LOCATION}" \
    --config=/dev/stdin <<'EOF'
steps:
- name: 'gcr.io/google.com/cloudsdktool/google-cloud-cli:slim'
  entrypoint: 'bash'
  args:
  - '-c'
  - |
    if [[ "$_GCS_MODEL_LOCATION" == *"vertex-model-garden-public-us"* ]]; then
      echo "Using the public cache bucket."
      exit 0
    fi
    gcloud config set storage/parallel_composite_upload_enabled True
    gcloud config set storage/parallel_composite_upload_threshold 150M
    gcloud config set storage/sliced_object_download_threshold 150M
    MODEL_NAME="$_MODEL_NAME"
    SHORT_NAME="$${MODEL_NAME#*/}"
    gcloud storage cp -r -D "gs://vertex-model-garden-public-us/gemma4/$${SHORT_NAME}" "$_GCS_MODEL_LOCATION"
EOF

6. กำหนดค่าเครือข่ายสำหรับ Direct VPC Egress

การกำหนดค่า Direct VPC Egress ต้องสร้างเครือข่ายและเครือข่ายย่อยที่เปิดใช้การเข้าถึง Google แบบส่วนตัว

ซึ่งจะช่วยให้บริการ Cloud Run เชื่อมต่อกับชุด IP ภายนอกที่ Google API และบริการต่างๆ ใช้ รวมถึง Cloud Storage

สร้างเครือข่าย

gcloud compute networks create "$VPC_NETWORK" \
        --subnet-mode=custom \
        --bgp-routing-mode=regional \
        --project "$GOOGLE_CLOUD_PROJECT"

สร้างเครือข่ายย่อย

gcloud compute networks subnets create "$VPC_SUBNET" \
        --network="$VPC_NETWORK" \
        --region="$GOOGLE_CLOUD_REGION" \
        --range="$SUBNET_RANGE" \
        --enable-private-ip-google-access \
        --project "$GOOGLE_CLOUD_PROJECT"

7. กำหนดค่านโยบายการเข้าถึงบัญชีบริการ

บัญชีบริการ Cloud Run ต้องมีสิทธิ์เข้าถึงน้ำหนักของโมเดลใน Bucket ของพื้นที่เก็บข้อมูลที่คุณสร้างขึ้น

gcloud storage buckets add-iam-policy-binding "gs://${MODEL_CACHE_BUCKET}" \
    --member "serviceAccount:${SERVICE_ACCOUNT_EMAIL}" \
    --role "roles/storage.admin" \
    --project "${GOOGLE_CLOUD_PROJECT}"

8. เริ่มต้นตัวแปรการกำหนดค่า

กำหนดตัวแปรสำหรับทั้งกลไกการอนุมาน vLLM และบริการ Cloud Run

# vLLM variables
export MAX_MODEL_LEN="32767"    # 32767 to improve concurrency. Keep it empty to use model's maximim context length (256K)
export QUANTIZATION_TYPE="fp8"  # Model quantization for faster performance and lower memory usage.
export KV_CACHE_DTYPE="fp8"     # KV-cache quantization to save GPU memory.
export GPU_MEM_UTIL="0.95"      # Fraction of GPU memory to be used by the vLLM engine.
export TENSOR_PARALLEL_SIZE="1" # Partitioning model across GPUs (1 here as we have only 1 GPU).
export MAX_NUM_SEQS="16"         # Max concurrent requests vLLM processes in one batch.

# Cloud Run variables
export CLOUD_RUN_CPU_NUM=20
export CLOUD_RUN_MEMORY_GB=80
export CLOUD_RUN_MAX_INSTANCES=1
export CLOUD_RUN_CONCURRENCY=16

9. ทำให้ใช้งานได้กับ Cloud Run

เตรียมบรรทัดคำสั่งคอนเทนเนอร์ vLLM

vLLM ต้องใช้พารามิเตอร์จำนวนมากเพื่อเรียกใช้โมเดลขนาดใหญ่อย่างรวดเร็วและมีประสิทธิภาพ ระบบจะส่งพารามิเตอร์เหล่านี้เป็นอาร์กิวเมนต์ไปยังคอนเทนเนอร์ที่ติดตั้งใช้งานใน Cloud Run

CONTAINER_ARGS=(
    "vllm"
    "serve"
    "${GCS_MODEL_LOCATION}"
    "--served-model-name" "${MODEL_NAME}"
    "--enable-log-requests"
    "--enable-chunked-prefill"
    "--enable-prefix-caching"
    "--generation-config" "auto"
    "--enable-auto-tool-choice"
    "--tool-call-parser" "gemma4"
    "--reasoning-parser" "gemma4"
    "--dtype" "bfloat16"
    "--quantization" "${QUANTIZATION_TYPE}"
    "--kv-cache-dtype" "${KV_CACHE_DTYPE}"
    "--max-num-seqs" "${MAX_NUM_SEQS}"
    "--gpu-memory-utilization" "${GPU_MEM_UTIL}"
    "--tensor-parallel-size" "${TENSOR_PARALLEL_SIZE}"
    "--load-format" "runai_streamer"
    "--port" "8080"
    "--host" "0.0.0.0"
)

if [[ "${MAX_MODEL_LEN}" != "" ]]; then
    CONTAINER_ARGS+=("--max-model-len" "${MAX_MODEL_LEN}")
fi

export CONTAINER_ARGS_STR="${CONTAINER_ARGS[*]}"

ติดตั้งใช้งานบริการ Cloud Run

เรียกใช้คำสั่งต่อไปนี้เพื่อติดตั้งใช้งานบริการ Cloud Run โปรดทราบประเภท GPU (RTX 6000 Pro), อิมเมจพื้นฐาน (pytorch-vllm-serve:gemma4) และความจำเป็นในการตรวจสอบสิทธิ์เพื่อเรียกใช้บริการ (--no-allow-unauthenticated)

gcloud beta run deploy "${SERVICE_NAME}" \
    --image="us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:gemma4" \
    --project "${GOOGLE_CLOUD_PROJECT}" \
    --region "${GOOGLE_CLOUD_REGION}" \
    --service-account "${SERVICE_ACCOUNT_EMAIL}" \
    --execution-environment gen2 \
    --no-allow-unauthenticated \
    --cpu="${CLOUD_RUN_CPU_NUM}" \
    --memory="${CLOUD_RUN_MEMORY_GB}Gi" \
    --gpu=1 \
    --gpu-type=nvidia-rtx-pro-6000 \
    --no-gpu-zonal-redundancy \
    --no-cpu-throttling \
    --max-instances ${CLOUD_RUN_MAX_INSTANCES} \
    --concurrency ${CLOUD_RUN_CONCURRENCY} \
    --network ${VPC_NETWORK} \
    --subnet ${VPC_SUBNET} \
    --vpc-egress all-traffic \
    --set-env-vars "MODEL_NAME=${MODEL_NAME}" \
    --set-env-vars "GOOGLE_CLOUD_PROJECT=${GOOGLE_CLOUD_PROJECT}" \
    --set-env-vars "GOOGLE_CLOUD_REGION=${GOOGLE_CLOUD_REGION}" \
    --port=8080 \
    --timeout=3600 \
    --cpu-boost \
    --startup-probe tcpSocket.port=8080,initialDelaySeconds=240,failureThreshold=40,timeoutSeconds=10,periodSeconds=15 \
    --command "bash" \
    --args="^;^-c;${CONTAINER_ARGS_STR}"

การติดตั้งใช้งานจะใช้เวลา 2-3 นาที เมื่อเสร็จแล้ว คุณจะมีสภาพแวดล้อมที่ทำงานด้วย GPU ซึ่งแสดง Gemma 4 โดยใช้โครงสร้างพื้นฐานแบบ Serverless ที่มีการปรับขนาดอัตโนมัติ รวมถึงการปรับขนาดเป็น 0 (ไม่มีการรับส่งข้อมูล ไม่มีค่าใช้จ่าย)

10. ทดสอบบริการ

เมื่อติดตั้งใช้งานแล้ว คุณสามารถโต้ตอบกับโมเดล Gemma 4 ได้โดยใช้ vLLM API ที่เข้ากันได้กับ OpenAI

รับ URL ของบริการ

ดึง URL ของบริการ Cloud Run ที่ติดตั้งใช้งาน

SERVICE_URL=$(gcloud run services describe $SERVICE_NAME --project "${GOOGLE_CLOUD_PROJECT}" --region "${GOOGLE_CLOUD_REGION}" --format 'value(status.url)')
echo "Service URL: $SERVICE_URL"

เรียกใช้การอนุมาน

ส่งพรอมต์ไปยังโมเดลโดยใช้ curl

curl -s "$SERVICE_URL/v1/chat/completions" \
  -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "'"${MODEL_NAME}"'",
  "messages": [
    {"role": "user", "content": "Why is the sky blue?"}
  ],
  "chat_template_kwargs": {
    "enable_thinking": true
  },
  "skip_special_tokens": false
}' | jq -r '.choices[0].message.content'

11. สร้าง Data Agent โดยใช้ Agent Development Kit

เขียนโค้ดของ Agent

จากเทอร์มินัล Cloud Shell หรือเทอร์มินัลในเครื่อง ให้สร้างไดเรกทอรีรากสำหรับแอปที่ใช้ Agent ดังนี้

mkdir data_agent

เปิด Cloud Shell Editor หรือเครื่องมือแก้ไขข้อความอื่น แล้วสร้าง agent.py ในไดเรกทอรี data_agent ดังนี้

data_agent/
    agent.py

agent.py

import os
import subprocess

from google.adk.agents import LlmAgent
from google.adk.models.lite_llm import LiteLlm
from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams

import google.auth
from google.auth.transport.requests import Request
from google.oauth2 import id_token

# Fetch Application Default Credentials (ADC)
application_default_credentials, project_id = google.auth.default()
application_default_credentials.refresh(Request())

# Retrieve Google Cloud project to use.
project_id = os.getenv("GOOGLE_CLOUD_PROJECT", project_id)
if not project_id:
    raise ValueError("GOOGLE_CLOUD_PROJECT environment variable is not set.")

if os.getenv("GOOGLE_GENAI_USE_ENTERPRISE", "").lower() not in ["true", "1"]:
    # Using Cloud Run for hosting LLM with LiteLLM wrapper
    api_base = os.getenv(
        "API_BASE",
        os.environ.get("OPENAI_API_BASE", "")
    ).rstrip("/")
    if not api_base:
        raise ValueError("API_BASE environment variable is not set")
    if not api_base.endswith("/v1"):
        api_base += "/v1"

    model_name = os.getenv("MODEL_NAME")
    if not model_name:
        raise ValueError("MODEL_NAME environment variable is not set")
    # Format required by LiteLLM for OpenAI-compatible APIs
    model_name=f"openai/{model_name}"

    # To access the model's Cloud Run service,
    # we need an identity token.
    try:
        model_service_token_string = id_token.fetch_id_token(Request(), api_base)
    except Exception as e:
        # Fallback with using gcloud CLI to get the identity token
        model_service_token_string = subprocess.check_output(
            f"gcloud auth print-identity-token -q",
            shell=True
        ).decode().strip()

    # Gemma 4 in vLLM requires additional parameters in the request body.
    extra_body={
        "chat_template_kwargs": {
            "enable_thinking": True
        },
        "skip_special_tokens": False
    }
    # Configure the model with LiteLLM and an OpenAI-compatible endpoint
    custom_model = LiteLlm(
      model=model_name,
      base_url=api_base,
      api_key=model_service_token_string,
      extra_body=extra_body
    )
    model = custom_model
else:
    # Gemini API in Agent Platform fallback
    model = "gemini-3.5-flash-lite"

# Initialize the MCP Toolset with the connection parameters
bigquery_toolset = MCPToolset(
    connection_params=StreamableHTTPConnectionParams(
        url="https://bigquery.googleapis.com/mcp",
        headers={
            "Authorization": f"Bearer {application_default_credentials.token}",
            "x-goog-user-project": project_id, # This is used for billing
        },
        tool_filter=[
            'get_dataset_info',
            'list_table_ids',
            'get_table_info',
            # Using readonly is a security measure to prevent accidental data modification.
            'execute_sql_readonly',
        ]
    )
)

# Configure the agent

system_instruction = f"""
You are a helpful assistant that can answer questions about data in BigQuery.
To answer the user's question, use data you have access to by using tools `list_table_ids` and `get_table_info`.
Your data is in `bigquery-public-data.new_york_citibike` dataset
   (Citi Bike trips and stations in the NYC area.
    It includes trip records starting from September 2013 and is updated daily.)

Plan of action:
0. ALWAYS start by analyzing dataset.
1. Analyze your data, investigate schema and dimensions by querying distrinct values of columns using `execute_sql_readonly`.
   Output information about tables, columns, their data types and sets of values (for dimensions).
   Note which columns can be joined or used in aggregations/filters, and what type conversion may be needed for joining or aggregating.
   DO NOT MAKE ASSUMPTIONS ABOUT DATA (structure, type, values, relationships) BASED ON YOUR PRIOR KNOWLEDGE. ALWAYS VERIFY YOUR ASSUMPTIONS.
2. Understand and interpret the user's question.
3. Formulate a plan to answer the user's question.
4. Write a SQL query to retrieve relevant data in necessary form.
   This is where you must pay extra attention to column types and dimensions' sets of values.
5. Retrieve data by generating BigQuery SQL and using `execute_sql_readonly`.
   Always use Dry Run to verify SQL correctness.
   Use `{project_id}` to run BigQuery queries (`project_id` parameter of `execute_sql_readonly`).

Do not use LaTeX in your responses. When giving a final answer, use Markdown.
"""

root_agent = LlmAgent(
    model=model,
    name="data_agent",
    instruction=system_instruction,
    description="A helpful assistant that can answer questions using NYC Citibike data.",
    tools=[bigquery_toolset]
)

นอกจากนี้ ADK ยังต้องใช้ __init__.py และ requirements.txt สำหรับการติดตั้งใช้งานด้วย

  • __init__.py ต้องมีการนำเข้าสำหรับ Agent
  • requirements.txt แสดงรายการทรัพยากร Dependency ของ Python ได้แก่ google-adk สำหรับ Agent Development Kit, litellm สำหรับไลบรารี LiteLLM ที่ ADK ใช้ประโยชน์ในการใช้โมเดลที่ไม่ใช่ Gemini และ mcp สำหรับไคลเอ็นต์ Model Context Protocol

คำสั่งต่อไปนี้ช่วยให้คุณสร้าง __init__.py และ requirements.txt ได้

echo "from . import agent" > data_agent/__init__.py
echo -e "google-adk==2.4.*\nlitellm\nmcp==1.29.*" > data_agent/requirements.txt

โครงสร้างโฟลเดอร์สุดท้ายควรมีลักษณะดังนี้

data_agent/
    __init__.py
    agent.py
    requirements.txt

ลองใช้ Agent ในเครื่อง

Agent Development Kit มาพร้อมกับเครื่องมือ CLI adk ซึ่งเป็นอินเทอร์เฟซเทอร์มินัลแบบโต้ตอบสำหรับการทดสอบ Agent เครื่องมือนี้มีประโยชน์สำหรับการทดสอบอย่างรวดเร็ว การโต้ตอบที่เขียนสคริปต์ไว้ และไปป์ไลน์ CI/CD ฟีเจอร์อย่างหนึ่งที่เครื่องมือนี้มีให้คือ adk web ซึ่งเป็น อินเทอร์เฟซเว็บ ADK ที่เป็นวิธีง่ายๆ ในการพัฒนาและแก้ไขข้อบกพร่องของ Agent แบบโต้ตอบ ADK Web ไม่ได้มีไว้สำหรับใช้ในการติดตั้งใช้งานจริง แต่ทำให้การลองใช้ Agent เป็นเรื่องง่ายมาก

คำสั่งนี้จะเปิดใช้ adk web ซึ่งจะเริ่มเว็บเซิร์ฟเวอร์ในเครื่องในพอร์ต 8080

export API_BASE=$(gcloud run services describe $SERVICE_NAME \
  --project $GOOGLE_CLOUD_PROJECT \
  --region $GOOGLE_CLOUD_REGION \
  --format 'value(status.url)')

# If Gemma 4 deployment failed, use Gemini fallback
if [[ "${API_BASE}" == "" ]]; then
  export GOOGLE_GENAI_USE_ENTERPRISE=true
else
  export GOOGLE_GENAI_USE_ENTERPRISE=false
fi

uv tool run --with litellm,"mcp==1.29.*" --from "google-adk[mcp]==2.4.*" adk web --allow_origins="*" --port 8080 .

เมื่อบริการเริ่มต้นแล้ว ให้เปิดหน้าเว็บ ADK ในเครื่องที่ http://localhost:8080/

หากคุณใช้ Google Cloud Shell ให้คลิกปุ่มตัวอย่างเว็บ

ใน UI ของ ADK Web ให้ถาม Agent เกี่ยวกับข้อมูลที่ Agent มีสิทธิ์เข้าถึง

What data do you have?

โค้ดของ Agent จะใช้โมเดล Gemma 4 ที่ติดตั้งใช้งานใน Cloud Run โมเดลจะใช้เครื่องมือ BigQuery MCP เพื่อสำรวจชุดข้อมูล Citibike และจะแสดงภาพรวมของตารางและช่องที่มีในชุดข้อมูล Citibike

12. ติดตั้งใช้งาน Agent ใน Cloud Run

คำสั่งนี้จะติดตั้งใช้งาน Agent ใน Cloud Run โดยใช้ ADK CLI

export API_BASE=$(gcloud run services describe $SERVICE_NAME \
  --project $GOOGLE_CLOUD_PROJECT \
  --region $GOOGLE_CLOUD_REGION \
  --format 'value(status.url)')

# If Gemma 4 deployment failed, use Gemini fallback
if [[ "${API_BASE}" == "" ]]; then
  export GOOGLE_GENAI_USE_ENTERPRISE=true
else
  export GOOGLE_GENAI_USE_ENTERPRISE=false
fi

uv tool run --from google-adk==2.4.0 \
  adk deploy cloud_run \
      --with_ui \
      --project $GOOGLE_CLOUD_PROJECT \
      --region $GOOGLE_CLOUD_REGION \
      --service_name gemma4-data-agent \
      --app_name data_agent \
      data_agent \
      -- \
      --allow-unauthenticated \
      --max-instances 1 \
      --set-env-vars GOOGLE_GENAI_USE_ENTERPRISE=${GOOGLE_GENAI_USE_ENTERPRISE},MODEL_NAME="${MODEL_NAME}",API_BASE="${API_BASE}",GOOGLE_CLOUD_PROJECT="${GOOGLE_CLOUD_PROJECT}"

ลองใช้ Agent

เราใช้ตัวเลือก --with_ui สำหรับการติดตั้งใช้งาน Agent ซึ่งจะติดตั้งใช้งาน Agent ด้วย อินเทอร์เฟซเว็บ ADK

  1. เปิด URL ของ Agent ในเว็บเบราว์เซอร์ คำสั่ง adk deploy จะแสดง URL และคุณยังดึง URL ได้โดยเรียกใช้คำสั่ง gcloud run services ดังนี้
gcloud run services describe gemma4-data-agent \
  --project $GOOGLE_CLOUD_PROJECT \
  --region $GOOGLE_CLOUD_REGION \
  --format 'value(status.url)'
  1. ขอให้ Agent ให้เหตุผลเกี่ยวกับข้อมูล Citibike ที่มี
We have budget for 3 coffee trucks.
We want to find the best city bike stations to place our coffee trucks.

Agent ควรสำรวจชุดข้อมูล Citibike โดยใช้เซิร์ฟเวอร์ BigQuery MCP เรียกใช้การค้นหา SQL 2-3 รายการ และแสดงรายการสถานี Citibike 3 แห่ง

13. ยินดีด้วย

ขอแสดงความยินดีที่ทำ Codelab นี้เสร็จสมบูรณ์

เราขอแนะนำให้คุณอ่านเอกสารประกอบของ Cloud Run

สิ่งที่เราได้พูดถึงไปแล้ว

  • วิธีติดตั้งใช้งานโมเดล Gemma 4 บน GPU ของ Cloud Run RTX 6000 Pro
  • วิธีกำหนดค่า Direct VPC Egress และการสตรีมโมเดล vLLM ด้วย Cloud Storage เพื่อให้บริการเริ่มต้นได้เร็วขึ้น
  • วิธีสร้างและติดตั้งใช้งาน AI Agent ด้วย Agent Development Kit ที่ใช้ Gemma 4 LLM และเซิร์ฟเวอร์ BigQuery MCP

14. ล้างข้อมูล

หากต้องการหลีกเลี่ยงการเรียกเก็บเงินจากบัญชี Google Cloud สำหรับทรัพยากรที่ใช้ในบทแนะนำนี้ คุณสามารถลบโปรเจ็กต์หรือลบทรัพยากรแต่ละรายการได้

ตัวเลือกที่ 1: ลบทรัพยากร

ลบบริการ Cloud Run

gcloud run services delete gemma4-data-agent \
      --project "${GOOGLE_CLOUD_PROJECT}" \
      --region "${GOOGLE_CLOUD_REGION}" \
      --quiet
gcloud run services delete $SERVICE_NAME \
      --project "${GOOGLE_CLOUD_PROJECT}" \
      --region "${GOOGLE_CLOUD_REGION}" \
      --quiet

ลบบัญชีบริการ

gcloud iam service-accounts delete \
      ${SERVICE_ACCOUNT_EMAIL} \
      --project "${GOOGLE_CLOUD_PROJECT}" \
      --quiet

ลบ Bucket ของ Cloud Storage

gcloud storage rm --recursive gs://$MODEL_CACHE_BUCKET

ลบเครือข่ายและเครือข่ายย่อย VPC

gcloud compute networks subnets delete $VPC_SUBNET \
    --region "${GOOGLE_CLOUD_REGION}" \
    --project "${GOOGLE_CLOUD_PROJECT}" \
    --quiet

gcloud compute networks delete $VPC_NETWORK \
    --project "${GOOGLE_CLOUD_PROJECT}" \
    --quiet

ตัวเลือกที่ 2: ลบโปรเจ็กต์

หากต้องการลบโปรเจ็กต์ทั้งหมด ให้ไปที่ จัดการทรัพยากร เลือกโปรเจ็กต์ที่คุณสร้างขึ้นในขั้นตอนที่ 2 แล้วเลือก "ลบ" หากลบโปรเจ็กต์ คุณจะต้องเปลี่ยนโปรเจ็กต์ใน Cloud SDK คุณดูรายการโปรเจ็กต์ทั้งหมดที่มีได้โดยเรียกใช้ gcloud projects list หากต้องการใช้บรรทัดคำสั่งต่อไป คุณสามารถใช้คำสั่งนี้ได้ด้วย

gcloud projects delete ${GOOGLE_CLOUD_PROJECT}