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.

# Implementierung eines semantischen Caches mit ElastiCache for Valkey
<a name="semantic-caching-implementation"></a>

Die folgende exemplarische Vorgehensweise zeigt, wie Sie einen semantischen Lesecache mithilfe von ElastiCache for Valkey mit Amazon Bedrock implementieren.

## Schritt 1: Erstellen Sie einen For-Valkey-Cluster ElastiCache
<a name="semantic-caching-step1"></a>

Erstellen Sie einen ElastiCache For Valkey-Cluster mit Version 8.2 oder höher mit dem: AWS CLI

```
aws elasticache create-replication-group \
  --replication-group-id "valkey-semantic-cache" \
  --cache-node-type cache.r7g.large \
  --engine valkey \
  --engine-version 8.2 \
  --num-node-groups 1 \
  --replicas-per-node-group 1
```

## Schritt 2: Connect zum Cluster her und konfigurieren Sie Einbettungen
<a name="semantic-caching-step2"></a>

Stellen Sie von Ihrem Anwendungscode aus, der auf Ihrer Amazon EC2 EC2-Instance ausgeführt wird, eine Verbindung zum ElastiCache Cluster her und richten Sie das Einbettungsmodell ein:

```
from valkey.cluster import ValkeyCluster
from langchain_aws import BedrockEmbeddings

# Connect to ElastiCache for Valkey
valkey_client = ValkeyCluster(
    host="mycluster.xxxxxx.clustercfg.use1.cache.amazonaws.com",  # Your cluster endpoint
    port=6379,
    decode_responses=False
)

# Set up Amazon Bedrock Titan embeddings
embeddings = BedrockEmbeddings(
    model_id="amazon.titan-embed-text-v2:0",
    region_name="us-east-1"
)
```

Ersetzen Sie den Host-Wert durch den ElastiCache Konfigurationsendpunkt Ihres Clusters. Anweisungen zur Suche nach Ihrem Cluster-Endpunkt finden Sie unter [Zugriff auf Ihren ElastiCache Cluster](accessing-elasticache.md).

## Schritt 3: Erstellen Sie den Vektorindex für den semantischen Cache
<a name="semantic-caching-step3"></a>

Konfigurieren Sie eine ValkeyStore , die Abfragen mithilfe eines HNSW-Index mit COSINE-Abstand für die Vektorsuche automatisch einbettet:

```
from langgraph_checkpoint_aws import ValkeyStore
from hashlib import md5

store = ValkeyStore(
    client=valkey_client,
    index={
        "collection_name": "semantic_cache",
        "embed": embeddings,
        "fields": ["query"],           # Fields to vectorize
        "index_type": "HNSW",          # Vector search algorithm
        "distance_metric": "COSINE",   # Similarity metric
        "dims": 1024                   # Titan V2 produces 1024-d vectors
    }
)
store.setup()

def cache_key_for_query(query: str):
    """Generate a deterministic cache key for a query."""
    return md5(query.encode("utf-8")).hexdigest()
```

**Anmerkung**  
ElastiCache for Valkey verwendet einen Index, um eine schnelle und genaue Vektorsuche zu ermöglichen. Der `FT.CREATE` Befehl erstellt den zugrunde liegenden Index. Weitere Informationen finden Sie unter [Vektorsuche nach ElastiCache](search.md).

## Schritt 4: Implementieren Sie die Cache-Such- und Aktualisierungsfunktionen
<a name="semantic-caching-step4"></a>

Erstellen Sie Funktionen, um den Cache nach semantisch ähnlichen Abfragen zu durchsuchen und neue Abfrage-Antwort-Paare zu speichern:

```
def search_cache(user_message: str, k: int = 3, min_similarity: float = 0.8):
    """Look up a semantically similar cached response from ElastiCache."""
    hits = store.search(
        namespace="semantic-cache",
        query=user_message,
        limit=k
    )
    if not hits:
        return None

    # Sort by similarity score (highest first)
    hits = sorted(hits, key=lambda h: h["score"], reverse=True)
    top_hit = hits[0]
    score = top_hit["score"]

    if score < min_similarity:
        return None  # Below similarity threshold

    return top_hit["value"]["answer"]  # Return cached answer


def store_cache(user_message: str, result_message: str):
    """Store a new query-response pair in the semantic cache."""
    key = cache_key_for_query(user_message)
    store.put(
        namespace="semantic-cache",
        key=key,
        value={
            "query": user_message,
            "answer": result_message
        }
    )
```

## Schritt 5: Implementieren Sie das Lese-Through-Cache-Muster
<a name="semantic-caching-step5"></a>

Integrieren Sie den Cache in die Anforderungsverarbeitung Ihrer Anwendung:

```
import time

def handle_query(user_message: str) -> dict:
    """Handle a user query with read-through semantic cache."""
    start = time.time()

    # Step 1: Search the semantic cache
    cached_response = search_cache(user_message, min_similarity=0.8)

    if cached_response:
        # Cache hit - return cached response
        elapsed = (time.time() - start) * 1000
        return {
            "response": cached_response,
            "source": "cache",
            "latency_ms": round(elapsed, 1),
        }

    # Step 2: Cache miss - invoke LLM
    llm_response = invoke_llm(user_message)  # Your LLM invocation function

    # Step 3: Store the response in cache for future reuse
    store_cache(user_message, llm_response)

    elapsed = (time.time() - start) * 1000
    return {
        "response": llm_response,
        "source": "llm",
        "latency_ms": round(elapsed, 1),
    }
```

## Zugrundeliegende Valkey-Befehle
<a name="semantic-caching-valkey-commands"></a>

Die folgende Tabelle zeigt die Valkey-Befehle, die zur Implementierung des semantischen Caches verwendet wurden:


| Operation | Valkey-Befehl | Typische Latenz | 
| --- | --- | --- | 
| Index erstellen | FT.CREATE semantic\_cache SCHEMA query TEXT answer TEXT embedding VECTOR HNSW 6 TYPE FLOAT32 DIM 1024 DISTANCE\_METRIC COSINE | One-time einrichten | 
| Cache-Suche | FT.SEARCH semantic\_cache "\*=>[KNN 3 @embedding $query\_vec]" PARAMS 2 query\_vec [bytes] DIALECT 2 | Mikrosekunden | 
| Antwort speichern | HSET cache:{hash} query "..." answer "..." embedding [bytes] | Mikrosekunden | 
| TTL einstellen | EXPIRE cache:{hash} 82800 | Mikrosekunden | 
| LLM-Inferenz (falsch) | Externer API-Aufruf für Amazon Bedrock | 500—6000 ms |