Prasyarat Langkah 1: Buat AgentCore Memori Langkah 2: Tulis 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 Amazon Bedrock AgentCore Memory memungkinkan Anda membuat dan mengelola sumber daya AgentCore Memori yang menyimpan konteks percakapan untuk agen AI Anda. Memulai ini memandu Anda melalui instalasi 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 lain, lihat contoh Amazon Bedrock AgentCore Memory.

Prasyarat

Sebelum memulai, pastikan Anda memiliki:

AWS Akun dengan kredensi yang dikonfigurasi () aws configure
Python 3.10+ diinstal
Node.js 18+ diinstal (untuk AgentCore CLI)

Untuk memulai dengan Amazon Bedrock Amazon Bedrock AgentCore Memory, menginstal dependensi, membuat proyek AgentCore CLI, dan mengatur lingkungan virtual. Perintah di bawah ini dapat dijalankan langsung di terminal.


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

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 AWS Python SDK (Boto3) (). bedrock-agentcore

catatan

AgentCore CLI membantu Anda membuat dan menyebarkan sumber daya memori. Untuk set lengkap operasi Amazon Bedrock AgentCore Memory, lihat dokumentasi Boto3: bedrock-agentcore-control dan bedrock-agentcore.

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 mendefinisikan 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: Tulis acara ke memori

Anda dapat menulis peristiwa ke AgentCore Memori sebagai 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 minta 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 kemungkinan disimpan adalah memori jangka panjang. Agen dapat menggunakan memori jangka panjang daripada riwayat percakapan lengkap untuk memastikan bahwa LLM tidak dibebani dengan konteks.

Menambahkan memori ke agen yang ada

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

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 manajer 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(payload.get("prompt"))
    return response

Menyebarkan 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