‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

איך יוצרים ופורסים סוכני AI באמצעות Gemma 4 ושרת MCP של BigQuery ב-Cloud Run

1. מבוא

סקירה כללית

מה תלמדו

כיצד לפרוס מודל Gemma 4 על כרטיס מסך RTX 6000 Pro מסוג Cloud Run עם vLLM
איך ליצור סוכן AI באמצעות Agent Development Kit (ADK) ולהשתמש בו עם Gemma 4.
איך מעניקים לסוכני AI גישה לנתונים מובְנים ב-BigQuery באמצעות שרת BigQuery MCP.

Gemma 4 היא משפחה של מודלים של משקל פתוח ברישיון Apache 2 מ-Google DeepMind. המודלים הם מולטי-מודאליים, רב-לשוניים, מציעים חשיבה רציונלית וארכיטקטורה יעילה.

‫Cloud Run היא סביבה ללא שרת לקונטיינרים עם תמיכה ביחידות GPU.

‫Agent Development Kit‏ (ADK) היא מסגרת קוד פתוח לפיתוח סוכנים, שמאפשרת לכם ליצור, לנפות באגים ולפרוס סוכני AI מהימנים בהיקף ארגוני.

BigQuery הוא מחסן נתונים ארגוני מנוהל במלואו וללא שרת, המאפשר לך לאחסן, לבצע שאילתות ולנתח מערכי נתונים עצומים.

Model Context Protocol‏ (MCP) הוא תקן שקובע איך מודלים גדולים של שפה (LLM) ואפליקציות או סוכני AI מתחברים למקורות נתונים חיצוניים. שרתי MCP מאפשרים להשתמש בכלים, במשאבים ובהנחיות שלהם כדי לבצע פעולות ולקבל נתונים מעודכנים משירות לקצה העורפי שלהם. ‫BigQuery MCP Server מספק לסוכני ה-AI שלכם דרך ישירה ומאובטחת לניתוח נתונים ב-BigQuery. שרת ה-MCP המנוהל הזה מסיר את תקורה הניהול, ומאפשר לכם להתמקד בפיתוח סוכנים חכמים.

2. הגדרה ודרישות

מתחילים בהגדרת פרויקט ברירת מחדל ואזור Cloud Run:

לְהַחלִיף<מזהה_פרויקט_שלך> עם מזהה הפרויקט שלך ב-Google Cloud. כדי למצוא את מזהה הפרויקט, לוחצים על שם הפרויקט בחלק העליון של המסוף ומסתכלים על מזהה הפרויקט שמשויך לשם הפרויקט.

PROJECT_ID=<YOUR_PROJECT_ID>

# set the project
gcloud config set project $PROJECT_ID

לְהַחלִיף<YOUR_CLOUD_RUN_REGION> עם אחד מאזורי הענן הבאים:

us-central1
asia-southeast1

# set Cloud Run region
REGION=<YOUR_CLOUD_RUN_REGION>

מגדירים את האזור:

gcloud config set run/region $REGION && echo $REGION > lab2rgn.txt

להלן משתני סביבה שישמשו לאורך 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 הדרושים עבור קודמעבדה זו. ייתכן שייקח 2-3 דקות עד ששינויים ב-API ייכנסו לתוקף.

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. יצירת חשבון שירות

אם לא מציינים חשבון שירות כשיוצרים את שירות Cloud Run או את משימת Cloud Run, מערכת 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

צור קטגוריה של 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 לקטגוריה של Cloud Storage שלכם. משקלי המודלים הם עשרות גיגה-בייט, ויכול להיות שלא יהיה אפשר להוריד אותם למחשב המקומי או ל-Cloud Shell. במקום זאת, השתמש ב-Cloud Build עם מספיק אחסון כדי להכיל משקלי מודל.

העתקת משקלים של מודלים מקטגוריה משותפת של Cloud Storage

ב-Google Cloud יש קטגוריה של Cloud Storage שנגישה לציבור, עם משקלים של מודל Gemma 4.

כדי להעתיק אותם לדלי האחסון שלך, הפעל את הפקודה:

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 APIs והשירותים של גוגל, כולל 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 צריכות להיות הרשאות גישה למשקלי המודל בדלי האחסון שיצרתם.

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

הערה לגבי אופטימיזציה של הביצועים: אופטימיזציה של המשתנים האלה היא איזון בין קצב העברת הנתונים לבין זמן האחזור:

‫MAX_NUM_SEQS לעומת CLOUD_RUN_CONCURRENCY: הערך של CLOUD_RUN_CONCURRENCY צריך להיות גדול לפחות כמו הערך של MAX_NUM_SEQS. כדי להשתמש במלוא היתרונות של התכונה הזו כשחלים שיאים בתנועה, כדאי להגדיר ערך קצת יותר גבוה (למשל, פי 2).
עומס על הזיכרון: גם MAX_MODEL_LEN וגם MAX_NUM_SEQS צורכים זיכרון GPU בשביל מטמון KV. אם אתם נתקלים בשגיאות של חוסר זיכרון (OOM) עם אורכי הקשר גדולים, כדאי להקטין את MAX_NUM_SEQS.
השהיה: זמן בו-זמני גבוה יותר (MAX_NUM_SEQS) מגדיל את התפוקה הכוללת, אך יכול להגדיל את זמן ההשהיה של בקשות בודדות.
שינוי קנה מידה: CLOUD_RUN_MAX_INSTANCES מאפשר לך לשנות קנה מידה אופקית. אם זמן ההשהיה של המופע הבודד שלך מקובל אך אתה זקוק לקיבולת כוללת גדולה יותר, הגדל ערך זה.

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}" \
    --labels dev-tutorial=codelab-cloud-run-adk-bq-mcp \
    --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}"

הפריסה תימשך כמה דקות. אחרי שתסיימו, תהיה לכם סביבה מבוססת-GPU שמריצה את Gemma 4 באמצעות תשתית ללא שרת (serverless) עם שינוי גודל אוטומטי, כולל שינוי גודל לאפס (אין תנועה, אין עלות).

10. בדיקת השירות

לאחר הפריסה, תוכלו לקיים אינטראקציה עם מודל Gemma 4 שלכם באמצעות ממשק ה-API התואם ל-vLLM 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. צור סוכן נתונים באמצעות ערכת פיתוח סוכנים

כתיבת קוד לסוכן

מטרמינל Cloud Shell או מהטרמינל המקומי שלך, צור ספריית שורש עבור אפליקציית הסוכן שלך:

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 חייב להיות ייבוא עבור הסוכן.
requirements.txt רשימת יחסי התלות של 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

איך מנסים את הסוכן באופן מקומי

הערכה לפיתוח סוכנים כוללת את כלי ה-CLI‏ adk – ממשק טרמינל אינטראקטיבי לבדיקת הסוכנים. האפשרות הזו שימושית לבדיקות מהירות, לאינטראקציות מתוסרטות ולצינורות CI/CD. אחת התכונות שהוא מספק היא adk web - ממשק אינטרנט של ADK - דרך פשוטה לפתח ולתקן באגים באופן אינטראקטיבי את הסוכנים שלך. ADK Web אינו מיועד לשימוש בפריסות ייצור, אך מאפשר ניסיון פשוט מאוד של הסוכן.

הפקודה הזו מפעילה את 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, לחצו על כפתור תצוגה מקדימה של אינטרנט .

בממשק המשתמש באינטרנט של ADK, שואלים את הסוכן על הנתונים שיש לו גישה אליהם:

What data do you have?

קוד הסוכן ישתמש במודל Gemma 4 שנפרס ב-Cloud Run. המודל ישתמש בכלים של BigQuery MCP כדי לחקור את מערך הנתונים של citibike. זה ייתן לך סקירה כללית של טבלאות ושדות זמינים במערך הנתונים של Citibike.

12. פריסת הסוכן ב-Cloud Run

הפקודה הזו תפרוס את הסוכן ב-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 \
      -- \
      --labels dev-tutorial=codelab-cloud-run-adk-bq-mcp \
      --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}"

התנסות בסוכן

השתמשנו באפשרות --with_ui עבור פריסת הסוכן שלנו. הסוכן נפרס באמצעות ממשק האינטרנט של ADK.

פותחים את כתובת ה-URL של הסוכן בדפדפן האינטרנט. הפקודה adk deploy החזירה את כתובת ה-URL, ואפשר גם לאחזר אותה באמצעות הפקודה gcloud run services:

gcloud run services describe gemma4-data-agent \
  --project $GOOGLE_CLOUD_PROJECT \
  --region $GOOGLE_CLOUD_REGION \
  --format 'value(status.url)'

תבקש מהסוכן להסיק מסקנות על סמך נתוני Citibike הזמינים:

We have budget for 3 coffee trucks.
We want to find the best city bike stations to place our coffee trucks.

הסוכן צריך לעיין במערך הנתונים של Citibike באמצעות שרת ה-MCP של BigQuery, להריץ כמה שאילתות SQL ולהחזיר רשימה של 3 תחנות Citibike.

13. מעולה!

כל הכבוד, סיימתם את ה-Codelab!

מומלץ לעיין במסמכי התיעוד של Cloud Run.

מה נכלל

איך פורסים את מודל Gemma 4 ביחידת GPU מסוג RTX 6000 Pro ב-Cloud Run
כיצד להגדיר Direct VPC Egress וסטרימינג של מודל vLLM עם Cloud Storage לאתחול מהיר יותר של השירות.
איך ליצור ולפרוס סוכן AI באמצעות ערכה לפיתוח סוכנים (ADK) שמשתמש במודל Gemma 4 LLM ובשרת MCP של BigQuery.

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

מחיקת הקטגוריה של 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}