@dudousxd/nestjs-agent-rag 0.1.0

package/dist/index.js

@@ -0,0 +1,845 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/chunk.ts
+function chunkText(text, options = {}) {
+  const chunkSize = options.chunkSize ?? 800;
+  const overlap = options.overlap ?? 100;
+  const normalized = text.trim();
+  if (normalized.length === 0) {
+    return [];
+  }
+  if (normalized.length <= chunkSize) {
+    return [
+      normalized
+    ];
+  }
+  const chunks = [];
+  let start = 0;
+  while (start < normalized.length) {
+    const end = Math.min(start + chunkSize, normalized.length);
+    let breakAt = end;
+    if (end < normalized.length) {
+      const window = normalized.slice(start, end);
+      const boundary = Math.max(window.lastIndexOf("\n\n"), window.lastIndexOf(". "), window.lastIndexOf(" "));
+      if (boundary > chunkSize / 2) {
+        breakAt = start + boundary + 1;
+      }
+    }
+    const chunk = normalized.slice(start, breakAt).trim();
+    if (chunk.length > 0) {
+      chunks.push(chunk);
+    }
+    if (breakAt >= normalized.length) {
+      break;
+    }
+    start = Math.max(breakAt - overlap, start + 1);
+  }
+  return chunks;
+}
+__name(chunkText, "chunkText");
+
+// src/vector-store.ts
+function documentIdOf(chunkId) {
+  return chunkId.replace(/#\d+$/, "");
+}
+__name(documentIdOf, "documentIdOf");
+
+// src/filter.ts
+function matchesFilter(metadata, filter) {
+  if (metadata === void 0) {
+    return Object.keys(filter).length === 0;
+  }
+  return Object.entries(filter).every(([key, value]) => metadata[key] === value);
+}
+__name(matchesFilter, "matchesFilter");
+
+// src/memory-vector-store.ts
+var MemoryVectorStore = class {
+  static {
+    __name(this, "MemoryVectorStore");
+  }
+  records = /* @__PURE__ */ new Map();
+  async upsert(records) {
+    for (const record of records) {
+      this.records.set(record.id, record);
+    }
+  }
+  async remove(documentId) {
+    for (const id of this.records.keys()) {
+      if (documentIdOf(id) === documentId) {
+        this.records.delete(id);
+      }
+    }
+  }
+  async listDocuments(filter) {
+    const documents = /* @__PURE__ */ new Map();
+    for (const record of this.records.values()) {
+      if (filter !== void 0 && !matchesFilter(record.metadata, filter)) {
+        continue;
+      }
+      const id = documentIdOf(record.id);
+      if (!documents.has(id)) {
+        documents.set(id, {
+          id,
+          ...record.metadata !== void 0 ? {
+            metadata: record.metadata
+          } : {}
+        });
+      }
+    }
+    return [
+      ...documents.values()
+    ];
+  }
+  async search(embedding, options) {
+    const scored = [];
+    for (const record of this.records.values()) {
+      if (options.filter !== void 0 && !matchesFilter(record.metadata, options.filter)) {
+        continue;
+      }
+      scored.push({
+        id: record.id,
+        text: record.text,
+        score: cosineSimilarity(embedding, record.embedding),
+        ...record.source !== void 0 ? {
+          source: record.source
+        } : {},
+        ...record.metadata !== void 0 ? {
+          metadata: record.metadata
+        } : {}
+      });
+    }
+    return scored.sort((a, b) => b.score - a.score).slice(0, options.topK);
+  }
+};
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  const length = Math.min(a.length, b.length);
+  for (let index = 0; index < length; index += 1) {
+    const valueA = a[index] ?? 0;
+    const valueB = b[index] ?? 0;
+    dot += valueA * valueB;
+    normA += valueA * valueA;
+    normB += valueB * valueB;
+  }
+  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+  return denominator === 0 ? 0 : dot / denominator;
+}
+__name(cosineSimilarity, "cosineSimilarity");
+
+// src/pg-vector-store.ts
+var PgVectorStore = class {
+  static {
+    __name(this, "PgVectorStore");
+  }
+  client;
+  table;
+  dimensions;
+  constructor(client, options = {}) {
+    this.client = client;
+    this.table = options.table ?? "agent_rag_chunks";
+    this.dimensions = options.dimensions ?? 1536;
+  }
+  /** Idempotent DDL: the `vector` extension, the chunks table, and the cosine HNSW index. */
+  async ensureSchema() {
+    await this.client.query("CREATE EXTENSION IF NOT EXISTS vector");
+    await this.client.query(`CREATE TABLE IF NOT EXISTS ${this.table} (
+        id TEXT PRIMARY KEY,
+        text TEXT NOT NULL,
+        source TEXT,
+        metadata JSONB,
+        embedding vector(${this.dimensions}) NOT NULL
+      )`);
+    await this.client.query(`CREATE INDEX IF NOT EXISTS ${this.table}_embedding_idx
+        ON ${this.table} USING hnsw (embedding vector_cosine_ops)`);
+  }
+  async upsert(records) {
+    for (const record of records) {
+      await this.client.query(`INSERT INTO ${this.table} (id, text, source, metadata, embedding)
+         VALUES ($1, $2, $3, $4, $5)
+         ON CONFLICT (id) DO UPDATE SET
+           text = EXCLUDED.text,
+           source = EXCLUDED.source,
+           metadata = EXCLUDED.metadata,
+           embedding = EXCLUDED.embedding`, [
+        record.id,
+        record.text,
+        record.source ?? null,
+        record.metadata !== void 0 ? JSON.stringify(record.metadata) : null,
+        toVectorLiteral(record.embedding)
+      ]);
+    }
+  }
+  async remove(documentId) {
+    await this.client.query(`DELETE FROM ${this.table} WHERE ${DOCUMENT_ID_FROM_CHUNK} = $1`, [
+      documentId
+    ]);
+  }
+  async listDocuments(filter) {
+    const hasFilter = filter !== void 0 && Object.keys(filter).length > 0;
+    const rows = await this.client.query(`SELECT DISTINCT ON (${DOCUMENT_ID_FROM_CHUNK}) ${DOCUMENT_ID_FROM_CHUNK} AS doc_id, metadata
+       FROM ${this.table}
+       ${hasFilter ? "WHERE metadata @> $1::jsonb" : ""}
+       ORDER BY ${DOCUMENT_ID_FROM_CHUNK}`, hasFilter ? [
+      JSON.stringify(filter)
+    ] : []);
+    return rows.map((row) => ({
+      id: row.doc_id,
+      ...row.metadata !== null ? {
+        metadata: row.metadata
+      } : {}
+    }));
+  }
+  async search(embedding, options) {
+    const vector = toVectorLiteral(embedding);
+    const hasFilter = options.filter !== void 0 && Object.keys(options.filter).length > 0;
+    const rows = await this.client.query(`SELECT id, text, source, metadata, 1 - (embedding <=> $1::vector) AS score
+       FROM ${this.table}
+       ${hasFilter ? "WHERE metadata @> $3::jsonb" : ""}
+       ORDER BY embedding <=> $1::vector
+       LIMIT $2`, hasFilter ? [
+      vector,
+      options.topK,
+      JSON.stringify(options.filter)
+    ] : [
+      vector,
+      options.topK
+    ]);
+    return rows.map((row) => ({
+      id: row.id,
+      text: row.text,
+      score: Number(row.score),
+      ...row.source !== null ? {
+        source: row.source
+      } : {},
+      ...row.metadata !== null ? {
+        metadata: row.metadata
+      } : {}
+    }));
+  }
+};
+var DOCUMENT_ID_FROM_CHUNK = "regexp_replace(id, '#[0-9]+$', '')";
+function toVectorLiteral(embedding) {
+  return `[${embedding.join(",")}]`;
+}
+__name(toVectorLiteral, "toVectorLiteral");
+
+// src/redis-vector-store.ts
+var RedisVectorStore = class {
+  static {
+    __name(this, "RedisVectorStore");
+  }
+  client;
+  index;
+  prefix;
+  dimensions;
+  filterableFields;
+  constructor(client, options = {}) {
+    this.client = client;
+    this.index = options.index ?? "agent_rag_idx";
+    this.prefix = options.prefix ?? "agent_rag:";
+    this.dimensions = options.dimensions ?? 1536;
+    this.filterableFields = options.filterableFields ?? [];
+  }
+  /** Idempotent: create the HNSW/cosine index if `FT.INFO` says it doesn't exist yet. */
+  async ensureSchema() {
+    try {
+      await this.client.sendCommand([
+        "FT.INFO",
+        this.index
+      ]);
+      return;
+    } catch {
+    }
+    const schema = [
+      "text",
+      "TEXT",
+      "source",
+      "TAG",
+      "metadata_json",
+      "TEXT",
+      "NOINDEX"
+    ];
+    for (const field of this.filterableFields) {
+      schema.push(`meta_${field}`, "TAG");
+    }
+    schema.push("embedding", "VECTOR", "HNSW", "6", "TYPE", "FLOAT32", "DIM", String(this.dimensions), "DISTANCE_METRIC", "COSINE");
+    await this.client.sendCommand([
+      "FT.CREATE",
+      this.index,
+      "ON",
+      "HASH",
+      "PREFIX",
+      "1",
+      this.prefix,
+      "SCHEMA",
+      ...schema
+    ]);
+  }
+  async upsert(records) {
+    for (const record of records) {
+      const args = [
+        "HSET",
+        `${this.prefix}${record.id}`,
+        "text",
+        record.text,
+        "embedding",
+        encodeVector(record.embedding)
+      ];
+      if (record.source !== void 0) {
+        args.push("source", record.source);
+      }
+      if (record.metadata !== void 0) {
+        args.push("metadata_json", JSON.stringify(record.metadata));
+        for (const field of this.filterableFields) {
+          const value = record.metadata[field];
+          if (value !== void 0) {
+            args.push(`meta_${field}`, String(value));
+          }
+        }
+      }
+      await this.client.sendCommand(args);
+    }
+  }
+  async remove(documentId) {
+    const keys = /* @__PURE__ */ new Set([
+      `${this.prefix}${documentId}`
+    ]);
+    const pattern = `${this.prefix}${escapeGlob(documentId)}#*`;
+    let cursor = "0";
+    do {
+      const reply = await this.client.sendCommand([
+        "SCAN",
+        cursor,
+        "MATCH",
+        pattern,
+        "COUNT",
+        "256"
+      ]);
+      const page = parseScanReply(reply);
+      cursor = page.cursor;
+      for (const key of page.keys) {
+        keys.add(key);
+      }
+    } while (cursor !== "0");
+    if (keys.size > 0) {
+      await this.client.sendCommand([
+        "DEL",
+        ...keys
+      ]);
+    }
+  }
+  async listDocuments(filter) {
+    const query = buildFilter(filter);
+    const documents = /* @__PURE__ */ new Map();
+    const batchSize = 1e3;
+    let offset = 0;
+    for (; ; ) {
+      const reply = await this.client.sendCommand([
+        "FT.SEARCH",
+        this.index,
+        query,
+        "RETURN",
+        "1",
+        "metadata_json",
+        "LIMIT",
+        String(offset),
+        String(batchSize),
+        "DIALECT",
+        "2"
+      ]);
+      const passages = parseSearchReply(reply, this.prefix);
+      for (const passage of passages) {
+        const id = documentIdOf(passage.id);
+        if (!documents.has(id)) {
+          documents.set(id, {
+            id,
+            ...passage.metadata !== void 0 ? {
+              metadata: passage.metadata
+            } : {}
+          });
+        }
+      }
+      if (passages.length < batchSize) {
+        break;
+      }
+      offset += batchSize;
+    }
+    return [
+      ...documents.values()
+    ];
+  }
+  async search(embedding, options) {
+    const query = `${buildFilter(options.filter)}=>[KNN ${options.topK} @embedding $BLOB AS vector_score]`;
+    const reply = await this.client.sendCommand([
+      "FT.SEARCH",
+      this.index,
+      query,
+      "PARAMS",
+      "2",
+      "BLOB",
+      encodeVector(embedding),
+      "RETURN",
+      "4",
+      "text",
+      "source",
+      "metadata_json",
+      "vector_score",
+      "SORTBY",
+      "vector_score",
+      "ASC",
+      "DIALECT",
+      "2",
+      "LIMIT",
+      "0",
+      String(options.topK)
+    ]);
+    return parseSearchReply(reply, this.prefix);
+  }
+};
+function encodeVector(embedding) {
+  return Buffer.from(new Float32Array(embedding).buffer);
+}
+__name(encodeVector, "encodeVector");
+function buildFilter(filter) {
+  if (filter === void 0 || Object.keys(filter).length === 0) {
+    return "*";
+  }
+  const clauses = Object.entries(filter).map(([key, value]) => `@meta_${key}:{${escapeTag(String(value))}}`);
+  return `(${clauses.join(" ")})`;
+}
+__name(buildFilter, "buildFilter");
+function escapeTag(value) {
+  return value.replace(/[^a-zA-Z0-9_]/g, (char) => `\\${char}`);
+}
+__name(escapeTag, "escapeTag");
+function escapeGlob(value) {
+  return value.replace(/[*?[\]\\]/g, (char) => `\\${char}`);
+}
+__name(escapeGlob, "escapeGlob");
+function parseScanReply(reply) {
+  if (Array.isArray(reply) && reply.length >= 2) {
+    const rawKeys = reply[1];
+    return {
+      cursor: toStr(reply[0]),
+      keys: Array.isArray(rawKeys) ? rawKeys.map(toStr) : []
+    };
+  }
+  if (typeof reply === "object" && reply !== null && "cursor" in reply && "keys" in reply) {
+    const { cursor, keys } = reply;
+    return {
+      cursor: toStr(cursor),
+      keys: Array.isArray(keys) ? keys.map(toStr) : []
+    };
+  }
+  return {
+    cursor: "0",
+    keys: []
+  };
+}
+__name(parseScanReply, "parseScanReply");
+function toStr(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return Buffer.isBuffer(value) ? value.toString("utf8") : String(value);
+}
+__name(toStr, "toStr");
+function parseSearchReply(reply, prefix) {
+  if (Array.isArray(reply)) {
+    const passages = [];
+    for (let index = 1; index + 1 < reply.length; index += 2) {
+      const rawFields = reply[index + 1];
+      if (Array.isArray(rawFields)) {
+        const attrs = {};
+        for (let field = 0; field + 1 < rawFields.length; field += 2) {
+          attrs[toStr(rawFields[field])] = toStr(rawFields[field + 1]);
+        }
+        passages.push(toPassage(toStr(reply[index]), attrs, prefix));
+      }
+    }
+    return passages;
+  }
+  if (typeof reply === "object" && reply !== null && "results" in reply) {
+    const results = reply.results;
+    if (Array.isArray(results)) {
+      return results.map((result) => toPassage(readId(result), readAttributes(result), prefix));
+    }
+  }
+  return [];
+}
+__name(parseSearchReply, "parseSearchReply");
+function readId(result) {
+  if (typeof result === "object" && result !== null && "id" in result) {
+    return toStr(result.id);
+  }
+  return "";
+}
+__name(readId, "readId");
+function readAttributes(result) {
+  const attrs = {};
+  if (typeof result === "object" && result !== null && "extra_attributes" in result) {
+    const raw = result.extra_attributes;
+    if (typeof raw === "object" && raw !== null) {
+      for (const [key, value] of Object.entries(raw)) {
+        attrs[key] = toStr(value);
+      }
+    }
+  }
+  return attrs;
+}
+__name(readAttributes, "readAttributes");
+function toPassage(rawId, attrs, prefix) {
+  const distance = Number(attrs.vector_score ?? "1");
+  const source = attrs.source;
+  return {
+    id: rawId.startsWith(prefix) ? rawId.slice(prefix.length) : rawId,
+    text: attrs.text ?? "",
+    score: 1 - distance,
+    ...source !== void 0 ? {
+      source
+    } : {},
+    ...parseMetadata(attrs.metadata_json)
+  };
+}
+__name(toPassage, "toPassage");
+function parseMetadata(raw) {
+  if (raw === void 0) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null) {
+      return {
+        metadata: parsed
+      };
+    }
+  } catch {
+  }
+  return {};
+}
+__name(parseMetadata, "parseMetadata");
+
+// src/embedding-retriever.ts
+var EmbeddingRetriever = class {
+  static {
+    __name(this, "EmbeddingRetriever");
+  }
+  embedder;
+  store;
+  constructor(embedder, store) {
+    this.embedder = embedder;
+    this.store = store;
+  }
+  async retrieve(query, options = {}) {
+    const [embedding] = await this.embedder.embed([
+      query
+    ]);
+    if (embedding === void 0) {
+      return [];
+    }
+    return this.store.search(embedding, {
+      topK: options.topK ?? 5,
+      ...options.filter !== void 0 ? {
+        filter: options.filter
+      } : {}
+    });
+  }
+};
+
+// src/keyword-retriever.ts
+var KeywordRetriever = class {
+  static {
+    __name(this, "KeywordRetriever");
+  }
+  docs = /* @__PURE__ */ new Map();
+  documentFrequency = /* @__PURE__ */ new Map();
+  totalLength = 0;
+  k1;
+  b;
+  constructor(options = {}) {
+    this.k1 = options.k1 ?? 1.5;
+    this.b = options.b ?? 0.75;
+  }
+  /** Index (or re-index) records. Re-adding an existing id replaces its posting and updates stats. */
+  add(records) {
+    for (const record of records) {
+      this.remove(record.id);
+      const tokens = tokenize(record.text);
+      const frequencies = /* @__PURE__ */ new Map();
+      for (const token of tokens) {
+        frequencies.set(token, (frequencies.get(token) ?? 0) + 1);
+      }
+      for (const term of frequencies.keys()) {
+        this.documentFrequency.set(term, (this.documentFrequency.get(term) ?? 0) + 1);
+      }
+      this.docs.set(record.id, {
+        record,
+        frequencies,
+        length: tokens.length
+      });
+      this.totalLength += tokens.length;
+    }
+  }
+  remove(id) {
+    const existing = this.docs.get(id);
+    if (existing === void 0) {
+      return;
+    }
+    for (const term of existing.frequencies.keys()) {
+      const next = (this.documentFrequency.get(term) ?? 1) - 1;
+      if (next <= 0) {
+        this.documentFrequency.delete(term);
+      } else {
+        this.documentFrequency.set(term, next);
+      }
+    }
+    this.totalLength -= existing.length;
+    this.docs.delete(id);
+  }
+  async retrieve(query, options = {}) {
+    const total = this.docs.size;
+    if (total === 0) {
+      return [];
+    }
+    const averageLength = this.totalLength / total;
+    const queryTerms = new Set(tokenize(query));
+    const scored = [];
+    for (const { record, frequencies, length } of this.docs.values()) {
+      if (options.filter !== void 0 && !matchesFilter(record.metadata, options.filter)) {
+        continue;
+      }
+      let score = 0;
+      for (const term of queryTerms) {
+        const termFrequency = frequencies.get(term);
+        if (termFrequency === void 0) {
+          continue;
+        }
+        const df = this.documentFrequency.get(term) ?? 0;
+        const idf = Math.log(1 + (total - df + 0.5) / (df + 0.5));
+        const denominator = termFrequency + this.k1 * (1 - this.b + this.b * length / averageLength);
+        score += idf * (termFrequency * (this.k1 + 1) / denominator);
+      }
+      if (score > 0) {
+        scored.push({
+          id: record.id,
+          text: record.text,
+          score,
+          ...record.source !== void 0 ? {
+            source: record.source
+          } : {},
+          ...record.metadata !== void 0 ? {
+            metadata: record.metadata
+          } : {}
+        });
+      }
+    }
+    return scored.sort((a, b) => b.score - a.score).slice(0, options.topK ?? 5);
+  }
+};
+function tokenize(text) {
+  return text.toLowerCase().match(/[a-z0-9]+/g) ?? [];
+}
+__name(tokenize, "tokenize");
+
+// src/hybrid-retriever.ts
+var HybridRetriever = class {
+  static {
+    __name(this, "HybridRetriever");
+  }
+  retrievers;
+  options;
+  constructor(retrievers, options = {}) {
+    this.retrievers = retrievers;
+    this.options = options;
+  }
+  async retrieve(query, options = {}) {
+    const k = this.options.k ?? 60;
+    const fetchTopK = this.options.fetchTopK ?? 20;
+    const weights = this.options.weights;
+    const lists = await Promise.all(this.retrievers.map((retriever) => retriever.retrieve(query, {
+      topK: fetchTopK,
+      ...options.filter !== void 0 ? {
+        filter: options.filter
+      } : {}
+    })));
+    const fused = /* @__PURE__ */ new Map();
+    lists.forEach((list, listIndex) => {
+      const weight = weights?.[listIndex] ?? 1;
+      list.forEach((passage, rank) => {
+        const contribution = weight / (k + rank + 1);
+        const existing = fused.get(passage.id);
+        if (existing !== void 0) {
+          existing.score += contribution;
+        } else {
+          fused.set(passage.id, {
+            passage,
+            score: contribution
+          });
+        }
+      });
+    });
+    return [
+      ...fused.values()
+    ].sort((a, b) => b.score - a.score).slice(0, options.topK ?? 5).map((entry) => ({
+      ...entry.passage,
+      score: entry.score
+    }));
+  }
+};
+
+// src/reranking-retriever.ts
+var RerankingRetriever = class {
+  static {
+    __name(this, "RerankingRetriever");
+  }
+  base;
+  reranker;
+  options;
+  constructor(base, reranker, options = {}) {
+    this.base = base;
+    this.reranker = reranker;
+    this.options = options;
+  }
+  async retrieve(query, options = {}) {
+    const candidates = await this.base.retrieve(query, {
+      topK: this.options.fetchTopK ?? 20,
+      ...options.filter !== void 0 ? {
+        filter: options.filter
+      } : {}
+    });
+    return this.reranker.rerank(query, candidates, {
+      topK: options.topK ?? 5
+    });
+  }
+};
+
+// src/filtered-retriever.ts
+var FilteredRetriever = class {
+  static {
+    __name(this, "FilteredRetriever");
+  }
+  base;
+  filter;
+  constructor(base, filter) {
+    this.base = base;
+    this.filter = filter;
+  }
+  async retrieve(query, options = {}) {
+    return this.base.retrieve(query, {
+      ...options,
+      filter: {
+        ...options.filter,
+        ...this.filter
+      }
+    });
+  }
+};
+
+// src/ingest.ts
+function chunkDocuments(documents, options = {}) {
+  const chunks = [];
+  for (const document of documents) {
+    chunkText(document.text, options).forEach((text, index) => {
+      chunks.push({
+        id: `${document.id}#${index}`,
+        text,
+        ...document.source !== void 0 ? {
+          source: document.source
+        } : {},
+        ...document.metadata !== void 0 ? {
+          metadata: document.metadata
+        } : {}
+      });
+    });
+  }
+  return chunks;
+}
+__name(chunkDocuments, "chunkDocuments");
+async function ingestChunks(chunks, options) {
+  if (chunks.length === 0) {
+    return 0;
+  }
+  const embeddings = await options.embedder.embed(chunks.map((chunk) => chunk.text));
+  const records = chunks.map((chunk, index) => ({
+    ...chunk,
+    embedding: embeddings[index] ?? []
+  }));
+  await options.store.upsert(records);
+  return records.length;
+}
+__name(ingestChunks, "ingestChunks");
+async function ingestDocuments(documents, options) {
+  return ingestChunks(chunkDocuments(documents, options), options);
+}
+__name(ingestDocuments, "ingestDocuments");
+
+// src/retrieval-tool.ts
+function isQueryInput(value) {
+  return typeof value === "object" && value !== null && "query" in value && typeof value.query === "string";
+}
+__name(isQueryInput, "isQueryInput");
+var querySchema = {
+  "~standard": {
+    version: 1,
+    vendor: "nestjs-agent-rag",
+    validate(value) {
+      return isQueryInput(value) ? {
+        value: {
+          query: value.query
+        }
+      } : {
+        issues: [
+          {
+            message: "retrieval tool expects { query: string }"
+          }
+        ]
+      };
+    }
+  }
+};
+function createRetrievalTool(retriever, options = {}) {
+  const topK = options.topK;
+  return {
+    spec: {
+      name: options.name ?? "search_knowledge",
+      kind: "read",
+      description: options.description ?? "Search the knowledge base for passages relevant to a query. Returns passages with their source for citation.",
+      inputSchema: querySchema
+    },
+    handler: {
+      async execute(input) {
+        if (!isQueryInput(input)) {
+          throw new Error("retrieval tool expects { query: string }");
+        }
+        const passages = await retriever.retrieve(input.query, topK !== void 0 ? {
+          topK
+        } : {});
+        return {
+          passages
+        };
+      }
+    }
+  };
+}
+__name(createRetrievalTool, "createRetrievalTool");
+export {
+  EmbeddingRetriever,
+  FilteredRetriever,
+  HybridRetriever,
+  KeywordRetriever,
+  MemoryVectorStore,
+  PgVectorStore,
+  RedisVectorStore,
+  RerankingRetriever,
+  chunkDocuments,
+  chunkText,
+  createRetrievalTool,
+  documentIdOf,
+  ingestChunks,
+  ingestDocuments
+};
+//# sourceMappingURL=index.js.map