Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Einrichtung von ElastiCache Valkey als Vektorspeicher für agentisches Gedächtnis
<a name="agentic-memory-setup"></a>

Die folgende exemplarische Vorgehensweise zeigt, wie Sie einen speicherfähigen KI-Agenten mit ElastiCache Mem0 für Valkey als Vektorspeicher erstellen.

## Schritt 1: Erstellen Sie einen Basisagenten ohne Speicher
<a name="agentic-memory-step1"></a>

Installieren Sie zunächst Strands Agents und erstellen Sie einen Basisagenten:

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

Initialisieren Sie einen Basisagenten mit einem HTTP-Tool für das Surfen im Internet:

```
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)
```

Ohne Speicher führt der Agent dieselben Rechercheaufgaben für jede Anfrage wiederholt durch. Beim Testen führt der Agent drei Tool-Aufrufe durch, um die Anfrage zu beantworten. Dabei werden etwa 70.000 Tokens verwendet und die Bearbeitung dauert mehr als 9 Sekunden.

## Schritt 2: Konfigurieren Sie Mem0 mit ElastiCache für Valkey
<a name="agentic-memory-step2"></a>

Installieren Sie die Mem0-Bibliothek mit dem Valkey Vector Store Connector:

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

Konfigurieren Sie Valkey als Vektorspeicher. ElastiCache for Valkey unterstützt Vektorsuchfunktionen ab Version 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)
```

Ersetzen Sie {{your-elasticache-cluster.cache.amazonaws.com}} durch den Endpunkt Ihres ElastiCache Clusters. Anweisungen zur Suche nach Ihrem Cluster-Endpunkt finden Sie unter [Zugreifen auf Ihren ElastiCache Cluster](accessing-elasticache.md).

## Schritt 3: Fügen Sie dem Agenten Speicher-Tools hinzu
<a name="agentic-memory-step3"></a>

Erstellen Sie Speichertools, die der Agent zum Speichern und Abrufen von Informationen verwenden kann. Der `@tool` Decorator wandelt reguläre Python-Funktionen in Tools um, die der Agent aufrufen kann:

```
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])
```

## Schritt 4: Testen Sie den speicherfähigen Agenten
<a name="agentic-memory-step4"></a>

Wenn der Speicher aktiviert ist, speichert der Agent Informationen aus seinen Interaktionen und ruft sie bei nachfolgenden Anfragen ab:

```
# 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)
```

Bei der zweiten Anfrage ruft der Agent die Informationen aus dem Speicher ab, anstatt Web-Tool-Aufrufe zu tätigen. In Tests wurde dadurch die Token-Nutzung von etwa 70.000 auf 6.300 reduziert (eine 12-fache Reduzierung) und die Reaktionszeit von 9,25 Sekunden auf 2 Sekunden verbessert (mehr als dreimal schneller).

## Wie funktioniert es unter der Haube
<a name="agentic-memory-valkey-commands"></a>

Die folgende Tabelle zeigt die Valkey-Befehle, die Mem0 intern verwendet, um agentischen Speicher zu implementieren. ElastiCache Mem0 abstrahiert diese Befehle über seine API — das genaue Schema und die Schlüsselbenennung können je nach Mem0-Version und Konfiguration variieren:


| Operation | Valkey-Befehl | Description | 
| --- | --- | --- | 
| Vektorindex erstellen | FT.CREATE agent\_memory SCHEMA embedding VECTOR HNSW 6 TYPE FLOAT32 DIM 1024 DISTANCE\_METRIC COSINE | Erzeugt einen Vektorindex für die semantische Speichersuche | 
| Speicher speichern | HSET mem:{id} memory "..." embedding [bytes] user\_id "user\_123" created\_at "..." | Speichert einen Speicher mit seiner Vektoreinbettung | 
| Suchen Sie nach Erinnerungen | FT.SEARCH agent\_memory "\*=>[KNN 5 @embedding $query\_vec]" PARAMS 2 query\_vec [bytes] DIALECT 2 | Findet die semantisch ähnlichsten Erinnerungen | 
| Ablauf festlegen | EXPIRE mem:{id} 86400 | Legt TTL für Speichereinträge fest |