@voyantjs/catalog-rag 0.19.0

package/dist/search/federate.js

@@ -0,0 +1,103 @@
+/**
+ * Cross-audience federated search.
+ *
+ * Per architecture §7, vectors are strictly per-audience — customer
+ * embedding pools only contain customer-visible text, partner pools only
+ * contain partner-visible text, etc. This means the most common admin AI
+ * use case ("find products similar to *X*" where *X* is in customer-
+ * facing language) needs to query a non-staff audience pool.
+ *
+ * Staff actors are authorized to query any audience pool; customer /
+ * partner / supplier agents are pinned to their own audience by API
+ * authorization. This helper takes a list of `search_audiences` and:
+ *
+ *   1. Verifies the actor is authorized for each requested audience.
+ *   2. Issues parallel `IndexerAdapter.search` calls — one per audience.
+ *   3. Deduplicates hits by entity id (same entity may rank in multiple
+ *      pools; keep the highest-scoring instance).
+ *   4. Merges the per-pool result sets into a single ranked list.
+ *
+ * If the adapter declares `supportsCrossAudienceFederation`, the helper
+ * delegates to a single multi-collection adapter call instead of fanning
+ * out client-side. Either way the API contract is the same to callers.
+ *
+ * See `docs/architecture/catalog-rag-architecture.md` §7.3.
+ */
+/**
+ * Federate a search across multiple audience pools. Returns a unified
+ * `SearchResults` with deduplicated hits ranked by score.
+ */
+export async function federateAudienceSearch(options) {
+    const { adapter, actor, searchAudiences, vertical, locale, market, request } = options;
+    if (searchAudiences.length === 0) {
+        throw new Error("federateAudienceSearch requires at least one searchAudience");
+    }
+    enforceAudienceAuthorization(actor, searchAudiences);
+    // If a single audience is requested, no federation needed — direct search.
+    if (searchAudiences.length === 1) {
+        const audience = searchAudiences[0];
+        const slice = { vertical, locale, audience, market };
+        return adapter.search(slice, request);
+    }
+    // Engine-side federation when supported — single adapter call.
+    if (adapter.capabilities.supportsCrossAudienceFederation) {
+        // The adapter contract doesn't currently expose multi-slice search
+        // directly. For Phase 2 v1 we use the client-side fan-out path below
+        // even when the engine could do better. A follow-up adds a
+        // `searchFederated(slices: IndexerSlice[], request)` method to the
+        // contract to take advantage of native federation.
+        // For now, fall through to the client-side path.
+    }
+    // Client-side fan-out: one search per audience pool, parallelized.
+    const slices = searchAudiences.map((audience) => ({
+        vertical,
+        locale,
+        audience,
+        market,
+    }));
+    const perSliceResults = await Promise.all(slices.map((slice) => adapter.search(slice, request)));
+    return mergeAndDedupe(perSliceResults, request.pagination?.limit);
+}
+/**
+ * Merge several `SearchResults` into one, deduplicating by hit id and
+ * keeping the highest-scoring instance. Total is the count of unique ids
+ * across all pools (after dedupe).
+ */
+export function mergeAndDedupe(perSlice, limit) {
+    const byId = new Map();
+    for (const result of perSlice) {
+        for (const hit of result.hits) {
+            const existing = byId.get(hit.id);
+            if (!existing || hit.score > existing.score) {
+                byId.set(hit.id, hit);
+            }
+        }
+    }
+    // Sort by score descending — federated semantics rank by best score.
+    const merged = Array.from(byId.values()).sort((a, b) => b.score - a.score);
+    const limited = limit != null ? merged.slice(0, limit) : merged;
+    return {
+        hits: limited,
+        total: byId.size,
+        // Facets aren't merged — federation across audiences with different
+        // facet vocabularies is ambiguous. Callers that need facets should
+        // search a single audience.
+    };
+}
+/**
+ * Enforce per-actor authorization rules: customer / partner / supplier
+ * agents may only search their own audience pool. Staff actors may
+ * federate across any pools.
+ */
+function enforceAudienceAuthorization(actor, requested) {
+    if (actor === "staff") {
+        // Staff may federate across anything.
+        return;
+    }
+    if (requested.length === 1 && requested[0] === actor) {
+        // Non-staff actor searching their own pool only — allowed.
+        return;
+    }
+    throw new Error(`Actor "${actor}" is not authorized to federate across audiences ${JSON.stringify(requested)}. ` +
+        `Non-staff actors may only search their own audience pool. To federate across audiences, the request must come from a staff actor.`);
+}

package/dist/search/federate.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=federate.test.d.ts.map

package/dist/search/federate.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"federate.test.d.ts","sourceRoot":"","sources":["../../src/search/federate.test.ts"],"names":[],"mappings":""}

package/dist/search/federate.test.js

@@ -0,0 +1,146 @@
+import { describe, expect, it } from "vitest";
+import { federateAudienceSearch, mergeAndDedupe } from "./federate.js";
+const capabilities = {
+    supportsKeywordSearch: true,
+    supportsHybridSearch: true,
+    supportsVectorFields: true,
+    vectorDimensions: 1536,
+    maxVectorsPerDocument: null,
+    supportsCrossAudienceFederation: false,
+    supportsAdminDenormalization: true,
+};
+function hit(id, score) {
+    return { id, score, document: { id, fields: {} } };
+}
+function makeAdapter(perAudience) {
+    return {
+        capabilities,
+        async ensureCollection() { },
+        async upsert() { },
+        async delete() { },
+        async bulkReindex() { },
+        async search(slice) {
+            const hits = perAudience[slice.audience] ?? [];
+            return { hits, total: hits.length };
+        },
+    };
+}
+describe("mergeAndDedupe", () => {
+    it("keeps the highest-scoring instance when an entity appears in multiple pools", () => {
+        const merged = mergeAndDedupe([
+            { hits: [hit("a", 1), hit("b", 2)], total: 2 },
+            { hits: [hit("a", 5), hit("c", 3)], total: 2 },
+        ]);
+        const ids = merged.hits.map((h) => h.id);
+        expect(ids).toEqual(["a", "c", "b"]); // sorted by score desc
+        const aHit = merged.hits.find((h) => h.id === "a");
+        expect(aHit?.score).toBe(5);
+        expect(merged.total).toBe(3);
+    });
+    it("respects the limit parameter", () => {
+        const merged = mergeAndDedupe([{ hits: [hit("a", 1), hit("b", 2), hit("c", 3)], total: 3 }], 2);
+        expect(merged.hits).toHaveLength(2);
+        expect(merged.total).toBe(3); // total is unique-id count, not limited
+    });
+    it("returns an empty result when no pools have hits", () => {
+        const merged = mergeAndDedupe([]);
+        expect(merged.hits).toEqual([]);
+        expect(merged.total).toBe(0);
+    });
+});
+describe("federateAudienceSearch — authorization", () => {
+    it("rejects non-staff actors trying to federate beyond their own pool", async () => {
+        const adapter = makeAdapter({});
+        await expect(federateAudienceSearch({
+            adapter,
+            actor: "customer",
+            searchAudiences: ["customer", "partner"],
+            vertical: "products",
+            locale: "en-GB",
+            market: "default",
+            request: { query: "x", mode: "keyword" },
+        })).rejects.toThrow(/not authorized to federate/);
+    });
+    it("allows non-staff actors to search their own audience pool only", async () => {
+        const adapter = makeAdapter({ customer: [hit("a", 1)] });
+        const result = await federateAudienceSearch({
+            adapter,
+            actor: "customer",
+            searchAudiences: ["customer"],
+            vertical: "products",
+            locale: "en-GB",
+            market: "default",
+            request: { query: "x", mode: "keyword" },
+        });
+        expect(result.hits).toHaveLength(1);
+    });
+    it("rejects non-staff actors trying to search a different audience pool", async () => {
+        const adapter = makeAdapter({});
+        await expect(federateAudienceSearch({
+            adapter,
+            actor: "customer",
+            searchAudiences: ["partner"],
+            vertical: "products",
+            locale: "en-GB",
+            market: "default",
+            request: { query: "x", mode: "keyword" },
+        })).rejects.toThrow(/not authorized to federate/);
+    });
+    it("allows staff actors to federate across multiple audience pools", async () => {
+        const adapter = makeAdapter({
+            customer: [hit("a", 1)],
+            partner: [hit("b", 2)],
+        });
+        const result = await federateAudienceSearch({
+            adapter,
+            actor: "staff",
+            searchAudiences: ["customer", "partner"],
+            vertical: "products",
+            locale: "en-GB",
+            market: "default",
+            request: { query: "x", mode: "keyword" },
+        });
+        expect(result.hits.map((h) => h.id).sort()).toEqual(["a", "b"]);
+        expect(result.total).toBe(2);
+    });
+});
+describe("federateAudienceSearch — single audience shortcut", () => {
+    it("issues a single adapter call when only one audience is requested", async () => {
+        let callCount = 0;
+        const wrapped = {
+            capabilities,
+            async ensureCollection() { },
+            async upsert() { },
+            async delete() { },
+            async bulkReindex() { },
+            async search(slice) {
+                callCount++;
+                return { hits: [hit(`from-${slice.audience}`, 1)], total: 1 };
+            },
+        };
+        await federateAudienceSearch({
+            adapter: wrapped,
+            actor: "staff",
+            searchAudiences: ["customer"],
+            vertical: "products",
+            locale: "en-GB",
+            market: "default",
+            request: { query: "x", mode: "keyword" },
+        });
+        expect(callCount).toBe(1);
+    });
+});
+describe("federateAudienceSearch — empty input rejected", () => {
+    it("requires at least one searchAudience", async () => {
+        const adapter = makeAdapter({});
+        await expect(federateAudienceSearch({
+            adapter,
+            actor: "staff",
+            searchAudiences: [],
+            vertical: "products",
+            locale: "en-GB",
+            market: "default",
+            request: { query: "x", mode: "keyword" },
+        })).rejects.toThrow(/at least one searchAudience/);
+    });
+});

package/dist/search/semantic.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Semantic / hybrid search orchestration.
+ *
+ * Wraps the Phase 1 `IndexerAdapter.search` with the embedding-generation
+ * step. When `mode: "semantic" | "hybrid"`, this helper embeds the query
+ * via the configured `EmbeddingProvider`, attaches the vector to the
+ * `SearchRequest` as `query_embedding`, and delegates to the adapter.
+ *
+ * Callers that already have a query embedding (an upstream agent that
+ * vectorized the user's intent) can skip embedding by passing
+ * `query_embedding` directly — `executeSemanticSearch` honors a
+ * caller-supplied vector and skips the embed call.
+ *
+ * See `docs/architecture/catalog-rag-architecture.md` §3 + §6.
+ */
+import type { IndexerAdapter, IndexerSlice, SearchRequest, SearchResults } from "@voyantjs/catalog";
+import type { EmbeddingProvider } from "../embeddings/contract.js";
+export interface SemanticSearchOptions {
+    /** Adapter to query. */
+    adapter: IndexerAdapter;
+    /** Embedding provider — used to vectorize the query string when needed. */
+    embeddings: EmbeddingProvider;
+    /** The variant slice (vertical, locale, audience, market) to search. */
+    slice: IndexerSlice;
+    /** The search request. `mode` controls keyword/hybrid/semantic blending. */
+    request: SearchRequest;
+}
+/**
+ * Run a search request that may need a query embedding generated.
+ *
+ * Behavior by mode:
+ *   - `keyword`   — adapter.search called directly; no embedding work.
+ *   - `hybrid`    — query string is embedded (unless caller supplied
+ *                   `query_embedding`), adapter blends keyword + vector
+ *                   scores.
+ *   - `semantic`  — query string is embedded, adapter does pure vector
+ *                   similarity. (Engines that don't support pure-semantic
+ *                   typically fall back to hybrid with the keyword weight
+ *                   set very low.)
+ *
+ * Verifies adapter capabilities at runtime: requesting `semantic` /
+ * `hybrid` against an adapter without `supportsVectorFields` throws
+ * a clear error rather than silently degrading to keyword-only.
+ */
+export declare function executeSemanticSearch(options: SemanticSearchOptions): Promise<SearchResults>;
+/**
+ * Helper for callers (typically AI agents) that have already vectorized
+ * a query upstream and want to bypass the embedding step entirely. The
+ * vector is attached to the request as-is.
+ */
+export declare function executeBYOVectorSearch(options: {
+    adapter: IndexerAdapter;
+    slice: IndexerSlice;
+    request: SearchRequest & {
+        query_embedding: number[];
+    };
+}): Promise<SearchResults>;
+//# sourceMappingURL=semantic.d.ts.map

package/dist/search/semantic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../src/search/semantic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,YAAY,EACZ,aAAa,EACb,aAAa,EACd,MAAM,mBAAmB,CAAA;AAE1B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AAElE,MAAM,WAAW,qBAAqB;IACpC,wBAAwB;IACxB,OAAO,EAAE,cAAc,CAAA;IACvB,2EAA2E;IAC3E,UAAU,EAAE,iBAAiB,CAAA;IAC7B,wEAAwE;IACxE,KAAK,EAAE,YAAY,CAAA;IACnB,4EAA4E;IAC5E,OAAO,EAAE,aAAa,CAAA;CACvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,aAAa,CAAC,CAmCxB;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAAC,OAAO,EAAE;IACpD,OAAO,EAAE,cAAc,CAAA;IACvB,KAAK,EAAE,YAAY,CAAA;IACnB,OAAO,EAAE,aAAa,GAAG;QAAE,eAAe,EAAE,MAAM,EAAE,CAAA;KAAE,CAAA;CACvD,GAAG,OAAO,CAAC,aAAa,CAAC,CAQzB"}

package/dist/search/semantic.js

@@ -0,0 +1,71 @@
+/**
+ * Semantic / hybrid search orchestration.
+ *
+ * Wraps the Phase 1 `IndexerAdapter.search` with the embedding-generation
+ * step. When `mode: "semantic" | "hybrid"`, this helper embeds the query
+ * via the configured `EmbeddingProvider`, attaches the vector to the
+ * `SearchRequest` as `query_embedding`, and delegates to the adapter.
+ *
+ * Callers that already have a query embedding (an upstream agent that
+ * vectorized the user's intent) can skip embedding by passing
+ * `query_embedding` directly — `executeSemanticSearch` honors a
+ * caller-supplied vector and skips the embed call.
+ *
+ * See `docs/architecture/catalog-rag-architecture.md` §3 + §6.
+ */
+/**
+ * Run a search request that may need a query embedding generated.
+ *
+ * Behavior by mode:
+ *   - `keyword`   — adapter.search called directly; no embedding work.
+ *   - `hybrid`    — query string is embedded (unless caller supplied
+ *                   `query_embedding`), adapter blends keyword + vector
+ *                   scores.
+ *   - `semantic`  — query string is embedded, adapter does pure vector
+ *                   similarity. (Engines that don't support pure-semantic
+ *                   typically fall back to hybrid with the keyword weight
+ *                   set very low.)
+ *
+ * Verifies adapter capabilities at runtime: requesting `semantic` /
+ * `hybrid` against an adapter without `supportsVectorFields` throws
+ * a clear error rather than silently degrading to keyword-only.
+ */
+export async function executeSemanticSearch(options) {
+    const { adapter, embeddings, slice, request } = options;
+    if (request.mode === "keyword") {
+        return adapter.search(slice, request);
+    }
+    if (!adapter.capabilities.supportsVectorFields) {
+        throw new Error(`Search mode "${request.mode}" requires an indexer that supports vector fields. ` +
+            `Configured adapter does not declare supportsVectorFields. Use mode: "keyword" or swap to a vector-capable adapter (e.g. Typesense).`);
+    }
+    if (request.mode === "hybrid" && !adapter.capabilities.supportsHybridSearch) {
+        throw new Error(`Search mode "hybrid" requires an indexer that declares supportsHybridSearch. ` +
+            `Configured adapter does not. Either use mode: "semantic" (pure vector) or swap to a hybrid-capable engine.`);
+    }
+    // Use caller-supplied embedding if provided; otherwise generate one.
+    let queryEmbedding = request.query_embedding;
+    if (!queryEmbedding && request.query.length > 0) {
+        const [vector] = await embeddings.embed([request.query]);
+        if (!vector) {
+            throw new Error("EmbeddingProvider returned no vector for the query string");
+        }
+        queryEmbedding = vector;
+    }
+    return adapter.search(slice, {
+        ...request,
+        query_embedding: queryEmbedding,
+    });
+}
+/**
+ * Helper for callers (typically AI agents) that have already vectorized
+ * a query upstream and want to bypass the embedding step entirely. The
+ * vector is attached to the request as-is.
+ */
+export async function executeBYOVectorSearch(options) {
+    const { adapter, slice, request } = options;
+    if (!adapter.capabilities.supportsVectorFields) {
+        throw new Error("BYO-vector search requires an indexer with supportsVectorFields. The configured adapter does not.");
+    }
+    return adapter.search(slice, request);
+}

package/dist/search/semantic.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=semantic.test.d.ts.map

package/dist/search/semantic.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic.test.d.ts","sourceRoot":"","sources":["../../src/search/semantic.test.ts"],"names":[],"mappings":""}

package/dist/search/semantic.test.js

@@ -0,0 +1,143 @@
+import { describe, expect, it, vi } from "vitest";
+import { executeBYOVectorSearch, executeSemanticSearch } from "./semantic.js";
+function makeAdapter(capabilities = {}) {
+    const baseCapabilities = {
+        supportsKeywordSearch: true,
+        supportsHybridSearch: true,
+        supportsVectorFields: true,
+        vectorDimensions: 1536,
+        maxVectorsPerDocument: null,
+        supportsCrossAudienceFederation: false,
+        supportsAdminDenormalization: true,
+        ...capabilities,
+    };
+    const searchSpy = vi.fn(async (_slice, _request) => ({
+        hits: [],
+        total: 0,
+    }));
+    return {
+        capabilities: baseCapabilities,
+        async ensureCollection() { },
+        async upsert() { },
+        async delete() { },
+        async bulkReindex() { },
+        search: searchSpy,
+        searchSpy,
+    };
+}
+function makeEmbeddings() {
+    const embedSpy = vi.fn(async (texts) => texts.map(() => [0.1, 0.2, 0.3]));
+    return {
+        capabilities: {
+            modelId: "test/v1",
+            dimensions: 3,
+            maxTokensPerInput: 1000,
+            maxBatchSize: 100,
+        },
+        embed: embedSpy,
+        embedSpy,
+    };
+}
+const slice = {
+    vertical: "products",
+    locale: "en-GB",
+    audience: "customer",
+    market: "default",
+};
+describe("executeSemanticSearch", () => {
+    it("keyword mode delegates directly without embedding", async () => {
+        const adapter = makeAdapter();
+        const embeddings = makeEmbeddings();
+        await executeSemanticSearch({
+            adapter,
+            embeddings,
+            slice,
+            request: { query: "wellness", mode: "keyword" },
+        });
+        expect(embeddings.embedSpy).not.toHaveBeenCalled();
+        expect(adapter.searchSpy).toHaveBeenCalledTimes(1);
+    });
+    it("semantic mode embeds the query and attaches the vector", async () => {
+        const adapter = makeAdapter();
+        const embeddings = makeEmbeddings();
+        await executeSemanticSearch({
+            adapter,
+            embeddings,
+            slice,
+            request: { query: "wellness", mode: "semantic" },
+        });
+        expect(embeddings.embedSpy).toHaveBeenCalledWith(["wellness"]);
+        const [, request] = adapter.searchSpy.mock.calls[0];
+        expect(request.query_embedding).toEqual([0.1, 0.2, 0.3]);
+    });
+    it("hybrid mode embeds the query when caller didn't supply one", async () => {
+        const adapter = makeAdapter();
+        const embeddings = makeEmbeddings();
+        await executeSemanticSearch({
+            adapter,
+            embeddings,
+            slice,
+            request: { query: "wellness", mode: "hybrid" },
+        });
+        expect(embeddings.embedSpy).toHaveBeenCalledTimes(1);
+    });
+    it("honors caller-supplied query_embedding without re-embedding", async () => {
+        const adapter = makeAdapter();
+        const embeddings = makeEmbeddings();
+        const caller_vector = [0.9, 0.8, 0.7];
+        await executeSemanticSearch({
+            adapter,
+            embeddings,
+            slice,
+            request: {
+                query: "wellness",
+                mode: "semantic",
+                query_embedding: caller_vector,
+            },
+        });
+        expect(embeddings.embedSpy).not.toHaveBeenCalled();
+        const [, request] = adapter.searchSpy.mock.calls[0];
+        expect(request.query_embedding).toBe(caller_vector);
+    });
+    it("throws when semantic mode is requested but adapter doesn't support vectors", async () => {
+        const adapter = makeAdapter({ supportsVectorFields: false });
+        const embeddings = makeEmbeddings();
+        await expect(executeSemanticSearch({
+            adapter,
+            embeddings,
+            slice,
+            request: { query: "x", mode: "semantic" },
+        })).rejects.toThrow(/supports vector fields/);
+    });
+    it("throws when hybrid mode is requested but adapter doesn't support hybrid", async () => {
+        const adapter = makeAdapter({ supportsVectorFields: true, supportsHybridSearch: false });
+        const embeddings = makeEmbeddings();
+        await expect(executeSemanticSearch({
+            adapter,
+            embeddings,
+            slice,
+            request: { query: "x", mode: "hybrid" },
+        })).rejects.toThrow(/supportsHybridSearch/);
+    });
+});
+describe("executeBYOVectorSearch", () => {
+    it("attaches the caller-supplied vector and delegates without embedding", async () => {
+        const adapter = makeAdapter();
+        const vector = [1, 2, 3];
+        await executeBYOVectorSearch({
+            adapter,
+            slice,
+            request: { query: "x", mode: "semantic", query_embedding: vector },
+        });
+        const [, request] = adapter.searchSpy.mock.calls[0];
+        expect(request.query_embedding).toBe(vector);
+    });
+    it("throws when adapter does not support vector fields", async () => {
+        const adapter = makeAdapter({ supportsVectorFields: false });
+        await expect(executeBYOVectorSearch({
+            adapter,
+            slice,
+            request: { query: "x", mode: "semantic", query_embedding: [1, 2, 3] },
+        })).rejects.toThrow(/supportsVectorFields/);
+    });
+});

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@voyantjs/catalog-rag",
+  "version": "0.19.0",
+  "license": "Apache-2.0",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./embeddings/contract": "./src/embeddings/contract.ts",
+    "./embeddings/openai": "./src/embeddings/openai.ts",
+    "./embeddings/model-registry": "./src/embeddings/model-registry.ts",
+    "./search/semantic": "./src/search/semantic.ts",
+    "./search/federate": "./src/search/federate.ts"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/",
+    "test": "vitest run",
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "prepack": "pnpm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js",
+        "default": "./dist/index.js"
+      },
+      "./embeddings/contract": {
+        "types": "./dist/embeddings/contract.d.ts",
+        "import": "./dist/embeddings/contract.js",
+        "default": "./dist/embeddings/contract.js"
+      },
+      "./embeddings/openai": {
+        "types": "./dist/embeddings/openai.d.ts",
+        "import": "./dist/embeddings/openai.js",
+        "default": "./dist/embeddings/openai.js"
+      },
+      "./embeddings/model-registry": {
+        "types": "./dist/embeddings/model-registry.d.ts",
+        "import": "./dist/embeddings/model-registry.js",
+        "default": "./dist/embeddings/model-registry.js"
+      },
+      "./search/semantic": {
+        "types": "./dist/search/semantic.d.ts",
+        "import": "./dist/search/semantic.js",
+        "default": "./dist/search/semantic.js"
+      },
+      "./search/federate": {
+        "types": "./dist/search/federate.d.ts",
+        "import": "./dist/search/federate.js",
+        "default": "./dist/search/federate.js"
+      }
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts"
+  },
+  "dependencies": {
+    "@voyantjs/catalog": "workspace:*"
+  },
+  "devDependencies": {
+    "@voyantjs/voyant-typescript-config": "workspace:*",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/voyantjs/voyant.git",
+    "directory": "packages/catalog-rag"
+  }
+}