Next ‘26 Developer Keynote: Enhancing Agents with Memory

1. บทนำ

ใน Codelab นี้ คุณจะได้ยกระดับเอเจนต์ ADK ไปอีกขั้นด้วยการเพิ่มความรู้ที่คงอยู่และความเชี่ยวชาญเฉพาะทาง คุณจะได้เรียนรู้วิธีจัดการสถานะการสนทนาด้วยเซสชัน Agent Platform, เปิดใช้การเรียนรู้ระยะยาวด้วย Memory Bank และผสานรวมข้อมูลกฎที่ซับซ้อนของเมืองโดยใช้ Spark และ AlloyDB สำหรับ RAG (Retrieval-Augmented Generation)

สิ่งที่คุณต้องดำเนินการ

  • กำหนดค่าเซสชันแพลตฟอร์มของ Agent เพื่อให้การสนทนาคงอยู่
  • ใช้คลังความทรงจำเพื่อให้ตัวแทนได้เรียนรู้จากการโต้ตอบก่อนหน้า
  • ใช้ Spark Lightning Engine เพื่อนำเข้าและประมวลผลเอกสารประกอบกฎของเมือง
  • สร้างระบบ RAG โดยใช้ AlloyDB และ Vector Search
  • ทําให้ Agent ที่ปรับปรุงแล้วใช้งานได้ในแพลตฟอร์ม Agent

สิ่งที่คุณต้องมี

ระยะเวลาโดยประมาณ: 60 นาที

ทรัพยากรที่สร้างในโค้ดแล็บนี้ควรมีค่าใช้จ่ายน้อยกว่า $5

2. ก่อนเริ่มต้น

สร้างโปรเจ็กต์ Google Cloud

  1. ในคอนโซล Google Cloud ในหน้าตัวเลือกโปรเจ็กต์ ให้เลือกหรือสร้างโปรเจ็กต์ Google Cloud
  2. ตรวจสอบว่าได้เปิดใช้การเรียกเก็บเงินสำหรับโปรเจ็กต์ที่อยู่ในระบบคลาวด์แล้ว ดูวิธีตรวจสอบว่าได้เปิดใช้การเรียกเก็บเงินในโปรเจ็กต์แล้วหรือไม่

เริ่มต้น Cloud Shell

Cloud Shell คือสภาพแวดล้อมบรรทัดคำสั่งที่ทำงานใน Google Cloud ซึ่งโหลดเครื่องมือที่จำเป็นไว้ล่วงหน้า

  1. คลิกเปิดใช้งาน Cloud Shell ที่ด้านบนของคอนโซล Google Cloud
  2. เมื่อเชื่อมต่อกับ Cloud Shell แล้ว ให้ยืนยันการตรวจสอบสิทธิ์โดยทำดังนี้
    gcloud auth list
  3. ตรวจสอบว่าได้กำหนดค่าโปรเจ็กต์แล้ว
    gcloud config get project
  4. หากไม่ได้ตั้งค่าโปรเจ็กต์ตามที่คาดไว้ ให้ตั้งค่าดังนี้
    export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID

ยืนยันการตรวจสอบสิทธิ์

gcloud auth list

ยืนยันโปรเจ็กต์

gcloud config get project

ตั้งค่าหากจำเป็น

export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID

เปิดใช้ API

เรียกใช้คำสั่งนี้เพื่อเปิดใช้ API ที่จำเป็นทั้งหมดสำหรับการจัดการเซสชัน การประมวลผล Spark และ AlloyDB

gcloud services enable \
  aiplatform.googleapis.com \
  run.googleapis.com \
  alloydb.googleapis.com \
  dataproc.googleapis.com \
  documentai.googleapis.com \
  storage.googleapis.com \
  secretmanager.googleapis.com

3. ตั้งค่าสภาพแวดล้อม

สำหรับ Codelab นี้ คุณจะได้ใช้สภาพแวดล้อมที่กำหนดค่าไว้ล่วงหน้าในที่เก็บข้อมูลของคีย์โน้ต

  1. โคลนที่เก็บและไปที่โฟลเดอร์โปรเจ็กต์
git clone https://github.com/GoogleCloudPlatform/next-26-keynotes
cd next-26-keynotes/devkey/enhancing-agents-with-memory
  1. ตั้งค่าสภาพแวดล้อมเสมือนของ Python และติดตั้งแพ็กเกจ ADK ที่จำเป็นโดยทำดังนี้
uv venv
source .venv/bin/activate
uv sync

กำหนดค่าตัวแปรสภาพแวดล้อม

Agent ต้องมีการกำหนดค่าที่เฉพาะเจาะจงเพื่อเชื่อมต่อกับแพลตฟอร์ม Agent และ AlloyDB

  1. คัดลอกไฟล์สภาพแวดล้อมตัวอย่าง
cp .env.example .env
  1. เปิด .env และอัปเดตช่องต่อไปนี้
    • GOOGLE_CLOUD_PROJECT: รหัสโปรเจ็กต์
    • GOOGLE_CLOUD_LOCATION: us-central1
    • ALLOYDB_CLUSTER_ID: rules-db
GOOGLE_CLOUD_PROJECT=<YOUR_PROJECT_ID>
GOOGLE_CLOUD_LOCATION=global
GOOGLE_GENAI_USE_VERTEXAI=TRUE
GOOGLE_CLOUD_REGION=us-central1
ALLOYDB_CLUSTER_ID=rules-db
  1. เรียกใช้สคริปต์ตัวช่วยต่อไปนี้เพื่อสร้างอินสแตนซ์ Agent Engine ที่จะใช้สำหรับเซสชันการสนทนาและหน่วยความจำระยะยาว ซึ่งจะสร้าง AGENT_ENGINE_ID ในไฟล์ .env โดยอัตโนมัติ
uv run utils/setup_agent_engine.py

เมื่อดำเนินการสำเร็จแล้ว คุณควรเห็นสิ่งต่อไปนี้

Creating Agent Engine instance...
Successfully created Agent Engine. ID: 1234567890
Updated .env with AGENT_ENGINE_ID=1234567890

4. สร้างเอเจนต์ด้วยการจัดการเซสชัน

ในขั้นตอนนี้ คุณจะเริ่มต้นใช้งาน Marathon Planner Agent ซึ่งสามารถเก็บประวัติการสนทนาไว้ได้หลายรอบ โดยใช้คลาส ADK App และเซสชันแพลตฟอร์ม Agent

เริ่มต้นบริการ Agent และเซสชัน

เปิด planner_agent/agent.py คุณจะเห็นวิธีที่เราเพิ่มคลาส ADK เพื่อผสานรวมเซสชันแพลตฟอร์ม Agent ซึ่งช่วยให้เราสามารถทำให้เอเจนต์เก็บสถานะเมื่อเวลาผ่านไป และแก้ไขบริบทได้ตามต้องการ

from google.adk.agents import LlmAgent
from google.adk.sessions import VertexAiSessionService
from vertexai.agent_engines import AdkApp

PROJECT_ID = os.environ.get("GOOGLE_CLOUD_PROJECT")
REGION = os.environ.get("GOOGLE_CLOUD_REGION", "us-central1")

# Initialize Vertex AI for regional services
if PROJECT_ID:
    vertexai.init(project=PROJECT_ID, location=REGION)

# Define the agent logic
root_agent = LlmAgent(
    name="planner_agent",
    model="gemini-3-flash-preview",
    instruction="You are a helpful marathon planning assistant...",
    tools=[] # We will add tools in the next steps
)

def session_service_builder():
    """Builder for Agent Platform Sessions."""
    return VertexAiSessionService(project=PROJECT_ID, location=REGION)

# Wrap the agent in an AdkApp to manage stateful context
app = AdkApp(
    agent=root_agent,
    session_service_builder=session_service_builder
)

5. เปิดใช้การเรียนรู้ระยะยาวด้วยคลังความทรงจำ

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

เริ่มต้นบริการ Memory Bank

Memory Bank ช่วยให้เอเจนต์เรียกคืนบริบทในเซสชันต่างๆ ได้ อัปเดต planner_agent/agent.py เพื่อรวมบริการหน่วยความจำ

from google.adk.memory import VertexAiMemoryBankService

def memory_service_builder():
    """Builder for Agent Platform Memory Bank."""
    return VertexAiMemoryBankService(
        project=PROJECT_ID,
        location=REGION,
        agent_engine_id=AGENT_ENGINE_ID
    )

ใช้การส่งผ่านข้อมูลหน่วยความจำอัตโนมัติ

เราจะเพิ่ม after_agent_callback เพื่อให้มั่นใจว่าเอเจนต์จะเรียนรู้จากทุกๆ เทิร์น ฟังก์ชันนี้จะทริกเกอร์หลังจากที่ตัวแทนตอบกลับเสร็จสมบูรณ์ ซึ่งจะช่วยให้ "ย่อย" เซสชันและบันทึกความทรงจำที่เกี่ยวข้องไว้ในธนาคารได้

  1. กำหนดฟังก์ชัน Callback
async def auto_save_memories(callback_context):
    """Callback to ingest the session into the memory bank after the turn."""
    # In AdkApp, the memory service is available via the invocation context
    if hasattr(callback_context._invocation_context, 'memory_service') and callback_context._invocation_context.memory_service:
        await callback_context._invocation_context.memory_service.add_session_to_memory(
            callback_context._invocation_context.session
        )
  1. แนบการเรียกกลับไปกับ LlmAgent โดยทำดังนี้
root_agent = LlmAgent(
    # ... other params
    after_agent_callback=[auto_save_memories],
)

6. การตั้งค่า AlloyDB สำหรับ RAG

ก่อนที่จะนำเข้าข้อมูลกฎของเมืองได้ เราต้องมีฐานข้อมูลที่มีประสิทธิภาพสูงเพื่อจัดเก็บข้อมูล ในขั้นตอนนี้ คุณจะสร้างคลัสเตอร์ AlloyDB และเริ่มต้นสคีมาฐานข้อมูลสำหรับการค้นหาเวกเตอร์

1. สร้างคลัสเตอร์และอินสแตนซ์หลักของ AlloyDB

เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อสร้างคลัสเตอร์และอินสแตนซ์หลัก

# Create the cluster
gcloud alloydb clusters create rules-db \
  --password=postgres \
  --region=us-central1

# Create the primary instance with IAM authentication enabled
gcloud alloydb instances create rules-db-primary \
  --instance-type=PRIMARY \
  --cpu-count=2 \
  --region=us-central1 \
  --cluster=rules-db \
  --database-flags=alloydb.iam_authentication=on

2. มอบบทบาท IAM ที่จำเป็น

หากต้องการใช้เซิร์ฟเวอร์ MCP ของ AlloyDB ที่มีการจัดการ ข้อมูลประจำตัวของคุณต้องมีสิทธิ์ที่เฉพาะเจาะจง เรียกใช้คำสั่งต่อไปนี้เพื่อมอบบทบาทที่จำเป็น

export USER_EMAIL=$(gcloud config get-value account)

# Role to use MCP tools
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="user:$USER_EMAIL" \
  --role="roles/mcp.toolUser"

# Role to execute SQL in AlloyDB
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="user:$USER_EMAIL" \
  --role="roles/alloydb.admin"

# Role for IAM database authentication
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="user:$USER_EMAIL" \
  --role="roles/alloydb.databaseUser"

# Create the IAM-based database user
gcloud alloydb users create "$USER_EMAIL" \
  --cluster=rules-db \
  --region=us-central1 \
  --type=IAM_BASED

3. สร้างฐานข้อมูลและตารางผ่าน AlloyDB Studio

เนื่องจากฐานข้อมูลและตาราง AlloyDB ได้รับการจัดการผ่าน SQL เราจึงจะใช้ AlloyDB Studio ในคอนโซล Google Cloud เพื่อสรุปสคีมา

  1. ไปที่ AlloyDB > คลัสเตอร์ แล้วคลิก rules-db
  2. คลิก AlloyDB Studio ในเมนูการนำทางด้านซ้าย
  3. เข้าสู่ระบบโดยใช้ผู้ใช้ postgres และรหัสผ่านที่คุณตั้งค่า (postgres)
  4. เรียกใช้ SQL ต่อไปนี้เพื่อสร้างฐานข้อมูล 
    CREATE DATABASE city_rules;
  5. เปลี่ยนการเชื่อมต่อฐานข้อมูลเป็น city_rules ใน AlloyDB Studio แล้วเรียกใช้ SQL ต่อไปนี้เพื่อติดตั้งส่วนขยายและสร้างตาราง rules 
    -- Install extensions for vector search and ML
CREATE EXTENSION IF NOT EXISTS vector;
CREATE EXTENSION IF NOT EXISTS google_ml_integration CASCADE;

-- Create the rules table
CREATE TABLE IF NOT EXISTS rules (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    text TEXT NOT NULL,
    city TEXT NOT NULL,
    embedding vector(3072) DEFAULT NULL
);

-- Grant your IAM user access to the table (replace with your email)
GRANT ALL PRIVILEGES ON TABLE rules TO "YOUR_EMAIL_ADDRESS";

7. การนำเข้าข้อมูลกฎของเมืองด้วย Spark Lightning Engine

Agent ต้องมีการเชื่อมต่อแหล่งข้อมูลในข้อมูลและบริบทขององค์กรเพื่อวางแผนได้อย่างถูกต้องแม่นยำจริงๆ ไม่ใช่แค่พรอมต์ที่สร้างขึ้นมาอย่างดี ในขั้นตอนนี้ คุณจะใช้ Spark Lightning Engine ใน Dataproc แบบไม่มีเซิร์ฟเวอร์เพื่อประมวลผล PDF ของกฎในเมืองขนาดใหญ่และนำเข้าลงใน AlloyDB

ทำไมจึงควรใช้ Spark Lightning Engine

การเชื่อมต่อแหล่งข้อมูลของเอเจนต์ในวงกว้างต้องประมวลผลข้อมูลที่ไม่มีโครงสร้างจำนวนมหาศาล Spark Lightning Engine เป็นเครื่องมือดำเนินการที่มีประสิทธิภาพสูงสำหรับ Spark ซึ่งช่วยเร่งภาระงานเหล่านี้ได้อย่างมาก เราใช้ที่นี่เพื่อทำการแบ่งกลุ่มตามความหมายในเอกสารโดยใช้ Document AI ของ Google

สำรวจไปป์ไลน์ Spark

ตรรกะการส่งผ่านข้อมูลกำหนดไว้ใน spark-setup/spark_alloydb_processor.py ไปป์ไลน์จะทำตามขั้นตอนต่อไปนี้

  1. แสดงรายการ PDF: ดึงข้อมูล URI ของเอกสารจาก Bucket ของ Google Cloud Storage
  2. การแยกความหมาย: ใช้ UDF (ฟังก์ชันที่ผู้ใช้กำหนด) เพื่อเรียกใช้ Document AI API
  3. เขียนไปยัง AlloyDB: บันทึกข้อความที่แยกออกมาเป็นกลุ่มลงในตาราง AlloyDB ที่ชื่อ rules
# Extract from spark_alloydb_processor.py
def process_document(gcs_uri: str):
    # ... calls Document AI to parse PDF ...
    return chunks

# Parallel processing with Spark Lightning Engine
process_udf = udf(process_document, chunk_schema)
chunked_df = uri_df.withColumn("chunks", process_udf(col("gcs_uri"))) \
                   .select(explode(col("chunks")).alias("chunk")) \
                   .select("chunk.*")

# Save to AlloyDB for Vector Search
chunked_df.write.format("jdbc") \
    .option("url", jdbc_url) \
    .option("dbtable", "rules") \
    .mode("append") \
    .save()

เรียกใช้งานการส่งผ่านข้อมูล

ทริกเกอร์กระบวนการนำเข้าโดยใช้สคริปต์ที่ให้ไว้

./spark-setup/run_dataproc.sh

8. RAG ด้วย AlloyDB

เมื่อข้อมูลกฎของเมืองอยู่ใน AlloyDB แล้ว Agent จะใช้ข้อมูลดังกล่าวเพื่อดำเนินการ Retrieval-Augmented Generation (RAG) ได้ ซึ่งจะช่วยให้มั่นใจได้ว่าแผนการวิ่งมาราธอนเป็นไปตามรหัสเมืองที่เฉพาะเจาะจง

ศักยภาพของ AlloyDB สำหรับ RAG

AlloyDB มีความโดดเด่นในการค้นหาเวกเตอร์ ซึ่งช่วยให้เราจัดเก็บทั้ง Structured Data และการฝังเวกเตอร์ไว้ในที่เดียวกันได้ เอเจนต์สามารถใช้ฟังก์ชัน embedding ในตัวใน AlloyDB เพื่อค้นหาข้อมูลกฎที่เกี่ยวข้องมากที่สุด

เรามีเครื่องมือที่ค้นหา AlloyDB โดยใช้ความคล้ายคลึงของเวกเตอร์เพื่อให้ Agent เข้าถึงข้อมูลนี้ได้ คุณดูตรรกะนี้ได้ใน hybrid_recall.sql ซึ่งแสดงวิธีคำนวณระยะทางระหว่างคำค้นหากับกฎที่เราจัดเก็บไว้

SELECT
    text,
    (embedding <=> 
     embedding('gemini-embedding-001', 
               'Restrictions for running a race on the Las Vegas strip')::vector) 
    as distance
FROM
    rules
WHERE city = 'Las Vegas'
ORDER BY
    distance ASC
LIMIT 5;

อ้างอิงกฎท้องถิ่นใน Agent ด้วยเครื่องมือ RAG

หากต้องการให้ตัวแทนใช้เครื่องมือได้ คุณต้องกำหนดเครื่องมือใน planner_agent/tools.py แล้วลงทะเบียนใน planner_agent/agent.py เราจะใช้เซิร์ฟเวอร์ MCP ของ AlloyDB ระยะไกลที่มีการจัดการจาก Google Cloud เพื่อเชื่อมต่อกับฐานข้อมูล

  1. กำหนดเครื่องมือใน planner_agent/tools.py โดยใช้รูปแบบ "Hybrid Recall" เราจะใช้โปรโตคอล streamable_http เพื่อเชื่อมต่อกับเซิร์ฟเวอร์ MCP ของ AlloyDB ที่มีการจัดการ
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

async def get_local_and_traffic_rules(query: str) -> str:
    """Uses vector search in AlloyDB via managed MCP server."""
    # Vector search query using built-in AlloyDB embedding functions
    sql = f"SELECT text FROM rules WHERE city = 'Las Vegas' ORDER BY embedding <=> google_ml.embedding('gemini-embedding-001', '{query}')::vector ASC LIMIT 5;"
    
    # Establish a streamable HTTP connection to the MCP server
    async with streamablehttp_client(url, headers=get_auth_headers()) as (read_stream, write_stream, _):
        async with ClientSession(read_stream, write_stream) as session:
            await session.initialize()
            result = await session.call_tool(
                "execute_sql",
                arguments={
                    "instance": full_instance_name,
                    "database": "city_rules",
                    "sqlStatement": sql
                }
            )
            return "\n".join([c.text for c in result.content if hasattr(c, 'text')])
  1. ลงทะเบียนเครื่องมือและดำเนินการให้เสร็จสมบูรณ์ planner_agent/agent.py โดยทำดังนี้
# ... imports ...

# Assemble the Agent
root_agent = LlmAgent(
    name="planner_agent",
    model="gemini-3-flash-preview",
    instruction="You are a helpful marathon planning assistant...",
    tools=[
        get_local_and_traffic_rules,
    ],
    after_agent_callback=[auto_save_memories],
)

# 2. Wrap the agent in an AdkApp to manage the stateful lifecycle
app = AdkApp(
    agent=root_agent,
    session_service_builder=session_service_builder,
    memory_service_builder=memory_service_builder
)

9. คำแนะนำจากผู้เชี่ยวชาญเกี่ยวกับทักษะของเอเจนต์

ทักษะของเอเจนต์คือโมดูลแบบสแตนด์อโลนที่มีคำสั่ง คำแนะนำ และแหล่งข้อมูลเฉพาะเพื่อช่วยให้เอเจนต์ทำงานได้อย่างมีประสิทธิภาพมากขึ้น แทนที่จะทำให้พรอมต์ของระบบรกด้วยวิธีการที่ซับซ้อนสำหรับเครื่องมือทุกอย่าง คุณสามารถสรุปความเชี่ยวชาญนั้นไว้ในทักษะที่จะโหลดเมื่อจำเป็นเท่านั้น

Google มีทักษะที่สร้างไว้ล่วงหน้าสำหรับผลิตภัณฑ์ของ Google (เช่น AlloyDB และ BigQuery) เพื่อให้มั่นใจว่าเอเจนต์จะปฏิบัติตามแนวทางปฏิบัติแนะนำในอุตสาหกรรมสำหรับการสืบค้นข้อมูลและการจัดการทรัพยากร คุณสามารถสำรวจรูปแบบเหล่านี้และรูปแบบเฉพาะอื่นๆ ได้ที่ Google Skills Depot คุณจะเห็นทักษะพื้นฐานของ AlloyDB ที่นี่

1. สำรวจไฟล์ทักษะ

เปิดไฟล์ทักษะที่กำหนดค่าไว้ล่วงหน้าที่ planner_agent/skills/get-local-and-traffic-rules/SKILL.md ซึ่งจะมีลักษณะดังนี้

---
name: get-local-and-traffic-rules
description: Retrieve local rules and traffic information for a specific jurisdiction.
---
# get_local_and_traffic_rules Skill

This skill provides guidelines on how to effectively use the `get_local_and_traffic_rules` tool.

## Overview
The `get_local_and_traffic_rules` tool interfaces with an AlloyDB database to perform vector similarity searches on a corpus of rules and traffic information using a provided natural language query.

## Usage Guidelines
1. **Query Specificity**: When calling the tool, provide specific details in the `query` argument. For example, instead of querying "food rules", use "rules regarding food vendors during public events".
2. **Contextual Use**: Use the tool when planning events or activities that require adherence to local municipal or state rules (e.g., street closures, noise ordinances, environmental rules).
3. **Handling Results**: The tool returns a string containing the text of the top 5 most relevant rules. If no error occurs, parse the returned string to inform your planning tasks.
4. **Error Handling**: If an error string is returned (e.g., "Error querying rules: ..."), you must report this failure or attempt an alternative approach if applicable.

## Underlying Mechanism
- The tool uses `google_ml.embedding` to convert the query into a vector representation.
- It calculates distance (`<=>`) against the `embedding` column in the `rules` table on an AlloyDB instance.
- Results are fetched in descending order of similarity, limited to 5 results.

2. วิธีลงทะเบียนทักษะ

ใน planner_agent/agent.py ระบบจะโหลดทักษะจากไดเรกทอรีและเพิ่มลงในเครื่องมือของเอเจนต์ โค้ดจะมีลักษณะดังนี้

import pathlib
from google.adk.skills import load_skill_from_dir
from google.adk.tools import skill_toolset

# Load the AlloyDB skill from its directory
alloydb_skill = load_skill_from_dir(pathlib.Path(__file__).parent / "skills" / "get-local-and-traffic-rules")

# Assemble the Agent with the Skill Toolset
root_agent = LlmAgent(
    name="planner_agent",
    model="gemini-3-flash-preview",
    instruction="You are a helpful marathon planning assistant...",
    tools=[
        get_local_and_traffic_rules,
        skill_toolset.SkillToolset(skills=[alloydb_skill])
    ],
    after_agent_callback=[auto_save_memories],
)

10. ทดสอบ Agent

  1. เริ่ม Agent ในเครื่อง
uv run adk run planner_agent
  1. ถามคำถามเกี่ยวกับกฎของเมือง [user]: What are the rules for running a race on the Las Vegas strip?

Agent จะเรียกใช้เครื่องมือ get_local_and_traffic_rules ดำเนินการค้นหาเวกเตอร์ใน AlloyDB และแสดงคำตอบตามกลุ่มกฎอย่างเป็นทางการที่ Spark ประมวลผล

11. ติดตั้งใช้งาน Agent

ทำให้ใช้งานได้กับ Agent Platform

uv run adk deploy agent_engine \
  --env_file .env \
  planner_agent

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

โปรดลบทรัพยากรที่สร้างขึ้นระหว่างการทำ Codelab นี้เพื่อไม่ให้มีการเรียกเก็บเงินอย่างต่อเนื่อง

ลบคลัสเตอร์ AlloyDB

# Delete the AlloyDB Cluster
gcloud alloydb clusters delete rules-db --region=us-central1 --force

ลบแอป Agent Runtime

คุณสามารถลบอินสแตนซ์ Reasoning Engine ผ่านคอนโซลหรือใช้คำสั่ง gcloud (หากมีชื่อทรัพยากร) ใช้คอนโซลเพื่อให้ง่ายขึ้น

  1. ไปที่หน้าAgent Runtime
  2. เลือก planner_agent -> คลิกปุ่ม 3 จุดทางด้านขวา
  3. คลิกลบ

13. ขอแสดงความยินดี

ยินดีด้วย คุณปรับปรุงเอเจนต์ ADK ด้วยความสามารถด้านหน่วยความจำขั้นสูงและการอ้างอิงข้อมูลเรียบร้อยแล้ว

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

  • Agent แบบเก็บสถานะ: ผสานรวมเซสชันแพลตฟอร์ม Agent เพื่อรักษาบริบทการสนทนา
  • การเรียนรู้ระยะยาว: การต่อเชื่อมธนาคารหน่วยความจำแพลตฟอร์ม Agentเพื่อให้ Agent เรียนรู้จากการโต้ตอบของผู้ใช้
  • การนำเข้าข้อมูล: ใช้ Spark Lightning Engine และ Document AI เพื่อประมวลผลเอกสารที่ไม่มีโครงสร้าง
  • RAG: สร้างระบบ Vector Search ใน AlloyDB เพื่อให้เอเจนต์อิงตามกฎในโลกแห่งความเป็นจริง

ขั้นตอนถัดไป