redis/redis-development

Que fait redis-development ?

Optimisation des performances Redis et bonnes pratiques. Utilisez cette compétence lorsque vous travaillez avec des structures de données Redis, le moteur de requêtes Redis (RQE), la recherche vectorielle avec RedisVL, la mise en cache sémantique avec LangCache ou l'optimisation des performances Redis.

Présentation

Redis est un magasin de structures de données en mémoire, utilisé comme base de données, cache et courtier de messages. Cette compétence vous aide à exploiter efficacement Redis dans vos applications, en mettant l'accent sur l'optimisation des performances et l'utilisation des fonctionnalités avancées.

Structures de données Redis

• Chaînes : Stockez des chaînes, des nombres ou des données binaires (taille maximale : 512 Mo).
• Listes : Listes chaînées pour files d'attente ou piles.
• Ensembles : Collections non ordonnées de chaînes uniques.
• Ensembles triés : Collections ordonnées par score.
• Hachages : Mappages entre champs et valeurs de type chaîne.
• Bitmaps et HyperLogLogs : Structures spécialisées pour le comptage et les opérations binaires.

Moteur de requêtes Redis (RQE)

Le moteur de requêtes Redis (RQE) permet d'interroger des documents JSON stockés dans Redis. Il prend en charge les index, les filtres et les agrégations.

Configuration

# Activer le module RedisJSON et RediSearch (nécessite Redis Stack)
redis-cli -c "MODULE LOAD /path/to/redisjson.so"
redis-cli -c "MODULE LOAD /path/to/redisearch.so"

Exemple d'indexation et de requête

import redis
from redis.commands.search.field import TextField, NumericField
from redis.commands.search.indexDefinition import IndexDefinition, IndexType

r = redis.Redis(host='localhost', port=6379, decode_responses=True)

# Définir un index
schema = (TextField("title"), NumericField("price"))
r.ft("idx:products").create_index(schema, definition=IndexDefinition(prefix=["product:"], index_type=IndexType.JSON))

# Ajouter un document
r.json().set("product:1", "$", {"title": "Laptop", "price": 999.99, "description": "Ordinateur portable performant"})

# Rechercher
results = r.ft("idx:products").search("Laptop")
for doc in results.docs:
    print(doc.title, doc.price)

Recherche vectorielle avec RedisVL

RedisVL est une bibliothèque Python pour la recherche vectorielle avec Redis. Elle s'appuie sur le module RediSearch.

Installation

pip install redisvl

Exemple de recherche vectorielle

import redis
from redisvl.index import AsyncSearchIndex
from redisvl.utils.vectorize import HFTextVectorizer

# Initialisation
vectorizer = HFTextVectorizer(model="sentence-transformers/all-MiniLM-L6-v2")
index = AsyncSearchIndex(
    redis_client=redis.Redis(),
    name="vector_idx",
    schema={
        "fields": [
            {"name": "embedding", "type": "vector", "dims": 384, "distance_metric": "cosine"}
        ]
    }
)

# Ajouter un vecteur
await index.load([{"id": "doc1", "embedding": vectorizer.embed("Texte à indexer")}])

# Recherche par similarité
query_vector = vectorizer.embed("Requête de recherche")
results = await index.query(query_vector, top_k=5)
print(results)

Mise en cache sémantique avec LangCache

LangCache est une bibliothèque pour la mise en cache sémantique des réponses de LLM, réduisant les coûts et la latence.

Installation

pip install langcache

Exemple

from langcache import SemanticCache
import openai

cache = SemanticCache(redis_url="redis://localhost:6379")

@cache.cached()
def generate_response(prompt):
    return openai.ChatCompletion.create(model="gpt-4", messages=[{"role": "user", "content": prompt}])

# Première exécution : appelle l'API OpenAI
response1 = generate_response("Qu'est-ce que Redis ?")

# Deuxième exécution : renvoie la réponse mise en cache
response2 = generate_response("Expliquez Redis")

Optimisation des performances

1. Choisir la structure de données appropriée : Utilisez des ensembles triés pour les classements, des hachages pour les profil utilisateur.
2. Éviter les clés volumineuses : Ne stockez pas de grandes chaînes dans une seule clé ; divisez-les en morceaux.
3. Utiliser la persistance avec parcimonie : AOF et RDB peuvent réduire les performances ; configurez-les en fonction de vos besoins.
4. Index dans RQE : Créez des index pour les requêtes fréquentes afin d'éviter les analyses séquentielles.
5. Gérer la mémoire : Utilisez MAXMEMORY et une politique d'éviction comme allkeys-lru.

Commandes CLI utiles

# Surveiller les performances
redis-cli --stat

# Vérifier l'utilisation mémoire
redis-cli info memory

# Lister les clés (à éviter en production)
redis-cli KEYS "*"

# Obtenir des informations sur les index
redis-cli FT.INFO idx:products

Gestion des erreurs courantes

import redis
from redis.exceptions import ResponseError

try:
    r = redis.Redis()
    r.ping()
except redis.ConnectionError as e:
    print(f"Impossible de se connecter à Redis : {e}")
except ResponseError as e:
    print(f"Erreur Redis : {e}")

Ressources

• Documentation officielle Redis
• RedisVL
• LangCache
• Module RediSearch