@devilsdev/rag-connectors 3.5.0 → 3.7.0

package/dist/index.cjs

@@ -99,7 +99,7 @@ var require_openai_connector = __commonJS({
   "src/connectors/openai-connector.js"(exports2, module2) {
     "use strict";
     var { BaseConnector } = require_base_connector();
-    var { loadOptionalPeer } = require_optional_peer();
+    var { missingPeer } = require_optional_peer();
     var {
       missingApiKeyError,
       raceAbort,
@@ -121,12 +121,15 @@ var require_openai_connector = __commonJS({
       }
     };
     function loadOpenAI() {
-      return loadOptionalPeer(
-        "openai",
-        () => require("openai"),
-        // eslint-disable-line global-require
-        'OpenAIConnector needs the "openai" package, an optional peer dependency since 3.0.0: npm install openai'
-      );
+      try {
+        return require("openai");
+      } catch (error) {
+        throw missingPeer(
+          error,
+          "openai",
+          'OpenAIConnector needs the "openai" package, an optional peer dependency since 3.0.0: npm install openai'
+        );
+      }
     }
     var OpenAIConnector = class extends BaseConnector {
       /**
@@ -230,8 +233,25 @@ var require_openai_connector = __commonJS({
       _request(signal, fn) {
         return this.withRetry(fn, this.config.maxRetries, this.config.retryDelay, {
           signal
+        }).catch((err) => {
+          throw this._tagError(err);
         });
       }
+      /**
+       * Name the provider on an HTTP error from the SDK, as the axios-based
+       * connectors do, so a caller such as the CLI can say which key was refused.
+       * A custom baseURL never reads OPENAI_API_KEY, so it gets no envVar.
+       * @private
+       */
+      _tagError(err) {
+        if (err && typeof err === "object" && typeof err.status === "number") {
+          if (!err.provider) {
+            err.provider = this.config.baseURL ? "The OpenAI-compatible API" : "OpenAI";
+          }
+          if (!this.config.baseURL && !err.envVar) err.envVar = API_KEY_ENV;
+        }
+        return err;
+      }
       /**
        * Generate a chat completion using the provided query and optional RAG context.
        *
@@ -275,19 +295,24 @@ var require_openai_connector = __commonJS({
         this._requireApiKey();
         const client = this._getClient();
         const messages = this._buildMessages(query, context);
-        const stream = await raceAbort(
-          client.chat.completions.create(
-            {
-              model: options.model || this.config.model,
-              messages,
-              temperature: options.temperature ?? this.config.temperature,
-              max_tokens: options.maxTokens ?? this.config.maxTokens,
-              stream: true
-            },
-            signal ? { signal } : void 0
-          ),
-          signal
-        );
+        let stream;
+        try {
+          stream = await raceAbort(
+            client.chat.completions.create(
+              {
+                model: options.model || this.config.model,
+                messages,
+                temperature: options.temperature ?? this.config.temperature,
+                max_tokens: options.maxTokens ?? this.config.maxTokens,
+                stream: true
+              },
+              signal ? { signal } : void 0
+            ),
+            signal
+          );
+        } catch (err) {
+          throw this._tagError(err);
+        }
         for await (const chunk of stream) {
           throwIfAborted(signal);
           const token = chunk.choices[0]?.delta?.content || "";
@@ -1608,220 +1633,914 @@ var require_qdrant_retriever = __commonJS({
   }
 });
 
-// src/retrieval/pgvector-retriever.js
-var require_pgvector_retriever = __commonJS({
-  "src/retrieval/pgvector-retriever.js"(exports2, module2) {
+// src/retrieval/pinecone-retriever.js
+var require_pinecone_retriever = __commonJS({
+  "src/retrieval/pinecone-retriever.js"(exports2, module2) {
     "use strict";
-    var { throwIfAborted, raceAbort } = require_connector_utils();
-    var IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]{0,62}$/;
-    var DEFAULT_TABLE = "rag_documents";
-    var PG_DEFAULT_EF_SEARCH = 40;
-    var MAX_BATCH = 1e3;
-    function quoteTable(name) {
-      const parts = String(name).split(".");
-      if (parts.length > 2 || !parts.every((p) => IDENTIFIER.test(p))) {
-        throw new Error(
-          `PgVectorRetriever: invalid table name "${name}" (letters, digits and underscores; optionally schema.table)`
-        );
-      }
-      return parts.map((p) => `"${p}"`).join(".");
+    var crypto = require("crypto");
+    var { throwIfAborted } = require_connector_utils();
+    var API_VERSION = "2026-07";
+    var CONTROL_PLANE = "https://api.pinecone.io";
+    var DEFAULT_NAMESPACE = "rag_documents";
+    var UPSERT_BATCH = 100;
+    var EMBED_UPSERT_BATCH = 96;
+    var REQUEST_BYTES = 2e6 - 1024;
+    var DELETE_BATCH = 1e3;
+    var PAGE = 100;
+    var SEARCH_MAX = 1e4;
+    var PLAIN_ID = /^[\x20-\x7e]{1,512}$/;
+    var FIELDS = ["rag_id", "rag_content", "rag_metadata"];
+    var OURS = { rag_id: { $exists: true } };
+    var PROBE_QUERY = "document";
+    function recordId(id) {
+      const s = String(id);
+      if (PLAIN_ID.test(s)) return s;
+      return `rag-${crypto.createHash("sha256").update(s).digest("hex")}`;
     }
-    function vectorLiteral(vector, id) {
+    function checkVector(vector, id) {
       if (!Array.isArray(vector) || vector.length === 0) {
-        throw new Error(`PgVectorRetriever: document "${id}" has no vector`);
-      }
-      for (const x of vector) {
-        if (typeof x !== "number" || !Number.isFinite(x)) {
-          throw new Error(
-            `PgVectorRetriever: document "${id}" has a vector with a non-finite value`
-          );
-        }
-      }
-      return `[${vector.join(",")}]`;
-    }
-    function explain(err, table) {
-      const code = err && err.code;
-      if (code === "42P01") {
-        return new Error(
-          `PgVectorRetriever: table ${table} does not exist. Store documents first (rag-pipeline ingest), or create it.`
-        );
+        throw new Error(`PineconeRetriever: document "${id}" has no vector`);
       }
-      if (code === "42501" || /permission denied/i.test(String(err && err.message))) {
-        return new Error(
-          `PgVectorRetriever: permission denied. Run \`CREATE EXTENSION IF NOT EXISTS vector;\` as a database owner, and grant this user access to ${table}. (${err.message})`
+      if (!vector.every((x) => typeof x === "number" && Number.isFinite(x))) {
+        throw new Error(
+          `PineconeRetriever: document "${id}" has a vector with a non-finite value`
         );
       }
-      if (/different vector dimensions|expected \d+ dimensions/i.test(
-        String(err && err.message)
-      )) {
-        return new Error(
-          `PgVectorRetriever: ${err.message}. The table holds vectors from another embedder; use the same embedder or a new table.`
-        );
+    }
+    function fromFields(fields, fallbackId) {
+      const m = fields || {};
+      let metadata = {};
+      try {
+        metadata = m.rag_metadata ? JSON.parse(m.rag_metadata) : {};
+      } catch {
+        metadata = {};
       }
-      return err;
+      return {
+        id: m.rag_id !== void 0 ? String(m.rag_id) : fallbackId,
+        content: m.rag_content || "",
+        metadata
+      };
     }
-    var PgVectorRetriever = class {
+    function normalizeHost(host) {
+      let h = String(host);
+      while (h.endsWith("/")) h = h.slice(0, -1);
+      return /^https?:\/\//.test(h) ? h : `https://${h}`;
+    }
+    var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    var PineconeRetriever = class {
       /**
        * @param {Object} options
-       * @param {{ query: Function, connect?: Function }} [options.pool] - A pg Pool or Client you manage
-       * @param {string} [options.connectionString] - Used to create a Pool when no `pool` is given
-       * @param {string} [options.table='rag_documents'] - Table name, optionally `schema.table`
-       * @param {number} [options.dimensions] - Vector size for a new table; defaults to the first stored vector's
-       * @param {boolean} [options.createTable=true] - Create the extension, table and index on first store
-       * @param {'hnsw'|'none'} [options.index='hnsw'] - Index created with the table
-       * @param {number} [options.efSearch] - HNSW candidate list size per query (pgvector's default is 40). Higher finds more of the true nearest neighbours, more slowly; a query always uses at least its topK
-       * @param {string} [options.cacheKey] - Cache identity; change it when the table changes (see getCacheKey)
+       * @param {string} [options.apiKey] - Defaults to PINECONE_API_KEY
+       * @param {string} [options.index] - The index name, described on first use
+       * @param {string} [options.host] - The index host (from the console), instead of or with `index`
+       * @param {string} [options.namespace='rag_documents'] - A namespace this retriever owns
+       * @param {'auto'|'documents'|'vectors'} [options.api='auto'] - Document index (Documents API) or vector index; auto reads it from the index description
+       * @param {string} [options.vectorField] - The document index's dense_vector field (default: the schema's)
+       * @param {string} [options.textField] - The document index's text field that Pinecone embeds (integrated embedding; default: the schema's, when the index has no dense_vector field)
+       * @param {number} [options.freshnessTimeoutMs=30000] - How long a read waits for this retriever's writes to be indexed; 0 to not wait
+       * @param {string} [options.cacheKey] - Cache identity; change it when the index changes
+       * @param {Function} [options.fetch] - fetch implementation (defaults to the global)
        */
       constructor(options = {}) {
         const {
-          pool,
-          connectionString,
-          table = DEFAULT_TABLE,
-          dimensions,
-          createTable = true,
-          index = "hnsw",
-          efSearch,
-          cacheKey
+          apiKey = typeof process !== "undefined" && process.env ? process.env.PINECONE_API_KEY : void 0,
+          host,
+          index,
+          namespace = DEFAULT_NAMESPACE,
+          api = "auto",
+          vectorField,
+          textField,
+          freshnessTimeoutMs = 3e4,
+          cacheKey,
+          fetch: fetchImpl = globalThis.fetch
         } = options;
-        if (!pool && !connectionString) {
+        if (!apiKey) {
           throw new Error(
-            "PgVectorRetriever needs a pg `pool` (or Client) or a `connectionString`"
+            "PineconeRetriever needs an API key: pass apiKey or set PINECONE_API_KEY"
           );
         }
-        if (pool && typeof pool.query !== "function") {
-          throw new Error("PgVectorRetriever: `pool` must have a query() method");
+        if (!host && !index) {
+          throw new Error(
+            "PineconeRetriever needs the index: pass index (its name) or host (the index host)"
+          );
         }
-        if (!["hnsw", "none"].includes(index)) {
+        if (typeof namespace !== "string") {
+          throw new Error("PineconeRetriever: namespace must be a string");
+        }
+        if (!["auto", "documents", "vectors"].includes(api)) {
           throw new Error(
-            `PgVectorRetriever: unknown index "${index}" (use "hnsw" or "none")`
+            'PineconeRetriever: api must be "auto", "documents" or "vectors"'
           );
         }
-        if (dimensions !== void 0 && !(Number.isInteger(dimensions) && dimensions > 0)) {
+        if (vectorField && textField) {
           throw new Error(
-            "PgVectorRetriever: `dimensions` must be a positive integer"
+            "PineconeRetriever: pass vectorField (your vectors) or textField (Pinecone embeds the text), not both"
           );
         }
-        if (efSearch !== void 0 && !(Number.isInteger(efSearch) && efSearch > 0 && efSearch <= 1e3)) {
+        if (textField && api === "vectors") {
           throw new Error(
-            "PgVectorRetriever: `efSearch` must be an integer from 1 to 1000"
+            'PineconeRetriever: textField needs a document index (api "documents" or "auto")'
           );
         }
-        this.efSearch = efSearch;
-        this.table = quoteTable(table);
-        this.tableName = table;
-        this.dimensions = dimensions;
-        this.createTable = createTable;
+        if (typeof fetchImpl !== "function") {
+          throw new Error("PineconeRetriever needs fetch (Node.js 18 or later)");
+        }
         this.index = index;
+        this.namespace = namespace;
+        this.freshnessTimeoutMs = freshnessTimeoutMs;
         this.cacheKey = cacheKey;
-        this._pool = pool || null;
-        this._connectionString = connectionString;
-        this._ownsPool = !pool;
-        this._ready = null;
+        this._apiKey = apiKey;
+        this._host = host ? normalizeHost(host) : null;
+        this._api = api;
+        this._vectorField = vectorField;
+        this._textField = textField;
+        this._fetch = fetchImpl === globalThis.fetch ? fetchImpl.bind(globalThis) : fetchImpl;
+        this._resolving = null;
+        this._writeLsn = 0;
+        this._dimension = null;
       }
-      /** The pg Pool or Client in use; creates the Pool on first use. */
-      _db() {
-        if (!this._pool) {
-          let pg;
-          try {
-            pg = require("pg");
-          } catch {
-            throw new Error(
-              'PgVectorRetriever with a connectionString needs the "pg" package: npm install pg'
-            );
-          }
-          this._pool = new pg.Pool({
-            connectionString: this._connectionString,
-            allowExitOnIdle: true
-          });
-        }
-        return this._pool;
+      /**
+       * Cache identity for createRagPipeline({ cache }): none unless you set
+       * `cacheKey`, since other clients can change the index.
+       * @param {'retriever'} role
+       * @returns {string|null}
+       */
+      getCacheKey(role) {
+        if (role !== "retriever" || !this.cacheKey) return null;
+        return `pinecone|${this._host || this.index}|${this.namespace}|${this.cacheKey}`;
       }
-      async _query(text, params, signal) {
+      /**
+       * Whether the index embeds text itself (integrated embedding): then
+       * store() needs no vectors and retrieve() takes the query text, so no
+       * embedder is needed. The CLI checks this before requiring an embedder.
+       * Reads the index description on first use.
+       * @param {{ signal?: AbortSignal }} [options]
+       * @returns {Promise<boolean>}
+       */
+      async embedsText({ signal } = {}) {
+        await this._resolve(signal);
+        return this._integrated;
+      }
+      /**
+       * One REST call; resolves the parsed body and the response headers.
+       * @private
+       */
+      async _call(url, method, body, signal) {
         throwIfAborted(signal);
+        const headers = {
+          "Api-Key": this._apiKey,
+          "X-Pinecone-Api-Version": API_VERSION,
+          accept: "application/json"
+        };
+        if (body !== void 0) headers["content-type"] = "application/json";
+        let res;
         try {
-          return await raceAbort(this._db().query(text, params), signal);
+          res = await this._fetch(url, {
+            method,
+            headers,
+            ...body !== void 0 && { body: JSON.stringify(body) },
+            ...signal && { signal }
+          });
         } catch (err) {
-          throw explain(err, this.table);
+          throwIfAborted(signal);
+          throw new Error(
+            `PineconeRetriever: cannot reach Pinecone (${err.message})`
+          );
         }
-      }
-      /** Runs one query with `SET LOCAL hnsw.ef_search`, in its own transaction. */
-      async _queryWithEfSearch(text, params, ef, signal) {
-        throwIfAborted(signal);
-        const db = this._db();
-        const pooled = typeof db.connect === "function" && typeof db.end === "function" && db.totalCount !== void 0;
-        const client = pooled ? await db.connect() : db;
+        const text = await res.text();
+        let json;
         try {
-          await client.query("BEGIN");
-          await client.query(`SET LOCAL hnsw.ef_search = ${Math.min(ef, 1e3)}`);
-          const result = await client.query(text, params);
-          await client.query("COMMIT");
-          return result;
-        } catch (err) {
-          await client.query("ROLLBACK").catch(() => {
-          });
-          throw explain(err, this.table);
-        } finally {
-          if (pooled) client.release();
+          json = text ? JSON.parse(text) : {};
+        } catch {
+          json = {};
         }
-      }
-      /** Creates the extension, table and index once, sized to `dimensions`. */
-      _ensureTable(dimensions) {
-        if (!this.createTable) return Promise.resolve();
-        if (!this._ready) {
-          const size = this.dimensions || dimensions;
-          const indexName = `"${this.tableName.split(".").pop()}_embedding_hnsw"`;
-          this._ready = (async () => {
-            await this._query("CREATE EXTENSION IF NOT EXISTS vector");
-            await this._query(
-              `CREATE TABLE IF NOT EXISTS ${this.table} (id text PRIMARY KEY, content text NOT NULL DEFAULT '', metadata jsonb NOT NULL DEFAULT '{}'::jsonb, embedding vector(${size}) NOT NULL)`
+        if (!res.ok) {
+          if (res.status === 401 || res.status === 403) {
+            throw new Error(
+              `PineconeRetriever: Pinecone refused the request (${res.status}); check PINECONE_API_KEY`
             );
-            if (this.index === "hnsw") {
-              await this._query(
-                `CREATE INDEX IF NOT EXISTS ${indexName} ON ${this.table} USING hnsw (embedding vector_cosine_ops)`
-              );
-            }
-          })().catch((err) => {
-            this._ready = null;
-            throw err;
-          });
+          }
+          const detail = json.message || json.error && json.error.message || text || res.statusText;
+          const err = new Error(
+            `PineconeRetriever: ${method} ${new URL(url).pathname} failed (${res.status}): ${detail}`
+          );
+          err.status = res.status;
+          throw err;
         }
-        return this._ready;
+        return { json, headers: res.headers };
       }
-      /**
-       * Cache identity for createRagPipeline({ cache }). Other processes can
-       * write to the table without this one knowing, so there is none unless
-       * you set `cacheKey`: then cached retrieval results are reused until you
-       * change the key or their time to live ends.
-       * @param {'retriever'} role
-       * @returns {string|null}
-       */
-      getCacheKey(role) {
-        if (role !== "retriever" || !this.cacheKey) return null;
-        return `pgvector|${this.tableName}|${this.cacheKey}`;
+      /** True on a document index that embeds text itself. @private */
+      get _integrated() {
+        return this._api === "documents" && Boolean(this._textField);
       }
       /**
-       * Inserts or replaces documents, in one transaction: a failed batch
-       * changes nothing.
-       * @param {Array<{ id: string, vector: number[], content?: string, metadata?: Object }>} docs
-       * @returns {Promise<void>}
+       * The index's host and kind, from its description (once): a document
+       * index's dense_vector field and dimension or the text field it embeds,
+       * or a vector index's dimension.
+       * @private
        */
-      async store(docs) {
-        if (!Array.isArray(docs))
-          throw new Error("PgVectorRetriever.store() takes an array");
-        if (docs.length === 0) return;
-        let dimensions = null;
-        const rows = docs.map((doc) => {
-          const id = doc && doc.id;
-          if (typeof id !== "string" || id.length === 0) {
+      _resolve(signal) {
+        if (this._host && this._textField) {
+          this._api = "documents";
+          return Promise.resolve();
+        }
+        if (this._host && this._api !== "auto" && (this._api === "vectors" || this._vectorField)) {
+          return Promise.resolve();
+        }
+        if (!this._resolving) {
+          this._resolving = this._describe(signal).catch((err) => {
+            this._resolving = null;
+            throw err;
+          });
+        }
+        return this._resolving;
+      }
+      /** @private */
+      async _describe(signal) {
+        let info;
+        if (this.index) {
+          ({ json: info } = await this._call(
+            `${CONTROL_PLANE}/indexes/${encodeURIComponent(this.index)}`,
+            "GET",
+            void 0,
+            signal
+          ));
+        } else {
+          const { json } = await this._call(
+            `${CONTROL_PLANE}/indexes`,
+            "GET",
+            void 0,
+            signal
+          );
+          const host = this._host.replace(/^https?:\/\//, "");
+          info = (json.indexes || []).find((i) => i.host === host);
+          if (!info) {
             throw new Error(
-              "PgVectorRetriever.store(): every document needs a string id"
+              `PineconeRetriever: no index with host ${host} in this project; check the host, or pass index (its name)`
             );
           }
-          const literal = vectorLiteral(doc.vector, id);
-          if (dimensions === null) dimensions = doc.vector.length;
-          else if (doc.vector.length !== dimensions) {
+        }
+        if (!info.host) {
+          throw new Error(
+            `PineconeRetriever: index "${info.name || this.index}" has no host yet (is it ready?)`
+          );
+        }
+        this._host = this._host || normalizeHost(info.host);
+        const fields = info.schema && info.schema.fields || null;
+        const named = fields ? Object.entries(fields).filter(([name]) => !name.startsWith("_")) : [];
+        const denseFields = named.filter(([, f]) => f && f.type === "dense_vector");
+        const textFields = named.filter(
+          ([, f]) => f && f.type === "string" && f.embed
+        );
+        if (this._api === "auto") {
+          this._api = named.length > 0 ? "documents" : "vectors";
+        }
+        if (this._textField) {
+          if (this._api !== "documents" || !textFields.some(([name]) => name === this._textField)) {
             throw new Error(
-              `PgVectorRetriever.store(): document "${id}" has ${doc.vector.length} dimensions, the batch has ${dimensions}`
+              `PineconeRetriever: index "${info.name}" has no text field named "${this._textField}" that it embeds`
+            );
+          }
+        } else if (this._api === "documents") {
+          const field = this._vectorField ? denseFields.find(([name]) => name === this._vectorField) : denseFields[0];
+          if (!field && !this._vectorField && textFields.length > 0) {
+            this._textField = textFields[0][0];
+            return;
+          }
+          if (!field) {
+            throw new Error(
+              `PineconeRetriever: index "${info.name}" has no dense_vector field${this._vectorField ? ` named "${this._vectorField}"` : ""}`
+            );
+          }
+          this._vectorField = field[0];
+          this._indexDimension = field[1].dimension;
+        } else {
+          const values = fields && fields._values;
+          this._indexDimension = info.dimension || values && values.dimension;
+        }
+      }
+      /** A data-plane call; records the log sequence number of writes. @private */
+      async _data(method, path, body, { signal, write = false } = {}) {
+        await this._resolve(signal);
+        const result = await this._call(
+          `${this._host}${path}`,
+          method,
+          body,
+          signal
+        );
+        if (write) {
+          const lsn = Number(result.headers.get("x-pinecone-request-lsn"));
+          if (Number.isFinite(lsn) && lsn > this._writeLsn) this._writeLsn = lsn;
+        }
+        return result;
+      }
+      /** The Documents API path for this namespace. @private */
+      _docs(action) {
+        const ns = encodeURIComponent(this.namespace || "__default__");
+        return `/namespaces/${ns}/documents/${action}`;
+      }
+      /**
+       * A search, repeated until it reflects this retriever's writes (when the
+       * index reports log sequence numbers) or `freshnessTimeoutMs` passes.
+       * `query` is a vector, or the query text on an index that embeds text
+       * itself. Resolves `[{ id, score, fields }]`.
+       * @private
+       */
+      async _search(query, topK, signal, filter) {
+        await this._resolve(signal);
+        const documents = this._api === "documents";
+        const [path, body] = documents ? [
+          this._docs("search"),
+          {
+            score_by: [
+              this._integrated ? { type: "embed", fields: [this._textField], query } : {
+                type: "dense_vector",
+                fields: [this._vectorField],
+                values: query
+              }
+            ],
+            top_k: topK,
+            include_fields: FIELDS,
+            ...filter && { filter }
+          }
+        ] : [
+          "/query",
+          {
+            vector: query,
+            topK,
+            namespace: this.namespace,
+            includeMetadata: true,
+            ...filter && { filter }
+          }
+        ];
+        const deadline = Date.now() + this.freshnessTimeoutMs;
+        for (let delay = 100; ; delay = Math.min(delay * 2, 2e3)) {
+          let json;
+          let headers;
+          try {
+            ({ json, headers } = await this._data("POST", path, body, { signal }));
+          } catch (err) {
+            if (err.status === 404) return [];
+            throw err;
+          }
+          const header = headers.get("x-pinecone-max-indexed-lsn");
+          const fresh = !this._writeLsn || header === null || !(Number(header) < this._writeLsn) || Date.now() + delay > deadline;
+          if (fresh) {
+            return (json.matches || []).map(
+              (m) => documents ? { id: m._id, score: m._score, fields: m } : { id: m.id, score: m.score, fields: m.metadata }
+            );
+          }
+          await sleep(delay);
+          throwIfAborted(signal);
+        }
+      }
+      /** Waits until this retriever's writes are indexed (for list and size). @private */
+      async _waitForWrites(signal) {
+        if (!this._writeLsn) return;
+        const probe = this._probe();
+        if (probe) await this._search(probe, 1, signal);
+      }
+      /**
+       * What list() and size() search with: a unit vector of the index's
+       * dimension, or a fixed text on an index that embeds text itself.
+       * @private
+       */
+      _probe() {
+        if (this._integrated) return PROBE_QUERY;
+        const dimension = this._indexDimension || this._dimension;
+        if (!dimension) return null;
+        return new Array(dimension).fill(0).map((_, i) => i === 0 ? 1 : 0);
+      }
+      /**
+       * Inserts or replaces documents. On an index that embeds text itself,
+       * Pinecone embeds `content` (required there) and `vector` is ignored.
+       * @param {Array<{ id: string, vector?: number[], content?: string, metadata?: Object }>} docs
+       *   `vector` is required unless the index embeds text itself
+       * @returns {Promise<void>}
+       */
+      async store(docs) {
+        if (!Array.isArray(docs)) {
+          throw new Error("PineconeRetriever.store() takes an array");
+        }
+        if (docs.length === 0) return;
+        await this._resolve();
+        if (this._integrated) return this._storeText(docs);
+        const expected = this._indexDimension || this._dimension;
+        let dimensions = null;
+        const records = docs.map((doc) => {
+          const id = doc && doc.id;
+          if (typeof id !== "string" || id.length === 0) {
+            throw new Error(
+              "PineconeRetriever.store(): every document needs a string id"
+            );
+          }
+          checkVector(doc.vector, id);
+          if (dimensions === null) dimensions = doc.vector.length;
+          else if (doc.vector.length !== dimensions) {
+            throw new Error(
+              `PineconeRetriever.store(): document "${id}" has ${doc.vector.length} dimensions, the batch has ${dimensions}`
+            );
+          }
+          if (expected && doc.vector.length !== expected) {
+            throw new Error(
+              `PineconeRetriever.store(): document "${id}" has ${doc.vector.length} dimensions, the index has ${expected}`
+            );
+          }
+          const metadata = doc.metadata || {};
+          return {
+            id: recordId(id),
+            values: doc.vector,
+            fields: {
+              rag_id: id,
+              rag_content: doc.content || "",
+              rag_metadata: JSON.stringify(metadata),
+              ...metadata.source !== void 0 && metadata.source !== null && {
+                rag_source: String(metadata.source)
+              }
+            }
+          };
+        });
+        for (let i = 0; i < records.length; i += UPSERT_BATCH) {
+          const batch = records.slice(i, i + UPSERT_BATCH);
+          if (this._api === "documents") {
+            await this._data(
+              "POST",
+              this._docs("upsert"),
+              {
+                documents: batch.map((r) => ({
+                  _id: r.id,
+                  [this._vectorField]: r.values,
+                  ...r.fields
+                }))
+              },
+              { write: true }
+            );
+          } else {
+            await this._data(
+              "POST",
+              "/vectors/upsert",
+              {
+                vectors: batch.map((r) => ({
+                  id: r.id,
+                  values: r.values,
+                  metadata: r.fields
+                })),
+                namespace: this.namespace
+              },
+              { write: true }
+            );
+          }
+        }
+        this._dimension = dimensions;
+      }
+      /** store() on an index that embeds text itself. @private */
+      async _storeText(docs) {
+        const records = docs.map((doc) => {
+          const id = doc && doc.id;
+          if (typeof id !== "string" || id.length === 0) {
+            throw new Error(
+              "PineconeRetriever.store(): every document needs a string id"
+            );
+          }
+          if (typeof doc.content !== "string" || doc.content.trim() === "") {
+            throw new Error(
+              `PineconeRetriever.store(): document "${id}" has no content for Pinecone to embed (the index embeds ${this._textField})`
+            );
+          }
+          const metadata = doc.metadata || {};
+          return {
+            _id: recordId(id),
+            [this._textField]: doc.content,
+            rag_id: id,
+            rag_content: doc.content,
+            rag_metadata: JSON.stringify(metadata),
+            ...metadata.source !== void 0 && metadata.source !== null && {
+              rag_source: String(metadata.source)
+            }
+          };
+        });
+        const encoder = new TextEncoder();
+        let batch = [];
+        let bytes = 0;
+        const send = async () => {
+          if (batch.length === 0) return;
+          await this._data(
+            "POST",
+            this._docs("upsert"),
+            { documents: batch },
+            { write: true }
+          );
+          batch = [];
+          bytes = 0;
+        };
+        for (const record of records) {
+          const size = encoder.encode(JSON.stringify(record)).length + 1;
+          if (batch.length === EMBED_UPSERT_BATCH || batch.length > 0 && bytes + size > REQUEST_BYTES) {
+            await send();
+          }
+          batch.push(record);
+          bytes += size;
+        }
+        await send();
+      }
+      /**
+       * The documents most similar to a query vector, or to the query text on
+       * an index that embeds text itself (Pinecone embeds the query; a
+       * `queryVector` is then ignored).
+       * @param {number[]|string|{ query?: string, queryVector?: number[], topK?: number, signal?: AbortSignal }} request
+       *   A vector, the query text, or an object with them: `queryVector`, or
+       *   `query` on an index that embeds text itself (required; optional in
+       *   the type to match the retriever contract)
+       * @param {number} [k=10] - Results when `request` is a vector or text
+       * @returns {Promise<Array<{ id: string, score: number, content: string, metadata: Object }>>}
+       */
+      async retrieve(request, k = 10) {
+        let input = request || {};
+        if (Array.isArray(request)) input = { queryVector: request };
+        else if (typeof request === "string") input = { query: request };
+        const { query, queryVector, topK = k, signal } = input;
+        if (!Number.isInteger(topK) || topK < 1) {
+          throw new Error(
+            "PineconeRetriever.retrieve(): topK must be a positive integer"
+          );
+        }
+        throwIfAborted(signal);
+        await this._resolve(signal);
+        if (!this._integrated) {
+          if (queryVector === void 0 || queryVector === null) {
+            throw new Error(
+              "PineconeRetriever.retrieve(): needs a queryVector; this index does not embed text itself, so use an embedder"
+            );
+          }
+          checkVector(queryVector, "query");
+        } else if (typeof query !== "string" || query.trim() === "") {
+          throw new Error(
+            `PineconeRetriever.retrieve(): the index embeds text itself (integrated embedding, field ${this._textField}), so it needs the query text: pass { query }`
+          );
+        }
+        const matches = await this._search(
+          this._integrated ? query : queryVector,
+          Math.min(topK, 1e4),
+          signal
+        );
+        throwIfAborted(signal);
+        const seen = /* @__PURE__ */ new Set();
+        const out = [];
+        for (const m of matches) {
+          if (seen.has(m.id)) continue;
+          seen.add(m.id);
+          out.push({ ...fromFields(m.fields, m.id), score: m.score });
+        }
+        return out;
+      }
+      /** @private */
+      async _delete(body) {
+        await this._resolve();
+        try {
+          if (this._api === "documents") {
+            await this._data("POST", this._docs("delete"), body.documents, {
+              write: true
+            });
+          } else {
+            await this._data(
+              "POST",
+              "/vectors/delete",
+              { namespace: this.namespace, ...body.vectors },
+              { write: true }
+            );
+          }
+        } catch (err) {
+          if (err.status !== 404) throw err;
+        }
+      }
+      /**
+       * Deletes the chunks of one source (`metadata.source`), for re-ingesting.
+       * @param {string} source
+       */
+      async removeBySource(source) {
+        const filter = { rag_source: { $eq: String(source) } };
+        await this._delete({ documents: { filter }, vectors: { filter } });
+      }
+      /**
+       * Deletes documents by id.
+       * @param {string[]} ids
+       */
+      async delete(ids) {
+        const recordIds = ids.map(recordId);
+        for (let i = 0; i < recordIds.length; i += DELETE_BATCH) {
+          const batch = recordIds.slice(i, i + DELETE_BATCH);
+          await this._delete({
+            documents: { ids: batch },
+            vectors: { ids: batch }
+          });
+        }
+      }
+      /** Deletes every document this retriever stored in its namespace. */
+      async clear() {
+        await this._delete({
+          documents: { filter: OURS },
+          vectors: { deleteAll: true }
+        });
+      }
+      /**
+       * Every document, without vectors.
+       * @param {{ limit?: number }} [options]
+       * @returns {Promise<Array<{ id: string, content: string, metadata: Object }>>}
+       */
+      async list({ limit } = {}) {
+        await this._resolve();
+        await this._waitForWrites();
+        return this._api === "documents" ? this._listDocuments(limit) : this._listVectors(limit);
+      }
+      /** @returns {Promise<number>} The documents this retriever stored */
+      async size() {
+        return (await this.list()).length;
+      }
+      /** Documents API: fetch by filter, page by page. @private */
+      async _listDocuments(limit) {
+        const probe = this._probe();
+        if (probe) {
+          const max = Math.min(limit || SEARCH_MAX, SEARCH_MAX);
+          const found = await this._search(probe, max, void 0, OURS);
+          if (found.length < SEARCH_MAX || limit) {
+            const seen = /* @__PURE__ */ new Set();
+            return found.filter((m) => !seen.has(m.id) && seen.add(m.id)).map((m) => fromFields(m.fields, m.id));
+          }
+        }
+        const out = [];
+        let token;
+        do {
+          let json;
+          try {
+            ({ json } = await this._data("POST", this._docs("fetch"), {
+              filter: OURS,
+              include_fields: FIELDS,
+              limit: limit ? Math.min(PAGE, limit - out.length) : PAGE,
+              ...token && { pagination_token: token }
+            }));
+          } catch (err) {
+            if (err.status === 404) break;
+            throw err;
+          }
+          for (const [id, fields] of Object.entries(json.documents || {})) {
+            out.push(fromFields(fields, id));
+          }
+          token = json.pagination && json.pagination.next;
+        } while (token && (!limit || out.length < limit));
+        return limit ? out.slice(0, limit) : out;
+      }
+      /** Vectors API: list ids, then fetch them. @private */
+      async _listVectors(limit) {
+        const ids = [];
+        let token;
+        do {
+          const params = new URLSearchParams({
+            namespace: this.namespace,
+            limit: String(PAGE)
+          });
+          if (token) params.set("paginationToken", token);
+          let json;
+          try {
+            ({ json } = await this._data("GET", `/vectors/list?${params}`));
+          } catch (err) {
+            if (err.status === 404) break;
+            throw err;
+          }
+          for (const v of json.vectors || []) ids.push(v.id);
+          token = json.pagination && json.pagination.next;
+        } while (token && (!limit || ids.length < limit));
+        const wanted = limit ? ids.slice(0, limit) : ids;
+        const out = [];
+        for (let i = 0; i < wanted.length; i += PAGE) {
+          const params = new URLSearchParams({ namespace: this.namespace });
+          for (const id of wanted.slice(i, i + PAGE)) params.append("ids", id);
+          const { json } = await this._data("GET", `/vectors/fetch?${params}`);
+          for (const id of wanted.slice(i, i + PAGE)) {
+            const record = json.vectors && json.vectors[id];
+            if (record) out.push(fromFields(record.metadata, id));
+          }
+        }
+        return out;
+      }
+    };
+    module2.exports = { PineconeRetriever, recordId, API_VERSION };
+  }
+});
+
+// src/retrieval/pgvector-retriever.js
+var require_pgvector_retriever = __commonJS({
+  "src/retrieval/pgvector-retriever.js"(exports2, module2) {
+    "use strict";
+    var { throwIfAborted, raceAbort } = require_connector_utils();
+    var IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]{0,62}$/;
+    var DEFAULT_TABLE = "rag_documents";
+    var PG_DEFAULT_EF_SEARCH = 40;
+    var MAX_BATCH = 1e3;
+    function quoteTable(name) {
+      const parts = String(name).split(".");
+      if (parts.length > 2 || !parts.every((p) => IDENTIFIER.test(p))) {
+        throw new Error(
+          `PgVectorRetriever: invalid table name "${name}" (letters, digits and underscores; optionally schema.table)`
+        );
+      }
+      return parts.map((p) => `"${p}"`).join(".");
+    }
+    function vectorLiteral(vector, id) {
+      if (!Array.isArray(vector) || vector.length === 0) {
+        throw new Error(`PgVectorRetriever: document "${id}" has no vector`);
+      }
+      for (const x of vector) {
+        if (typeof x !== "number" || !Number.isFinite(x)) {
+          throw new Error(
+            `PgVectorRetriever: document "${id}" has a vector with a non-finite value`
+          );
+        }
+      }
+      return `[${vector.join(",")}]`;
+    }
+    function explain(err, table) {
+      const code = err && err.code;
+      if (code === "42P01") {
+        return new Error(
+          `PgVectorRetriever: table ${table} does not exist. Store documents first (rag-pipeline ingest), or create it.`
+        );
+      }
+      if (code === "42501" || /permission denied/i.test(String(err && err.message))) {
+        return new Error(
+          `PgVectorRetriever: permission denied. Run \`CREATE EXTENSION IF NOT EXISTS vector;\` as a database owner, and grant this user access to ${table}. (${err.message})`
+        );
+      }
+      if (/different vector dimensions|expected \d+ dimensions/i.test(
+        String(err && err.message)
+      )) {
+        return new Error(
+          `PgVectorRetriever: ${err.message}. The table holds vectors from another embedder; use the same embedder or a new table.`
+        );
+      }
+      return err;
+    }
+    var PgVectorRetriever = class {
+      /**
+       * @param {Object} options
+       * @param {{ query: Function, connect?: Function }} [options.pool] - A pg Pool or Client you manage
+       * @param {string} [options.connectionString] - Used to create a Pool when no `pool` is given
+       * @param {string} [options.table='rag_documents'] - Table name, optionally `schema.table`
+       * @param {number} [options.dimensions] - Vector size for a new table; defaults to the first stored vector's
+       * @param {boolean} [options.createTable=true] - Create the extension, table and index on first store
+       * @param {'hnsw'|'none'} [options.index='hnsw'] - Index created with the table
+       * @param {number} [options.efSearch] - HNSW candidate list size per query (pgvector's default is 40). Higher finds more of the true nearest neighbours, more slowly; a query always uses at least its topK
+       * @param {string} [options.cacheKey] - Cache identity; change it when the table changes (see getCacheKey)
+       */
+      constructor(options = {}) {
+        const {
+          pool,
+          connectionString,
+          table = DEFAULT_TABLE,
+          dimensions,
+          createTable = true,
+          index = "hnsw",
+          efSearch,
+          cacheKey
+        } = options;
+        if (!pool && !connectionString) {
+          throw new Error(
+            "PgVectorRetriever needs a pg `pool` (or Client) or a `connectionString`"
+          );
+        }
+        if (pool && typeof pool.query !== "function") {
+          throw new Error("PgVectorRetriever: `pool` must have a query() method");
+        }
+        if (!["hnsw", "none"].includes(index)) {
+          throw new Error(
+            `PgVectorRetriever: unknown index "${index}" (use "hnsw" or "none")`
+          );
+        }
+        if (dimensions !== void 0 && !(Number.isInteger(dimensions) && dimensions > 0)) {
+          throw new Error(
+            "PgVectorRetriever: `dimensions` must be a positive integer"
+          );
+        }
+        if (efSearch !== void 0 && !(Number.isInteger(efSearch) && efSearch > 0 && efSearch <= 1e3)) {
+          throw new Error(
+            "PgVectorRetriever: `efSearch` must be an integer from 1 to 1000"
+          );
+        }
+        this.efSearch = efSearch;
+        this.table = quoteTable(table);
+        this.tableName = table;
+        this.dimensions = dimensions;
+        this.createTable = createTable;
+        this.index = index;
+        this.cacheKey = cacheKey;
+        this._pool = pool || null;
+        this._connectionString = connectionString;
+        this._ownsPool = !pool;
+        this._ready = null;
+      }
+      /** The pg Pool or Client in use; creates the Pool on first use. */
+      _db() {
+        if (!this._pool) {
+          let pg;
+          try {
+            pg = require("pg");
+          } catch {
+            throw new Error(
+              'PgVectorRetriever with a connectionString needs the "pg" package: npm install pg'
+            );
+          }
+          this._pool = new pg.Pool({
+            connectionString: this._connectionString,
+            allowExitOnIdle: true
+          });
+        }
+        return this._pool;
+      }
+      async _query(text, params, signal) {
+        throwIfAborted(signal);
+        try {
+          return await raceAbort(this._db().query(text, params), signal);
+        } catch (err) {
+          throw explain(err, this.table);
+        }
+      }
+      /** Runs one query with `SET LOCAL hnsw.ef_search`, in its own transaction. */
+      async _queryWithEfSearch(text, params, ef, signal) {
+        throwIfAborted(signal);
+        const db = this._db();
+        const pooled = typeof db.connect === "function" && typeof db.end === "function" && db.totalCount !== void 0;
+        const client = pooled ? await db.connect() : db;
+        try {
+          await client.query("BEGIN");
+          await client.query(`SET LOCAL hnsw.ef_search = ${Math.min(ef, 1e3)}`);
+          const result = await client.query(text, params);
+          await client.query("COMMIT");
+          return result;
+        } catch (err) {
+          await client.query("ROLLBACK").catch(() => {
+          });
+          throw explain(err, this.table);
+        } finally {
+          if (pooled) client.release();
+        }
+      }
+      /** Creates the extension, table and index once, sized to `dimensions`. */
+      _ensureTable(dimensions) {
+        if (!this.createTable) return Promise.resolve();
+        if (!this._ready) {
+          const size = this.dimensions || dimensions;
+          const indexName = `"${this.tableName.split(".").pop()}_embedding_hnsw"`;
+          this._ready = (async () => {
+            await this._query("CREATE EXTENSION IF NOT EXISTS vector");
+            await this._query(
+              `CREATE TABLE IF NOT EXISTS ${this.table} (id text PRIMARY KEY, content text NOT NULL DEFAULT '', metadata jsonb NOT NULL DEFAULT '{}'::jsonb, embedding vector(${size}) NOT NULL)`
+            );
+            if (this.index === "hnsw") {
+              await this._query(
+                `CREATE INDEX IF NOT EXISTS ${indexName} ON ${this.table} USING hnsw (embedding vector_cosine_ops)`
+              );
+            }
+          })().catch((err) => {
+            this._ready = null;
+            throw err;
+          });
+        }
+        return this._ready;
+      }
+      /**
+       * Cache identity for createRagPipeline({ cache }). Other processes can
+       * write to the table without this one knowing, so there is none unless
+       * you set `cacheKey`: then cached retrieval results are reused until you
+       * change the key or their time to live ends.
+       * @param {'retriever'} role
+       * @returns {string|null}
+       */
+      getCacheKey(role) {
+        if (role !== "retriever" || !this.cacheKey) return null;
+        return `pgvector|${this.tableName}|${this.cacheKey}`;
+      }
+      /**
+       * Inserts or replaces documents, in one transaction: a failed batch
+       * changes nothing.
+       * @param {Array<{ id: string, vector: number[], content?: string, metadata?: Object }>} docs
+       * @returns {Promise<void>}
+       */
+      async store(docs) {
+        if (!Array.isArray(docs))
+          throw new Error("PgVectorRetriever.store() takes an array");
+        if (docs.length === 0) return;
+        let dimensions = null;
+        const rows = docs.map((doc) => {
+          const id = doc && doc.id;
+          if (typeof id !== "string" || id.length === 0) {
+            throw new Error(
+              "PgVectorRetriever.store(): every document needs a string id"
+            );
+          }
+          const literal = vectorLiteral(doc.vector, id);
+          if (dimensions === null) dimensions = doc.vector.length;
+          else if (doc.vector.length !== dimensions) {
+            throw new Error(
+              `PgVectorRetriever.store(): document "${id}" has ${doc.vector.length} dimensions, the batch has ${dimensions}`
             );
           }
           return [
@@ -1961,6 +2680,453 @@ var require_pgvector_retriever = __commonJS({
   }
 });
 
+// src/retrieval/weaviate-retriever.js
+var require_weaviate_retriever = __commonJS({
+  "src/retrieval/weaviate-retriever.js"(exports2, module2) {
+    "use strict";
+    var { throwIfAborted } = require_connector_utils();
+    var { pointId } = require_qdrant_retriever();
+    var COLLECTION = /^[A-Za-z][A-Za-z0-9_]{0,254}$/;
+    var DEFAULT_COLLECTION = "RagDocuments";
+    var PAGE = 256;
+    var UPSERT_BATCH = 256;
+    var DELETE_BATCH = 256;
+    var PROPERTIES = [
+      {
+        name: "rag_id",
+        dataType: ["text"],
+        tokenization: "field",
+        indexFilterable: true,
+        indexSearchable: false
+      },
+      { name: "content", dataType: ["text"], indexFilterable: false },
+      {
+        name: "rag_source",
+        dataType: ["text"],
+        tokenization: "field",
+        indexFilterable: true,
+        indexSearchable: false
+      },
+      {
+        name: "rag_metadata",
+        dataType: ["text"],
+        indexFilterable: false,
+        indexSearchable: false
+      }
+    ];
+    var OURS = { path: ["rag_id"], operator: "Like", valueText: "*" };
+    var OURS_GRAPHQL = '{ path: ["rag_id"], operator: Like, valueText: "*" }';
+    function checkVector(vector, id) {
+      if (!Array.isArray(vector) || vector.length === 0) {
+        throw new Error(`WeaviateRetriever: document "${id}" has no vector`);
+      }
+      if (!vector.every((x) => typeof x === "number" && Number.isFinite(x))) {
+        throw new Error(
+          `WeaviateRetriever: document "${id}" has a vector with a non-finite value`
+        );
+      }
+    }
+    function trimSlashes(url) {
+      let end = url.length;
+      while (end > 0 && url[end - 1] === "/") end--;
+      return url.slice(0, end);
+    }
+    function parseMetadata(text) {
+      if (!text) return {};
+      try {
+        const value = JSON.parse(text);
+        return value && typeof value === "object" ? value : {};
+      } catch {
+        return {};
+      }
+    }
+    function errorDetail(json) {
+      const list = json && (json.error || json.errors) || [];
+      if (Array.isArray(list) && list.length) {
+        return list.map((e) => e && e.message || String(e)).join("; ");
+      }
+      return json && json.message || "";
+    }
+    var WeaviateRetriever = class {
+      /**
+       * @param {Object} [options]
+       * @param {string} [options.url='http://localhost:8080'] - Weaviate's REST endpoint (without /v1)
+       * @param {string} [options.apiKey] - Sent as `Authorization: Bearer <key>`
+       * @param {string} [options.collection='RagDocuments'] - Class name; the first letter is upper-cased, as Weaviate does
+       * @param {number} [options.dimensions] - Expected vector size; defaults to the collection's or the first stored vector's
+       * @param {boolean} [options.createCollection=true] - Create the collection (and any missing properties) on first store
+       * @param {string} [options.cacheKey] - Cache identity; change it when the collection changes
+       * @param {Function} [options.fetch] - fetch implementation (defaults to the global)
+       */
+      constructor(options = {}) {
+        const {
+          url = "http://localhost:8080",
+          apiKey,
+          collection = DEFAULT_COLLECTION,
+          dimensions,
+          createCollection = true,
+          cacheKey,
+          fetch: fetchImpl = globalThis.fetch
+        } = options;
+        if (typeof collection !== "string" || !COLLECTION.test(collection)) {
+          throw new Error(
+            `WeaviateRetriever: invalid collection name "${collection}" (a letter, then letters, digits and "_")`
+          );
+        }
+        if (dimensions !== void 0 && !(Number.isInteger(dimensions) && dimensions > 0)) {
+          throw new Error(
+            "WeaviateRetriever: `dimensions` must be a positive integer"
+          );
+        }
+        if (typeof fetchImpl !== "function") {
+          throw new Error("WeaviateRetriever needs fetch (Node.js 18 or later)");
+        }
+        this.url = trimSlashes(String(url));
+        this.collection = collection[0].toUpperCase() + collection.slice(1);
+        this.dimensions = dimensions;
+        this.createCollection = createCollection;
+        this.cacheKey = cacheKey;
+        this._apiKey = apiKey;
+        this._fetch = fetchImpl === globalThis.fetch ? fetchImpl.bind(globalThis) : fetchImpl;
+        this._ready = null;
+        this._exists = false;
+      }
+      /**
+       * Cache identity for createRagPipeline({ cache }): none unless you set
+       * `cacheKey`, since other clients can change the collection.
+       * @param {'retriever'} role
+       * @returns {string|null}
+       */
+      getCacheKey(role) {
+        if (role !== "retriever" || !this.cacheKey) return null;
+        return `weaviate|${this.url}|${this.collection}|${this.cacheKey}`;
+      }
+      /** The message without the API key, should a server ever echo it. */
+      _redact(message) {
+        const text = String(message);
+        return this._apiKey ? text.split(this._apiKey).join("***") : text;
+      }
+      /**
+       * One REST call; resolves the parsed body.
+       * @private
+       * @param {string} method
+       * @param {string} path - After /v1
+       * @param {Object} [body]
+       * @param {{ signal?: AbortSignal, allow404?: boolean }} [options] - allow404 resolves null on 404
+       * @returns {Promise<any>}
+       */
+      async _request(method, path, body, { signal, allow404 = false } = {}) {
+        throwIfAborted(signal);
+        const headers = { "content-type": "application/json" };
+        if (this._apiKey) headers.authorization = `Bearer ${this._apiKey}`;
+        let res;
+        try {
+          res = await this._fetch(`${this.url}/v1${path}`, {
+            method,
+            headers,
+            ...body !== void 0 && { body: JSON.stringify(body) },
+            ...signal && { signal }
+          });
+        } catch (err) {
+          throwIfAborted(signal);
+          throw new Error(
+            this._redact(
+              `WeaviateRetriever: cannot reach Weaviate at ${this.url} (${err.message})`
+            )
+          );
+        }
+        if (res.status === 404 && allow404) return null;
+        const text = await res.text();
+        let json;
+        try {
+          json = text ? JSON.parse(text) : {};
+        } catch {
+          json = {};
+        }
+        if (!res.ok) {
+          if (res.status === 401 || res.status === 403) {
+            throw new Error(
+              `WeaviateRetriever: Weaviate refused the request (${res.status}); check WEAVIATE_API_KEY`
+            );
+          }
+          const detail = errorDetail(json) || text || res.statusText;
+          const where = path.split("?")[0];
+          throw new Error(
+            this._redact(
+              `WeaviateRetriever: ${method} ${where} failed (${res.status}): ${detail}`
+            )
+          );
+        }
+        return json;
+      }
+      /** A GraphQL query; resolves `data`, throws on GraphQL errors. */
+      async _graphql(query, signal) {
+        const json = await this._request("POST", "/graphql", { query }, { signal });
+        if (json.errors && json.errors.length) {
+          throw new Error(
+            this._redact(
+              `WeaviateRetriever: GraphQL query failed: ${errorDetail(json)}`
+            )
+          );
+        }
+        return json.data || {};
+      }
+      /** The collection's schema, or null when it doesn't exist. */
+      _schema(signal) {
+        return this._request("GET", `/schema/${this.collection}`, void 0, {
+          signal,
+          allow404: true
+        });
+      }
+      /** Whether the collection exists; only a yes is remembered. */
+      async _collectionExists(signal) {
+        if (!this._exists) this._exists = Boolean(await this._schema(signal));
+        return this._exists;
+      }
+      _ensureCollection() {
+        if (!this._ready) {
+          this._ready = (async () => {
+            if (this.createCollection) {
+              const schema = await this._schema();
+              if (!schema) {
+                try {
+                  await this._request("POST", "/schema", {
+                    class: this.collection,
+                    vectorizer: "none",
+                    vectorIndexType: "hnsw",
+                    vectorIndexConfig: { distance: "cosine" },
+                    properties: PROPERTIES
+                  });
+                } catch (err) {
+                  if (!/already exists/i.test(err.message)) throw err;
+                }
+              } else {
+                const have = new Set((schema.properties || []).map((p) => p.name));
+                for (const property of PROPERTIES) {
+                  if (!have.has(property.name)) {
+                    await this._request(
+                      "POST",
+                      `/schema/${this.collection}/properties`,
+                      property
+                    );
+                  }
+                }
+              }
+              this._exists = true;
+            }
+            if (!this.dimensions) {
+              const page = await this._request(
+                "GET",
+                `/objects?class=${this.collection}&limit=1&include=vector`,
+                void 0,
+                { allow404: true }
+              );
+              const vector = page && page.objects && page.objects[0] && page.objects[0].vector;
+              if (Array.isArray(vector) && vector.length) {
+                this.dimensions = vector.length;
+              }
+            }
+          })().catch((err) => {
+            this._ready = null;
+            throw err;
+          });
+        }
+        return this._ready;
+      }
+      /**
+       * Inserts or replaces documents.
+       * @param {Array<{ id: string, vector: number[], content?: string, metadata?: Object }>} docs
+       * @returns {Promise<void>}
+       */
+      async store(docs) {
+        if (!Array.isArray(docs))
+          throw new Error("WeaviateRetriever.store() takes an array");
+        if (docs.length === 0) return;
+        let dimensions = null;
+        const objects = docs.map((doc) => {
+          const id = doc && doc.id;
+          if (typeof id !== "string" || id.length === 0) {
+            throw new Error(
+              "WeaviateRetriever.store(): every document needs a string id"
+            );
+          }
+          checkVector(doc.vector, id);
+          if (dimensions === null) dimensions = doc.vector.length;
+          else if (doc.vector.length !== dimensions) {
+            throw new Error(
+              `WeaviateRetriever.store(): document "${id}" has ${doc.vector.length} dimensions, the batch has ${dimensions}`
+            );
+          }
+          const metadata = doc.metadata || {};
+          const properties = {
+            rag_id: id,
+            content: doc.content || "",
+            rag_metadata: JSON.stringify(metadata)
+          };
+          if (metadata.source !== void 0 && metadata.source !== null) {
+            properties.rag_source = String(metadata.source);
+          }
+          return {
+            class: this.collection,
+            id: pointId(id),
+            vector: doc.vector,
+            properties
+          };
+        });
+        await this._ensureCollection();
+        if (this.dimensions && dimensions !== this.dimensions) {
+          throw new Error(
+            `WeaviateRetriever.store(): the documents have ${dimensions} dimensions, the collection has ${this.dimensions}`
+          );
+        }
+        for (let i = 0; i < objects.length; i += UPSERT_BATCH) {
+          const batch = objects.slice(i, i + UPSERT_BATCH);
+          const results = await this._request("POST", "/batch/objects", {
+            objects: batch
+          });
+          for (const [j, item] of (Array.isArray(results) ? results : []).entries()) {
+            const detail = item && item.result && errorDetail(item.result.errors);
+            if (!detail) continue;
+            const id = batch[j] ? batch[j].properties.rag_id : "?";
+            const kind = /vectors? with length/i.test(detail) ? "has the wrong vector dimensions" : "was not stored";
+            throw new Error(
+              this._redact(
+                `WeaviateRetriever.store(): document "${id}" ${kind}: ${detail}`
+              )
+            );
+          }
+        }
+        this._exists = true;
+        if (!this.dimensions) this.dimensions = dimensions;
+      }
+      /**
+       * The documents most similar to a query vector.
+       * @param {number[]|{ queryVector?: number[], topK?: number, signal?: AbortSignal }} request
+       *   A vector, or an object with one (required; optional in the type to
+       *   match the retriever contract)
+       * @param {number} [k=10] - Results when `request` is a vector
+       * @returns {Promise<Array<{ id: string, score: number, content: string, metadata: Object }>>}
+       */
+      async retrieve(request, k = 10) {
+        const {
+          queryVector,
+          topK = k,
+          signal
+        } = Array.isArray(request) ? { queryVector: request } : request || {};
+        if (!Number.isInteger(topK) || topK < 1) {
+          throw new Error(
+            "WeaviateRetriever.retrieve(): topK must be a positive integer"
+          );
+        }
+        checkVector(queryVector, "query");
+        throwIfAborted(signal);
+        if (!await this._collectionExists(signal)) return [];
+        const data = await this._graphql(
+          `{ Get { ${this.collection}(nearVector: { vector: ${JSON.stringify(queryVector)} }, limit: ${topK}, where: ${OURS_GRAPHQL}) { rag_id content rag_metadata _additional { distance } } } }`,
+          signal
+        );
+        throwIfAborted(signal);
+        const hits = data.Get && data.Get[this.collection] || [];
+        return hits.map((hit) => ({
+          id: hit.rag_id,
+          score: 1 - hit._additional.distance,
+          content: hit.content || "",
+          metadata: parseMetadata(hit.rag_metadata)
+        }));
+      }
+      /**
+       * Deletes the matching objects, a server-limited round at a time.
+       * @private
+       */
+      async _deleteWhere(where) {
+        if (!await this._collectionExists()) return;
+        for (; ; ) {
+          const json = await this._request("DELETE", "/batch/objects", {
+            match: { class: this.collection, where },
+            output: "minimal"
+          });
+          const r = json && json.results || {};
+          if (r.failed > 0) {
+            throw new Error(
+              `WeaviateRetriever: ${r.failed} objects could not be deleted`
+            );
+          }
+          if (!(r.limit > 0 && r.matches > r.limit && r.successful > 0)) return;
+        }
+      }
+      /**
+       * Deletes the chunks of one source (`metadata.source`), for re-ingesting.
+       * @param {string} source
+       */
+      async removeBySource(source) {
+        await this._deleteWhere({
+          path: ["rag_source"],
+          operator: "Equal",
+          valueText: String(source)
+        });
+      }
+      /**
+       * Deletes documents by id.
+       * @param {string[]} ids
+       */
+      async delete(ids) {
+        for (let i = 0; i < ids.length; i += DELETE_BATCH) {
+          await this._deleteWhere({
+            path: ["rag_id"],
+            operator: "ContainsAny",
+            valueTextArray: ids.slice(i, i + DELETE_BATCH).map(String)
+          });
+        }
+      }
+      /** Deletes every document this class stored; the collection stays. */
+      async clear() {
+        await this._deleteWhere(OURS);
+      }
+      /** @returns {Promise<number>} */
+      async size() {
+        if (!await this._collectionExists()) return 0;
+        const data = await this._graphql(
+          `{ Aggregate { ${this.collection}(where: ${OURS_GRAPHQL}) { meta { count } } } }`
+        );
+        const rows = data.Aggregate && data.Aggregate[this.collection] || [];
+        return rows[0] && rows[0].meta ? rows[0].meta.count : 0;
+      }
+      /**
+       * Every document, without vectors.
+       * @param {{ limit?: number }} [options]
+       * @returns {Promise<Array<{ id: string, content: string, metadata: Object }>>}
+       */
+      async list({ limit } = {}) {
+        const out = [];
+        if (!await this._collectionExists()) return out;
+        let after = "";
+        for (; ; ) {
+          const page = await this._request(
+            "GET",
+            `/objects?class=${this.collection}&limit=${PAGE}&after=${encodeURIComponent(after)}`,
+            void 0,
+            { allow404: true }
+          );
+          const objects = page && page.objects || [];
+          for (const o of objects) {
+            const p = o.properties || {};
+            if (typeof p.rag_id !== "string") continue;
+            out.push({
+              id: p.rag_id,
+              content: p.content || "",
+              metadata: parseMetadata(p.rag_metadata)
+            });
+            if (limit && out.length >= limit) return out;
+          }
+          if (objects.length < PAGE) return out;
+          after = objects[objects.length - 1].id;
+        }
+      }
+    };
+    module2.exports = { WeaviateRetriever };
+  }
+});
+
 // src/adapters/ai-sdk.js
 var require_ai_sdk = __commonJS({
   "src/adapters/ai-sdk.js"(exports2, module2) {
@@ -2119,7 +3285,9 @@ var require_connectors = __commonJS({
     var { OllamaConnector } = require_ollama_connector();
     var { LocalEmbedder } = require_local_embedder();
     var { QdrantRetriever } = require_qdrant_retriever();
+    var { PineconeRetriever } = require_pinecone_retriever();
     var { PgVectorRetriever } = require_pgvector_retriever();
+    var { WeaviateRetriever } = require_weaviate_retriever();
     var { createAiSdkAdapter } = require_ai_sdk();
     module2.exports = {
       OpenAIConnector,
@@ -2128,7 +3296,9 @@ var require_connectors = __commonJS({
       OllamaConnector,
       LocalEmbedder,
       QdrantRetriever,
+      PineconeRetriever,
       PgVectorRetriever,
+      WeaviateRetriever,
       createAiSdkAdapter
     };
   }
@@ -2147,7 +3317,9 @@ var modules = {
   "connectors/rag-prompt.js": () => require_rag_prompt(),
   "packages/connectors.js": () => require_connectors(),
   "retrieval/pgvector-retriever.js": () => require_pgvector_retriever(),
-  "retrieval/qdrant-retriever.js": () => require_qdrant_retriever()
+  "retrieval/pinecone-retriever.js": () => require_pinecone_retriever(),
+  "retrieval/qdrant-retriever.js": () => require_qdrant_retriever(),
+  "retrieval/weaviate-retriever.js": () => require_weaviate_retriever()
 };
 Object.defineProperty(mod, Symbol.for("@devilsdev/rag-connectors/internal"), {
   value: (file) => {