@mastra/pinecone 0.1.10-alpha.0 → 0.2.0-alpha.2

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/pinecone@0.1.10-alpha.0 build /home/runner/work/mastra/mastra/stores/pinecone
+> @mastra/pinecone@0.2.0-alpha.2 build /home/runner/work/mastra/mastra/stores/pinecone
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.4.0
 TSC Build start
-TSC ⚡️ Build success in 6662ms
+TSC ⚡️ Build success in 6455ms
 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
 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 8769ms
+DTS ⚡️ Build success in 8676ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 6.08 KB
-ESM ⚡️ Build success in 726ms
-CJS dist/index.cjs 6.12 KB
-CJS ⚡️ Build success in 727ms
+CJS dist/index.cjs 6.64 KB
+CJS ⚡️ Build success in 464ms
+ESM dist/index.js 6.61 KB
+ESM ⚡️ Build success in 465ms

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @mastra/pinecone
 
+## 0.2.0-alpha.2
+
+### Patch Changes
+
+- Updated dependencies [fc2f89c]
+- Updated dependencies [dfbb131]
+- Updated dependencies [0850b4c]
+- Updated dependencies [9116d70]
+  - @mastra/core@0.6.1-alpha.2
+
+## 0.2.0-alpha.1
+
+### Minor Changes
+
+- 2ee56ad: Added new operation implementations for MastraVector in pinecone store
+
+### Patch Changes
+
+- Updated dependencies [f4854ee]
+- Updated dependencies [afaf73f]
+- Updated dependencies [44631b1]
+- Updated dependencies [6e559a0]
+- Updated dependencies [5f43505]
+  - @mastra/core@0.6.1-alpha.1
+
 ## 0.1.10-alpha.0
 
 ### Patch Changes

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

@@ -26,6 +26,11 @@ declare class PineconeVector extends MastraVector {
     listIndexes(): Promise<string[]>;
     describeIndex(indexName: string): Promise<IndexStats>;
     deleteIndex(indexName: string): Promise<void>;
+    updateIndexById(indexName: string, id: string, update: {
+        vector?: number[];
+        metadata?: Record<string, any>;
+    }): Promise<void>;
+    deleteIndexById(indexName: string, id: string): Promise<void>;
 }
 export { PineconeVector }
 export { PineconeVector as PineconeVector_alias_1 }

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

@@ -26,6 +26,11 @@ declare class PineconeVector extends MastraVector {
     listIndexes(): Promise<string[]>;
     describeIndex(indexName: string): Promise<IndexStats>;
     deleteIndex(indexName: string): Promise<void>;
+    updateIndexById(indexName: string, id: string, update: {
+        vector?: number[];
+        metadata?: Record<string, any>;
+    }): Promise<void>;
+    deleteIndexById(indexName: string, id: string): Promise<void>;
 }
 export { PineconeVector }
 export { PineconeVector as PineconeVector_alias_1 }

package/dist/index.cjs

@@ -179,6 +179,24 @@ var PineconeVector = class extends vector.MastraVector {
       throw new Error(`Failed to delete Pinecone index: ${error.message}`);
     }
   }
+  async updateIndexById(indexName, id, update) {
+    if (!update.vector && !update.metadata) {
+      throw new Error("No updates provided");
+    }
+    const index = this.client.Index(indexName);
+    const updateObj = { id };
+    if (update.vector) {
+      updateObj.values = update.vector;
+    }
+    if (update.metadata) {
+      updateObj.metadata = update.metadata;
+    }
+    await index.update(updateObj);
+  }
+  async deleteIndexById(indexName, id) {
+    const index = this.client.Index(indexName);
+    await index.deleteOne(id);
+  }
 };
 
 exports.PineconeVector = PineconeVector;

package/dist/index.js

@@ -177,6 +177,24 @@ var PineconeVector = class extends MastraVector {
       throw new Error(`Failed to delete Pinecone index: ${error.message}`);
     }
   }
+  async updateIndexById(indexName, id, update) {
+    if (!update.vector && !update.metadata) {
+      throw new Error("No updates provided");
+    }
+    const index = this.client.Index(indexName);
+    const updateObj = { id };
+    if (update.vector) {
+      updateObj.values = update.vector;
+    }
+    if (update.metadata) {
+      updateObj.metadata = update.metadata;
+    }
+    await index.update(updateObj);
+  }
+  async deleteIndexById(indexName, id) {
+    const index = this.client.Index(indexName);
+    await index.deleteOne(id);
+  }
 };
 
 export { PineconeVector };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/pinecone",
-  "version": "0.1.10-alpha.0",
+  "version": "0.2.0-alpha.2",
   "description": "Pinecone vector store provider for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -20,7 +20,7 @@
   },
   "dependencies": {
     "@pinecone-database/pinecone": "^3.0.3",
-    "@mastra/core": "^0.6.1-alpha.0"
+    "@mastra/core": "^0.6.1-alpha.2"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.1",

package/src/vector/index.test.ts

@@ -2,6 +2,7 @@ import dotenv from 'dotenv';
 import { describe, it, expect, beforeAll, afterAll, beforeEach, vi, afterEach } from 'vitest';
 
 import { PineconeVector } from './';
+import type { QueryResult } from '@mastra/core/vector';
 
 dotenv.config();
 
@@ -125,6 +126,153 @@ describe.skip('PineconeVector Integration Tests', () => {
       expect(results?.[0]?.vector).toBeDefined();
       expect(results?.[0]?.vector).toHaveLength(dimension);
     }, 500000);
+
+    describe('vector update operations', () => {
+      const testVectors = [
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 8, 9],
+      ];
+
+      it('should update the vector by id', async () => {
+        const ids = await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors });
+        expect(ids).toHaveLength(3);
+
+        const idToBeUpdated = ids[0];
+        const newVector = [1, 2, 4];
+        const newMetaData = {
+          test: 'updates',
+        };
+
+        const update = {
+          vector: newVector,
+          metadata: newMetaData,
+        };
+
+        await vectorDB.updateIndexById(testIndexName, idToBeUpdated, update);
+
+        await new Promise(resolve => setTimeout(resolve, 3000));
+
+        const results: QueryResult[] = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: newVector,
+          topK: 10,
+          includeVector: true,
+        });
+
+        expect(results[0]?.id).toBe(idToBeUpdated);
+        expect(results[0]?.vector).toEqual(newVector);
+        expect(results[0]?.metadata).toEqual(newMetaData);
+      }, 500000);
+
+      it('should only update the metadata by id', async () => {
+        const ids = await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors });
+        expect(ids).toHaveLength(3);
+
+        const idToBeUpdated = ids[0];
+        const newMetaData = {
+          test: 'updates',
+        };
+
+        const update = {
+          metadata: newMetaData,
+        };
+
+        await vectorDB.updateIndexById(testIndexName, idToBeUpdated, update);
+
+        await new Promise(resolve => setTimeout(resolve, 3000));
+
+        const results: QueryResult[] = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: testVectors[0],
+          topK: 2,
+          includeVector: true,
+        });
+
+        expect(results[0]?.id).toBe(idToBeUpdated);
+        expect(results[0]?.vector).toEqual(testVectors[0]);
+        expect(results[0]?.metadata).toEqual(newMetaData);
+      }, 500000);
+
+      it('should only update vector embeddings by id', async () => {
+        const ids = await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors });
+        await new Promise(resolve => setTimeout(resolve, 3000));
+
+        expect(ids).toHaveLength(3);
+
+        const idToBeUpdated = ids[0];
+        const newVector = [1, 2, 3];
+
+        const update = {
+          vector: newVector,
+        };
+
+        await vectorDB.updateIndexById(testIndexName, idToBeUpdated, update);
+
+        await new Promise(resolve => setTimeout(resolve, 5000));
+
+        const results: QueryResult[] = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: newVector,
+          topK: 10,
+          includeVector: true,
+          filter: { ids: [idToBeUpdated] },
+        });
+
+        const resultIds = results.map(res => res.id);
+        const resultVectors = results.map(res => res.vector);
+        expect(resultIds).toContain(idToBeUpdated);
+        expect(resultVectors).toContain(newVector);
+      }, 500000);
+
+      it('should throw exception when no updates are given', () => {
+        expect(vectorDB.updateIndexById(testIndexName, 'id', {})).rejects.toThrow('No updates provided');
+      });
+
+      it('should throw error for non-existent index', async () => {
+        const nonExistentIndex = 'non-existent-index';
+        await expect(vectorDB.updateIndexById(nonExistentIndex, 'test-id', { vector: [1, 2, 3] })).rejects.toThrow();
+      });
+
+      it('should throw error for invalid vector dimension', async () => {
+        const [id] = await vectorDB.upsert({
+          indexName: testIndexName,
+          vectors: [[1, 2, 3]],
+          metadata: [{ test: 'initial' }],
+        });
+
+        await expect(
+          vectorDB.updateIndexById(testIndexName, id, { vector: [1, 2] }), // Wrong dimension
+        ).rejects.toThrow();
+      }, 500000);
+    });
+
+    describe('vector delete operations', () => {
+      const testVectors = [
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 8, 9],
+      ];
+
+      it('should delete the vector by id', async () => {
+        const ids = await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors });
+        expect(ids).toHaveLength(3);
+        const idToBeDeleted = ids[0];
+
+        await vectorDB.deleteIndexById(testIndexName, idToBeDeleted);
+
+        // Query all vectors similar to the deleted one
+        const results: QueryResult[] = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: testVectors[0],
+          topK: 3,
+          includeVector: true,
+        });
+
+        const resultIds = results.map(r => r.id);
+        expect(resultIds).not.toContain(idToBeDeleted);
+      }, 500000);
+    });
   });
 
   describe('Error Handling', () => {

package/src/vector/index.ts

@@ -9,6 +9,7 @@ import type {
 } from '@mastra/core/vector';
 import type { VectorFilter } from '@mastra/core/vector/filter';
 import { Pinecone } from '@pinecone-database/pinecone';
+import type { UpdateOptions } from '@pinecone-database/pinecone';
 
 import { PineconeFilterTranslator } from './filter';
 
@@ -136,4 +137,36 @@ export class PineconeVector extends MastraVector {
       throw new Error(`Failed to delete Pinecone index: ${error.message}`);
     }
   }
+
+  async updateIndexById(
+    indexName: string,
+    id: string,
+    update: {
+      vector?: number[];
+      metadata?: Record<string, any>;
+    },
+  ): Promise<void> {
+    if (!update.vector && !update.metadata) {
+      throw new Error('No updates provided');
+    }
+
+    const index = this.client.Index(indexName);
+
+    const updateObj: UpdateOptions = { id };
+
+    if (update.vector) {
+      updateObj.values = update.vector;
+    }
+
+    if (update.metadata) {
+      updateObj.metadata = update.metadata;
+    }
+
+    await index.update(updateObj);
+  }
+
+  async deleteIndexById(indexName: string, id: string): Promise<void> {
+    const index = this.client.Index(indexName);
+    await index.deleteOne(id);
+  }
 }