Redis / Valkey

Redis and Valkey vector store integration for semantic caching in Bifrost.

Redis

Redis provides high-performance in-memory vector storage using RediSearch-compatible APIs, ideal for applications requiring sub-millisecond response times and fast semantic search capabilities. Valkey deployments that expose compatible FT.* commands are supported through the same configuration.

Key Features

• High Performance: Sub-millisecond cache retrieval with Redis’s in-memory storage
• Cost Effective: Open-source solution with no licensing costs
• HNSW Algorithm: Fast vector similarity search with excellent recall rates
• Connection Pooling: Advanced connection management for high-throughput applications
• TTL Support: Automatic expiration of cached entries
• Streaming Support: Full streaming response caching with proper chunk ordering
• Flexible Filtering: Advanced metadata filtering with exact string matching

Setup & Installation

Redis Cloud:

• Sign up at cloud.redis.io
• Create a new database with RediSearch module enabled
• Get your connection details

Local Redis with RediSearch:

# Using Docker with Redis Stack (includes RediSearch)
docker run -d --name redis-stack -p 6379:6379 redis/redis-stack:latest

Local Valkey Bundle:

# Example Valkey bundle with search/vector support
docker run -d --name valkey-bundle -p 6379:6379 valkey/valkey-bundle:9.0.0

Configuration Options

Go SDK

// Configure Redis-compatible vector store (Redis or Valkey endpoint)
vectorConfig := &vectorstore.Config{
    Enabled: true,
    Type:    vectorstore.VectorStoreTypeRedis, // Keep type as "redis" for Valkey too
    Config: vectorstore.RedisConfig{
        Addr:     "localhost:6379",        // Redis/Valkey server address - REQUIRED
        Username: "",                      // Optional: Redis username
        Password: "",                      // Optional: Redis password
        DB:       0,                       // Optional: Redis database number (default: 0)

        // Optional: TLS and cluster settings
        UseTLS:             false,             // Enable TLS for encrypted connections
        InsecureSkipVerify: false,             // Skip TLS cert verification
        ClusterMode:        false,             // Use Redis Cluster client for cluster endpoints

        // Optional: Connection pool settings
        PoolSize:        10,               // Maximum socket connections
        MaxActiveConns:  10,               // Maximum active connections
        MinIdleConns:    5,                // Minimum idle connections
        MaxIdleConns:    10,               // Maximum idle connections

        // Optional: Timeout settings
        DialTimeout:     5 * time.Second,  // Connection timeout
        ReadTimeout:     3 * time.Second,  // Read timeout
        WriteTimeout:    3 * time.Second,  // Write timeout
        ContextTimeout:  10 * time.Second, // Operation timeout
    },
}

// Create vector store
store, err := vectorstore.NewVectorStore(context.Background(), vectorConfig, logger)
if err != nil {
    log.Fatal("Failed to create vector store:", err)
}

config.json

{
  "vector_store": {
    "enabled": true,
    "type": "redis",
    "config": {
      "addr": "localhost:6379",
      "username": "",
      "password": "",
      "db": 0,
      "use_tls": false,
      "insecure_skip_verify": false,
      "ca_cert_pem": "",
      "cluster_mode": false,
      "pool_size": 10,
      "max_active_conns": 10,
      "min_idle_conns": 5,
      "max_idle_conns": 10,
      "dial_timeout": "5s",
      "read_timeout": "3s",
      "write_timeout": "3s",
      "context_timeout": "10s"
    }
  }
}

For Redis Cloud or Valkey service endpoints:

{
  "vector_store": {
    "enabled": true,
    "type": "redis",
    "config": {
      "addr": "your-redis-host:port",
      "username": "your-username",
      "password": "your-password",
      "db": 0,
      "use_tls": true,
      "ca_cert_pem": "-----BEGIN CERTIFICATE-----\n...\n-----END CERTIFICATE-----",
      "cluster_mode": false,
      "context_timeout": "10s"
    }
  }
}

For managed Redis Cluster endpoints:

{
  "vector_store": {
    "enabled": true,
    "type": "redis",
    "config": {
      "addr": "your-cluster-endpoint:6379",
      "username": "your-username",
      "password": "your-password",
      "db": 0,
      "use_tls": true,
      "ca_cert_pem": "-----BEGIN CERTIFICATE-----\n...\n-----END CERTIFICATE-----",
      "cluster_mode": true,
      "context_timeout": "10s"
    }
  }
}

Redis-Specific Features

Vector Search Algorithm: Redis uses the HNSW (Hierarchical Navigable Small World) algorithm for vector similarity search, which provides:

• Fast Search: O(log N) search complexity
• High Accuracy: Excellent recall rates for similarity search
• Memory Efficient: Optimized for in-memory operations
• Cosine Similarity: Uses cosine distance metric for semantic similarity

Connection Pool Management: Redis provides extensive connection pool configuration:

config := vectorstore.RedisConfig{
    Addr:            "localhost:6379",
    UseTLS:          true,                     // Enable TLS
    ClusterMode:     true,                     // Enable cluster mode
    PoolSize:        20,                    // Max socket connections
    MaxActiveConns:  20,                    // Max active connections
    MinIdleConns:    5,                     // Min idle connections
    MaxIdleConns:    10,                    // Max idle connections
    ConnMaxLifetime: 30 * time.Minute,      // Connection lifetime
    ConnMaxIdleTime: 5 * time.Minute,       // Idle connection timeout
    DialTimeout:     5 * time.Second,       // Connection timeout
    ReadTimeout:     3 * time.Second,       // Read timeout
    WriteTimeout:    3 * time.Second,       // Write timeout
    ContextTimeout:  10 * time.Second,      // Operation timeout
}

Performance Optimization

Connection Pool Tuning: For high-throughput applications, tune the connection pool settings:

{
  "vector_store": {
    "config": {
      "pool_size": 50,           // Increase for high concurrency
      "max_active_conns": 50,    // Match pool_size
      "min_idle_conns": 10,      // Keep connections warm
      "max_idle_conns": 20,      // Allow some idle connections
      "conn_max_lifetime": "1h", // Refresh connections periodically
      "conn_max_idle_time": "10m" // Close idle connections
    }
  }
}

Memory Optimization:

• TTL: Use appropriate TTL values to prevent memory bloat
• Namespace Cleanup: Regularly clean up unused namespaces

Batch Operations: Redis supports efficient batch operations:

// Batch retrieval
results, err := store.GetChunks(ctx, namespace, []string{"id1", "id2", "id3"})

// Batch deletion
deleteResults, err := store.DeleteAll(ctx, namespace, queries)

Production Considerations

TLS and Cluster Mode: Set use_tls: true to enable TLS encryption for the Redis connection, and insecure_skip_verify: true if using self-signed certificates. Set cluster_mode: true when connecting to a Redis Cluster endpoint. When cluster mode is enabled, the db field must be 0 (Redis Cluster does not support database selection).

Search Module Required: Redis/Valkey integration requires a search module/API that supports FT.* commands (index creation and vector search). If FT.INFO or FT.SEARCH is unavailable, semantic caching will not work.

Production Considerations:

• Use Redis AUTH for production deployments
• Configure appropriate connection timeouts
• Monitor memory usage and set appropriate TTL values

For the VectorStore interface API and usage examples, see Vector Store Architecture. For semantic caching setup, see Semantic Caching.