Class ValkeyVectorStore

backend/src/core/vector/valkey.ts:6–261

import { vectorToBuffer, bufferToVector } from "../../memory/embed";

export class ValkeyVectorStore implements VectorStore {
    private client: Redis;

    constructor() {
        this.client = new Redis({
            host: env.valkey_host || "localhost",
            port: env.valkey_port || 6379,
            password: env.valkey_password,
        });
    }

    private getKey(id: string, sector: string): string {
        return `vec:${sector}:${id}`;
    }

    async storeVector(id: string, sector: string, vector: number[], dim: number, user_id?: string): Promise<void> {
        const key = this.getKey(id, sector);
        const buf = vectorToBuffer(vector);
        // Store as Hash: v (blob), dim (int), user_id (string)
        await this.client.hset(key, {
            v: buf,
            dim: dim,
            user_id: user_id || "anonymous",
            id: id,
            sector: sector
        });
    }

    async deleteVector(id: string, sector: string): Promise<void> {
        const key = this.getKey(id, sector);
        await this.client.del(key);
    }

    async deleteVectors(id: string): Promise<void> {
        // This is inefficient in Redis without an index on ID across sectors.
        // We might need to track which sectors an ID has.
        // For now, we can scan or just assume we know the sectors?
        // The interface implies we delete ALL vectors for this ID.
        // In Postgres we did `delete from vectors where id=$1`.
        // In Redis, we might need to know the sectors.
        // Or we can use `keys vec:*:${id}` which is slow.
        // Better approach: maintain a set of sectors for each ID?
        // Or just iterate over known sectors (from hsg.ts sectors list).
        // I'll import `sectors` from `../../memory/hsg`? No, circular dependency risk.
        // I'll use a scan for now as it's safer, or just accept it might be slow.
        // Actually, `keys` is blocking. `scan` is better.
        // But `id` is at the end of the key `vec:{sector}:{id}`.
        // Pattern: `vec:*:${id}`.

        let cursor = "0";
        do {
            const res = await this.client.scan(cursor, "MATCH", `vec:*:${id}`, "COUNT", 100);
            cursor = res[0];
            const keys = res[1];
            if (keys.length) await this.client.del(...keys);
        } while (cursor !== "0");
    }