@devilsdev/rag-connectors 3.4.0 → 3.6.0

package/README.md

@@ -1,6 +1,6 @@
 # @devilsdev/rag-connectors
 
-Embedders, LLMs and vector stores for @devilsdev/rag-core: OpenAI, Anthropic, Cohere, Ollama, the AI SDK, Qdrant and pgvector.
+Embedders, LLMs and vector stores for @devilsdev/rag-core: OpenAI, Anthropic, Cohere, Ollama, the AI SDK, Qdrant, pgvector and Pinecone.
 
 Part of [@devilsdev/rag-pipeline-utils](https://www.npmjs.com/package/@devilsdev/rag-pipeline-utils), split into packages so you install only what you use. The objects are the same ones the full package exports; versions move in lockstep.
 
@@ -8,7 +8,7 @@ Part of [@devilsdev/rag-pipeline-utils](https://www.npmjs.com/package/@devilsdev
 npm install @devilsdev/rag-connectors
 ```
 
-Exports: `OpenAIConnector`, `AnthropicConnector`, `CohereConnector`, `OllamaConnector`, `LocalEmbedder`, `QdrantRetriever`, `PgVectorRetriever`, `createAiSdkAdapter`.
+Exports: `OpenAIConnector`, `AnthropicConnector`, `CohereConnector`, `OllamaConnector`, `LocalEmbedder`, `QdrantRetriever`, `PineconeRetriever`, `PgVectorRetriever`, `createAiSdkAdapter`.
 
 Documentation: https://devilsdev.github.io/rag-pipeline-utils/
 

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 {
       /**
@@ -363,6 +366,7 @@ var require_anthropic_connector = __commonJS({
     var loadAxios = () => require("axios");
     var { BaseConnector } = require_base_connector();
     var {
+      cleanAxiosErrors,
       missingApiKeyError,
       raceAbort,
       resolveApiKey,
@@ -374,6 +378,38 @@ var require_anthropic_connector = __commonJS({
     var { componentCacheKey } = require_component_keys();
     var API_KEY_ENV = "ANTHROPIC_API_KEY";
     var API_DEFAULT_TEMPERATURE = 1;
+    var NO_TEMPERATURE = /* @__PURE__ */ new Set();
+    var warnedTemperature = /* @__PURE__ */ new Set();
+    function isTemperatureRejection(error) {
+      const response = error && error.response;
+      if (!response || response.status !== 400) return false;
+      const data = response.data;
+      if (!data || typeof data.pipe === "function") return true;
+      const message = data.error && data.error.message || (typeof data === "string" ? data : "");
+      return /temperature/i.test(message);
+    }
+    function warnTemperatureDropped(model, temperature) {
+      if (warnedTemperature.has(model)) return;
+      warnedTemperature.add(model);
+      process.emitWarning(
+        `${model} does not accept temperature ${temperature}; sent without it (the API default). Claude 4.7 and later models accept only the default.`,
+        { code: "RAG_ANTHROPIC_TEMPERATURE" }
+      );
+    }
+    function responseText(data) {
+      const blocks = Array.isArray(data && data.content) ? data.content : [];
+      const text = blocks.filter(
+        (b) => b && typeof b.text === "string" && (b.type === "text" || b.type === void 0)
+      ).map((b) => b.text).join("");
+      if (text) return text;
+      const stop = data && data.stop_reason;
+      const error = new Error(
+        stop === "refusal" ? "Claude declined to answer (stop_reason: refusal)" : stop === "max_tokens" ? "Claude reached maxTokens before writing an answer (stop_reason: max_tokens); raise maxTokens" : `Claude returned no text (stop_reason: ${stop || "unknown"})`
+      );
+      error.code = stop === "refusal" ? "MODEL_REFUSED" : "NO_TEXT";
+      error.stopReason = stop || null;
+      throw error;
+    }
     var DEFAULT_CONFIG = {
       model: "claude-sonnet-5-5",
       baseURL: "https://api.anthropic.com",
@@ -431,6 +467,7 @@ var require_anthropic_connector = __commonJS({
             "content-type": "application/json"
           }
         });
+        cleanAxiosErrors(this.client, "Anthropic");
       }
       /**
        * @throws {Error} code MISSING_API_KEY when no key is configured
@@ -466,7 +503,7 @@ var require_anthropic_connector = __commonJS({
           messages: [{ role: "user", content: prompt.user }]
         };
         const temperature = options.temperature ?? this.config.temperature;
-        if (temperature !== void 0 && temperature !== API_DEFAULT_TEMPERATURE) {
+        if (temperature !== void 0 && temperature !== API_DEFAULT_TEMPERATURE && !NO_TEMPERATURE.has(body.model)) {
           body.temperature = temperature;
         }
         if (prompt.system) body.system = prompt.system;
@@ -479,26 +516,69 @@ var require_anthropic_connector = __commonJS({
        * @param {Array<Object|string>} [context=[]] - Retrieved documents for RAG
        * @param {Object} [options={}] - Override model, temperature, maxTokens per-call
        * @param {AbortSignal} [options.signal] - Cancels the request
-       * @returns {Promise<string>} The generated text
+       * @returns {Promise<string>} The answer: every text block of the reply,
+       *   joined. Rejects (code MODEL_REFUSED or NO_TEXT) when the reply has no
+       *   text, such as a refusal or a reply that ran out of maxTokens while
+       *   thinking.
        */
       async generate(query, context = [], options = {}) {
+        return (await this.generateWithUsage(query, context, options)).text;
+      }
+      /**
+       * Like generate(), with the reply's token usage. The LLM judge uses it so
+       * `check.judge.usage` reports what the judge cost.
+       *
+       * @param {string} query
+       * @param {Array<Object|string>} [context=[]]
+       * @param {Object} [options={}] - As for generate()
+       * @returns {Promise<{text: string, usage: {inputTokens: number, outputTokens: number, totalTokens: number}}>}
+       */
+      async generateWithUsage(query, context = [], options = {}) {
         const { signal } = options;
         throwIfAborted(signal);
         this._requireApiKey();
         const body = this._buildBody(query, context, options);
-        return this.withRetry(
-          async () => {
-            const response = await this.client.post(
-              "/v1/messages",
-              body,
-              signal ? { signal } : void 0
-            );
-            return response.data.content[0].text;
-          },
+        const data = await this._post(body, signal);
+        const text = responseText(data);
+        const u = data.usage || {};
+        const inputTokens = (u.input_tokens || 0) + (u.cache_creation_input_tokens || 0) + (u.cache_read_input_tokens || 0);
+        const outputTokens = u.output_tokens || 0;
+        return {
+          text,
+          usage: {
+            inputTokens,
+            outputTokens,
+            totalTokens: inputTokens + outputTokens
+          }
+        };
+      }
+      /**
+       * POST a Messages request with retries; a model that rejects
+       * `temperature` gets the request again without it.
+       * @private
+       */
+      async _post(body, signal) {
+        const send = (b) => this.withRetry(
+          async () => (await this.client.post(
+            "/v1/messages",
+            b,
+            signal ? { signal } : void 0
+          )).data,
           this.config.maxRetries,
           this.config.retryDelay,
           { signal }
         );
+        try {
+          return await send(body);
+        } catch (error) {
+          if (body.temperature === void 0 || !isTemperatureRejection(error)) {
+            throw error;
+          }
+          NO_TEMPERATURE.add(body.model);
+          warnTemperatureDropped(body.model, body.temperature);
+          const { temperature: _t, ...rest } = body;
+          return send(rest);
+        }
       }
       /**
        * Stream a response from Claude token-by-token via SSE.
@@ -513,14 +593,27 @@ var require_anthropic_connector = __commonJS({
         const { signal } = options;
         throwIfAborted(signal);
         this._requireApiKey();
-        const body = { ...this._buildBody(query, context, options), stream: true };
-        const response = await raceAbort(
-          this.client.post("/v1/messages", body, {
+        let body = { ...this._buildBody(query, context, options), stream: true };
+        const open = (b) => raceAbort(
+          this.client.post("/v1/messages", b, {
             responseType: "stream",
             ...signalOptions(signal)
           }),
           signal
         );
+        let response;
+        try {
+          response = await open(body);
+        } catch (error) {
+          if (body.temperature === void 0 || !isTemperatureRejection(error)) {
+            throw error;
+          }
+          NO_TEMPERATURE.add(body.model);
+          warnTemperatureDropped(body.model, body.temperature);
+          const { temperature: _t, ...rest } = body;
+          body = rest;
+          response = await open(body);
+        }
         let buffer = "";
         for await (const text of textChunks(response.data)) {
           throwIfAborted(signal);
@@ -560,7 +653,7 @@ var require_anthropic_connector = __commonJS({
         return buildRagPrompt(query, context).user;
       }
     };
-    module2.exports = { AnthropicConnector, DEFAULT_CONFIG };
+    module2.exports = { AnthropicConnector, DEFAULT_CONFIG, responseText };
   }
 });
 
@@ -572,6 +665,7 @@ var require_cohere_connector = __commonJS({
     var { componentCacheKey } = require_component_keys();
     var { BaseConnector } = require_base_connector();
     var {
+      cleanAxiosErrors,
       missingApiKeyError,
       resolveApiKey,
       throwIfAborted
@@ -627,6 +721,7 @@ var require_cohere_connector = __commonJS({
             "Content-Type": "application/json"
           }
         });
+        cleanAxiosErrors(this.client, "Cohere");
       }
       /**
        * @throws {Error} code MISSING_API_KEY when no key is configured
@@ -764,6 +859,7 @@ var require_ollama_connector = __commonJS({
     var loadAxios = () => require("axios");
     var { BaseConnector } = require_base_connector();
     var {
+      cleanAxiosErrors,
       raceAbort,
       signalOptions,
       textChunks,
@@ -822,6 +918,7 @@ var require_ollama_connector = __commonJS({
           baseURL: this.config.baseURL,
           timeout: this.config.timeout
         });
+        cleanAxiosErrors(this.client, "Ollama");
       }
       /**
        * Connect to the Ollama server by verifying it is reachable.
@@ -1514,6 +1611,582 @@ var require_qdrant_retriever = __commonJS({
   }
 });
 
+// src/retrieval/pinecone-retriever.js
+var require_pinecone_retriever = __commonJS({
+  "src/retrieval/pinecone-retriever.js"(exports2, module2) {
+    "use strict";
+    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 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 } };
+    function recordId(id) {
+      const s = String(id);
+      if (PLAIN_ID.test(s)) return s;
+      return `rag-${crypto.createHash("sha256").update(s).digest("hex")}`;
+    }
+    function checkVector(vector, id) {
+      if (!Array.isArray(vector) || vector.length === 0) {
+        throw new Error(`PineconeRetriever: document "${id}" has no vector`);
+      }
+      if (!vector.every((x) => typeof x === "number" && Number.isFinite(x))) {
+        throw new Error(
+          `PineconeRetriever: document "${id}" has a vector with a non-finite value`
+        );
+      }
+    }
+    function fromFields(fields, fallbackId) {
+      const m = fields || {};
+      let metadata = {};
+      try {
+        metadata = m.rag_metadata ? JSON.parse(m.rag_metadata) : {};
+      } catch {
+        metadata = {};
+      }
+      return {
+        id: m.rag_id !== void 0 ? String(m.rag_id) : fallbackId,
+        content: m.rag_content || "",
+        metadata
+      };
+    }
+    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 {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 {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 {
+          apiKey = typeof process !== "undefined" && process.env ? process.env.PINECONE_API_KEY : void 0,
+          host,
+          index,
+          namespace = DEFAULT_NAMESPACE,
+          api = "auto",
+          vectorField,
+          freshnessTimeoutMs = 3e4,
+          cacheKey,
+          fetch: fetchImpl = globalThis.fetch
+        } = options;
+        if (!apiKey) {
+          throw new Error(
+            "PineconeRetriever needs an API key: pass apiKey or set PINECONE_API_KEY"
+          );
+        }
+        if (!host && !index) {
+          throw new Error(
+            "PineconeRetriever needs the index: pass index (its name) or host (the index host)"
+          );
+        }
+        if (typeof namespace !== "string") {
+          throw new Error("PineconeRetriever: namespace must be a string");
+        }
+        if (!["auto", "documents", "vectors"].includes(api)) {
+          throw new Error(
+            'PineconeRetriever: api must be "auto", "documents" or "vectors"'
+          );
+        }
+        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._apiKey = apiKey;
+        this._host = host ? normalizeHost(host) : null;
+        this._api = api;
+        this._vectorField = vectorField;
+        this._fetch = fetchImpl === globalThis.fetch ? fetchImpl.bind(globalThis) : fetchImpl;
+        this._resolving = null;
+        this._writeLsn = 0;
+        this._dimension = null;
+      }
+      /**
+       * 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}`;
+      }
+      /**
+       * 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 {
+          res = await this._fetch(url, {
+            method,
+            headers,
+            ...body !== void 0 && { body: JSON.stringify(body) },
+            ...signal && { signal }
+          });
+        } catch (err) {
+          throwIfAborted(signal);
+          throw new Error(
+            `PineconeRetriever: cannot reach Pinecone (${err.message})`
+          );
+        }
+        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(
+              `PineconeRetriever: Pinecone refused the request (${res.status}); check PINECONE_API_KEY`
+            );
+          }
+          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 { json, headers: res.headers };
+      }
+      /**
+       * The index's host and kind, from its description (once): a document
+       * index's dense_vector field and dimension, or a vector index's.
+       * @private
+       */
+      _resolve(signal) {
+        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(
+              `PineconeRetriever: no index with host ${host} in this project; check the host, or pass index (its name)`
+            );
+          }
+        }
+        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");
+        if (this._api === "auto") {
+          this._api = named.length > 0 ? "documents" : "vectors";
+        }
+        if (this._api === "documents") {
+          const field = this._vectorField ? denseFields.find(([name]) => name === this._vectorField) : denseFields[0];
+          if (!field) {
+            const embeds = fields && Object.values(fields).some((f) => f && f.embed);
+            throw new Error(
+              embeds ? `PineconeRetriever: index "${info.name}" embeds text itself (integrated embedding) and has no dense_vector field for your vectors; create an index with a dense_vector field` : `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.
+       * Resolves `[{ id, score, fields }]`.
+       * @private
+       */
+      async _search(vector, topK, signal, filter) {
+        await this._resolve(signal);
+        const documents = this._api === "documents";
+        const [path, body] = documents ? [
+          this._docs("search"),
+          {
+            score_by: [
+              {
+                type: "dense_vector",
+                fields: [this._vectorField],
+                values: vector
+              }
+            ],
+            top_k: topK,
+            include_fields: FIELDS,
+            ...filter && { filter }
+          }
+        ] : [
+          "/query",
+          {
+            vector,
+            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 dimension = this._indexDimension || this._dimension;
+        if (!dimension) return;
+        await this._search(
+          new Array(dimension).fill(0).map((_, i) => i === 0 ? 1 : 0),
+          1,
+          signal
+        );
+      }
+      /**
+       * 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("PineconeRetriever.store() takes an array");
+        }
+        if (docs.length === 0) return;
+        await this._resolve();
+        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;
+      }
+      /**
+       * 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(
+            "PineconeRetriever.retrieve(): topK must be a positive integer"
+          );
+        }
+        checkVector(queryVector, "query");
+        throwIfAborted(signal);
+        const matches = await this._search(
+          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 dimension = this._indexDimension || this._dimension;
+        if (dimension) {
+          const max = Math.min(limit || SEARCH_MAX, SEARCH_MAX);
+          const found = await this._search(
+            new Array(dimension).fill(0).map((_, i) => i === 0 ? 1 : 0),
+            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) {
@@ -2025,6 +2698,7 @@ 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 { createAiSdkAdapter } = require_ai_sdk();
     module2.exports = {
@@ -2034,6 +2708,7 @@ var require_connectors = __commonJS({
       OllamaConnector,
       LocalEmbedder,
       QdrantRetriever,
+      PineconeRetriever,
       PgVectorRetriever,
       createAiSdkAdapter
     };
@@ -2053,6 +2728,7 @@ var modules = {
   "connectors/rag-prompt.js": () => require_rag_prompt(),
   "packages/connectors.js": () => require_connectors(),
   "retrieval/pgvector-retriever.js": () => require_pgvector_retriever(),
+  "retrieval/pinecone-retriever.js": () => require_pinecone_retriever(),
   "retrieval/qdrant-retriever.js": () => require_qdrant_retriever()
 };
 Object.defineProperty(mod, Symbol.for("@devilsdev/rag-connectors/internal"), {

package/dist/index.d.ts

@@ -1 +1 @@
-export { OpenAIConnector, AnthropicConnector, CohereConnector, OllamaConnector, LocalEmbedder, QdrantRetriever, PgVectorRetriever, createAiSdkAdapter } from "@devilsdev/rag-core/all-types";
+export { OpenAIConnector, AnthropicConnector, CohereConnector, OllamaConnector, LocalEmbedder, QdrantRetriever, PineconeRetriever, PgVectorRetriever, createAiSdkAdapter } from "@devilsdev/rag-core/all-types";

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 const mod = require('./index.cjs');
-export const { OpenAIConnector, AnthropicConnector, CohereConnector, OllamaConnector, LocalEmbedder, QdrantRetriever, PgVectorRetriever, createAiSdkAdapter } = mod;
+export const { OpenAIConnector, AnthropicConnector, CohereConnector, OllamaConnector, LocalEmbedder, QdrantRetriever, PineconeRetriever, PgVectorRetriever, createAiSdkAdapter } = mod;
 export default mod;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@devilsdev/rag-connectors",
-  "version": "3.4.0",
-  "description": "Embedders, LLMs and vector stores for @devilsdev/rag-core: OpenAI, Anthropic, Cohere, Ollama, the AI SDK, Qdrant and pgvector.",
+  "version": "3.6.0",
+  "description": "Embedders, LLMs and vector stores for @devilsdev/rag-core: OpenAI, Anthropic, Cohere, Ollama, the AI SDK, Qdrant, pgvector and Pinecone.",
   "keywords": [
     "rag",
     "openai",
@@ -28,6 +28,7 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
+      "workerd": "./dist/index.cjs",
       "require": "./dist/index.cjs",
       "import": "./dist/index.mjs"
     },
@@ -43,7 +44,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@devilsdev/rag-core": "3.4.0",
+    "@devilsdev/rag-core": "3.6.0",
     "axios": "^1.21.0"
   },
   "peerDependencies": {