@anvia/redis 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Indra Zulfi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-KFFPZPCE.js

@@ -0,0 +1,112 @@
+// src/helpers.ts
+import { createHash } from "crypto";
+
+// src/types.ts
+import { SchemaFieldTypes, VectorAlgorithms } from "redis";
+var documentIdField = "__anvia_document_id";
+var documentField = "__anvia_document";
+var vectorField = "__anvia_vector";
+var reservedFieldPrefix = "__anvia_";
+
+// src/helpers.ts
+function assertNoReservedMetadata(metadata) {
+  for (const key of Object.keys(metadata ?? {})) {
+    if (key.startsWith(reservedFieldPrefix)) {
+      throw new Error(`Metadata key ${key} is reserved for Anvia Redis fields`);
+    }
+  }
+}
+function redisKeyId(keyPrefix, id) {
+  const hash = createHash("sha256").update(id).digest("hex").slice(0, 32);
+  return `${keyPrefix}${hash}`;
+}
+function serializeDocument(document) {
+  return typeof document === "string" ? document : JSON.stringify(document);
+}
+function parseDocument(document) {
+  if (document === null || document === void 0) {
+    return "";
+  }
+  if (typeof document !== "string") {
+    return document;
+  }
+  try {
+    return JSON.parse(document);
+  } catch {
+    return document;
+  }
+}
+function redisHashEntries(keyPrefix, document) {
+  if (document.embeddings.length === 0) {
+    throw new Error(`Document ${document.id} has no embeddings`);
+  }
+  assertNoReservedMetadata(document.metadata);
+  return document.embeddings.map((embedding, index) => {
+    const logicalId = document.embeddings.length === 1 ? document.id : `${document.id}#embedding:${index}`;
+    return {
+      key: redisKeyId(keyPrefix, logicalId),
+      fields: {
+        [documentIdField]: document.id,
+        [documentField]: serializeDocument(document.document),
+        [vectorField]: Buffer.from(new Float32Array(embedding.vector).buffer),
+        ...document.metadata ?? {}
+      }
+    };
+  });
+}
+function parseQueryResults(response, threshold) {
+  const raw = response;
+  const documents = raw.documents ?? [];
+  const byId = /* @__PURE__ */ new Map();
+  for (const doc of documents) {
+    const value = doc.value ?? {};
+    const scoreRaw = value.score ?? value.__vector_score;
+    const score = typeof scoreRaw === "string" ? parseFloat(scoreRaw) : scoreRaw ?? 0;
+    if (threshold !== void 0 && score < threshold) {
+      continue;
+    }
+    const id = String(value[documentIdField] ?? "");
+    const result = {
+      id,
+      score,
+      document: parseDocument(value[documentField]),
+      ...metadataFromFields(value)
+    };
+    const current = byId.get(id);
+    if (current === void 0 || result.score > current.score) {
+      byId.set(id, result);
+    }
+  }
+  return [...byId.values()];
+}
+async function defaultRedisClient() {
+  const redis = await import("redis");
+  const url = process.env.REDIS_URL ?? "redis://localhost:6379";
+  const client = redis.createClient({ url });
+  await client.connect();
+  return client;
+}
+function metadataFromFields(fields) {
+  const metadata = Object.fromEntries(
+    Object.entries(fields).filter(
+      ([key]) => !key.startsWith(reservedFieldPrefix) && key !== vectorField && key !== "score" && key !== "__vector_score"
+    )
+  );
+  return Object.keys(metadata).length === 0 ? {} : { metadata };
+}
+
+export {
+  SchemaFieldTypes,
+  VectorAlgorithms,
+  documentIdField,
+  documentField,
+  vectorField,
+  assertNoReservedMetadata,
+  redisKeyId,
+  serializeDocument,
+  parseDocument,
+  redisHashEntries,
+  parseQueryResults,
+  defaultRedisClient
+};
+//# sourceMappingURL=chunk-KFFPZPCE.js.map

package/dist/chunk-KFFPZPCE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/helpers.ts","../src/types.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport type { EmbeddedDocument, VectorMetadata } from \"@anvia/core/embeddings\";\nimport type { VectorSearchResult } from \"@anvia/core/vector-store\";\nimport {\n  documentField,\n  documentIdField,\n  type RedisClientLike,\n  reservedFieldPrefix,\n  vectorField,\n} from \"./types.js\";\n\nexport function assertNoReservedMetadata(metadata: VectorMetadata | undefined): void {\n  for (const key of Object.keys(metadata ?? {})) {\n    if (key.startsWith(reservedFieldPrefix)) {\n      throw new Error(`Metadata key ${key} is reserved for Anvia Redis fields`);\n    }\n  }\n}\n\nexport function redisKeyId(keyPrefix: string, id: string): string {\n  const hash = createHash(\"sha256\").update(id).digest(\"hex\").slice(0, 32);\n  return `${keyPrefix}${hash}`;\n}\n\nexport function serializeDocument(document: unknown): string {\n  return typeof document === \"string\" ? document : JSON.stringify(document);\n}\n\nexport function parseDocument<T>(document: unknown): T {\n  if (document === null || document === undefined) {\n    return \"\" as T;\n  }\n  if (typeof document !== \"string\") {\n    return document as T;\n  }\n  try {\n    return JSON.parse(document) as T;\n  } catch {\n    return document as T;\n  }\n}\n\nexport function redisHashEntries<T, Metadata extends VectorMetadata>(\n  keyPrefix: string,\n  document: EmbeddedDocument<T, Metadata>,\n): Array<{ key: string; fields: Record<string, unknown> }> {\n  if (document.embeddings.length === 0) {\n    throw new Error(`Document ${document.id} has no embeddings`);\n  }\n  assertNoReservedMetadata(document.metadata);\n\n  return document.embeddings.map((embedding, index) => {\n    const logicalId =\n      document.embeddings.length === 1 ? document.id : `${document.id}#embedding:${index}`;\n    return {\n      key: redisKeyId(keyPrefix, logicalId),\n      fields: {\n        [documentIdField]: document.id,\n        [documentField]: serializeDocument(document.document),\n        [vectorField]: Buffer.from(new Float32Array(embedding.vector).buffer),\n        ...(document.metadata ?? {}),\n      },\n    };\n  });\n}\n\nexport function parseQueryResults<T, Metadata extends VectorMetadata>(\n  response: unknown,\n  threshold: number | undefined,\n): Array<VectorSearchResult<T, Metadata>> {\n  const raw = response as {\n    total?: number;\n    documents?: Array<{\n      id?: string;\n      value?: Record<string, unknown>;\n    }>;\n  };\n  const documents = raw.documents ?? [];\n  const byId = new Map<string, VectorSearchResult<T, Metadata>>();\n\n  for (const doc of documents) {\n    const value = doc.value ?? {};\n    const scoreRaw = value.score ?? value.__vector_score;\n    const score = typeof scoreRaw === \"string\" ? parseFloat(scoreRaw) : ((scoreRaw as number) ?? 0);\n\n    if (threshold !== undefined && score < threshold) {\n      continue;\n    }\n\n    const id = String(value[documentIdField] ?? \"\");\n    const result = {\n      id,\n      score,\n      document: parseDocument(value[documentField]),\n      ...metadataFromFields<Metadata>(value),\n    } as VectorSearchResult<T, Metadata>;\n    const current = byId.get(id);\n    if (current === undefined || result.score > current.score) {\n      byId.set(id, result);\n    }\n  }\n\n  return [...byId.values()];\n}\n\nexport async function defaultRedisClient(): Promise<RedisClientLike> {\n  const redis = await import(\"redis\");\n  const url = process.env.REDIS_URL ?? \"redis://localhost:6379\";\n  const client = redis.createClient({ url });\n  await client.connect();\n  return client as unknown as RedisClientLike;\n}\n\nfunction metadataFromFields<Metadata extends VectorMetadata>(\n  fields: Record<string, unknown>,\n): { metadata?: Metadata | undefined } {\n  const metadata = Object.fromEntries(\n    Object.entries(fields).filter(\n      ([key]) =>\n        !key.startsWith(reservedFieldPrefix) &&\n        key !== vectorField &&\n        key !== \"score\" &&\n        key !== \"__vector_score\",\n    ),\n  ) as Metadata;\n  return Object.keys(metadata).length === 0 ? {} : { metadata };\n}\n","import { SchemaFieldTypes, VectorAlgorithms } from \"redis\";\n\nexport const documentIdField = \"__anvia_document_id\";\nexport const documentField = \"__anvia_document\";\nexport const vectorField = \"__anvia_vector\";\nexport const reservedFieldPrefix = \"__anvia_\";\n\nexport type RedisDistance = \"COSINE\" | \"L2\" | \"IP\";\n\nexport type RedisClientLike = {\n  ft: {\n    create(\n      indexName: string,\n      schema: Record<string, unknown>,\n      options?: Record<string, unknown>,\n    ): Promise<unknown>;\n    search(indexName: string, query: string, options?: Record<string, unknown>): Promise<unknown>;\n    dropindex(indexName: string): Promise<unknown>;\n    info(indexName: string): Promise<unknown>;\n  };\n  hSet(key: string, fieldValues: Record<string, unknown>): Promise<unknown>;\n  expire(key: string, seconds: number): Promise<unknown>;\n};\n\nexport type RedisVectorStoreConnectOptions = {\n  client?: RedisClientLike | undefined;\n  indexName: string;\n  keyPrefix?: string | undefined;\n  vectorSize: number;\n  createIfMissing?: boolean | undefined;\n  distance?: RedisDistance | undefined;\n};\n\nexport { SchemaFieldTypes, VectorAlgorithms };\n"],"mappings":"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","names":[]}

package/dist/helpers-ICLEB6TC.js

@@ -0,0 +1,19 @@
+import {
+  assertNoReservedMetadata,
+  defaultRedisClient,
+  parseDocument,
+  parseQueryResults,
+  redisHashEntries,
+  redisKeyId,
+  serializeDocument
+} from "./chunk-KFFPZPCE.js";
+export {
+  assertNoReservedMetadata,
+  defaultRedisClient,
+  parseDocument,
+  parseQueryResults,
+  redisHashEntries,
+  redisKeyId,
+  serializeDocument
+};
+//# sourceMappingURL=helpers-ICLEB6TC.js.map

package/dist/helpers-ICLEB6TC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+import { VectorFilter, VectorSearchIndex, VectorSearchRequest, VectorSearchResult, VectorSearchToolOptions } from '@anvia/core/vector-store';
+import { VectorMetadata, EmbeddingModel, EmbeddedDocument } from '@anvia/core/embeddings';
+import { Tool } from '@anvia/core/tool';
+
+declare function filterToRedisQuery(filter: VectorFilter | undefined): string;
+
+type RedisDistance = "COSINE" | "L2" | "IP";
+type RedisClientLike = {
+    ft: {
+        create(indexName: string, schema: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
+        search(indexName: string, query: string, options?: Record<string, unknown>): Promise<unknown>;
+        dropindex(indexName: string): Promise<unknown>;
+        info(indexName: string): Promise<unknown>;
+    };
+    hSet(key: string, fieldValues: Record<string, unknown>): Promise<unknown>;
+    expire(key: string, seconds: number): Promise<unknown>;
+};
+type RedisVectorStoreConnectOptions = {
+    client?: RedisClientLike | undefined;
+    indexName: string;
+    keyPrefix?: string | undefined;
+    vectorSize: number;
+    createIfMissing?: boolean | undefined;
+    distance?: RedisDistance | undefined;
+};
+
+declare class RedisVectorIndex<T, Metadata extends VectorMetadata = VectorMetadata> implements VectorSearchIndex<T, Metadata> {
+    private readonly model;
+    private readonly client;
+    private readonly indexName;
+    constructor(model: EmbeddingModel, client: RedisClientLike, indexName: string);
+    search(request: VectorSearchRequest): Promise<Array<VectorSearchResult<T, Metadata>>>;
+    searchIds(request: VectorSearchRequest): Promise<Array<{
+        score: number;
+        id: string;
+    }>>;
+    asTool(options: VectorSearchToolOptions): Tool<{
+        query: string;
+        topK?: number;
+    }, unknown>;
+}
+
+declare class RedisVectorStore<T, Metadata extends VectorMetadata = VectorMetadata> {
+    private readonly client;
+    private readonly indexName;
+    private readonly keyPrefix;
+    private readonly vectorSize;
+    private constructor();
+    static connect<T, Metadata extends VectorMetadata = VectorMetadata>(options: RedisVectorStoreConnectOptions): Promise<RedisVectorStore<T, Metadata>>;
+    upsertDocuments(documents: Array<EmbeddedDocument<T, Metadata>>): Promise<void>;
+    index(model: EmbeddingModel): RedisVectorIndex<T, Metadata>;
+}
+
+export { type RedisClientLike, type RedisDistance, RedisVectorIndex, RedisVectorStore, type RedisVectorStoreConnectOptions, filterToRedisQuery };

package/dist/index.js

@@ -0,0 +1,147 @@
+import {
+  SchemaFieldTypes,
+  VectorAlgorithms,
+  documentField,
+  documentIdField,
+  parseQueryResults,
+  redisHashEntries,
+  vectorField
+} from "./chunk-KFFPZPCE.js";
+
+// src/filters.ts
+function filterToRedisQuery(filter) {
+  if (filter === void 0) {
+    return "*";
+  }
+  return `(${translateFilter(filter)})`;
+}
+function translateFilter(filter) {
+  switch (filter.type) {
+    case "eq":
+      if (typeof filter.value === "string") {
+        return `@${filter.key}:"${escapeRedisValue(filter.value)}"`;
+      }
+      if (typeof filter.value === "boolean") {
+        return `@${filter.key}:{${filter.value ? "1" : "0"}}`;
+      }
+      return `@${filter.key}:[${filter.value} ${filter.value}]`;
+    case "gt":
+      return `@${filter.key}:[(${filter.value} +inf]`;
+    case "lt":
+      return `@${filter.key}:[-inf (${filter.value}]`;
+    case "and":
+      return filter.filters.map((f) => `(${translateFilter(f)})`).join(" ");
+    case "or":
+      return filter.filters.map((f) => `(${translateFilter(f)})`).join(" | ");
+  }
+}
+function escapeRedisValue(value) {
+  return value.replace(/(["\\])/g, "\\$1");
+}
+
+// src/search-index.ts
+import { embedText } from "@anvia/core/embeddings";
+import {
+  createVectorSearchTool
+} from "@anvia/core/vector-store";
+var RedisVectorIndex = class {
+  constructor(model, client, indexName) {
+    this.model = model;
+    this.client = client;
+    this.indexName = indexName;
+  }
+  model;
+  client;
+  indexName;
+  async search(request) {
+    const queryEmbedding = await embedText(this.model, request.query);
+    const filterQuery = filterToRedisQuery(request.filter);
+    const knnQuery = `${filterQuery}=>[KNN ${request.topK} @${vectorField} $vec AS score]`;
+    const response = await this.client.ft.search(this.indexName, knnQuery, {
+      PARAMS: {
+        vec: Buffer.from(new Float32Array(queryEmbedding.vector).buffer)
+      },
+      RETURN: ["__anvia_document_id", "__anvia_document", "score"],
+      DIALECT: 2
+    });
+    return parseQueryResults(response, request.threshold);
+  }
+  async searchIds(request) {
+    return (await this.search(request)).map(({ score, id }) => ({ score, id }));
+  }
+  asTool(options) {
+    return createVectorSearchTool(this, options);
+  }
+};
+
+// src/store.ts
+var RedisVectorStore = class _RedisVectorStore {
+  constructor(client, indexName, keyPrefix, vectorSize) {
+    this.client = client;
+    this.indexName = indexName;
+    this.keyPrefix = keyPrefix;
+    this.vectorSize = vectorSize;
+  }
+  client;
+  indexName;
+  keyPrefix;
+  vectorSize;
+  static async connect(options) {
+    const client = options.client ?? await (await import("./helpers-ICLEB6TC.js")).defaultRedisClient();
+    const keyPrefix = options.keyPrefix ?? `anvia:${options.indexName}:`;
+    if (options.createIfMissing === false) {
+      await client.ft.info(options.indexName);
+      return new _RedisVectorStore(
+        client,
+        options.indexName,
+        keyPrefix,
+        options.vectorSize
+      );
+    }
+    try {
+      await client.ft.info(options.indexName);
+    } catch {
+      const distanceMap = {
+        COSINE: "COSINE",
+        L2: "L2",
+        IP: "IP"
+      };
+      await client.ft.create(
+        options.indexName,
+        {
+          [documentIdField]: { type: SchemaFieldTypes.TEXT },
+          [documentField]: { type: SchemaFieldTypes.TEXT },
+          [vectorField]: {
+            type: SchemaFieldTypes.VECTOR,
+            ALGORITHM: VectorAlgorithms.HNSW,
+            TYPE: "FLOAT32",
+            DIM: options.vectorSize,
+            DISTANCE_METRIC: distanceMap[options.distance ?? "COSINE"]
+          }
+        },
+        { ON: "HASH", PREFIX: keyPrefix }
+      );
+    }
+    return new _RedisVectorStore(
+      client,
+      options.indexName,
+      keyPrefix,
+      options.vectorSize
+    );
+  }
+  async upsertDocuments(documents) {
+    const entries = documents.flatMap((document) => redisHashEntries(this.keyPrefix, document));
+    for (const entry of entries) {
+      await this.client.hSet(entry.key, entry.fields);
+    }
+  }
+  index(model) {
+    return new RedisVectorIndex(model, this.client, this.indexName);
+  }
+};
+export {
+  RedisVectorIndex,
+  RedisVectorStore,
+  filterToRedisQuery
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/filters.ts","../src/search-index.ts","../src/store.ts"],"sourcesContent":["import type { VectorFilter } from \"@anvia/core/vector-store\";\n\nexport function filterToRedisQuery(filter: VectorFilter | undefined): string {\n  if (filter === undefined) {\n    return \"*\";\n  }\n\n  return `(${translateFilter(filter)})`;\n}\n\nfunction translateFilter(filter: VectorFilter): string {\n  switch (filter.type) {\n    case \"eq\":\n      if (typeof filter.value === \"string\") {\n        return `@${filter.key}:\"${escapeRedisValue(filter.value)}\"`;\n      }\n      if (typeof filter.value === \"boolean\") {\n        return `@${filter.key}:{${filter.value ? \"1\" : \"0\"}}`;\n      }\n      return `@${filter.key}:[${filter.value} ${filter.value}]`;\n    case \"gt\":\n      return `@${filter.key}:[(${filter.value} +inf]`;\n    case \"lt\":\n      return `@${filter.key}:[-inf (${filter.value}]`;\n    case \"and\":\n      return filter.filters.map((f) => `(${translateFilter(f)})`).join(\" \");\n    case \"or\":\n      return filter.filters.map((f) => `(${translateFilter(f)})`).join(\" | \");\n  }\n}\n\nfunction escapeRedisValue(value: string): string {\n  return value.replace(/([\"\\\\])/g, \"\\\\$1\");\n}\n","import { type EmbeddingModel, embedText, type VectorMetadata } from \"@anvia/core/embeddings\";\nimport type { Tool } from \"@anvia/core/tool\";\nimport {\n  createVectorSearchTool,\n  type VectorSearchIndex,\n  type VectorSearchRequest,\n  type VectorSearchResult,\n  type VectorSearchToolOptions,\n} from \"@anvia/core/vector-store\";\nimport { filterToRedisQuery } from \"./filters.js\";\nimport { parseQueryResults } from \"./helpers.js\";\nimport { type RedisClientLike, vectorField } from \"./types.js\";\n\nexport class RedisVectorIndex<T, Metadata extends VectorMetadata = VectorMetadata>\n  implements VectorSearchIndex<T, Metadata>\n{\n  constructor(\n    private readonly model: EmbeddingModel,\n    private readonly client: RedisClientLike,\n    private readonly indexName: string,\n  ) {}\n\n  async search(request: VectorSearchRequest): Promise<Array<VectorSearchResult<T, Metadata>>> {\n    const queryEmbedding = await embedText(this.model, request.query);\n    const filterQuery = filterToRedisQuery(request.filter);\n    const knnQuery = `${filterQuery}=>[KNN ${request.topK} @${vectorField} $vec AS score]`;\n\n    const response = await this.client.ft.search(this.indexName, knnQuery, {\n      PARAMS: {\n        vec: Buffer.from(new Float32Array(queryEmbedding.vector).buffer),\n      },\n      RETURN: [\"__anvia_document_id\", \"__anvia_document\", \"score\"],\n      DIALECT: 2,\n    });\n\n    return parseQueryResults<T, Metadata>(response, request.threshold);\n  }\n\n  async searchIds(request: VectorSearchRequest): Promise<Array<{ score: number; id: string }>> {\n    return (await this.search(request)).map(({ score, id }) => ({ score, id }));\n  }\n\n  asTool(options: VectorSearchToolOptions): Tool<{ query: string; topK?: number }, unknown> {\n    return createVectorSearchTool(this, options);\n  }\n}\n","import type { EmbeddedDocument, EmbeddingModel, VectorMetadata } from \"@anvia/core/embeddings\";\nimport { redisHashEntries } from \"./helpers.js\";\nimport { RedisVectorIndex } from \"./search-index.js\";\nimport {\n  documentField,\n  documentIdField,\n  type RedisClientLike,\n  type RedisDistance,\n  type RedisVectorStoreConnectOptions,\n  SchemaFieldTypes,\n  VectorAlgorithms,\n  vectorField,\n} from \"./types.js\";\n\nexport class RedisVectorStore<T, Metadata extends VectorMetadata = VectorMetadata> {\n  private constructor(\n    private readonly client: RedisClientLike,\n    private readonly indexName: string,\n    private readonly keyPrefix: string,\n    private readonly vectorSize: number,\n  ) {}\n\n  static async connect<T, Metadata extends VectorMetadata = VectorMetadata>(\n    options: RedisVectorStoreConnectOptions,\n  ): Promise<RedisVectorStore<T, Metadata>> {\n    const client = options.client ?? (await (await import(\"./helpers.js\")).defaultRedisClient());\n    const keyPrefix = options.keyPrefix ?? `anvia:${options.indexName}:`;\n\n    if (options.createIfMissing === false) {\n      await client.ft.info(options.indexName);\n      return new RedisVectorStore<T, Metadata>(\n        client,\n        options.indexName,\n        keyPrefix,\n        options.vectorSize,\n      );\n    }\n\n    try {\n      await client.ft.info(options.indexName);\n    } catch {\n      const distanceMap: Record<RedisDistance, string> = {\n        COSINE: \"COSINE\",\n        L2: \"L2\",\n        IP: \"IP\",\n      };\n      await client.ft.create(\n        options.indexName,\n        {\n          [documentIdField]: { type: SchemaFieldTypes.TEXT },\n          [documentField]: { type: SchemaFieldTypes.TEXT },\n          [vectorField]: {\n            type: SchemaFieldTypes.VECTOR,\n            ALGORITHM: VectorAlgorithms.HNSW,\n            TYPE: \"FLOAT32\",\n            DIM: options.vectorSize,\n            DISTANCE_METRIC: distanceMap[options.distance ?? \"COSINE\"],\n          },\n        },\n        { ON: \"HASH\", PREFIX: keyPrefix },\n      );\n    }\n\n    return new RedisVectorStore<T, Metadata>(\n      client,\n      options.indexName,\n      keyPrefix,\n      options.vectorSize,\n    );\n  }\n\n  async upsertDocuments(documents: Array<EmbeddedDocument<T, Metadata>>): Promise<void> {\n    const entries = documents.flatMap((document) => redisHashEntries(this.keyPrefix, document));\n    for (const entry of entries) {\n      await this.client.hSet(entry.key, entry.fields);\n    }\n  }\n\n  index(model: EmbeddingModel): RedisVectorIndex<T, Metadata> {\n    return new RedisVectorIndex(model, this.client, this.indexName);\n  }\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@anvia/redis",
+  "version": "0.2.0",
+  "description": "Redis vector store adapter for Anvia.",
+  "author": "anvia",
+  "maintainer": "Indra Zulfi",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anvia-hq/anvia",
+    "directory": "packages/vector-redis"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "redis": "^4.7.0",
+    "@anvia/core": "0.6.3"
+  },
+  "devDependencies": {
+    "@types/node": "^24.9.1",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.8"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --sourcemap --clean",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}