Membangun Agen yang Berstatus dan Dipersonalisasi dengan ADK

1. Pengantar

judul

Masalah "Ikan Mas"

Bayangkan Anda menyewa agen perjalanan untuk merencanakan liburan impian Anda ke Tokyo. Gunakan Agen Sesi untuk melihat cara kerja "Masalah Ikan Mas".

Anda masuk ke kantornya dan berkata:

"Halo! Saya ingin merencanakan perjalanan 2 hari ke Tokyo. Saya tertarik dengan situs bersejarah dan sushi."

Agen menjawab dengan antusias:

"Great! Saya telah merencanakan kunjungan ke Istana Kekaisaran dan makan malam sushi di Sukiyabashi Jiro."

Anda tersenyum dan berkata:

"Kedengarannya bagus. Bisa tolong kirimkan itinerarinya?"

Agen menatap Anda dengan tatapan kosong dan bertanya:

"Halo! Ada yang bisa saya bantu untuk merencanakan perjalanan hari ini?"

Ini adalah "Masalah Ikan Mas". Tanpa memori, setiap interaksi akan dimulai dari awal. Kecerdasannya ada—agen tahu cara merencanakan perjalanan—tetapi kontinuitasnya tidak ada. Agar dapat benar-benar berguna, agen AI perlu mengingat.

Misi Anda Hari Ini

Dalam workshop ini, Anda akan menyelesaikan Masalah Goldfish dengan membangun Agen Perjalanan yang mengingat, belajar, dan beradaptasi. Anda akan mempelajari 6 Level Memori Agen, membuat sistem yang berperilaku lebih seperti asisten pribadi khusus, bukan chatbot.

Level

Konsep

"Kekuatan Super"

Level 1

Sesi & Status

Melakukan percakapan tanpa lupa

Level 2

Status Multi-Agen

Berbagi catatan antaranggota tim

Level 3

Persistensi

Mengingat Anda bahkan setelah sistem dimulai ulang

Level 4

Callback

Memperbarui memori sepenuhnya secara mandiri

Level 5

Alat Kustom

Membaca & menulis profil pengguna terstruktur

Level 6

Memori Multimodal

"Melihat" dan mengingat foto & video

Stack Memori ADK

Sebelum menulis kode, mari kita pahami alat yang kita gunakan. Google Agent Development Kit (ADK) menyediakan cara terstruktur untuk menangani memori:

  1. Sesi: Penampung untuk percakapan. Memori ini menyimpan histori dari apa yang telah dikatakan.
  2. Status: "Scratchpad" nilai kunci yang dilampirkan ke sesi. Agen menggunakan ini untuk menyimpan fakta tertentu (misalnya, destination="Tokyo").
  3. MemoryService: Penyimpanan jangka panjang. Di sinilah kita menyimpan berbagai hal selamanya, seperti preferensi pengguna atau dokumen yang dianalisis.

2. Siapkan

Untuk mendukung agen AI, kita memerlukan dua hal: Project Google Cloud untuk menyediakan fondasi.

Bagian Satu: Mengaktifkan Akun Penagihan

Untuk menjalankan codelab ini, Anda memerlukan akun penagihan dengan sejumlah kredit. Gunakan kredit dari banner di bagian atas codelab ini untuk memulai. Jika Anda sudah terhubung ke akun penagihan, Anda dapat melewati langkah ini.

Bagian Dua: Lingkungan Terbuka

  1. 👉 Klik link ini untuk langsung membuka Cloud Shell Editor
  2. 👉 Jika diminta untuk memberikan otorisasi kapan saja hari ini, klik Authorize untuk melanjutkan. Klik untuk memberikan otorisasi pada Cloud Shell
  3. 👉 Jika terminal tidak muncul di bagian bawah layar, buka terminal:
    • Klik View
    • Klik TerminalMembuka terminal baru di Cloud Shell Editor
  4. 👉💻 Di terminal, verifikasi bahwa Anda sudah diautentikasi dan project ditetapkan ke project ID Anda menggunakan perintah berikut:
    gcloud auth list
  5. 👉💻 Buat clone project bootstrap dari GitHub:
    git clone https://github.com/cuppibla/memory_agent_starter
  6. 👉💻 Jalankan skrip penyiapan dari direktori project.
    cd ~/memory_agent_starter
./init.sh
    Skrip akan menangani sisa proses penyiapan secara otomatis.
  7. 👉💻 Tetapkan Project ID yang diperlukan:
    gcloud config set project $(cat ~/project_id.txt) --quiet

Bagian Tiga: Menyiapkan izin

  1. 👉💻 Aktifkan API yang diperlukan menggunakan perintah berikut. Tindakan ini dapat memerlukan waktu beberapa menit.
    gcloud services enable \
    cloudresourcemanager.googleapis.com \
    servicenetworking.googleapis.com \
    run.googleapis.com \
    aiplatform.googleapis.com \
    compute.googleapis.com
  2. 👉💻 Berikan izin yang diperlukan dengan menjalankan perintah berikut di terminal:
    . ~/memory_agent_starter/set_env.sh

Perhatikan bahwa file .env dibuat untuk Anda. Tindakan ini akan menampilkan informasi project Anda.

3. Fondasi - Sesi & Status

stateful

Konsep: Konteks adalah Hal Terpenting

Bentuk memori yang paling dasar adalah Memori Sesi. Hal ini memungkinkan agen mengetahui bahwa "itu" dalam kalimat "Saya ingin membelinya" mengacu pada sepatu yang Anda bicarakan 10 detik yang lalu.

Di ADK, kami mengelolanya dengan objek Session.

  • Pendekatan Stateless: Membuat sesi baru untuk setiap pesan.
  • Pendekatan Stateful: Membuat satu sesi dan menggunakannya kembali untuk seluruh percakapan.

Langkah 1: Memeriksa Agen

👉💻 Di terminal Cloud Shell, buka file di Cloud Shell Editor dengan menjalankan:

cloudshell edit ~/memory_agent_starter/01_session_agent/agent.py

Buka ~/memory_agent_starter/01_session_agent/agent.py.

👉 Temukan komentar # TODO: Create a root agent di dalam fungsi agent.py.

Ganti seluruh baris ini dengan kode berikut:

root_agent = LlmAgent(
    name="multi_day_trip_agent",
    model="gemini-2.5-flash",
    description="Agent that progressively plans a multi-day trip, remembering previous days and adapting to user feedback.",
    instruction="""
    You are the "Adaptive Trip Planner" 🗺️ - an AI assistant that builds multi-day travel itineraries step-by-step.

    Your Defining Feature:
    You have short-term memory. You MUST refer back to our conversation to understand the trip's context, what has already been planned, and the user's preferences. If the user asks for a change, you must adapt the plan while keeping the unchanged parts consistent.

    Your Mission:
    1.  **Initiate**: Start by asking for the destination, trip duration, and interests.
    2.  **Plan Progressively**: Plan ONLY ONE DAY at a time. After presenting a plan, ask for confirmation.
    3.  **Handle Feedback**: If a user dislikes a suggestion (e.g., "I don't like museums"), acknowledge their feedback, and provide a *new, alternative* suggestion for that time slot that still fits the overall theme.
    4.  **Maintain Context**: For each new day, ensure the activities are unique and build logically on the previous days. Do not suggest the same things repeatedly.
    5.  **Final Output**: Return each day's itinerary in MARKDOWN format.
    """,
    tools=[google_search]
)

Petunjuk memberi tahu LLM untuk mengingat, tetapi kode harus memberikan kemampuan untuk mengingat.

Langkah 2: Dua Skenario

Buka ~/memory_agent_starter/01_session_agent/main.py.

👉 Di terminal Cloud Shell, buka file di Cloud Shell Editor dengan menjalankan:

cloudshell edit ~/memory_agent_starter/01_session_agent/main.py

Buka ~/memory_agent_starter/01_session_agent/main.py, temukan komentar # TODO: Create a runner with in memorysession service di dalam fungsi main.py.

Ganti seluruh baris ini dengan kode berikut:

    runner = Runner(
        agent=agent,
        session_service=session_service,
        app_name=agent.name
    )

👉 Temukan komentar # TODO: create a different session to test di dalam fungsi main.py.

Ganti seluruh baris ini dengan kode berikut:

    tokyo_session_2 = await session_service.create_session(
        app_name=multi_day_agent.name,
        user_id=user_id
    )

Melakukan pengujian

Kita memiliki dua fungsi yang menunjukkan perbedaan antara memori "Ikan Mas" dan "Gajah".

Skenario 1: Stateful (Sesi Bersama)

async def run_trip_same_session_scenario(session_service, user_id):
    # 1. Create ONE session
    trip_session = await session_service.create_session(...)

    # 2. Turn 1
    await run_agent_query(..., trip_session, ...)

    # 3. Turn 2 - REUSING the same session!
    # The agent can "see" Turn 1 because it's in the session history.
    await run_agent_query(..., trip_session, ...)

Skenario 2: Stateless (Sesi Baru Setiap Saat)

async def run_trip_different_session_scenario(session_service, user_id):
    # Turn 1
    tokyo_session = await session_service.create_session(...)
    await run_agent_query(..., tokyo_session, ...)

    # Turn 2 - Creating a FREASH session
    # The agent has NO IDEA what happened in Turn 1.
    tokyo_session_2 = await session_service.create_session(...)
    await run_agent_query(..., tokyo_session_2, ...)

Langkah 3: Jalankan Agen

Mari kita lihat perbedaannya dalam tindakan. Jalankan skrip:

👉💻 Di command line, jalankan command line di bawah:

cd ~/memory_agent_starter
uv run python ~/memory_agent_starter/01_session_agent/main.py

Amati Skenario 1: Agen mengingat preferensi Anda dari pesan pertama dan menyesuaikan rencana dalam pesan kedua.

Amati Skenario 2: Pada giliran kedua ("apakah Anda ingat apa yang saya sukai dari makanan itu?"), agen gagal total karena ini adalah sesi baru. Respons ini secara efektif mengatakan, "Saya tidak tahu apa yang Anda bicarakan."

Poin Utama

Aturan #1 Memori: Selalu gunakan kembali session.id untuk mempertahankan konteks percakapan. Objek Session adalah buffer memori jangka pendek agen Anda.

4. Tim - Status Multi-Agen

makanan

Konsep: "Permainan Telepon"

Saat beberapa agen bekerja bersama, mereka seperti rekan kerja yang saling mengoper folder file. Jika satu agen menulis catatan di folder, agen berikutnya harus dapat membacanya.

Di ADK, "folder" ini adalah Status.

  • State adalah kamus ({"key": "value"}) yang berada di dalam Sesi.
  • Setiap agen dalam sesi dapat membaca atau menulis ke sesi tersebut.

Langkah 1: Memeriksa Alur Kerja

👉💻 Di terminal Cloud Shell, buka file di Cloud Shell Editor dengan menjalankan:

cloudshell edit ~/memory_agent_starter/02_multi_agent/agent.py

👉Di file ~/memory_agent_starter/02_multi_agent/agent.py, temukan komentar # TODO: foodie agent.

Ganti seluruh baris ini dengan kode berikut:

foodie_agent = LlmAgent(
    name="foodie_agent",
    model="gemini-2.5-flash",
    tools=[google_search],
    instruction="""You are an expert food critic. Your goal is to find the best restaurant based on a user's request.

    When you recommend a place, you must output *only* the name of the establishment and nothing else.
    For example, if the best sushi is at 'Jin Sho', you should output only: Jin Sho
    """,
    output_key="destination"  # ADK will save the agent's final response to state['destination']
)

👉 Temukan komentar # TODO: transportation agent di dalam fungsi agent.py.

Ganti seluruh baris ini dengan kode berikut:

transportation_agent = LlmAgent(
    name="transportation_agent",
    model="gemini-2.5-flash",
    tools=[google_search],
    instruction="""You are a navigation assistant. Given a destination, provide clear directions.
    The user wants to go to: {destination}.

    Analyze the user's full original query to find their starting point.
    Then, provide clear directions from that starting point to {destination}.
    """,
)

👉 Temukan komentar # TODO: root_agent di dalam fungsi agent.py.

Ganti seluruh baris ini dengan kode berikut:

root_agent = SequentialAgent(
    name="find_and_navigate_agent",
    sub_agents=[foodie_agent, transportation_agent],
    description="A workflow that first finds a location and then provides directions to it."
)

Sekarang kita memiliki dua agen yang bekerja secara berurutan:

  1. Foodie Agent: Menemukan restoran.
  2. Agen Transportasi: Memberikan rute ke restoran tersebut.

Pengalihan yang Mulus: Perhatikan cara foodie_agent mengalihkan tugas ke transportation_agent.

foodie_agent = LlmAgent(
    # ...
    # CRITICAL: This tells ADK to save the agent's output to state['destination']
    output_key="destination"
)

transportation_agent = LlmAgent(
    # ...
    # CRITICAL: This injects state['destination'] into the prompt
    instruction="""
    The user wants to go to: {destination}.
    Provide clear directions...
    """,
)
  1. output_key="destination": Jawaban Agen Foodie disimpan secara efisien.
  2. {destination}: Agen Transportasi membaca jawaban tersebut secara otomatis.

(Tidak Diperlukan Tindakan) Langkah 2: Orchestrator

Buka 02_multi_agent/main.py.

Kami menggunakan SequentialAgent untuk menjalankannya secara berurutan.

# 1. Create a single session for the sequential agent
session = await session_service.create_session(...)

# 2. Run the query
# The SequentialAgent manages the state flow:
# Query -> Foodie -> state['destination'] -> Transportation -> Final Answer
await run_agent_query(root_agent, query, ...)

Pengguna mengirim satu perintah:

"Find best sushi in Palo Alto and then tell me how to get there."

Agen bekerja sama untuk menjawabnya.

Langkah 3: Jalankan Tim

👉💻 Di Terminal Cloud Shell, jalankan alur kerja multi-agen:

cd ~/memory_agent_starter
uv run python ~/memory_agent_starter/02_multi_agent/main.py

Apa yang terjadi?

  1. Agen Foodie: Menemukan "Jin Sho" (atau yang serupa).
  2. ADK: Menyimpan "Jin Sho" ke state['destination'].
  3. Agen Transportasi: Menerima "Jin Sho" dalam petunjuknya.
  4. Hasil: "Untuk sampai ke Jin Sho dari stasiun Caltrain, berjalanlah menyusuri University Ave..."

Poin Utama

Aturan #2 Memori: Gunakan State untuk meneruskan informasi terstruktur antar-agen. Gunakan output_key untuk menulis dan {placeholders} untuk membaca.

5. The Reboot - Persistence

stateful

Konsep: "Masalah Reboot"

Sejauh ini, memori kita adalah InMemory. Jika Anda menghentikan skrip dan memulainya lagi, agen akan melupakan semuanya. Ini seperti komputer yang menghapus hard drive-nya setiap kali Anda mematikannya.

Untuk memperbaikinya, kita memerlukan Persistence. Kita menukar InMemorySessionService dengan DatabaseSessionService.

Langkah 1: Pengalihan Database

👉💻 Di terminal Cloud Shell, buka file di Cloud Shell Editor dengan menjalankan:

cloudshell edit ~/memory_agent_starter/03_persistent_agent/main.py

👉 Di file ~/memory_agent_starter/03_persistent_agent/main.py, temukan komentar # TODO: Configuration for Persistent Sessions.

Ganti seluruh baris ini dengan kode berikut:

SESSIONS_DIR = Path(os.path.expanduser("~")) / ".adk_codelab" / "sessions"
os.makedirs(SESSIONS_DIR, exist_ok=True)
SESSION_DB_FILE = SESSIONS_DIR / "trip_planner.db"
SESSION_URL = f"sqlite:///{SESSION_DB_FILE}"

Sekarang, setiap sesi dan peristiwa disimpan ke file SQLite.

Langkah 2: Pengambilan Lintas Sesi

Persistensi tidak hanya memungkinkan melanjutkan percakapan, tetapi juga belajar dari percakapan sebelumnya.

Di file yang sama ~/memory_agent_starter/03_persistent_agent/main.py, lihat Kasus Pengujian 3: Cross-Session Retrieval.

👉 Temukan komentar # TODO: retrieve the previous session manually

Ganti seluruh baris ini dengan kode berikut:

    old_session = await session_service.get_session(
        app_name=root_agent.name, user_id="user_01", session_id=session_id
    )

👉 Temukan komentar # TODO: Extract content from the OLD session di dalam fungsi main.py.

Ganti seluruh baris ini dengan kode berikut:

                    previous_context += f"- {role}: {text}\n"

👉 Temukan komentar # TODO: Manually inject the context to the query di dalam fungsi main.py.

Ganti seluruh baris ini dengan kode berikut:

    query_3 = f"""
    {previous_context}

    I'm planning a new trip to Osaka this time. 
    Based on my previous preferences (above), what should I eat?
    """

Tindakan ini menyimulasikan pengguna yang kembali beberapa bulan kemudian. Anda hanya dapat mengambil histori lama tersebut dengan database.

Langkah 3: Mempertahankan Perubahan Setelah Reboot

👉💻 Di terminal, jalankan skrip:

cd ~/memory_agent_starter
uv run python ~/memory_agent_starter/03_persistent_agent/main.py

Perintah ini akan membuat file ~/memory_agent_starter/trip_planner.db. Coba ini: Jalankan skrip dua kali.

  • Pada operasi kedua, cari "Resumed existing session".
  • Agen akan mengingat konteks dari eksekusi pertama karena memuat dari file database.

Poin Utama

Aturan Memori #3: Gunakan DatabaseSessionService untuk produksi. Hal ini memastikan percakapan pengguna tetap ada meskipun server dimulai ulang dan memungkinkan analisis histori jangka panjang.

6. Mata-mata - Callback

stateful

Terkadang, Anda perlu memperbarui memori secara otomatis berdasarkan tindakan agen, bukan hanya ucapannya. Anda memerlukan "mata-mata" yang mengamati agen dan membuat catatan.

Di ADK, mata-mata ini adalah Callback. adk_callback

  • after_tool_callback: Fungsi yang berjalan setiap kali agen bekerja.
  • ToolContext: Cara menulis ke State dari dalam fungsi tersebut.

Langkah 1: Logika

👉💻 Di terminal Cloud Shell, buka file di Cloud Shell Editor dengan menjalankan:

cloudshell edit ~/memory_agent_starter/04_stateful_agent/agent.py

👉 Di file ~/memory_agent_starter/04_stateful_agent/agent.py, temukan komentar # TODO: Implement call back logic

Ganti seluruh baris ini dengan kode berikut:

def save_activity_type_callback(
    tool,
    args: Dict[str, Any],
    tool_context: ToolContext,
    tool_response: Dict[str, Any],
) -> Optional[Dict[str, Any]]:
    """
    Callback to save the TYPE of activity just planned into the session state.
    """
    # 1. Get the actual agent name.
    if tool.name == "transfer_to_agent":
         agent_name = args.get("agent_name")
    else:
         agent_name = tool.name

    activity_type = "unknown"

    # 2. Determine the type based on which agent was actually used
    if agent_name == "museum_expert":
        activity_type = "CULTURAL"
    elif agent_name == "restaurant_expert":
        activity_type = "FOOD"
    elif agent_name == "outdoor_expert":
        activity_type = "OUTDOOR"

    print(f"\n🔔 [CALLBACK] The planner transferred to '{agent_name}'.")

    # 3. Update the state directly
    tool_context.state["last_activity_type"] = activity_type
    print(f"💾 [STATE UPDATE] 'last_activity_type' is now set to: {activity_type}\n")

    return tool_response

👉 Di file yang sama, temukan komentar # TODO: add callback to root agent di dalam fungsi 04_stateful_agent/agent.py.

Ganti seluruh baris ini dengan kode berikut:

    after_tool_callback=save_activity_type_callback,

Petunjuk Dinamis: Petunjuk agen kini berupa fungsi, bukan string. Tampilan ini berubah berdasarkan status.

def get_planner_instruction(context):
    last_activity = context.state.get("last_activity_type", "None")
    
    return f"""
    The last activity was: {last_activity}
    
    If last_activity is 'CULTURAL' -> `museum_expert` is BANNED.
    """

Langkah 3: Menguji Spy

👉💻 Di terminal, jalankan skrip dengan menyalin dan menempelkan perintah di bawah:

cd ~/memory_agent_starter
uv run python ~/memory_agent_starter/04_stateful_agent/main.py

Saat menjalankan agen ini, Anda akan melihat loop.

  1. Giliran 1: Anda meminta museum. Spy menetapkan last_activity="CULTURAL".
  2. Giliran 2: Anda meminta museum lain.
  3. Pembaruan Petunjuk Agen: "BUDAYA DILARANG".
  4. Agen berkata: "Saya tidak bisa mengunjungi museum lain. Bagaimana dengan taman?"

Perhatikan log konsol untuk [CALLBACK] dan [STATE UPDATE]. Anda dapat melihat memori berubah secara real-time saat agen bekerja.

Poin Utama

Aturan Memori #4: Gunakan Callback untuk mengotomatiskan pengelolaan status. Agen Anda membangun konteksnya sendiri hanya dengan melakukan tugasnya.

7. Arsip File - Alat Kustom

Konsep: "Memori Terstruktur"

stateful

Sejauh ini, "Memori" telah menjadi log percakapan atau pasangan nilai kunci sederhana. Namun, bagaimana jika Anda perlu mengingat profil pengguna yang kompleks? misalnya, diet: vegan, budget: high, pets: [cat, dog].

Untuk melakukannya, kita memperlakukan memori sebagai Alat. Agen secara eksplisit memutuskan kapan harus membuka arsip file (membaca) dan kapan harus mengajukan laporan (menulis). diagram alat kustom

Langkah 1: Alat

👉💻 Di terminal Cloud Shell, buka file di Cloud Shell Editor dengan menjalankan:

cloudshell edit ~/memory_agent_starter/05_profile_agent/tools.py

👉 Dalam file ini: ~/memory_agent_starter/05_profile_agent/tools.py.

Kita perlu mengimplementasikan dua alat khusus ini:

  1. save_user_preferences: Menulis ke database.
  2. recall_user_preferences: Membaca dari database.

Temukan komentar # TODO: implement save_user_preferences tools di dalam fungsi ~/memory_agent_starter/05_profile_agent/tools.py.

Ganti seluruh baris ini dengan kode berikut:

def save_user_preferences(tool_context: ToolContext, new_preferences: Dict[str, Any]) -> str:
    user_id = tool_context.session.user_id
    with sqlite3.connect(USER_DB_FILE) as conn:
        for key, value in new_preferences.items():
            conn.execute("INSERT INTO user_preferences (user_id, pref_key, pref_value) VALUES (?, ?, ?) ON CONFLICT(user_id, pref_key) DO UPDATE SET pref_value = excluded.pref_value;",
                         (user_id, key, json.dumps(value)))
    return f"Preferences updated: {list(new_preferences.keys())}"

👉 Temukan komentar # TODO: implement recall_user_preferences tools di dalam fungsi 05/tools.py.

Ganti seluruh baris ini dengan kode berikut:

def recall_user_preferences(tool_context: ToolContext) -> Dict[str, Any]:
    user_id = tool_context.session.user_id
    preferences = {}
    with sqlite3.connect(USER_DB_FILE) as conn:
        rows = conn.execute("SELECT pref_key, pref_value FROM user_preferences WHERE user_id = ?", (user_id,)).fetchall()
        if not rows: return {"message": "No preferences found."}
        for key, value_str in rows: preferences[key] = json.loads(value_str)
    return preferences

Petunjuk ini memaksa alur kerja:

instruction="""
1. RECALL FIRST: First action MUST be `recall_user_preferences`.
3. LEARN: If a user states a new preference, use `save_user_preferences`.
"""

Langkah 2: Eksekusi

👉💻 Di terminal Cloud Shell, buka file di Cloud Shell Editor dengan menjalankan:

cloudshell edit ~/memory_agent_starter/05_profile_agent/main.py

Buka ~/memory_agent_starter/05_profile_agent/main.py.

Tidak seperti modul sebelumnya yang statusnya ditangani ADK secara otomatis, di sini Agen yang memegang kendali.

  • Model memilih untuk memanggil recall_user_preferences di awal.
  • Asisten memilih untuk memanggil save_user_preferences saat Anda mengucapkan "Saya vegan".

Langkah 3: Membangun Profil

👉💻 Jalankan skrip:

cd ~/memory_agent_starter
uv run python ~/memory_agent_starter/05_profile_agent/main.py

Coba alur percakapan ini:

  1. "Halo, rencanakan makan malam." -> Agen memeriksa DB, tidak menemukan apa pun. Meminta preferensi.
  2. "Saya vegan." -> Agen menyimpan "vegan" ke DB.
  3. Mulai ulang skrip.
  4. "Halo, rencanakan makan malam." -> Agen memeriksa DB, melihat "vegan", dan langsung menyarankan restoran vegan.

Poin Utama

Aturan Memori #5: Untuk data terstruktur yang kompleks, berikan Alat Baca/Tulis kepada agen Anda. Membiarkan LLM mengelola penyimpanan jangka panjangnya sendiri.

8. Otak - Memori Multimodal

stateful

Konsep: "Pengalaman Manusia"

Manusia mengingat lebih dari sekadar teks. Kita mengingat suasana foto, bunyi suara, perasaan dari video.

Vertex AI Memory Bank memungkinkan agen Anda menangani Memori Multimodal. Model ini dapat menyerap gambar, video, dan audio, "memahaminya", dan mengambilnya nanti.

Langkah 1: Konfigurasi

👉💻 Di terminal Cloud Shell, buka file di Cloud Shell Editor dengan menjalankan:

cloudshell edit ~/memory_agent_starter/06_multimodal_agent/main.py

👉 Buka 06_multimodal_agent/main.py. Temukan komentar # TODO: Configure Memory Bank Topic.

Ganti seluruh baris ini dengan kode berikut:

travel_topics = [
    MemoryTopic(
        managed_memory_topic=ManagedMemoryTopic(
            managed_topic_enum=ManagedTopicEnum.USER_PREFERENCES
        )
    ),
    MemoryTopic(
        managed_memory_topic=ManagedMemoryTopic(
            managed_topic_enum=ManagedTopicEnum.USER_PERSONAL_INFO
        )
    ),
    MemoryTopic(
        custom_memory_topic=CustomMemoryTopic(
            label="travel_experiences",
            description="""Memorable travel experiences including:
                - Places visited and impressions
                - Favorite restaurants, cafes, and food experiences
                - Preferred accommodation types and locations
                - Activities enjoyed (museums, hiking, beaches, etc.)
                - Travel companions and social preferences
                - Photos and videos from trips with location context""",
        )
    ),
    MemoryTopic(
        custom_memory_topic=CustomMemoryTopic(
            label="travel_preferences",
            description="""Travel style and preferences:
                - Budget preferences (luxury, mid-range, budget)
                - Transportation preferences (flying, trains, driving)
                - Trip duration preferences
                - Season and weather preferences
                - Cultural interests and language abilities
                - Dietary restrictions and food preferences""",
        )
    ),
    MemoryTopic(
        custom_memory_topic=CustomMemoryTopic(
            label="travel_logistics",
            description="""Practical travel information:
                - Passport and visa information
                - Frequent flyer numbers and hotel loyalty programs
                - Emergency contacts
                - Medical considerations and insurance
                - Packing preferences and essentials
                - Time zone preferences and jet lag strategies""",
        )
    ),
]

Temukan komentar # TODO: Configure Memory Bank Customization

Ganti seluruh baris ini dengan kode berikut:

memory_bank_config = {
    "customization_configs": [
        {
            "memory_topics": travel_topics,
        }
    ],
    "similarity_search_config": {
        "embedding_model": f"projects/{PROJECT_ID}/locations/{LOCATION}/publishers/google/models/gemini-embedding-001"
    },
    "generation_config": {
        "model": f"projects/{PROJECT_ID}/locations/{LOCATION}/publishers/google/models/gemini-2.5-flash"
    },
}

Langkah 2: Menyerap Dunia

Di test_trip_planner, kami mengirim:

  1. Pesan teks ("Halo")
  2. Gambar (Tempat terkenal)
  3. Video (Laut Mediterania)
  4. Klip Audio (Catatan suara tentang Gaeta)

Temukan komentar # TODO create session service and memory service di dalam fungsi 6_multimodal_agent/main.py.

Ganti seluruh baris ini dengan kode berikut:

session_service = VertexAiSessionService(
    project=PROJECT_ID, location=LOCATION, agent_engine_id=agent_engine_id
)
memory_service = VertexAiMemoryBankService(
    project=PROJECT_ID, location=LOCATION, agent_engine_id=agent_engine_id
)

👉 Di file yang sama 06_multimodal_agent/main.py, temukan komentar # TODO: create memory from session

Ganti seluruh baris ini dengan kode berikut:

    await memory_service.add_session_to_memory(final_session_state)

Ini adalah garis ajaib. Aplikasi ini mengirimkan semua multimedia tersebut ke Vertex AI, yang memproses dan mengindeksnya.

Langkah 3: Pengambilan

👉💻 Di terminal Cloud Shell, buka file di Cloud Shell Editor dengan menjalankan:

cloudshell edit ~/memory_agent_starter/06_multimodal_agent/agent.py

Agen memiliki PreloadMemoryTool.

tools=[PreloadMemoryTool(), budget_tool]

Saat sesi baru dimulai, alat ini otomatis menelusuri Bank Memori untuk menemukan pengalaman relevan sebelumnya dan memasukkannya ke dalam konteks.

Langkah 4: Jalankan Brain

👉💻 Di terminal Cloud Shell, jalankan skrip (Catatan: Tindakan ini memerlukan project cloud Google Cloud dengan Vertex AI yang diaktifkan):

cd ~/memory_agent_starter
uv run python ~/memory_agent_starter/06_multimodal_agent/main.py

Tonton langkah verifikasi akhir:

"Berdasarkan gambar, video, DAN audio yang saya bagikan kepada Anda sebelumnya..."

Agen akan membalas:

"Anda harus mengunjungi Gaeta! Anda menunjukkan video Laut Mediterania, dan klip audio yang menyatakan bahwa Anda menyukai Gaeta."

Alat ini menghubungkan berbagai jenis media dari masa lalu.

Poin Utama

Aturan Memori #6: Gunakan Vertex AI Memory Bank untuk pengalaman memori terbaik. NotebookLM menyatukan teks, gambar, dan video ke dalam satu sistem yang dapat ditelusuri.

9. Kesimpulan

Anda telah mempelajari dari Goldfish yang pelupa hingga Multimodal Elephant.

Anda Membangun

Kemampuan

Agen Sesi

Memori percakapan jangka pendek

Multi-Agen

Memori tim bersama

Agen Persisten

Histori jangka panjang

Agen Stateful

Memori dinamis yang diupdate otomatis

Agen Profil

Memori data terstruktur

Agen Multimodal

Memori sensoris seperti manusia

Kepercayaan dibangun berdasarkan memori. Dengan menerapkan pola ini, Anda akan membuat agen yang menghargai waktu dan histori pengguna, sehingga menghasilkan interaksi yang lebih mendalam dan efektif.

Mulai bangun agen yang dipersonalisasi sekarang.