@mastra/pinecone 0.1.6-alpha.1 → 0.1.6-alpha.3

package/.turbo/turbo-build.log

@@ -1,18 +1,23 @@
 
-> @mastra/pinecone@0.1.6-alpha.1 build /home/runner/work/mastra/mastra/stores/pinecone
-> tsup src/index.ts --format esm --experimental-dts --clean --treeshake
+> @mastra/pinecone@0.1.6-alpha.3 build /home/runner/work/mastra/mastra/stores/pinecone
+> tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.3.6
 TSC Build start
-TSC ⚡️ Build success in 7448ms
+TSC ⚡️ Build success in 6185ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.7.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/pinecone/dist/_tsup-dts-rollup.d.ts
-DTS ⚡️ Build success in 5356ms
+Analysis will use the bundled TypeScript version 5.7.3
+Writing package typings: /home/runner/work/mastra/mastra/stores/pinecone/dist/_tsup-dts-rollup.d.cts
+DTS ⚡️ Build success in 8479ms
 CLI Cleaning output folder
 ESM Build start
-ESM dist/index.js 5.86 KB
-ESM ⚡️ Build success in 427ms
+CJS Build start
+CJS dist/index.cjs 6.12 KB
+CJS ⚡️ Build success in 461ms
+ESM dist/index.js 6.08 KB
+ESM ⚡️ Build success in 562ms

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @mastra/pinecone
 
+## 0.1.6-alpha.3
+
+### Patch Changes
+
+- 0fd78ac: Update vector store functions to use object params
+- fd14a3f: Updating filter location from @mastra/core/filter to @mastra/core/vector/filter
+- c4fdac3: Updated tests for upstash and astra
+- 4d4e1e1: Updated vector tests and pinecone
+- bb4f447: Add support for commonjs
+- Updated dependencies [0fd78ac]
+- Updated dependencies [0d25b75]
+- Updated dependencies [fd14a3f]
+- Updated dependencies [3f369a2]
+- Updated dependencies [4d4e1e1]
+- Updated dependencies [bb4f447]
+  - @mastra/core@0.4.3-alpha.3
+
+## 0.1.6-alpha.2
+
+### Patch Changes
+
+- Updated dependencies [2512a93]
+- Updated dependencies [e62de74]
+  - @mastra/core@0.4.3-alpha.2
+
 ## 0.1.6-alpha.1
 
 ### Patch Changes

package/README.md

@@ -19,21 +19,21 @@ const vectorStore = new PineconeVector(
 );
 
 // Create a new index
-await vectorStore.createIndex('my-index', 1536, 'cosine');
+await vectorStore.createIndex({ indexName: 'my-index', dimension: 1536, metric: 'cosine' });
 
 // Add vectors
 const vectors = [[0.1, 0.2, ...], [0.3, 0.4, ...]];
 const metadata = [{ text: 'doc1' }, { text: 'doc2' }];
-const ids = await vectorStore.upsert('my-index', vectors, metadata);
+const ids = await vectorStore.upsert({ indexName: 'my-index', vectors, metadata });
 
 // Query vectors
-const results = await vectorStore.query(
-  'my-index',
-  [0.1, 0.2, ...],
-  10, // topK
-  { text: { $eq: 'doc1' } }, // optional filter
-  false // includeValues
-);
+const results = await vectorStore.query({
+  indexName: 'my-index',
+  queryVector: [0.1, 0.2, ...],
+  topK: 10, // topK
+  filter: { text: { $eq: 'doc1' } }, // optional filter
+  includeVector: false, // includeValues
+});
 ```
 
 ## Configuration
@@ -59,9 +59,9 @@ Optional:
 
 ## Methods
 
-- `createIndex(indexName, dimension, metric?)`: Create a new index
-- `upsert(indexName, vectors, metadata?, ids?)`: Add or update vectors
-- `query(indexName, queryVector, topK?, filter?, includeVector?)`: Search for similar vectors
+- `createIndex({indexName, dimension, metric?})`: Create a new index
+- `upsert({indexName, vectors, metadata?, ids?})`: Add or update vectors
+- `query({indexName, queryVector, topK?, filter?, includeVector?})`: Search for similar vectors
 - `listIndexes()`: List all indexes
 - `describeIndex(indexName)`: Get index statistics
 - `deleteIndex(indexName)`: Delete an index

package/dist/_tsup-dts-rollup.d.cts

@@ -0,0 +1,33 @@
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { CreateIndexParams } from '@mastra/core/vector';
+import type { IndexStats } from '@mastra/core/vector';
+import { MastraVector } from '@mastra/core/vector';
+import type { OperatorSupport } from '@mastra/core/vector/filter';
+import type { ParamsToArgs } from '@mastra/core/vector';
+import type { QueryResult } from '@mastra/core/vector';
+import type { QueryVectorParams } from '@mastra/core/vector';
+import type { UpsertVectorParams } from '@mastra/core/vector';
+import type { VectorFilter } from '@mastra/core/vector/filter';
+
+export declare class PineconeFilterTranslator extends BaseFilterTranslator {
+    protected getSupportedOperators(): OperatorSupport;
+    translate(filter?: VectorFilter): VectorFilter;
+    private translateNode;
+    private translateOperator;
+}
+
+declare class PineconeVector extends MastraVector {
+    private client;
+    constructor(apiKey: string, environment?: string);
+    createIndex(...args: ParamsToArgs<CreateIndexParams>): Promise<void>;
+    upsert(...args: ParamsToArgs<UpsertVectorParams>): Promise<string[]>;
+    transformFilter(filter?: VectorFilter): VectorFilter;
+    query(...args: ParamsToArgs<QueryVectorParams>): Promise<QueryResult[]>;
+    listIndexes(): Promise<string[]>;
+    describeIndex(indexName: string): Promise<IndexStats>;
+    deleteIndex(indexName: string): Promise<void>;
+}
+export { PineconeVector }
+export { PineconeVector as PineconeVector_alias_1 }
+
+export { }

package/dist/_tsup-dts-rollup.d.ts

@@ -1,13 +1,17 @@
-import { BaseFilterTranslator } from '@mastra/core/filter';
-import type { Filter } from '@mastra/core/filter';
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { CreateIndexParams } from '@mastra/core/vector';
 import type { IndexStats } from '@mastra/core/vector';
 import { MastraVector } from '@mastra/core/vector';
-import type { OperatorSupport } from '@mastra/core/filter';
+import type { OperatorSupport } from '@mastra/core/vector/filter';
+import type { ParamsToArgs } from '@mastra/core/vector';
 import type { QueryResult } from '@mastra/core/vector';
+import type { QueryVectorParams } from '@mastra/core/vector';
+import type { UpsertVectorParams } from '@mastra/core/vector';
+import type { VectorFilter } from '@mastra/core/vector/filter';
 
 export declare class PineconeFilterTranslator extends BaseFilterTranslator {
     protected getSupportedOperators(): OperatorSupport;
-    translate(filter?: Filter): Filter | undefined;
+    translate(filter?: VectorFilter): VectorFilter;
     private translateNode;
     private translateOperator;
 }
@@ -15,10 +19,10 @@ export declare class PineconeFilterTranslator extends BaseFilterTranslator {
 declare class PineconeVector extends MastraVector {
     private client;
     constructor(apiKey: string, environment?: string);
-    createIndex(indexName: string, dimension: number, metric?: 'cosine' | 'euclidean' | 'dotproduct'): Promise<void>;
-    upsert(indexName: string, vectors: number[][], metadata?: Record<string, any>[], ids?: string[]): Promise<string[]>;
-    transformFilter(filter?: Filter): Filter | undefined;
-    query(indexName: string, queryVector: number[], topK?: number, filter?: Filter, includeVector?: boolean): Promise<QueryResult[]>;
+    createIndex(...args: ParamsToArgs<CreateIndexParams>): Promise<void>;
+    upsert(...args: ParamsToArgs<UpsertVectorParams>): Promise<string[]>;
+    transformFilter(filter?: VectorFilter): VectorFilter;
+    query(...args: ParamsToArgs<QueryVectorParams>): Promise<QueryResult[]>;
     listIndexes(): Promise<string[]>;
     describeIndex(indexName: string): Promise<IndexStats>;
     deleteIndex(indexName: string): Promise<void>;

package/dist/index.cjs

@@ -0,0 +1,184 @@
+'use strict';
+
+var vector = require('@mastra/core/vector');
+var pinecone = require('@pinecone-database/pinecone');
+var filter = require('@mastra/core/vector/filter');
+
+// src/vector/index.ts
+var PineconeFilterTranslator = class extends filter.BaseFilterTranslator {
+  getSupportedOperators() {
+    return {
+      ...filter.BaseFilterTranslator.DEFAULT_OPERATORS,
+      logical: ["$and", "$or"],
+      array: ["$in", "$all", "$nin"],
+      element: ["$exists"],
+      regex: [],
+      custom: []
+    };
+  }
+  translate(filter) {
+    if (this.isEmpty(filter)) return filter;
+    this.validateFilter(filter);
+    return this.translateNode(filter);
+  }
+  translateNode(node, currentPath = "") {
+    if (this.isRegex(node)) {
+      throw new Error("Regex is not supported in Pinecone");
+    }
+    if (this.isPrimitive(node)) return this.normalizeComparisonValue(node);
+    if (Array.isArray(node)) return { $in: this.normalizeArrayValues(node) };
+    const entries = Object.entries(node);
+    const firstEntry = entries[0];
+    if (entries.length === 1 && firstEntry && this.isOperator(firstEntry[0])) {
+      const [operator, value] = firstEntry;
+      const translated = this.translateOperator(operator, value, currentPath);
+      return this.isLogicalOperator(operator) ? { [operator]: translated } : translated;
+    }
+    const result = {};
+    for (const [key, value] of entries) {
+      const newPath = currentPath ? `${currentPath}.${key}` : key;
+      if (this.isOperator(key)) {
+        result[key] = this.translateOperator(key, value, currentPath);
+        continue;
+      }
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        if (Object.keys(value).length === 1 && "$all" in value) {
+          const translated = this.translateNode(value, key);
+          if (translated.$and) {
+            return translated;
+          }
+        }
+        if (Object.keys(value).length === 0) {
+          result[newPath] = this.translateNode(value);
+        } else {
+          const hasOperators = Object.keys(value).some((k) => this.isOperator(k));
+          if (hasOperators) {
+            const normalizedValue = {};
+            for (const [op, opValue] of Object.entries(value)) {
+              normalizedValue[op] = this.isOperator(op) ? this.translateOperator(op, opValue) : opValue;
+            }
+            result[newPath] = normalizedValue;
+          } else {
+            Object.assign(result, this.translateNode(value, newPath));
+          }
+        }
+      } else {
+        result[newPath] = this.translateNode(value);
+      }
+    }
+    return result;
+  }
+  translateOperator(operator, value, currentPath = "") {
+    if (operator === "$all") {
+      if (!Array.isArray(value) || value.length === 0) {
+        throw new Error("A non-empty array is required for the $all operator");
+      }
+      return this.simulateAllOperator(currentPath, value);
+    }
+    if (this.isLogicalOperator(operator)) {
+      return Array.isArray(value) ? value.map((item) => this.translateNode(item)) : this.translateNode(value);
+    }
+    return this.normalizeComparisonValue(value);
+  }
+};
+
+// src/vector/index.ts
+var PineconeVector = class extends vector.MastraVector {
+  client;
+  constructor(apiKey, environment) {
+    super();
+    const opts = { apiKey };
+    if (environment) {
+      opts["controllerHostUrl"] = environment;
+    }
+    const baseClient = new pinecone.Pinecone(opts);
+    const telemetry = this.__getTelemetry();
+    this.client = telemetry?.traceClass(baseClient, {
+      spanNamePrefix: "pinecone-vector",
+      attributes: {
+        "vector.type": "pinecone"
+      }
+    }) ?? baseClient;
+  }
+  async createIndex(...args) {
+    const params = this.normalizeArgs("createIndex", args);
+    const { indexName, dimension, metric = "cosine" } = params;
+    if (!Number.isInteger(dimension) || dimension <= 0) {
+      throw new Error("Dimension must be a positive integer");
+    }
+    await this.client.createIndex({
+      name: indexName,
+      dimension,
+      metric,
+      spec: {
+        serverless: {
+          cloud: "aws",
+          region: "us-east-1"
+        }
+      }
+    });
+  }
+  async upsert(...args) {
+    const params = this.normalizeArgs("upsert", args);
+    const { indexName, vectors, metadata, ids } = params;
+    const index = this.client.Index(indexName);
+    const vectorIds = ids || vectors.map(() => crypto.randomUUID());
+    const records = vectors.map((vector, i) => ({
+      id: vectorIds[i],
+      values: vector,
+      metadata: metadata?.[i] || {}
+    }));
+    const batchSize = 100;
+    for (let i = 0; i < records.length; i += batchSize) {
+      const batch = records.slice(i, i + batchSize);
+      await index.upsert(batch);
+    }
+    return vectorIds;
+  }
+  transformFilter(filter) {
+    const translator = new PineconeFilterTranslator();
+    return translator.translate(filter);
+  }
+  async query(...args) {
+    const params = this.normalizeArgs("query", args);
+    const { indexName, queryVector, topK = 10, filter, includeVector = false } = params;
+    const index = this.client.Index(indexName);
+    const translatedFilter = this.transformFilter(filter) ?? void 0;
+    const results = await index.query({
+      vector: queryVector,
+      topK,
+      filter: translatedFilter,
+      includeMetadata: true,
+      includeValues: includeVector
+    });
+    return results.matches.map((match) => ({
+      id: match.id,
+      score: match.score || 0,
+      metadata: match.metadata,
+      ...includeVector && { vector: match.values || [] }
+    }));
+  }
+  async listIndexes() {
+    const indexesResult = await this.client.listIndexes();
+    return indexesResult?.indexes?.map((index) => index.name) || [];
+  }
+  async describeIndex(indexName) {
+    const index = this.client.Index(indexName);
+    const stats = await index.describeIndexStats();
+    const description = await this.client.describeIndex(indexName);
+    return {
+      dimension: description.dimension,
+      count: stats.totalRecordCount || 0,
+      metric: description.metric
+    };
+  }
+  async deleteIndex(indexName) {
+    try {
+      await this.client.deleteIndex(indexName);
+    } catch (error) {
+      throw new Error(`Failed to delete Pinecone index: ${error.message}`);
+    }
+  }
+};
+
+exports.PineconeVector = PineconeVector;

package/dist/index.d.cts

@@ -0,0 +1 @@
+export { PineconeVector } from './_tsup-dts-rollup.cjs';

package/dist/index.js

@@ -1,6 +1,6 @@
 import { MastraVector } from '@mastra/core/vector';
 import { Pinecone } from '@pinecone-database/pinecone';
-import { BaseFilterTranslator } from '@mastra/core/filter';
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 
 // src/vector/index.ts
 var PineconeFilterTranslator = class extends BaseFilterTranslator {
@@ -98,7 +98,9 @@ var PineconeVector = class extends MastraVector {
       }
     }) ?? baseClient;
   }
-  async createIndex(indexName, dimension, metric = "cosine") {
+  async createIndex(...args) {
+    const params = this.normalizeArgs("createIndex", args);
+    const { indexName, dimension, metric = "cosine" } = params;
     if (!Number.isInteger(dimension) || dimension <= 0) {
       throw new Error("Dimension must be a positive integer");
     }
@@ -114,7 +116,9 @@ var PineconeVector = class extends MastraVector {
       }
     });
   }
-  async upsert(indexName, vectors, metadata, ids) {
+  async upsert(...args) {
+    const params = this.normalizeArgs("upsert", args);
+    const { indexName, vectors, metadata, ids } = params;
     const index = this.client.Index(indexName);
     const vectorIds = ids || vectors.map(() => crypto.randomUUID());
     const records = vectors.map((vector, i) => ({
@@ -130,13 +134,14 @@ var PineconeVector = class extends MastraVector {
     return vectorIds;
   }
   transformFilter(filter) {
-    const pineconeFilter = new PineconeFilterTranslator();
-    const translatedFilter = pineconeFilter.translate(filter);
-    return translatedFilter;
+    const translator = new PineconeFilterTranslator();
+    return translator.translate(filter);
   }
-  async query(indexName, queryVector, topK = 10, filter, includeVector = false) {
+  async query(...args) {
+    const params = this.normalizeArgs("query", args);
+    const { indexName, queryVector, topK = 10, filter, includeVector = false } = params;
     const index = this.client.Index(indexName);
-    const translatedFilter = this.transformFilter(filter);
+    const translatedFilter = this.transformFilter(filter) ?? void 0;
     const results = await index.query({
       vector: queryVector,
       topK,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/pinecone",
-  "version": "0.1.6-alpha.1",
+  "version": "0.1.6-alpha.3",
   "description": "Pinecone vector store provider for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -10,13 +10,17 @@
       "import": {
         "types": "./dist/index.d.ts",
         "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
       }
     },
     "./package.json": "./package.json"
   },
   "dependencies": {
     "@pinecone-database/pinecone": "^3.0.3",
-    "@mastra/core": "^0.4.3-alpha.1"
+    "@mastra/core": "^0.4.3-alpha.3"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.49.2",
@@ -29,7 +33,7 @@
     "@internal/lint": "0.0.0"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format esm --experimental-dts --clean --treeshake",
+    "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake",
     "build:watch": "pnpm build --watch",
     "test": "vitest run",
     "lint": "eslint ."

package/src/vector/filter.ts

@@ -1,5 +1,5 @@
-import { BaseFilterTranslator } from '@mastra/core/filter';
-import type { FieldCondition, Filter, OperatorSupport, QueryOperator } from '@mastra/core/filter';
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { FieldCondition, VectorFilter, OperatorSupport, QueryOperator } from '@mastra/core/vector/filter';
 
 export class PineconeFilterTranslator extends BaseFilterTranslator {
   protected override getSupportedOperators(): OperatorSupport {
@@ -13,13 +13,13 @@ export class PineconeFilterTranslator extends BaseFilterTranslator {
     };
   }
 
-  translate(filter?: Filter): Filter | undefined {
+  translate(filter?: VectorFilter): VectorFilter {
     if (this.isEmpty(filter)) return filter;
-    this.validateFilter(filter as Filter);
+    this.validateFilter(filter);
     return this.translateNode(filter);
   }
 
-  private translateNode(node: Filter | FieldCondition, currentPath: string = ''): any {
+  private translateNode(node: VectorFilter | FieldCondition, currentPath: string = ''): any {
     if (this.isRegex(node)) {
       throw new Error('Regex is not supported in Pinecone');
     }