Prasyarat Langkah 1: Buat AgentCore Memori Langkah 2: Menulis acara ke memori Langkah 3: Ambil catatan dari memori jangka panjang Menambahkan memori ke agen yang ada Pembersihan Langkah selanjutnya

Memulai dengan AgentCore Memori

Amazon Bedrock AgentCore Memory memungkinkan Anda membuat dan mengelola sumber daya AgentCore Memori yang menyimpan konteks percakapan untuk agen AI Anda. Permulaan ini memandu Anda melalui menginstal dependensi dan menerapkan fitur memori jangka pendek dan jangka panjang. Instruksi menggunakan AgentCore CLI.

Langkah-langkahnya adalah sebagai berikut:

Buat AgentCore Memori yang berisi strategi semantik
Tulis peristiwa (riwayat percakapan) ke sumber daya memori
Ambil catatan memori dari memori jangka panjang

Untuk contoh lainnya, lihat contoh Contoh Memori Amazon Bedrock AgentCore Amazon Bedrock AgentCore Memory.

Prasyarat

Sebelum memulai, pastikan Anda memiliki:

AWS Akun dengan kredenSIAL dikonfigurasi (aws configure)
Python 3.10+ diinstal
Node.js 20+ diinstal (untuk AgentCore CLI)

Untuk memulai dengan Amazon Bedrock AgentCore Memory, instal dependensi, buat proyek AgentCore CLI, dan siapkan lingkungan virtual. Perintah berikut dapat dijalankan langsung di terminal.


npm install -g @aws/agentcore
agentcore create --project-name MemoryQuickstart --no-agent
cd MemoryQuickstart
python -m venv .venv
source .venv/bin/activate
pip install bedrock-agentcore

AgentCore CLI menyediakan perintah untuk membuat dan mengelola sumber daya memori. Gunakan agentcore add memory untuk membuat memori, dan agentcore deploy untuk menyediakannya AWS. Untuk operasi acara dan manajemen sesi, gunakan AgentCore Python SDK (bedrock-agentcore).

catatan

AgentCore CLI membantu Anda membuat dan menyebarkan sumber daya memori. Untuk operasi API layanan langsung, lihat dokumentasi Boto3: bedrock-agentcore-control dan bedrock -agentcore. https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/bedrock-agentcore.html

Contoh lengkap: Lihat AgentCore sampel Amazon Bedrock yang menunjukkan langkah 1-3.

Langkah 1: Buat AgentCore Memori

Anda memerlukan AgentCore Memori untuk mulai menyimpan informasi untuk agen Anda. Secara default, peristiwa memori (yang kita sebut sebagai memori jangka pendek) dapat ditulis ke AgentCore Memori. Agar wawasan dapat diekstraksi dan ditempatkan ke dalam catatan memori jangka panjang, sumber daya memerlukan strategi memori yang merupakan konfigurasi yang menentukan bagaimana data percakapan harus diproses, dan informasi apa yang akan diekstrak (seperti fakta, preferensi, atau ringkasan).

Pada langkah ini, Anda membuat AgentCore Memori dengan strategi semantik sehingga memori jangka pendek dan jangka panjang dapat dimanfaatkan. Ini akan memakan waktu 2-3 menit. Anda juga dapat membuat sumber daya AgentCore Memori di AWS konsol.

Buat memori dengan strategi semantik:

contoh

Setelah penerapan, verifikasi memori telah dibuat:


agentcore status

Langkah 2: Menulis acara ke memori

Anda dapat menulis peristiwa ke Memori sebagai AgentCore memori jangka pendek dan mengekstrak wawasan untuk memori jangka panjang.

Menulis peristiwa ke memori memiliki banyak tujuan. Pertama, konten acara (paling sering riwayat percakapan) disimpan sebagai memori jangka pendek. Kedua, wawasan yang relevan ditarik dari peristiwa dan ditulis ke dalam catatan memori sebagai bagian dari memori jangka panjang.

ID sumber daya memori, id aktor, dan id sesi diperlukan untuk membuat acara. Pada langkah ini, Anda membuat tiga acara, mensimulasikan pesan antara pengguna akhir dan bot obrolan.


import boto3
from bedrock_agentcore.memory import MemorySessionManager
from bedrock_agentcore.memory.constants import ConversationalMessage, MessageRole

control_client = boto3.client('bedrock-agentcore-control', region_name='us-west-2')

# Retrieve the memory created in Step 1
response = control_client.list_memories()
memory = response['memories'][0]
memory_id = memory['id']

# Create a session to store memory events
session_manager = MemorySessionManager(
    memory_id=memory_id,
    region_name="us-west-2")

session = session_manager.create_memory_session(
    actor_id="User1",
    session_id="OrderSupportSession1"
)

# Write memory events (conversation turns)
session.add_turns(
    messages=[
        ConversationalMessage(
            "Hi, how can I help you today?",
            MessageRole.ASSISTANT)],
)

session.add_turns(
    messages=[
        ConversationalMessage(
            "Hi, I am a new customer. I just made an order, but it hasn't arrived. The Order number is #35476",
            MessageRole.USER)],
)

session.add_turns(
    messages=[
        ConversationalMessage(
            "I'm sorry to hear that. Let me look up your order.",
            MessageRole.ASSISTANT)],
)

Anda bisa mendapatkan acara (giliran) untuk aktor tertentu setelah ditulis.


# Get the last k turns in the session
turns = session.get_last_k_turns(k=5)

for turn in turns:
    print(f"Turn: {turn}")

Dalam hal ini, Anda dapat melihat tiga acara terakhir untuk aktor dan sesi.

Langkah 3: Ambil catatan dari memori jangka panjang

Setelah peristiwa ditulis ke sumber daya memori, mereka dianalisis dan informasi yang berguna dikirim ke memori jangka panjang. Karena memori berisi strategi memori jangka panjang semantik, sistem mengekstrak dan menyimpan informasi faktual.

Anda dapat membuat daftar semua catatan memori dengan:


# List all memory records
memory_records = session.list_long_term_memory_records(
    namespace_path="/"
)

for record in memory_records:
    print(f"Memory record: {record}")
    print("--------------------------------------------------------------------")

Atau mintalah informasi yang paling relevan sebagai bagian dari pencarian semantik:


# Perform a semantic search
memory_records = session.search_long_term_memories(
    query="can you summarize the support issue",
    namespace_path="/",
    top_k=3
)

Informasi penting tentang pengguna yang kemungkinan disimpan adalah memori jangka panjang. Agen dapat menggunakan memori jangka panjang daripada riwayat percakapan penuh untuk memastikan bahwa LLM tidak kelebihan beban dengan konteks.

Menambahkan memori ke agen yang ada

Jika Anda membuat agen Strands tanpa memori dan ingin menambahkannya nanti, ikuti langkah-langkah ini:

Tambahkan sumber daya memori ke proyek Anda:


agentcore add memory --name MyMemory --strategies SEMANTIC,SUMMARIZATION
agentcore deploy

Buat memory/ direktori di agen Anda:
```
mkdir -p app/MyAgent/memory
```

Buatapp/MyAgent/memory/session.py:


import os
from typing import Optional
from bedrock_agentcore.memory.integrations.strands.config import AgentCoreMemoryConfig, RetrievalConfig
from bedrock_agentcore.memory.integrations.strands.session_manager import AgentCoreMemorySessionManager

MEMORY_ID = os.getenv("MEMORY_MYMEMORY_ID")
REGION = os.getenv("AWS_REGION")

def get_memory_session_manager(session_id: str, actor_id: str) -> Optional[AgentCoreMemorySessionManager]:
    if not MEMORY_ID:
        return None

    retrieval_config = {
        f"/users/{actor_id}/facts": RetrievalConfig(top_k=3, relevance_score=0.5),
        f"/summaries/{actor_id}/{session_id}": RetrievalConfig(top_k=3, relevance_score=0.5)
    }

    return AgentCoreMemorySessionManager(
        AgentCoreMemoryConfig(
            memory_id=MEMORY_ID,
            session_id=session_id,
            actor_id=actor_id,
            retrieval_config=retrieval_config,
        ),
        REGION
    )

Perbarui Anda main.py untuk menggunakan pengelola sesi:


from memory.session import get_memory_session_manager

@app.entrypoint
async def invoke(payload, context):
    session_id = getattr(context, 'session_id', 'default-session')
    user_id = getattr(context, 'user_id', 'default-user')

    agent = Agent(
        model=load_model(),
        session_manager=get_memory_session_manager(session_id, user_id),
        system_prompt="You are a helpful assistant.",
    )

    response = agent(str(payload.get("prompt", "")))
    return response

Terapkan proyek yang diperbarui:
```
agentcore deploy
```

catatan

Setiap sumber daya memori mendapatkan variabel lingkungan MEMORY_<NAME>_ID (huruf besar, dengan garis bawah) yang secara otomatis tersedia di lingkungan runtime agen Anda setelah penerapan.

Pembersihan

Setelah selesai dengan sumber daya memori, Anda dapat menghapusnya:


agentcore remove memory --name CustomerSupportSemantic
agentcore deploy

Langkah selanjutnya

Pertimbangkan hal berikut:

Tambahkan strategi lain ke sumber daya memori Anda.
Aktifkan observabilitas untuk lebih banyak visibilitas tentang cara kerja memori
Lihatlah contoh lebih lanjut.

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

Bandingkan memori jangka panjang dengan Retrieval-Augmented Generasi

Buat AgentCore Memori