Posts Tagged - redis

Optimize data structures for vector storage (Redis)

Hash storage es más rápido y usa menos memoria porque los vectores se guardan como compact binary blobs.

Usar Hash cuando:

  • Tienes datos flat y simples, sin nested objects
  • necesitas maxima query performance
  • priorizas memory efficiency
  • tu modelo de datos no necesita objetos nesteados

JSON storage añade overhead debido al array structure, pero ofrece más flexibilidad.

Usar JSON cuando:

  • tus datos necesitan estructuras nested
  • necesitas almacenar múltiples vectores por item
  • tu aplicación ya usa JSON
  • la flexibilidad es más importante que la raw performance

Using Redis Hash for vectors

IMPORTANTE

Redis Hash es una data structure que guarda la información como pares clave-valor en una single key (ej: product:12345), similar a un diccionario. Cuando usas Hash para vector storage, tus embeddings se convierten en un campo (guardados como binary bytes) junto a otros datos. Hash es muy buena en performance y memory eficiente. Ofrece las queries más rápidas y el menor consumo de memoria.

/IMPORTANTE

Storing vectors in hash

# Code fragment - focus on Hash storage
import numpy as np

embedding = np.array([0.1, 0.2, 0.3, ...], dtype=np.float32)

redis_client.hset(
    "product:12345",
    mapping={
        "name": "Wireless Mouse",
        "price": "29.99",
        "category": "electronics",
        "embedding": embedding.tobytes()  # Store vector as bytes
    }
)

Creating an index for Hash-based vectors

# Code fragment - focus on Hash index
from redis.commands.search.field import TextField, NumericField, VectorField
from redis.commands.search.indexDefinition import IndexDefinition, IndexType

schema = (
    TextField("name"),
    NumericField("price"),
    TextField("category"),
    VectorField("embedding", "HNSW", {
        "TYPE": "FLOAT32",
        "DIM": 1536,
        "DISTANCE_METRIC": "COSINE"
    })
)

redis_client.ft("idx:products").create_index(
    fields=schema,
    definition=IndexDefinition(
        prefix=["product:"],
        index_type=IndexType.HASH
    )
)

Using Redis JSON for vectors

IMPORTANTE

Redis JSON guarda los datos como JSON documents, permitiendo guardar información jerárquica con nested objects y arrays.

A diferencia de Hash que está flatted, JSON te permite estructurar datos complejos de forma natural. Esta flexibilidad viene con un overhead mayor de memoria y query time comparado con Hash.

/IMPORTANTE

Storing vectors in JSON

Al guardar vectors en JSON, conviertes tu NumPy array a Python list usando tolist()

# Code fragment - focus on JSON storage
import redis.commands.json as json_commands

document = {
    "name": "Wireless Mouse",
    "price": 29.99,
    "category": "electronics",
    "embedding": embedding.tolist(),  # Convert to list for JSON
    "specs": {
        "color": "black",
        "wireless": True,
        "battery": "AA"
    }
}

redis_client.json().set("product:12345", "$", document)

Creating an index for JSON-based vectors

hay una diferencia con $. para los field names y as_name param para query references

# Code fragment - focus on JSON index
from redis.commands.search.field import TextField, NumericField, VectorField
from redis.commands.search.indexDefinition import IndexDefinition, IndexType

schema = (
    TextField("$.name", as_name="name"),
    NumericField("$.price", as_name="price"),
    TextField("$.category", as_name="category"),
    VectorField("$.embedding", "HNSW", {
        "TYPE": "FLOAT32",
        "DIM": 1536,
        "DISTANCE_METRIC": "COSINE"
    }, as_name="embedding")
)

redis_client.ft("idx:products").create_index(
    fields=schema,
    definition=IndexDefinition(
        prefix=["product:"],
        index_type=IndexType.JSON
    )
)

Read More

Index and query vector data (Redis)

Azure Managed Redis ofrece capacidades de BBDD vectorial a través de RediSearch, lo que permite guardar y querying de embeddings con una latencia medida en milisegundos.

Crear un vector index

Para poder guardar vectores necesitas definir un index schema que especifique como manejar los embeddings.

Index schema components

IMPORTANTE

El campo crítico del schema es VectorField, ya que le indica a Redis como manejar tus embeddings.

/IMPORTANTE

# Code fragment - focus on VectorField configuration
from redis.commands.search.field import TextField, VectorField
from redis.commands.search.indexDefinition import IndexDefinition, IndexType

schema = (
    TextField("title"),
    TextField("content"),
    VectorField(
        "embedding",           # Field name in your Redis hashes
        "HNSW",               # Algorithm: FLAT or HNSW
        {
            "TYPE": "FLOAT32",          # Standard for AI embeddings
            "DIM": 1536,                # Must match your model's output
            "DISTANCE_METRIC": "COSINE" # Use COSINE for text, L2 for images
        }
    )
)

redis_client.ft("idx:documents").create_index(
    fields=schema,
    definition=IndexDefinition(
        prefix=["doc:"],          # Index keys starting with "doc:"
        index_type=IndexType.HASH # HASH or JSON
    )
)

Elegir indexing algorithm

REVISAR TODOS LOS SITIOS DONDE HABLE DE ESTO Y UNIFICARLO. ES UN TEMA A LO LARGO DE LA CERTIFICACIÓN

IMPORTANTE

Compara tu query contra cada vector individual en el índice para encontrar matches exactos. garantiza perfect accuracy para encontrar NN (Nearest Neighbour), pero se vuelve muy lento a medida que tus datos crecen.

FLAT es ideal para:

  • DEV
  • prototipos
  • PROD systems con datasets pequeños
  • necesitas perfect accuracy
  • puedes aceptar query latency
# Code fragment - focus on FLAT index configuration
VectorField(
    "embedding",
    "FLAT",  # Exact nearest neighbor search
    {
        "TYPE": "FLOAT32",
        "DIM": 1536,
        "DISTANCE_METRIC": "COSINE"
    }
)

Construye un grafo de varias capas y lo navega. Encuentra ANN (Aproximate Nearest Neighbour) en ms, pero no garantiza un 100% de matches exactos.

HNSW es ideal para:

  • large datasets (> 10.000 vectores)
  • PROD systems que necesiten fast queries (<10ms)
  • si 95-99% accuracy es aceptable

La mayoría de sistemas en PROD usan HNSW por las ganancias de performance, aún con la pérdida de accuracy

# Code fragment - focus on HNSW index configuration
VectorField(
    "embedding",
    "HNSW",  # Approximate nearest neighbor search
    {
        "TYPE": "FLOAT32",
        "DIM": 1536,
        "DISTANCE_METRIC": "COSINE"
    }
)

El param EF_RUNTIME indica el número de grafos a explorar para cada query

# Code fragment - focus on runtime tuning
query = Query(
    "*=>[KNN 10 @embedding $query_vec EF_RUNTIME 100 AS score]"
).dialect(2)

/IMPORTANTE

Ingest vector data

La ingestión es el proceso de cargar los embeddings en Redis para que sean buscables. A diferencia de datos normales, los vectores necesitan cuidados especiales.

IMPORTANTE

Redis guarda los emebddings como binary blobs (byte arrays) por temas de eficiencia, lo que significa que tienes que convertir tus arrays a bytes con tobytes() antes de guardarlos.

Al añadir embeddings a index prefix (ej: doc:*) Redis automáticamente se encarga de indexarlos. No tienes que hacer nada más.

/IMPORTANTE

Store vectors with metadata

IMPORTANTE

Siempre debemos guardar vectores junto a metadatos para filtrar resultados. Redis Hash permite guardar todo junto en una single key usando hset con un mapping dictionary.

/IMPORTANTE

# Code fragment - focus on vector storage with tobytes()
import numpy as np

embedding = np.array([0.1, 0.2, 0.3, ...], dtype=np.float32)

redis_client.hset(
    "doc:001",
    mapping={
        "title": "Getting Started with Azure AI",
        "content": "Azure AI Services provide pre-built models...",
        "embedding": embedding.tobytes(),  # Convert NumPy array to bytes
        "category": "documentation"
    }
)

Bulk ingestion (for performance)

IMPORTANTE

No es ideal mandar cientos de millones de vectores de golpe con hset ya que la red puede ser un límite al throughput. Solucionamos estos con Pipeles, enviando batches de multiples comandos juntos en un single network trip. Todos los comandos se ejecutan de manera atómica en el server y recives las respuestas de todos a una cuando llamas execute()

/IMPORTANTE

# Code fragment - focus on bulk ingestion pattern
# Assumes `documents` is a list of dicts with 'id', 'title', 'content', 'embedding'

pipeline = redis_client.pipeline()

for doc in documents:
    vector_bytes = np.array(doc['embedding'], dtype=np.float32).tobytes()

    pipeline.hset(
        f"doc:{doc['id']}",
        mapping={
            "title": doc['title'],
            "content": doc['content'],
            "embedding": vector_bytes,
            "category": doc.get('category', 'general')
        }
    )

# Execute all HSETs in one network round-trip
pipeline.execute()

Querying por similaridad

Vector similarity usa KNN (K-Nearest Neighbours) para encontrar los vectores más similares - para COSINE distance 0.0 significa vectores idénticos mientras que 2.0 indica vectores opuestos.

Basic KNN queries

Una query KNN requiere

  • query vector (convertido a bytes)
  • número K a devolver (cuantos queremos)
  • vector field a buscar (@embedding)
  • dialect(2) (requerido para vector queries)

Ejemplo de query string

*=>[KNN 5 @embedding $query_vec as score]

la cual indica:

  • * busca todos los documentos
  • => indica vector search syntax
  • KNN 5 pide 5 NN
  • @embedding especifica que campo contiene los vectores
  • $query_vec es un placeholder para tu query vectorial
  • AS score devuelve la distancia como un campo que puedas filtrar
# Code fragment - focus on KNN query syntax
from redis.commands.search.query import Query

query_bytes = np.array(query_embedding, dtype=np.float32).tobytes()

query = (
    Query("*=>[KNN 5 @embedding $query_vec AS score]")
    .return_fields("title", "content", "score")
    .sort_by("score")
    .dialect(2)
)

results = redis_client.ft("idx:documents").search(
    query,
    query_params={"query_vec": query_bytes}
)

Hybrid search: Filtrar por metadatos

Hybrid search mezcla vector similarity con metadata filters.

Ejemplo de query string con filtros

@category:{documentation}=>[KNN 3 @embedding $query_vec AS score]

la cual indica:

  • @category:{documentation} antes de => indica que filtre los matching items antes de pasar a la búsqueda vectorial
# Code fragment - focus on hybrid query syntax
hybrid_query = Query(
    "@category:{documentation}=>[KNN 3 @embedding $query_vec AS score]"
).return_fields("title", "category", "score").sort_by("score").dialect(2)

results = redis_client.ft("idx:documents").search(
    hybrid_query,
    query_params={"query_vec": query_bytes}
)

Range queries: Threshold-based retrieval

Mientras que KNN devuelve un número fijo de resultados, las range queries devuelven todos los vectores que haya a una distancia especificada.

Es útil cuando quieres todo lo que haya con un cierto nivel de similitud, independientemente de devolver un número arbitrario.

Por ejemplo: queremos todos los docs con un COSINE distance menor de 0.2, lo cual puede devolver 3 o 300

# Code fragment - focus on VECTOR_RANGE syntax
range_query = Query(
    "@embedding:[VECTOR_RANGE 0.2 $query_vec]=>{$YIELD_DISTANCE_AS: score}"
).return_fields("title", "score").sort_by("score").dialect(2)

results = redis_client.ft("idx:documents").search(
    range_query,
    query_params={"query_vec": query_bytes}
)

Understand distance metrics

ATENCION: esto moverlo a otra parte ya que es un tema multi-repetido a lo largo de toda la cert.

  • COSINE: Usar para text embeddings
  • L2 (Euclidean): Usar para image embeddings o spatial data
  • IP: Usar solo para embeddings pre-normalizados

/ATENCION: esto moverlo a otra parte ya que es un tema multi-repetido a lo largo de toda la cert.

Read More

Choose vector types and indexing strategies (Redis)

Vector data types

Redis usa FLOAT32 o FLOAT64, lo cual impacta en la memoria que consumen tus vectores (junto a la dimensionalidad de los embeddings) y en la precisión de las búsquedas semánticas,

IMPORTANTE

Para la mayoría de AI apps FLOAT64 no provee de ninguna mejora respecto a FLOAT32 porque los modelos no dan valores tan precisos. Para standard work se debe usar FLOAT32

/IMPORTANTE

# Code fragment - focus on vector data type configuration
VectorField(
    "embedding",
    "HNSW",
    {
        "TYPE": "FLOAT32",  # Standard choice for AI embeddings
        "DIM": 1536,
        "DISTANCE_METRIC": "COSINE"
    }
)

Match embeddings dimensions

La dimensionalidad tiene que ser la misma en Redis y en el embedding’s model output

# Code fragment - focus on dimension matching
embedding_models = {
    "small-model": 384,
    "medium-model": 768,
    "large-model": 1536,
    "xlarge-model": 3072,
}

# Create index matching your model
VectorField(
    "embedding",
    "HNSW",
    {
        "TYPE": "FLOAT32",
        "DIM": 1536,  # Must match model output
        "DISTANCE_METRIC": "COSINE"
    }
)

Distance metrics

IMPORTANTE

Para la mayoría de AI apps que envuelven texto, usaremos COSINE

  • COSINE: mide el ángulo entre vectores, ignorando la magnitud. Se usa para text embeddinsg y semantic similarity (OpenAI y lo que la mayoría de LLMs esperan)
  • L2 (Euclidean): mide la distancia recta en el espacio vectorial. Se usa para image embeddings y spatial data donde importan ambos la dirección y la magnitud
  • IP (Inner product): Computa el dot product entre vectores. Se usa solo cuanto tenemos embeddings pre-normalizados o modelos espacializados que lo requieren.

/IMPORTANTE

Es importante tener en cuenta la distancia para la que está entrenado el embeddings model - hay modelos que necesitan distance metrics específicas.

# Code fragment - focus on distance metric selection

# For text embeddings (most common)
VectorField("embedding", "HNSW", {
    "TYPE": "FLOAT32",
    "DIM": 1536,
    "DISTANCE_METRIC": "COSINE"  # Use for OpenAI, Cohere, Sentence Transformers
})

# For image embeddings
VectorField("image_embedding", "HNSW", {
    "TYPE": "FLOAT32",
    "DIM": 768,
    "DISTANCE_METRIC": "L2"  # Use for vision models
})

Read More

Broadcast (pub/sub) vs Coordinated distribution (streams)

Imagina que tienes tres worker services procesando requests.

Con pub/sub si suscribes a los 3 workers al mismo channel, cada worker recibe cada mensaje, lo que crea duplica el procesamiento.

Con Streams consumer groups cada request va a un solo worker, distribuyendo la carga de trabajo automáticamente.

Choosing the right approach

IMPORTANTE

Usa pub/sub cuando:

  • Todos los subscribers necesiten procesar el mismo mensaje (cache invalidation, config updates, notifications)
  • No necesites garantias de entrega o acknowledgments
  • Cada subscriber ejecuta acciones diferentes basados en el mismo evento

Usa Stream consumer groups cuando:

  • Cada mensaje deba ser procesado por exactamente un worker (task queues, job processing)
  • Si que necesites garantias de entrega o acknowledgments
  • Necesites escalar el procesamiento añadiendo más consumidores
  • Necesites poder manejar fallos y reasignar tareas

/IMPORTANTE

Pub/Sub: Broadcast to all subscribers

Cuando subscribes multiples servicios al mismo pub/sub channel, cada subscriber recibe cada mensaje. Redis pub/sub está diseñado para hacer broadcasting de eventos a múltiples consumidores de manera simultánea.

How broadcast distribution works

Redis delivers each published message to all active subscribers of that channel.

Si tienes 5 consumidores subscritos al channel ai:models:updated y publicas un mensaje en ese canal, los 5 servicios reciben el mismo mensaje de manera simultánea

# Publisher service
redis_client.publish('ai:cache:invalidate', 'embeddings-v2')

# All of these subscribers receive the message:
# - Subscriber 1 (API server instance 1)
# - Subscriber 2 (API server instance 2)
# - Subscriber 3 (Background worker)
# - Subscriber 4 (Analytics service)

Casos de uso

IMPORTANTE

Este diseño es intencional y es útil para escenarios específicos.

Usa pub/sub cuando necesites que todos tus servicios reaccionen al mismo evento de manera simultánea

  • Cache invalidation across microservices: publicamos en un channel para asegurar que cada instancia y cada microservicio recibe la señal de invalidar caché
# Model update service
def update_model(model_id, new_version):
    save_model_to_storage(model_id, new_version)
    # Notify all API instances to clear cache
    redis_client.publish('ai:models:cache:invalidate',
                        f'{model_id}:{new_version}')

# Each API instance subscribes and clears its own cache
pubsub = redis_client.pubsub()
pubsub.subscribe('ai:models:cache:invalidate')
for message in pubsub.listen():
    if message['type'] == 'message':
        clear_local_model_cache(message['data'])
  • Configuration updates for distributed services: Cuando al cambiar un param o una feature flag queremos que todos los servicios actualicen su conf
  • Real-time monitoring and metrics collection: podemos conectar multiples monitoring systems al mismo canal para que todos reciban los mismos datos sin interferir entre ellos
  • Event notification: Cuando un user completa una interacción y necesitamos avisar a múltiples servicios de manera simultánea

/IMPORTANTE

Cuando causa problemas

IMPORTANTE

No uses pub/sub cuando necesites:

  • Process tasks that should only run once: si tienes 3 consumers subscritos a un channel y publicas un mensaje, los 3 consumers procesan la misma request.
  • Load balancing across workers: pub/sub no distribuye mensajes - los duplica. No sirve para escalar horizontalmente.
  • Queue-like work distribution: pub/sub no garantiza que los mensajes han sido consumidos y no da acknowledgments. pub/sub es fire-and-forget. Los mensajes puedes ser procesados múltiples veces o ninguna - no hay manera de saberlo

/IMPORTANTE

Streams: Coordinated work distribution

Usar Streams cuando necesitas coordinar multiples subscribers para evitar duplica processing y distribuir carga de trabajo. Redis Streams consumer groups resuelven este problema. A diferencia de pub/sub, los consumer groups aseguran que cada mensaje vaya a un único subscriber.

How consumer groups distribute work

Los consumer groups particionan el Stream entre los group members. Cuando múltiples workers leen del mismo consumer group, Redis reparte automáticamente y asigna diferentes mensajes a diferentes workers. Cada mensaje se entrega a un único consumer en el grupo.
Esto ocurre automáticamente, no tienes que balancear nada.

# Setup: Create a consumer group once
redis_client.xgroup_create('ai:inference:queue', 'workers', '0', mkstream=True)

# Worker 1 gets messages 1, 3, 5
# Worker 2 gets messages 2, 4, 6
# Worker 3 gets messages 7, 8, 9

# All workers use the same group name but different consumer names
messages = redis_client.xreadgroup(
    groupname='workers',  # Same group
    consumername=f'worker-{worker_id}',  # Unique per worker
    streams={'ai:inference:queue': '>'},
    count=10
)

Setting up consumer groups in your worker services

Lo normal es crear el consumer group una única vez durante la inicialización de la App, y a partir de entonces que cada worker instance lea del mismo group.

cada worker obtiene tasks diferentes de manera automática, lo que permite un escalado horizontal

# Application startup code (runs once per deployment, not per instance)
def setup_worker_infrastructure():
    try:
        redis_client.xgroup_create(
            'ai:document:analysis',
            'analysis-workers',
            '0',  # Start from beginning
            mkstream=True  # Create stream if doesn't exist
        )
    except redis.ResponseError as e:
        # Group already exists, which is fine
        if 'BUSYGROUP' not in str(e):
            raise

# Worker processing loop (runs on each worker instance)
def process_documents():
    worker_id = f"{os.getenv('HOSTNAME')}-{os.getpid()}"

    while True:
        messages = redis_client.xreadgroup(
            groupname='analysis-workers',
            consumername=worker_id,
            streams={'ai:document:analysis': '>'},
            count=5,
            block=5000
        )

        for stream, tasks in messages:
            for task_id, task_data in tasks:
                analyze_document(task_data)
                redis_client.xack('ai:document:analysis',
                                 'analysis-workers',
                                 task_id)

Understand the > symbol and consumer positions

Al leer del consumer group el símbolo > le comunica a Redis que te dé nuevos mensajes que no hayan sido entregados todavía a ningún consumidor.

esto es lo que permite work distribution. Cuando worker-1 lee con > obtienes mensajes que worker-2 no recibe. Redis hace track de que mensajes se entregan a que consumidores

# Read only NEW messages not yet delivered to any consumer
redis_client.xreadgroup('workers', 'worker-1',
                       {'ai:queue': '>'}, count=10)

También podemos especificar un ID para leer de una posición específica, lo cual es útil para manejar pending messages.

# Read messages pending for this specific consumer
redis_client.xreadgroup('workers', 'worker-1',
                       {'ai:queue': '0'}, count=10)

Scaling workers dynamically

Una de las ventajas principales de los consumer groups es que permiten escalar horizontalmente sin cambios de código. Solo con escalar los micros es suficiente ya que automaticamente se distribuye el trabajo

# This same code runs on 2 workers or 20 workers
# Redis automatically distributes work based on how many workers are reading

def worker_main():
    setup_worker_infrastructure()  # Idempotent group creation

    worker_id = generate_unique_worker_id()

    while True:
        tasks = fetch_next_tasks('workers', worker_id)
        process_tasks(tasks)
        acknowledge_completion(tasks)

Handling failures and task reassignment

Los consumer groups tienen built-in mechanism para manejar fallos de los consumidores. Cuando un consumidor (worker) se crashea mientras procesa una task, esa task se queda en la lista de pendientes y se puede reasignar a otro healthy worker.

Detecting and claiming stuck tasks

Usa XPENDING para encontrar tasks que llevan en progreso demasiado tiempo y usa XCLAIM para reasignarlas.

# In a separate monitoring/health-check service or worker
def reassign_abandoned_tasks():
    # Check for tasks pending more than 5 minutes
    pending = redis_client.xpending_range(
        'ai:inference:queue',
        'workers',
        '-', '+',
        count=100
    )

    current_time = int(time.time() * 1000)

    for task in pending:
        task_id = task['message_id']
        idle_time = current_time - task['time_since_delivered']

        # Task processes for more than 5 minutes, likely stuck
        if idle_time > 300000:
            # Claim it for reprocessing
            redis_client.xclaim(
                'ai:inference:queue',
                'workers',
                f'recovery-worker-{os.getpid()}',
                300000,
                message_ids=(task_id,)
            )

            # Now process it
            reprocess_stuck_task(task_id)

Implement automatic retry in workers

Cada worker puede hacer check de sus propias tasks en startup, permitiendo automatic recovery después de los restarts.

def worker_startup_recovery():
    worker_id = get_worker_id()

    # Check if this worker holds any pending tasks from before crash
    pending = redis_client.xpending_range(
        'ai:inference:queue',
        'workers',
        '-', '+',
        count=100
    )

    # Filter for tasks assigned to this consumer
    my_pending = [p for p in pending if p['consumer'] == worker_id]

    # Retry each pending task
    for task in my_pending:
        try:
            retry_task(task['message_id'])
            redis_client.xack('ai:inference:queue', 'workers',
                            task['message_id'])
        except Exception as e:
            log_error(f"Retry failed for {task['message_id']}: {e}")

Read More

Task queues with Redis Streams

Redis Streams es una manera de implementar task queues y event processing en backend services. Se usa cuando necesitas encolar requests, coordinar pipes multi-proceso o gestionar long-running ops.
Los Streams te dan la durabilidad y la coordinacion que pub/sub no da.

Redis Streams

Los Streams son append-only task queues donde añades items y los consumers hacen pull de los items de la cola.

Puedes usar

  • XADD para añadir tasks
  • XREADGROUP para hacer pull de tasks en tu worker
  • XACK para marcar tasks como completas

IMPORTANTE

La diferencia de listas con los Streams es que estos trackean que consumidor ha procesado que task, y permiten retries automáticos si tu servicio se crashea.

/IMPORTANTE

What devs get from Streams

  • task survive crashes: cuando hay un reinicio, no pierdes las tasks no procesadas. Estas siguen en el Stream.
  • automatic retry handling: si tu codigo se crashea mientras procesa una task, esa task se pone como disponible para reintentarla automaticamente
  • built-in work distribution: cuando escalas a múltiples workers, Stream consumer groups automaticamente distribuyen tasks a lo largo de instancias sin duplicar trabajo
  • processing history: puedes hacer queries para ver que ha pasado en la pipe, hacer un replay para debuggear o que servicios nuevos se pongan al dia con datos historicos
  • simple async patterns: Los handlers pueden añadir tasks a los streams y volver inmediatamente mientras background workers procesan tasks a su ritmo

Stream task structure

Cada task que añades a un Stream obtiene su ID auto-generado y puede contener cualquier campo que necesites. Piensa que es como añadir un JSON object a una cola.

este ID se asegura que las tasks se procesan en orden

# Adding an AI processing task
stream_id = redis.xadd('ai:inference:requests', {
    'user_id': '12345',
    'model': 'gpt-4',
    'prompt': 'Summarize this document...',
    'priority': 'high'
})
# Returns ID like: '1699980000000-0'

Scaling with multiple workers

Cuando haces deploy de multiples instancias, los consumer groups se aseguran de que cada task solo vaya a un único worker. Creas un grupo una única vez y entonces cada worker instance lee del mismo grupo.

ahora puedes escalar horizontalmente - añade más worker instances para compartir la carga

# In your worker deployment/startup code
try:
    redis.xgroup_create('ai:inference:requests', 'workers', id='0', mkstream=True)
except redis.ResponseError:
    pass  # Group already exists

# In your worker's processing loop (runs on each instance)
while True:
    tasks = redis.xreadgroup('workers', 'worker-instance-1',
                             {'ai:inference:requests': '>'},
                             count=10, block=5000)
    for task_id, task_data in tasks:
        process_ai_task(task_data)
        redis.xack('ai:inference:requests', 'workers', task_id)

Cuando usar Streams

Redis Streams son ideales para escenarios donde queremos reliability y la persistencia de las tasks es importante.

  • API endpoints que encolan requests: En vez de bloquear la API mientras espera una request lo podemos en una cola y devolvemos el ID automáticamente. Los background workers lo procesan y hacen update de los resultados
  • Multi-step processing pipelines: Cuando procesar requiere multiples pasos todos en orden (extraer - analizar - resumir). Si cualquier paso falla, no pierdes progreso
  • Worker services que escalan horizontalmente: los streams distribuyen automaticamente el trabajo
  • Long running operations que necesitan retry
  • System requiring processing history: cuando necesitamos un historial para ver que ha pasado y cuando

Code Examples

Adding AI tasks to a queue

Usa XADD para añadir a un Stream. Cada task tiene un ID unico.

# Your API handler code
def queue_inference_request(user_prompt, model_name):
    task_id = redis.xadd('ai:inference:queue', {
        'prompt': user_prompt,
        'model': model_name,
        'user_id': current_user.id,
        'requested_at': datetime.now().isoformat()
    })
    return task_id

Processing tasks in your worker service

Worker services usan XREADGROUP para hacer fetch de tasks desde un Stream y XACK para marcarlas como completadas.

# Worker service processing loop
def process_ai_tasks():
    # One-time setup: create consumer group
    try:
        redis.xgroup_create('ai:inference:queue', 'workers', id='0', mkstream=True)
    except:
        pass  # Already exists

    # Main processing loop
    while True:
        # Get up to 5 tasks, wait 5 seconds if queue empty
        messages = redis.xreadgroup(
            groupname='workers',
            consumername=f'worker-{os.getpid()}',
            streams={'ai:inference:queue': '>'},
            count=5,
            block=5000
        )

        for stream, tasks in messages:
            for task_id, task_data in tasks:
                try:
                    # Do your AI processing
                    result = run_inference(task_data['prompt'], task_data['model'])
                    save_result(task_id, result)

                    # Mark task complete
                    redis.xack('ai:inference:queue', 'workers', task_id)
                except Exception as e:
                    # Task stays in pending, will retry
                    log_error(f"Task {task_id} failed: {e}")

Handling failed tasks

Usa XPENDING para encontrawr tasks que han estado procesando demasiado tiempo y XCLAIM para reasignarlas. Esto se encarga de casos donde los workers se crashean a medio del proceso.

# Check for tasks that have been pending too long (stuck/crashed)
def retry_stuck_tasks():
    pending = redis.xpending('ai:inference:queue', 'workers', '-', '+', 10)

    for task in pending:
        task_id = task['message_id']
        idle_time = task['time_since_delivered']

        # If task pending more than 5 minutes, reassign it
        if idle_time > 300000:  # milliseconds
            redis.xclaim('ai:inference:queue', 'workers',
                        f'worker-{os.getpid()}', 0, [task_id])

Monitoring queue health

Usa XINFO para obtener metricas de Stream queues. Estos datos son utiles para dashboards y alertas.

# Get Stream metrics for your application dashboard
def get_queue_stats():
    info = redis_client.xinfo_stream('ai:documents:queue')
    groups = redis_client.xinfo_groups('ai:documents:queue')

    return {
        'total_tasks': info['length'],
        'pending_tasks': groups[0]['pending'],
        'consumers': groups[0]['consumers']
    }

Trade-offs a considerar

  • Memory management es TU responsabilidad: A diferencia de pub/sub donde los mensajes desaparecen despues de ser entregamos, Stream tasks se mantienen en memoria hasta que tu los borrar. Para high-volume queues necesitas encargarte de limpiar
# Trim to most recent 10,000 tasks when adding new ones
redis.xadd('ai:inference:queue', task_data, maxlen=10000, approximate=True)

# Or trim periodically in your worker after acknowledging tasks
if task_count % 100 == 0:  # Every 100 tasks
    redis_client.xtrim('ai:documents:queue', maxlen=10000, approximate=True)
  • Slighty higher latency than pub/sub: Streams añaden unos ms de latencia por la persistencia y el ack tracking. Si necesitas esos ms de latencia, usa pub/sub
  • Más complejidad: Necesitas gestionar consumer groups, ack, y pending task checks. Pub/sub es más simple pero a cambio obtienes esa erliability
  • Tasks no auto-expiran: Las tasks completadas se quedan en el Steram hasta que se borran

Read More

Redis pub/sub

Azure Managed Redis incorpora messaging capabilities a través del patrón publish/subscribe (pub/sub). Esto permite comunicación asíncrona en tiempo real entre diferentes partes de tu AI app.

Este modelo permite a los publishers enviar mensajes a named channels sin tener detalles de quién los va a recibir, o sin saber si hay alguien escuchando. Los subscribers pueden escuchar uno o más canales y recibir los mensajes publicados, creando una loosely coupled, event-driven AI architecture.

Redis pub/sub es útil en AI apps donde los componentes necesitan reaccionar inmediatamente a eventos sin bloqueos.

Como funciona pub/sub

  • at-most-once delivery: los mensajes se entregan a los subscribers que están activamente conectados cuando se publica el mensaje. No hay garantías si un subscriber se desconecta temporalmente.
  • no message persistence: los mensajes existen solo en memoria mientras se distribuyen a los subscribers. Una vez entregados no se guardan por Redis. Esto lo hace ideal para real-time notifications pero no es util para escenarios que requieren persistencia de mensajes
  • fire-and-forget: Los publishers no saben si hay subscribers que reciben los mensajes. Este desacoplado lo hace muy fuerte para el escalado, pero significa que no hay confirmación
  • high throughput

Límites a considerar

  • No message durability: Los mensajes que llegan cuando no hay subscribers escuchando se pierden para siempre. Si un subscriber se desconecta temporalmente, se pierde los mensajes que hayan llegado mientras estaba offline
  • No delivery guarantees: Los publishers no saben si alguien recibe los mensajes correctamente. Si todos los subscribers están offline, los mensajes se pierden
  • Memory-only operation: Los mensajes solo se mantienen en memoria, nunca en disco. Redis pub/sub no es útil para escenarios que requieren de persistencia de los mensajes, un orden procesado o replay capabilities

Cuando usar pub/sub

Usarlo cuando necesites:

  • coordinación en tiempo real con latencia sub-millisecond
  • broadcasting updates a multiples componentes de manera simultanea
  • un loose coupling entre micros
  • high throughput messages
  • simple event distribution
  • parallel processing triggers

Channel naming and patterns

Los canales en Redis son strings

ai:conversations:123       # Conversation-specific AI events
ml:model:predictions       # ML model prediction results
ai:training:status         # Model training status updates
embeddings:cache:refresh   # Vector embedding cache updates

Redis soporta pattern matching para los subscriptores, permitiendo a los componentes escuchar en múltiples canales relacionados

ai:conversations:*        # All conversation AI events
ml:models:*:status       # All model status updates
ai:*:predictions        # All AI prediction events

Code examples

publish events

Usa PUBLISH para enviar messages a channels.

# Publish a cache invalidation event
def notify_model_updated(model_name, version):
    message = f"{model_name}:{version}"
    redis_client.publish('ai:models:updated', message)

# Publish embedding refresh notification
def notify_embeddings_refreshed(collection_id):
    redis_client.publish('ai:embeddings:refresh', collection_id)

subscribe to channels in worker services

Usa SUBSCRIBE para escuchar a canales específicos. Los subscriben son servicios que corren en background y reaccionan a eventos

# Subscribe to specific channels
pubsub = redis_client.pubsub()
pubsub.subscribe('ai:models:updated', 'ai:embeddings:refresh')

# Listen for messages
for message in pubsub.listen():
    if message['type'] == 'message':
        channel = message['channel']
        data = message['data']

        if channel == 'ai:models:updated':
            # Clear model cache
            clear_model_cache(data)
        elif channel == 'ai:embeddings:refresh':
            # Refresh embedding cache
            refresh_embeddings(data)

use pattern subscriptions

Usa PSUBSCRIBE para subscribirte a múltiples canales con pattern matching. Esto es útil cuando quieres escuchar en todos los canales de una categoría.

# Subscribe to all AI-related channels
pubsub = redis_client.pubsub()
pubsub.psubscribe('ai:*')

# Handle messages from any AI channel
for message in pubsub.listen():
    if message['type'] == 'pmessage':
        pattern = message['pattern']  # 'ai:*'
        channel = message['channel']  # Actual channel name
        data = message['data']

        print(f"Received on {channel}: {data}")
        handle_ai_event(channel, data)

broadcasting to WebSocket clients

Combina pub/sub con WebSocket connections para pushear eral-time updates to browser clients

from fastapi import FastAPI, WebSocket
import redis.asyncio as redis
import asyncio

app = FastAPI()

# Background task to listen for Redis pub/sub messages
async def redis_listener(websocket: WebSocket):
    redis_client = redis.Redis(
        host='your-redis.redis.cache.windows.net',
        port=<PORT>,
        password='your-access-key',
        ssl=True,
        decode_responses=True
    )

    async with redis_client.pubsub() as pubsub:
        await pubsub.subscribe('ai:predictions:ready')

        async for message in pubsub.listen():
            if message['type'] == 'message':
                # Forward Redis message to WebSocket client
                await websocket.send_json({
                    'type': 'prediction',
                    'data': message['data']
                })

@app.websocket("/ws/{client_id}")
async def websocket_endpoint(websocket: WebSocket, client_id: str):
    await websocket.accept()
    await redis_listener(websocket)

Read More

Implement data ops (Redis)

IMPORTANTE

Azure Managed Redis soporta standard Redis commands para data ops. Redis soporta varios tipos de datos más allá de strings.

Data type Ops
string operations String ops (SET, GET, MSET, MGET) funcionan con texto o datos serializados. ATENCIÓN: Al usar decode_responses=True en la conexión, Redis automáticamente convierte byte responses en strings. Para datos binarios como imágenes poner decode_responses=False para trabajar con raw bytes.
hash operations Redis Hashes (HSET, HGET, HGETALL) guarda pares clave-valor. Es ideal para representar datos estructurados. Los hashes son más memory-efficient que guardar cada campo como una key separada.
list operations Redis Lists (LPUSH/RPUSH, LPOP/RPOP, LRANGE) son colecciones ordenadas de strings, perfectas para queues, activity feeds o items recientes. Soporta ambos stack LIFO y queue FIFO.
numeric operations Redis proporciona incrementos y decrementos atómicos (INCR, DECR, INCRBY, DECRBY) que funcionan con string values numéricos. Al ser atómicos lo hace ideal para contadores, rate limits y distributed counting scenarios with race conditions. Los valores se guardan como strings pero Redis los trata como ints para estas operaciones

/IMPORTANTE

Usamos la librería redis-py. Soporta ambos sync y async ops.

Uso standard de Redis

import redis

# Create a Redis client
r = redis.Redis(
    host='your-redis-instance',
    port=10000,
    ssl=True,
    decode_responses=True,  # Convert byte responses to strings automatically
    password='your-access-key'
)

Para PROD podemos usar Entra ID con redis-entraid

import redis
from azure.identity import DefaultAzureCredential
from redis_entraid.cred_provider import create_from_default_azure_credential

# Create credential provider using DefaultAzureCredential
credential_provider = create_from_default_azure_credential(
    ("https://redis.azure.com/.default",),
)

# Create a Redis client with Azure Entra ID authentication
r = redis.Redis(
    host='your-redis-instance',
    port=10000,
    ssl=True,
    decode_responses=True,  # Convert byte responses to strings automatically
    credential_provider=credential_provider
)

Basic data ops

Get and Set ops

obtener y guardar valores

# Store a value
result = r.set('user:1001:name', 'Alice Smith')
print(f"SET operation successful: {result}")  # Returns True

# Retrieve the value
name = r.get('user:1001:name')
print(f"Retrieved name: {name}")  # Output: Alice Smith

Los Hashes guardan multiples pares clave-valor en una sola key. Ideal para estructuras como user profiles

# Store multiple fields in a hash
r.hset('user:1001', mapping={
    'name': 'Alice Smith',
    'email': 'alice@example.com',
    'age': '28'
})

# Retrieve a single field
name = r.hget('user:1001', 'name')
print(f"Name: {name}")  # Output: Alice Smith

# Retrieve all fields
user_data = r.hgetall('user:1001')
print(f"User data: {user_data}")  # Returns dict with all fields

Multiple key ops

Cuando necesitas trabajar con multiples string keys de manera simultanea usa MSET y MGET para mejor performance.

# Set multiple keys at once
r.mset({
    'user:1001:name': 'Alice Smith',
    'user:1001:email': 'alice@example.com',
    'user:1001:age': '28'
})

# Get multiple values at once
values = r.mget('user:1001:name', 'user:1001:email', 'user:1001:age')
print(f"User data: {values}")  # Returns list of values

Para Hash ops, multiple key ops puede involucrar trabajar con multiple hash keys

# Using pipeline for multiple hash operations (efficient)
pipe = r.pipeline()
pipe.hgetall('user:1001')
pipe.hgetall('user:1002')
results = pipe.execute()
# Returns list of dicts, one for each hash

# Or retrieve specific fields from multiple hashes
pipe = r.pipeline()
pipe.hget('user:1001', 'name')
pipe.hget('user:1002', 'name')
names = pipe.execute()
# Returns list of names: ['Alice Smith', 'Bob Jones', 'Carol White']

Check Key existence

Antes de sacar o actualizar datos verificar que existen con EXISTS - se puede usar con todos los tipos de datos

# Check if a key exists
if r.exists('user:1001:name'):
    print("Key exists")

# Check multiple keys
count = r.exists('user:1001:name', 'user:1001:email', 'user:9999:name')
print(f"Number of existing keys: {count}")  # Returns 2

Delete ops

Borramos keys de la cache con DELETE cuando los datos ya no se necesitan o se vuelven obsoletos. DELETE funciona para todos los tipos de data types. Borra la key y sus datos asociados.

# Delete a single key
result = r.delete('user:1001:name')
print(f"Keys deleted: {result}")  # Returns count of deleted keys

# Delete multiple keys
result = r.delete('user:1001:email', 'user:1001:age')
print(f"Keys deleted: {result}")

Working with expiration

Es crucial poner expiration times para que se invaliden automaticamente. EXPIRE, SETEX, TTL funcionan con todos los data types.

Set value with expiration

Usamos SETEX para hacer set de un string value y su fecha de expiracion en una sola operacion atomica. Para otros datos como Hashes o Listas primero se guardan los datos, luego se usa EXPIRE para añadir fecha de expiración.

# Set a key with 60-second expiration
r.setex('session:abc123', 60, 'user_data')

# Alternative: Set value with expiration in milliseconds
r.psetex('temp:data', 5000, 'temporary_value')  # Expires in 5000ms

Add expiration to existing keys

Añadimos fecha de expiracion a todas las keys que ya existen en cache. Usamos EXPIRE, PEXPIRE, EXPIREAT. Funcionan con todos los tipos de datos

# Set a key without expiration
r.set('user:1002:preferences', 'dark_mode')

# Add 3600-second (1 hour) expiration
r.expire('user:1002:preferences', 3600)

# Set expiration in milliseconds
r.pexpire('user:1002:preferences', 3600000)

# Set expiration at specific Unix timestamp
import time
expire_at = int(time.time()) + 7200  # 2 hours from now
r.expireat('user:1002:preferences', expire_at)

Check y manage TTL

Monitorizamos el TTL para saber cuando expiran las keys. TTL, PTTL, PERSIST funcionan con todos los tipos de datos.

# Get TTL in seconds
ttl = r.ttl('user:1002:preferences')
if ttl == -1:
    print("Key exists but has no expiration")
elif ttl == -2:
    print("Key does not exist")
else:
    print(f"Key expires in {ttl} seconds")

# Get TTL in milliseconds
ttl_ms = r.pttl('user:1002:preferences')
print(f"Key expires in {ttl_ms} milliseconds")

# Remove expiration (persist the key)
r.persist('user:1002:preferences')

Cache invalidation patterns

Una cache efectiva asegura que tu app sirve datos frescos y mantiene una buena performance.

Time-based invalidation

La manera más simple. Usamos TTL para expirar automaticamente los datos de la cache después de un tiempo.

def cache_database_query(query_key, query_function, ttl=300):
    """
    Cache database query results with automatic expiration.

    Args:
        query_key: Cache key for the query
        query_function: Function that executes the database query
        ttl: Time to live in seconds (default: 5 minutes)
    """
    # Check if result is cached
    cached_result = r.get(query_key)
    if cached_result:
        print("Cache hit")
        return cached_result

    # Execute query and cache result
    print("Cache miss - executing query")
    result = query_function()
    r.setex(query_key, ttl, result)
    return result

# Usage example
def get_product_details():
    # Simulate database query
    return "Product: Laptop, Price: $999"

product_data = cache_database_query('product:12345', get_product_details, ttl=600)

Manual invalidation on update

Cuando los datos cambian, hacemos update o remove de los datos en cache de manera explicita para mantener consistencia

def update_user_profile(user_id, new_data):
    """
    Update user profile and invalidate related cache entries.
    """
    # Update database (simulated)
    save_to_database(user_id, new_data)

    # Invalidate all related cache keys
    cache_keys = [
        f'user:{user_id}:profile',
        f'user:{user_id}:summary',
        f'dashboard:user:{user_id}'
    ]
    deleted = r.delete(*cache_keys)
    print(f"Invalidated {deleted} cache entries")

def save_to_database(user_id, data):
    # Placeholder for database operation
    pass

Cache-aside pattern with expiration

Implementar el patrón cache-aside (lazy loading) con expiración automática para optimal cache usage

def get_user_data(user_id, ttl=3600):
    """
    Retrieve user data using cache-aside pattern.

    Args:
        user_id: User identifier
        ttl: Cache expiration in seconds (default: 1 hour)
    """
    cache_key = f'user:{user_id}:data'

    # Try to get from cache
    cached_data = r.get(cache_key)
    if cached_data:
        return cached_data

    # Cache miss - fetch from database
    user_data = fetch_from_database(user_id)

    # Store in cache with expiration
    if user_data:
        r.setex(cache_key, ttl, user_data)

    return user_data

def fetch_from_database(user_id):
    # Placeholder for database query
    return f"User data for {user_id}"

Pattern-based invalidation

Borramos multiples keys relacionadas usando pattern matching con el comando SCAN (no KEYS, lo cual bloquea el server)

def invalidate_user_cache(user_id):
    """
    Invalidate all cache entries for a specific user.
    Uses SCAN for non-blocking pattern matching.
    """
    pattern = f'user:{user_id}:*'
    cursor = 0
    deleted_count = 0

    while True:
        cursor, keys = r.scan(cursor, match=pattern, count=100)
        if keys:
            deleted_count += r.delete(*keys)
        if cursor == 0:
            break

    print(f"Invalidated {deleted_count} keys for user {user_id}")

# Usage
invalidate_user_cache(1001)

Best practices

  • Use connection pooling: La libreria redis usa automaticamente connection pooling, pero es algo que se puede configurar
  • Handle errors gracefully
  • Choose appropiate TTL values
    • Frequent chaging data: 1-5 mins
    • Moderate change rate: 15-60 mins
    • Relative stable data: 1-24 hours
    • Static reference data: +24 hours

Read More

Azure Managed Redis

Azure Managed Redis es un data store en memoria basado en Redis Enterprise. La versión Enterprise mejora la performance y fiabilidad de la community edition. Es managed, por lo que microsoft opera el servicio.

Azure Managed Redis puede mejorar la performance y escalabilidad de una aplicación que tiene un uso heavy de backend data stores, ya que al almacenar los datos frecuentes en la memoria del servidor permite leer más rápido.

Common caching strategies

Data Cache

Los datos se guardan en la caché al ser pedidos por una petición. Cuando la aplicación necesita datos primero mira si están en la caché de Redis. Si los datos no se encuentran, los saca de la BBDD y los almacena en Redis para queries posteriores.

Cuando la app hace cambios en los datos, tiene que invalidar o actualizar la caché correspondiente para mantener consistencia. El servicio soporta un TTL para borrar automáticamente datos viejos y hay eviction policies para cuando Redis se queda sin memoria.

Content cache

Almacenamos el contenido estático de la web como headers, footers, banners, nav menus. Estos rara vez cambian por lo que se pueden cachear. Reduce el server processing time y loading. Permite a los web servers servir más usuarios de forma concurrente.

Session store

Session store es útil para shopping carts, user preferences, auth tokens y otros datos user-specific que la web mantiene a través de requests. Se usa la caché para esto ya que guardar datos directamente en las cookies impacta negativamente a la performance.

La solución típica es guardar un session ID en la cookie, y usar esta ID para hacer retrieve de todos los datos de la sesión. Una implementación tradicional lee esto de la BBDD, pero Redis es más rápido leyendo esto de la memoria.

Redis Tiers

  • Memory Optimized: necesitas memoria pero no CPU (ratio memoria-vCPU de 8:1). Lower price point.
  • Balanced (Memory + Compute): (ratio memoria-vCPU de 4:1). Ideal para standard workloads
  • Compute Optimized: necesitas CPU pero no memoria (ratio memoria-vCPU de 2:1). Ideal para apps que necesitan la mejor performance

Redis Libraries

Client library Language
StackExchange.Redis C#/.NET
Lettuce Java
node_redis Node.JS
redis-py Python

Reddis supports two clustering policies

  • Enterprise clustering policy - all client libraries support it
  • OSS (Open Source Software) clustering policy - it depends by client library - check that it supports it

Commands

Microsoft manages the conf and management of Redis, which disables some commands by default

(no entro en detalle en esto de momento)

Development best practices

Data design and performance

  • use smaller values: divide larger data chunks into multiple keys with smaller values
  • handle large responses: optimize for many small values, increase VM size (higher bandwidth)
  • use pipelining: choose clients that support Redis pipelining for better network efficiency
  • avoid expensive operations: Don’t use KEYS in PROD; use SCAN for iterating over keys

Network and connectivity

  • co-locate resources: place Redis and app instances in the same Azure region
  • use hostnames: rely in hostnames instead of public UP addresses
  • enable TLS

Monitoring and scaling

Monitorizar estas métricas y escalar cuando pasen del 75%

  • Used memory %
  • CPU usage
  • Connected Clients
  • Network bandwidth

Configuration

  • Choose the right tier: based on memory, balanced or compute
  • Enable high availability: Use high availability for PROD workloads; disable for DEV envs
  • Implement data protection: Enable data persistence for quick recovery or use import/export for periodic backups

Read More