Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# ElastiCache Menyiapkan Valkey sebagai penyimpanan vektor untuk memori agen
<a name="agentic-memory-setup"></a>

Panduan berikut menunjukkan cara membuat agen AI berkemampuan memori menggunakan Mem0 dengan ElastiCache for Valkey sebagai penyimpanan vektor.

## Langkah 1: Buat agen dasar tanpa memori
<a name="agentic-memory-step1"></a>

Pertama, instal Strands Agents dan buat agen dasar:

```
pip install strands-agents strands-agents-tools strands-agents-builder
```

Inisialisasi agen dasar dengan alat HTTP untuk penjelajahan web:

```
from strands import Agent
from strands.tools import http_request

# Initialize agent with access to the tool to browse the web
agent = Agent(tools=[http_request])

# Format messages as expected by Strands
formatted_messages = [
    {
        "role": "user",
        "content": [{"text": "What is the URL for the project mem0 and its most important metrics?"}]
    }
]

result = agent(formatted_messages)
```

Tanpa memori, agen melakukan tugas penelitian yang sama berulang kali untuk setiap permintaan. Dalam pengujian, agen melakukan tiga panggilan alat untuk menjawab permintaan, menggunakan sekitar 70.000 token dan mengambil lebih dari 9 detik untuk menyelesaikannya.

## Langkah 2: Konfigurasikan Mem0 dengan ElastiCache untuk Valkey
<a name="agentic-memory-step2"></a>

Instal perpustakaan Mem0 dengan konektor penyimpanan vektor Valkey:

```
pip install mem0ai "mem0ai[vector_stores]"
```

Konfigurasikan Valkey sebagai penyimpanan vektor. ElastiCache untuk Valkey mendukung kemampuan pencarian vektor dimulai dengan versi 8.2:

```
from mem0 import Memory

# Configure Mem0 with ElastiCache for Valkey
config = {
    "vector_store": {
        "provider": "valkey",
        "config": {
            "valkey_url": "your-elasticache-cluster.cache.amazonaws.com:6379",
            "index_name": "agent_memory",
            "embedding_model_dims": 1024,
            "index_type": "flat"
        }
    }
}

m = Memory.from_config(config)
```

Ganti {{your-elasticache-cluster.cache.amazonaws.com}} dengan titik akhir ElastiCache cluster Anda. Untuk petunjuk tentang menemukan titik akhir klaster Anda, lihat [Mengakses klaster Anda ElastiCache ](accessing-elasticache.md).

## Langkah 3: Tambahkan alat memori ke agen
<a name="agentic-memory-step3"></a>

Buat alat memori yang dapat digunakan agen untuk menyimpan dan mengambil informasi. `@tool`Dekorator mengubah fungsi Python biasa menjadi alat yang dapat dipanggil agen:

```
from strands import Agent, tool
from strands.tools import http_request

@tool
def store_memory_tool(information: str, user_id: str = "user") -> str:
    """Store important information in long-term memory."""
    memory_message = [{"role": "user", "content": information}]

    # Create new memories using Mem0 and store them in Valkey
    m.add(memory_message, user_id=user_id)

    return f"Stored: {information}"

@tool
def search_memory_tool(query: str, user_id: str = "user") -> str:
    """Search stored memories for relevant information."""

    # Search memories using Mem0 stored in Valkey
    results = m.search(query, user_id=user_id)
    if results['results']:
        return "\n".join([r['memory'] for r in results['results']])
    return "No memories found"

# Initialize Strands agent with memory tools
agent = Agent(tools=[http_request, store_memory_tool, search_memory_tool])
```

## Langkah 4: Uji agen yang mendukung memori
<a name="agentic-memory-step4"></a>

Dengan memori diaktifkan, agen menyimpan informasi dari interaksinya dan mengambilnya dalam permintaan berikutnya:

```
# First request - agent searches the web and stores results in memory
formatted_messages = [
    {
        "role": "user",
        "content": [{"text": "What is the URL for the project mem0 and its most important metrics?"}]
    }
]
result = agent(formatted_messages)

# Second request (same question) - agent retrieves from memory
result = agent(formatted_messages)
```

Pada permintaan kedua, agen mengambil informasi dari memori alih-alih membuat panggilan alat web. Dalam pengujian, ini mengurangi penggunaan token dari sekitar 70.000 menjadi 6.300 (pengurangan 12x) dan meningkatkan waktu respons dari 9,25 detik menjadi 2 detik (lebih dari 3x lebih cepat).

## Cara kerjanya di bawah tenda
<a name="agentic-memory-valkey-commands"></a>

Tabel berikut menunjukkan perintah Valkey yang Mem0 menggunakan internal untuk mengimplementasikan memori agen dengan. ElastiCache Mem0 mengabstraksi perintah ini melalui API-nya — skema dan penamaan kunci yang tepat dapat bervariasi tergantung pada versi dan konfigurasi Mem0:


| Operasi | Perintah Valkey | Deskripsi | 
| --- | --- | --- | 
| Buat indeks vektor | FT.CREATE agent\_memory SCHEMA embedding VECTOR HNSW 6 TYPE FLOAT32 DIM 1024 DISTANCE\_METRIC COSINE | Membuat indeks vektor untuk pencarian memori semantik | 
| Menyimpan memori | HSET mem:{id} memory "..." embedding [bytes] user\_id "user\_123" created\_at "..." | Menyimpan memori dengan embedding vektornya | 
| Cari kenangan | FT.SEARCH agent\_memory "\*=>[KNN 5 @embedding $query\_vec]" PARAMS 2 query\_vec [bytes] DIALECT 2 | Menemukan kenangan yang paling mirip secara semantik | 
| Tetapkan kedaluwarsa | EXPIRE mem:{id} 86400 | Set TTL untuk entri memori |