Struct RedisBackend 

pub struct RedisBackend {
    client: Client,
    index_name: String,
    connection: Mutex<Option<Connection>>,
    timeout: Duration,
}

Redis-based index backend using RediSearch.

Connection Management (DB-H6)

Maintains a reusable connection via Mutex<Option<Connection>>. The connection is lazily initialized and reused across operations to avoid the overhead of establishing new connections for each command.

Command Timeout (CHAOS-HIGH-005)

Connections are configured with a configurable response timeout (default 5s) to prevent indefinite blocking on unresponsive servers. Set SUBCOG_TIMEOUT_REDIS_MS to override.

Fields

client: Client

Redis client.

index_name: String

Index name in Redis.

connection: Mutex<Option<Connection>>

Cached connection for reuse (DB-H6).

timeout: Duration

Operation timeout (CHAOS-HIGH-005).

Implementations

impl RedisBackend

pub fn new(connection_url: &str, index_name: impl Into<String>) -> Result<Self>

Creates a new Redis backend.

Configures the connection with a 5-second timeout (CHAOS-H2) to prevent indefinite blocking on slow or unresponsive Redis servers.

Errors

Returns an error if the Redis connection fails.

pub fn with_defaults() -> Result<Self>

Creates a backend with default settings.

Errors

Returns an error if the Redis connection fails.

pub fn health_check(&self) -> Result<bool>

Checks if the Redis connection is healthy (DB-HIGH-001).

Performs a PING command to verify connectivity and responsiveness.

Returns

Ok(true) if the connection is healthy, Ok(false) if unhealthy, or Err if the health check itself fails unexpectedly.

Example

let backend = RedisBackend::new("redis://localhost:6379", "subcog")?;
if backend.health_check()? {
    println!("Redis is healthy");
} else {
    eprintln!("Redis is not responding");
}

Errors

Returns an error if the connection cannot be established.

fn get_connection(&self) -> Result<Connection>

Gets a connection, reusing the cached one if available (DB-H6).

This method reuses an existing connection when possible, falling back to creating a new connection if the cache is empty or the connection is broken. The connection is stored in a Mutex for thread-safety.

Timeout (CHAOS-H2)

New connections are configured with a 5-second response timeout.

Connection Retry (CHAOS-HIGH-003)

New connection attempts use exponential backoff with jitter for transient failures (Redis starting up, network issues, etc.).

fn return_connection(&self, conn: Connection)

Returns a connection to the cache for reuse (DB-H6).

fn ensure_index(&self) -> Result<()>

Ensures the RediSearch index exists.

fn index_exists(&self, conn: &mut Connection) -> bool

Checks if the index already exists.

fn create_index(&self, conn: &mut Connection) -> Result<()>

Creates the RediSearch index.

fn build_filter_clause(filter: &SearchFilter) -> String

Builds a filter clause for RediSearch queries.

Trait Implementations

impl IndexBackend for RedisBackend

fn index(&self, memory: &Memory) -> Result<()>

Indexes a memory for full-text search.

fn remove(&self, id: &MemoryId) -> Result<bool>

Removes a memory from the index.

fn search( &self, query: &str, filter: &SearchFilter, limit: usize, ) -> Result<Vec<(MemoryId, f32)>>

Searches for memories matching a text query.

fn list_all( &self, filter: &SearchFilter, limit: usize, ) -> Result<Vec<(MemoryId, f32)>>

Lists all indexed memories, optionally filtered.

fn get_memory(&self, id: &MemoryId) -> Result<Option<Memory>>

Retrieves a memory by ID.

fn clear(&self) -> Result<()>

Clears the entire index.

fn reindex(&self, memories: &[Memory]) -> Result<()>

Re-indexes all memories.

fn get_memories_batch(&self, ids: &[MemoryId]) -> Result<Vec<Option<Memory>>>

Retrieves multiple memories by their IDs in a single batch query.