@mastra/pinecone 0.2.4 → 0.2.5-alpha.1

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/pinecone@0.2.4-alpha.3 build /home/runner/work/mastra/mastra/stores/pinecone
+> @mastra/pinecone@0.2.5-alpha.1 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 6101ms
+TSC ⚡️ Build success in 5798ms
 DTS Build start
 CLI Target: es2022
-CLI Cleaning output folder
-ESM Build start
-CJS Build start
 Analysis will use the bundled TypeScript version 5.8.2
 Writing package typings: /home/runner/work/mastra/mastra/stores/pinecone/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.2
 Writing package typings: /home/runner/work/mastra/mastra/stores/pinecone/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 8873ms
-CJS dist/index.cjs 6.64 KB
-CJS ⚡️ Build success in 9296ms
-ESM dist/index.js 6.61 KB
-ESM ⚡️ Build success in 9299ms
+DTS ⚡️ Build success in 9062ms
+CLI Cleaning output folder
+ESM Build start
+CJS Build start
+CJS dist/index.cjs 7.13 KB
+CJS ⚡️ Build success in 648ms
+ESM dist/index.js 7.09 KB
+ESM ⚡️ Build success in 649ms

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @mastra/pinecone
 
+## 0.2.5-alpha.1
+
+### Patch Changes
+
+- 7071597: Update pinecone to include namespace and hybrid search
+- Updated dependencies [619c39d]
+- Updated dependencies [fe56be0]
+- Updated dependencies [a0967a0]
+- Updated dependencies [fca3b21]
+- Updated dependencies [0118361]
+- Updated dependencies [619c39d]
+  - @mastra/core@0.8.0-alpha.1
+
+## 0.2.5-alpha.0
+
+### Patch Changes
+
+- Updated dependencies [107bcfe]
+- Updated dependencies [5b4e19f]
+- Updated dependencies [7599d77]
+- Updated dependencies [cafae83]
+- Updated dependencies [8076ecf]
+- Updated dependencies [304397c]
+  - @mastra/core@0.7.1-alpha.0
+
 ## 0.2.4
 
 ### Patch Changes

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

@@ -1,11 +1,15 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 import type { CreateIndexParams } from '@mastra/core/vector';
 import type { IndexStats } from '@mastra/core/vector';
+import type { IndexStatsDescription } from '@pinecone-database/pinecone';
 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 { QueryVectorArgs } from '@mastra/core/vector';
 import type { QueryVectorParams } from '@mastra/core/vector';
+import type { RecordSparseValues } from '@pinecone-database/pinecone';
+import type { UpsertVectorArgs } from '@mastra/core/vector';
 import type { UpsertVectorParams } from '@mastra/core/vector';
 import type { VectorFilter } from '@mastra/core/vector/filter';
 
@@ -16,21 +20,39 @@ export declare class PineconeFilterTranslator extends BaseFilterTranslator {
     private translateOperator;
 }
 
+declare interface PineconeIndexStats extends IndexStats {
+    namespaces?: IndexStatsDescription['namespaces'];
+}
+
+declare type PineconeQueryVectorArgs = [...QueryVectorArgs, string?, RecordSparseValues?];
+
+declare interface PineconeQueryVectorParams extends QueryVectorParams {
+    namespace?: string;
+    sparseVector?: RecordSparseValues;
+}
+
+declare type PineconeUpsertVectorArgs = [...UpsertVectorArgs, string?, RecordSparseValues[]?];
+
+declare interface PineconeUpsertVectorParams extends UpsertVectorParams {
+    namespace?: string;
+    sparseVectors?: RecordSparseValues[];
+}
+
 declare class PineconeVector extends MastraVector {
     private client;
     constructor(apiKey: string, environment?: string);
     createIndex(...args: ParamsToArgs<CreateIndexParams>): Promise<void>;
-    upsert(...args: ParamsToArgs<UpsertVectorParams>): Promise<string[]>;
+    upsert(...args: ParamsToArgs<PineconeUpsertVectorParams> | PineconeUpsertVectorArgs): Promise<string[]>;
     transformFilter(filter?: VectorFilter): VectorFilter;
-    query(...args: ParamsToArgs<QueryVectorParams>): Promise<QueryResult[]>;
+    query(...args: ParamsToArgs<PineconeQueryVectorParams> | PineconeQueryVectorArgs): Promise<QueryResult[]>;
     listIndexes(): Promise<string[]>;
-    describeIndex(indexName: string): Promise<IndexStats>;
+    describeIndex(indexName: string): Promise<PineconeIndexStats>;
     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>;
+    }, namespace?: string): Promise<void>;
+    deleteIndexById(indexName: string, id: string, namespace?: string): Promise<void>;
 }
 export { PineconeVector }
 export { PineconeVector as PineconeVector_alias_1 }

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

@@ -1,11 +1,15 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 import type { CreateIndexParams } from '@mastra/core/vector';
 import type { IndexStats } from '@mastra/core/vector';
+import type { IndexStatsDescription } from '@pinecone-database/pinecone';
 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 { QueryVectorArgs } from '@mastra/core/vector';
 import type { QueryVectorParams } from '@mastra/core/vector';
+import type { RecordSparseValues } from '@pinecone-database/pinecone';
+import type { UpsertVectorArgs } from '@mastra/core/vector';
 import type { UpsertVectorParams } from '@mastra/core/vector';
 import type { VectorFilter } from '@mastra/core/vector/filter';
 
@@ -16,21 +20,39 @@ export declare class PineconeFilterTranslator extends BaseFilterTranslator {
     private translateOperator;
 }
 
+declare interface PineconeIndexStats extends IndexStats {
+    namespaces?: IndexStatsDescription['namespaces'];
+}
+
+declare type PineconeQueryVectorArgs = [...QueryVectorArgs, string?, RecordSparseValues?];
+
+declare interface PineconeQueryVectorParams extends QueryVectorParams {
+    namespace?: string;
+    sparseVector?: RecordSparseValues;
+}
+
+declare type PineconeUpsertVectorArgs = [...UpsertVectorArgs, string?, RecordSparseValues[]?];
+
+declare interface PineconeUpsertVectorParams extends UpsertVectorParams {
+    namespace?: string;
+    sparseVectors?: RecordSparseValues[];
+}
+
 declare class PineconeVector extends MastraVector {
     private client;
     constructor(apiKey: string, environment?: string);
     createIndex(...args: ParamsToArgs<CreateIndexParams>): Promise<void>;
-    upsert(...args: ParamsToArgs<UpsertVectorParams>): Promise<string[]>;
+    upsert(...args: ParamsToArgs<PineconeUpsertVectorParams> | PineconeUpsertVectorArgs): Promise<string[]>;
     transformFilter(filter?: VectorFilter): VectorFilter;
-    query(...args: ParamsToArgs<QueryVectorParams>): Promise<QueryResult[]>;
+    query(...args: ParamsToArgs<PineconeQueryVectorParams> | PineconeQueryVectorArgs): Promise<QueryResult[]>;
     listIndexes(): Promise<string[]>;
-    describeIndex(indexName: string): Promise<IndexStats>;
+    describeIndex(indexName: string): Promise<PineconeIndexStats>;
     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>;
+    }, namespace?: string): Promise<void>;
+    deleteIndexById(indexName: string, id: string, namespace?: string): Promise<void>;
 }
 export { PineconeVector }
 export { PineconeVector as PineconeVector_alias_1 }

package/dist/index.cjs

@@ -119,13 +119,17 @@ var PineconeVector = class extends vector.MastraVector {
     });
   }
   async upsert(...args) {
-    const params = this.normalizeArgs("upsert", args);
-    const { indexName, vectors, metadata, ids } = params;
-    const index = this.client.Index(indexName);
+    const params = this.normalizeArgs("upsert", args, [
+      "namespace",
+      "sparseVectors"
+    ]);
+    const { indexName, vectors, metadata, ids, namespace, sparseVectors } = params;
+    const index = this.client.Index(indexName).namespace(namespace || "");
     const vectorIds = ids || vectors.map(() => crypto.randomUUID());
     const records = vectors.map((vector, i) => ({
       id: vectorIds[i],
       values: vector,
+      ...sparseVectors?.[i] && { sparseValues: sparseVectors?.[i] },
       metadata: metadata?.[i] || {}
     }));
     const batchSize = 100;
@@ -140,17 +144,24 @@ var PineconeVector = class extends vector.MastraVector {
     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 params = this.normalizeArgs("query", args, [
+      "namespace",
+      "sparseVector"
+    ]);
+    const { indexName, queryVector, topK = 10, filter, includeVector = false, namespace, sparseVector } = params;
+    const index = this.client.Index(indexName).namespace(namespace || "");
     const translatedFilter = this.transformFilter(filter) ?? void 0;
-    const results = await index.query({
+    const queryParams = {
       vector: queryVector,
       topK,
-      filter: translatedFilter,
       includeMetadata: true,
-      includeValues: includeVector
-    });
+      includeValues: includeVector,
+      filter: translatedFilter
+    };
+    if (sparseVector) {
+      queryParams.sparseVector = sparseVector;
+    }
+    const results = await index.query(queryParams);
     return results.matches.map((match) => ({
       id: match.id,
       score: match.score || 0,
@@ -169,7 +180,8 @@ var PineconeVector = class extends vector.MastraVector {
     return {
       dimension: description.dimension,
       count: stats.totalRecordCount || 0,
-      metric: description.metric
+      metric: description.metric,
+      namespaces: stats.namespaces
     };
   }
   async deleteIndex(indexName) {
@@ -179,11 +191,11 @@ var PineconeVector = class extends vector.MastraVector {
       throw new Error(`Failed to delete Pinecone index: ${error.message}`);
     }
   }
-  async updateIndexById(indexName, id, update) {
+  async updateIndexById(indexName, id, update, namespace) {
     if (!update.vector && !update.metadata) {
       throw new Error("No updates provided");
     }
-    const index = this.client.Index(indexName);
+    const index = this.client.Index(indexName).namespace(namespace || "");
     const updateObj = { id };
     if (update.vector) {
       updateObj.values = update.vector;
@@ -193,8 +205,8 @@ var PineconeVector = class extends vector.MastraVector {
     }
     await index.update(updateObj);
   }
-  async deleteIndexById(indexName, id) {
-    const index = this.client.Index(indexName);
+  async deleteIndexById(indexName, id, namespace) {
+    const index = this.client.Index(indexName).namespace(namespace || "");
     await index.deleteOne(id);
   }
 };

package/dist/index.js

@@ -117,13 +117,17 @@ var PineconeVector = class extends MastraVector {
     });
   }
   async upsert(...args) {
-    const params = this.normalizeArgs("upsert", args);
-    const { indexName, vectors, metadata, ids } = params;
-    const index = this.client.Index(indexName);
+    const params = this.normalizeArgs("upsert", args, [
+      "namespace",
+      "sparseVectors"
+    ]);
+    const { indexName, vectors, metadata, ids, namespace, sparseVectors } = params;
+    const index = this.client.Index(indexName).namespace(namespace || "");
     const vectorIds = ids || vectors.map(() => crypto.randomUUID());
     const records = vectors.map((vector, i) => ({
       id: vectorIds[i],
       values: vector,
+      ...sparseVectors?.[i] && { sparseValues: sparseVectors?.[i] },
       metadata: metadata?.[i] || {}
     }));
     const batchSize = 100;
@@ -138,17 +142,24 @@ var PineconeVector = class extends MastraVector {
     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 params = this.normalizeArgs("query", args, [
+      "namespace",
+      "sparseVector"
+    ]);
+    const { indexName, queryVector, topK = 10, filter, includeVector = false, namespace, sparseVector } = params;
+    const index = this.client.Index(indexName).namespace(namespace || "");
     const translatedFilter = this.transformFilter(filter) ?? void 0;
-    const results = await index.query({
+    const queryParams = {
       vector: queryVector,
       topK,
-      filter: translatedFilter,
       includeMetadata: true,
-      includeValues: includeVector
-    });
+      includeValues: includeVector,
+      filter: translatedFilter
+    };
+    if (sparseVector) {
+      queryParams.sparseVector = sparseVector;
+    }
+    const results = await index.query(queryParams);
     return results.matches.map((match) => ({
       id: match.id,
       score: match.score || 0,
@@ -167,7 +178,8 @@ var PineconeVector = class extends MastraVector {
     return {
       dimension: description.dimension,
       count: stats.totalRecordCount || 0,
-      metric: description.metric
+      metric: description.metric,
+      namespaces: stats.namespaces
     };
   }
   async deleteIndex(indexName) {
@@ -177,11 +189,11 @@ var PineconeVector = class extends MastraVector {
       throw new Error(`Failed to delete Pinecone index: ${error.message}`);
     }
   }
-  async updateIndexById(indexName, id, update) {
+  async updateIndexById(indexName, id, update, namespace) {
     if (!update.vector && !update.metadata) {
       throw new Error("No updates provided");
     }
-    const index = this.client.Index(indexName);
+    const index = this.client.Index(indexName).namespace(namespace || "");
     const updateObj = { id };
     if (update.vector) {
       updateObj.values = update.vector;
@@ -191,8 +203,8 @@ var PineconeVector = class extends MastraVector {
     }
     await index.update(updateObj);
   }
-  async deleteIndexById(indexName, id) {
-    const index = this.client.Index(indexName);
+  async deleteIndexById(indexName, id, namespace) {
+    const index = this.client.Index(indexName).namespace(namespace || "");
     await index.deleteOne(id);
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/pinecone",
-  "version": "0.2.4",
+  "version": "0.2.5-alpha.1",
   "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.7.0"
+    "@mastra/core": "^0.8.0-alpha.1"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.1",

package/src/vector/index.test.ts

@@ -1,8 +1,8 @@
+import type { QueryResult } from '@mastra/core/vector';
 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();
 
@@ -13,6 +13,25 @@ const PINECONE_API_KEY = process.env.PINECONE_API_KEY!;
 // }
 // TODO: skip until we the secrets on Github
 
+vi.setConfig({ testTimeout: 80_000, hookTimeout: 80_000 });
+
+// Helper function to create sparse vectors for testing
+function createSparseVector(text: string) {
+  const words = text.toLowerCase().split(/\W+/).filter(Boolean);
+  const uniqueWords = Array.from(new Set(words));
+  const indices: number[] = [];
+  const values: number[] = [];
+
+  // Create a simple term frequency vector
+  uniqueWords.forEach((word, i) => {
+    const frequency = words.filter(w => w === word).length;
+    indices.push(i);
+    values.push(frequency);
+  });
+
+  return { indices, values };
+}
+
 function waitUntilReady(vectorDB: PineconeVector, indexName: string) {
   return new Promise(resolve => {
     const interval = setInterval(async () => {
@@ -25,22 +44,63 @@ function waitUntilReady(vectorDB: PineconeVector, indexName: string) {
       } catch (error) {
         console.log(error);
       }
-    }, 1000);
+    }, 5000);
   });
 }
 
-function waitUntilVectorsIndexed(vectorDB: PineconeVector, indexName: string, expectedCount: number) {
+function waitUntilIndexDeleted(vectorDB: PineconeVector, indexName: string) {
   return new Promise((resolve, reject) => {
-    const maxAttempts = 30; // 30 seconds max
+    const maxAttempts = 60;
     let attempts = 0;
+
     const interval = setInterval(async () => {
       try {
-        const stats = await vectorDB.describeIndex(indexName);
-        if (stats && stats.count >= expectedCount) {
+        const indexes = await vectorDB.listIndexes();
+        if (!indexes.includes(indexName)) {
           clearInterval(interval);
           resolve(true);
         }
         attempts++;
+        if (attempts >= maxAttempts) {
+          clearInterval(interval);
+          reject(new Error('Timeout waiting for index to be deleted'));
+        }
+      } catch (error) {
+        console.log(error);
+      }
+    }, 5000);
+  });
+}
+
+function waitUntilVectorsIndexed(
+  vectorDB: PineconeVector,
+  indexName: string,
+  expectedCount: number,
+  exactCount = false,
+) {
+  return new Promise((resolve, reject) => {
+    const maxAttempts = 60;
+    let attempts = 0;
+    let lastCount = 0;
+    let stableCount = 0;
+
+    const interval = setInterval(async () => {
+      try {
+        const stats = await vectorDB.describeIndex(indexName);
+        const check = exactCount ? stats?.count === expectedCount : stats?.count >= expectedCount;
+        if (stats && check) {
+          if (stats.count === lastCount) {
+            stableCount++;
+            if (stableCount >= 2) {
+              clearInterval(interval);
+              resolve(true);
+            }
+          } else {
+            stableCount = 1;
+          }
+          lastCount = stats.count;
+        }
+        attempts++;
         if (attempts >= maxAttempts) {
           clearInterval(interval);
           reject(new Error('Timeout waiting for vectors to be indexed'));
@@ -48,17 +108,52 @@ function waitUntilVectorsIndexed(vectorDB: PineconeVector, indexName: string, ex
       } catch (error) {
         console.log(error);
       }
-    }, 1000);
+    }, 10000);
   });
 }
 // TODO: our pinecone account is over the limit, tests don't work in CI
 describe.skip('PineconeVector Integration Tests', () => {
   let vectorDB: PineconeVector;
-  const testIndexName = 'test-index-' + Date.now(); // Unique index name for each test run
+  const testIndexName = 'test-index'; // Unique index name for each test run
+  const indexNameUpdate = 'test-index-update';
+  const indexNameDelete = 'test-index-delete';
+  const indexNameNamespace = 'test-index-namespace';
+  const indexNameHybrid = 'test-index-hybrid';
   const dimension = 3;
 
   beforeAll(async () => {
     vectorDB = new PineconeVector(PINECONE_API_KEY);
+    // Delete test index
+    try {
+      await vectorDB.deleteIndex(testIndexName);
+      await waitUntilIndexDeleted(vectorDB, testIndexName);
+    } catch {
+      // Ignore errors if index doesn't exist
+    }
+    try {
+      await vectorDB.deleteIndex(indexNameUpdate);
+      await waitUntilIndexDeleted(vectorDB, indexNameUpdate);
+    } catch {
+      // Ignore errors if index doesn't exist
+    }
+    try {
+      await vectorDB.deleteIndex(indexNameDelete);
+      await waitUntilIndexDeleted(vectorDB, indexNameDelete);
+    } catch {
+      // Ignore errors if index doesn't exist
+    }
+    try {
+      await vectorDB.deleteIndex(indexNameNamespace);
+      await waitUntilIndexDeleted(vectorDB, indexNameNamespace);
+    } catch {
+      // Ignore errors if index doesn't exist
+    }
+    try {
+      await vectorDB.deleteIndex(indexNameHybrid);
+      await waitUntilIndexDeleted(vectorDB, indexNameHybrid);
+    } catch {
+      // Ignore errors if index doesn't exist
+    }
     // Create test index
     await vectorDB.createIndex({ indexName: testIndexName, dimension });
     await waitUntilReady(vectorDB, testIndexName);
@@ -66,7 +161,31 @@ describe.skip('PineconeVector Integration Tests', () => {
 
   afterAll(async () => {
     // Cleanup: delete test index
-    await vectorDB.deleteIndex(testIndexName);
+    try {
+      await vectorDB.deleteIndex(testIndexName);
+    } catch {
+      // Ignore errors if index doesn't exist
+    }
+    try {
+      await vectorDB.deleteIndex(indexNameUpdate);
+    } catch {
+      // Ignore errors if index doesn't exist
+    }
+    try {
+      await vectorDB.deleteIndex(indexNameDelete);
+    } catch {
+      // Ignore errors if index doesn't exist
+    }
+    try {
+      await vectorDB.deleteIndex(indexNameNamespace);
+    } catch {
+      // Ignore errors if index doesn't exist
+    }
+    try {
+      await vectorDB.deleteIndex(indexNameHybrid);
+    } catch {
+      // Ignore errors if index doesn't exist
+    }
   }, 500000);
 
   describe('Index Operations', () => {
@@ -134,8 +253,22 @@ describe.skip('PineconeVector Integration Tests', () => {
         [7, 8, 9],
       ];
 
+      beforeEach(async () => {
+        await vectorDB.createIndex({ indexName: indexNameUpdate, dimension, metric: 'cosine' });
+        await waitUntilReady(vectorDB, indexNameUpdate);
+      });
+
+      afterEach(async () => {
+        try {
+          await vectorDB.deleteIndex(indexNameUpdate);
+          await waitUntilIndexDeleted(vectorDB, indexNameUpdate);
+        } catch {
+          // Ignore errors if index doesn't exist
+        }
+      });
+
       it('should update the vector by id', async () => {
-        const ids = await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors });
+        const ids = await vectorDB.upsert({ indexName: indexNameUpdate, vectors: testVectors });
         expect(ids).toHaveLength(3);
 
         const idToBeUpdated = ids[0];
@@ -149,12 +282,12 @@ describe.skip('PineconeVector Integration Tests', () => {
           metadata: newMetaData,
         };
 
-        await vectorDB.updateIndexById(testIndexName, idToBeUpdated, update);
+        await vectorDB.updateIndexById(indexNameUpdate, idToBeUpdated, update);
 
-        await new Promise(resolve => setTimeout(resolve, 3000));
+        await waitUntilVectorsIndexed(vectorDB, indexNameUpdate, 3);
 
         const results: QueryResult[] = await vectorDB.query({
-          indexName: testIndexName,
+          indexName: indexNameUpdate,
           queryVector: newVector,
           topK: 10,
           includeVector: true,
@@ -166,7 +299,7 @@ describe.skip('PineconeVector Integration Tests', () => {
       }, 500000);
 
       it('should only update the metadata by id', async () => {
-        const ids = await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors });
+        const ids = await vectorDB.upsert({ indexName: indexNameUpdate, vectors: testVectors });
         expect(ids).toHaveLength(3);
 
         const idToBeUpdated = ids[0];
@@ -178,12 +311,12 @@ describe.skip('PineconeVector Integration Tests', () => {
           metadata: newMetaData,
         };
 
-        await vectorDB.updateIndexById(testIndexName, idToBeUpdated, update);
+        await vectorDB.updateIndexById(indexNameUpdate, idToBeUpdated, update);
 
-        await new Promise(resolve => setTimeout(resolve, 3000));
+        await waitUntilVectorsIndexed(vectorDB, indexNameUpdate, 3);
 
         const results: QueryResult[] = await vectorDB.query({
-          indexName: testIndexName,
+          indexName: indexNameUpdate,
           queryVector: testVectors[0],
           topK: 2,
           includeVector: true,
@@ -195,38 +328,34 @@ describe.skip('PineconeVector Integration Tests', () => {
       }, 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));
-
+        const ids = await vectorDB.upsert({ indexName: indexNameUpdate, vectors: testVectors });
         expect(ids).toHaveLength(3);
 
         const idToBeUpdated = ids[0];
-        const newVector = [1, 2, 3];
+        const newVector = [4, 4, 4];
 
         const update = {
           vector: newVector,
         };
 
-        await vectorDB.updateIndexById(testIndexName, idToBeUpdated, update);
+        await vectorDB.updateIndexById(indexNameUpdate, idToBeUpdated, update);
 
-        await new Promise(resolve => setTimeout(resolve, 5000));
+        await waitUntilVectorsIndexed(vectorDB, indexNameUpdate, 3);
 
         const results: QueryResult[] = await vectorDB.query({
-          indexName: testIndexName,
+          indexName: indexNameUpdate,
           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);
+        const updatedResult = results.find(r => r.id === idToBeUpdated);
+        expect(updatedResult).toBeDefined();
+        expect(updatedResult?.vector).toEqual(newVector);
       }, 500000);
 
-      it('should throw exception when no updates are given', () => {
-        expect(vectorDB.updateIndexById(testIndexName, 'id', {})).rejects.toThrow('No updates provided');
+      it('should throw exception when no updates are given', async () => {
+        await expect(vectorDB.updateIndexById(indexNameUpdate, 'id', {})).rejects.toThrow('No updates provided');
       });
 
       it('should throw error for non-existent index', async () => {
@@ -236,13 +365,13 @@ describe.skip('PineconeVector Integration Tests', () => {
 
       it('should throw error for invalid vector dimension', async () => {
         const [id] = await vectorDB.upsert({
-          indexName: testIndexName,
+          indexName: indexNameUpdate,
           vectors: [[1, 2, 3]],
           metadata: [{ test: 'initial' }],
         });
 
         await expect(
-          vectorDB.updateIndexById(testIndexName, id, { vector: [1, 2] }), // Wrong dimension
+          vectorDB.updateIndexById(indexNameUpdate, id, { vector: [1, 2] }), // Wrong dimension
         ).rejects.toThrow();
       }, 500000);
     });
@@ -254,16 +383,31 @@ describe.skip('PineconeVector Integration Tests', () => {
         [7, 8, 9],
       ];
 
+      beforeEach(async () => {
+        await vectorDB.createIndex({ indexName: indexNameDelete, dimension, metric: 'cosine' });
+        await waitUntilReady(vectorDB, indexNameDelete);
+      });
+
+      afterEach(async () => {
+        try {
+          await vectorDB.deleteIndex(indexNameDelete);
+          await waitUntilIndexDeleted(vectorDB, indexNameDelete);
+        } catch {
+          // Ignore errors if index doesn't exist
+        }
+      });
+
       it('should delete the vector by id', async () => {
-        const ids = await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors });
+        const ids = await vectorDB.upsert({ indexName: indexNameDelete, vectors: testVectors });
         expect(ids).toHaveLength(3);
         const idToBeDeleted = ids[0];
 
-        await vectorDB.deleteIndexById(testIndexName, idToBeDeleted);
+        await vectorDB.deleteIndexById(indexNameDelete, idToBeDeleted);
+        await waitUntilVectorsIndexed(vectorDB, indexNameDelete, 2, true);
 
         // Query all vectors similar to the deleted one
         const results: QueryResult[] = await vectorDB.query({
-          indexName: testIndexName,
+          indexName: indexNameDelete,
           queryVector: testVectors[0],
           topK: 3,
           includeVector: true,
@@ -275,6 +419,141 @@ describe.skip('PineconeVector Integration Tests', () => {
     });
   });
 
+  describe('Namespace Operations', () => {
+    const namespace1 = 'test-namespace-1';
+    const namespace2 = 'test-namespace-2';
+    const testVector = [1.0, 0.0, 0.0];
+    const testMetadata = { label: 'test' };
+
+    beforeEach(async () => {
+      await vectorDB.createIndex({ indexName: indexNameNamespace, dimension, metric: 'cosine' });
+      await waitUntilReady(vectorDB, indexNameNamespace);
+    });
+
+    afterEach(async () => {
+      try {
+        await vectorDB.deleteIndex(indexNameNamespace);
+        await waitUntilIndexDeleted(vectorDB, indexNameNamespace);
+      } catch {
+        // Ignore errors if index doesn't exist
+      }
+    });
+
+    it('should isolate vectors in different namespaces', async () => {
+      // Insert same vector in two namespaces
+      const [id1] = await vectorDB.upsert({
+        indexName: indexNameNamespace,
+        vectors: [testVector],
+        metadata: [testMetadata],
+        namespace: namespace1,
+      });
+      await waitUntilVectorsIndexed(vectorDB, indexNameNamespace, 1);
+
+      const [id2] = await vectorDB.upsert({
+        indexName: indexNameNamespace,
+        vectors: [testVector],
+        metadata: [{ ...testMetadata, label: 'test2' }],
+        namespace: namespace2,
+      });
+      await waitUntilVectorsIndexed(vectorDB, indexNameNamespace, 2);
+
+      // Query namespace1
+      const results1 = await vectorDB.query({
+        indexName: indexNameNamespace,
+        queryVector: testVector,
+        namespace: namespace1,
+      });
+
+      // Query namespace2
+      const results2 = await vectorDB.query({
+        indexName: indexNameNamespace,
+        queryVector: testVector,
+        namespace: namespace2,
+      });
+
+      // Verify isolation
+      expect(results1).toHaveLength(1);
+      expect(results2).toHaveLength(1);
+      expect(results1[0]?.id).toBe(id1);
+      expect(results1[0]?.metadata?.label).toBe('test');
+      expect(results2[0]?.id).toBe(id2);
+      expect(results2[0]?.metadata?.label).toBe('test2');
+    }, 500000);
+
+    it('should update vectors within specific namespace', async () => {
+      const [id] = await vectorDB.upsert({
+        indexName: indexNameNamespace,
+        vectors: [testVector],
+        metadata: [testMetadata],
+        namespace: namespace1,
+      });
+      await waitUntilVectorsIndexed(vectorDB, indexNameNamespace, 1);
+
+      // Update in namespace1
+      await vectorDB.updateIndexById(indexNameNamespace, id, { metadata: { label: 'updated' } }, namespace1);
+
+      await waitUntilVectorsIndexed(vectorDB, indexNameNamespace, 1);
+
+      // Query to verify update
+      const results = await vectorDB.query({
+        indexName: indexNameNamespace,
+        queryVector: testVector,
+        namespace: namespace1,
+      });
+
+      expect(results).toHaveLength(1);
+      expect(results[0]?.metadata?.label).toBe('updated');
+    }, 500000);
+
+    it('should delete vectors from specific namespace', async () => {
+      const [id] = await vectorDB.upsert({
+        indexName: indexNameNamespace,
+        vectors: [testVector],
+        metadata: [testMetadata],
+        namespace: namespace1,
+      });
+      await waitUntilVectorsIndexed(vectorDB, indexNameNamespace, 1);
+
+      // Delete from namespace1
+      await vectorDB.deleteIndexById(indexNameNamespace, id, namespace1);
+
+      await waitUntilVectorsIndexed(vectorDB, indexNameNamespace, 0, true);
+
+      // Query to verify deletion
+      const results = await vectorDB.query({
+        indexName: indexNameNamespace,
+        queryVector: testVector,
+        namespace: namespace1,
+      });
+
+      expect(results.length).toBe(0);
+    }, 500000);
+
+    it('should show namespace stats in describeIndex', async () => {
+      await vectorDB.upsert({
+        indexName: indexNameNamespace,
+        vectors: [testVector],
+        metadata: [testMetadata],
+        namespace: namespace1,
+      });
+      await waitUntilVectorsIndexed(vectorDB, indexNameNamespace, 1);
+      await vectorDB.upsert({
+        indexName: indexNameNamespace,
+        vectors: [testVector],
+        metadata: [{ ...testMetadata, label: 'test2' }],
+        namespace: namespace2,
+      });
+      await waitUntilVectorsIndexed(vectorDB, indexNameNamespace, 2);
+
+      const stats = await vectorDB.describeIndex(indexNameNamespace);
+      expect(stats.namespaces).toBeDefined();
+      expect(stats.namespaces?.[namespace1]).toBeDefined();
+      expect(stats.namespaces?.[namespace2]).toBeDefined();
+      expect(stats.namespaces?.[namespace1].recordCount).toBe(1);
+      expect(stats.namespaces?.[namespace2].recordCount).toBe(1);
+    }, 500000);
+  });
+
   describe('Error Handling', () => {
     it('should handle non-existent index query gracefully', async () => {
       const nonExistentIndex = 'non-existent-index';
@@ -1024,6 +1303,109 @@ describe.skip('PineconeVector Integration Tests', () => {
       expect(results.length).toBeGreaterThan(0);
     });
   });
+
+  describe('Hybrid Search Operations', () => {
+    const testVectors = [
+      [0.9, 0.1, 0.0], // cats (very distinct)
+      [0.1, 0.9, 0.0], // dogs (very distinct)
+      [0.0, 0.0, 0.9], // birds (completely different)
+    ];
+
+    const testMetadata = [
+      { text: 'cats purr and meow', animal: 'cat' },
+      { text: 'dogs bark and fetch', animal: 'dog' },
+      { text: 'birds fly and nest', animal: 'bird' },
+    ];
+
+    // Create sparse vectors with fixed vocabulary indices
+    const testSparseVectors = [
+      { indices: [0], values: [1.0] }, // cat terms only
+      { indices: [1], values: [1.0] }, // dog terms only
+      { indices: [2], values: [1.0] }, // bird terms only
+    ];
+
+    beforeEach(async () => {
+      await vectorDB.createIndex({ indexName: indexNameHybrid, dimension: 3, metric: 'dotproduct' });
+      await waitUntilReady(vectorDB, indexNameHybrid);
+
+      // Upsert with both dense and sparse vectors
+      await vectorDB.upsert({
+        indexName: indexNameHybrid,
+        vectors: testVectors,
+        sparseVectors: testSparseVectors,
+        metadata: testMetadata,
+      });
+      await waitUntilVectorsIndexed(vectorDB, indexNameHybrid, 3);
+    });
+
+    afterEach(async () => {
+      try {
+        await vectorDB.deleteIndex(indexNameHybrid);
+        await waitUntilIndexDeleted(vectorDB, indexNameHybrid);
+      } catch {
+        // Ignore errors if index doesn't exist
+      }
+    });
+
+    it('should combine dense and sparse signals in hybrid search', async () => {
+      // Query vector strongly favors cats
+      const queryVector = [1.0, 0.0, 0.0];
+      // But sparse vector strongly favors dogs
+      const sparseVector = {
+        indices: [1], // Index 1 corresponds to dog-related terms
+        values: [1.0], // Maximum weight for dog terms
+      };
+
+      const results = await vectorDB.query({
+        indexName: indexNameHybrid,
+        queryVector,
+        sparseVector,
+        topK: 2,
+      });
+
+      expect(results).toHaveLength(2);
+
+      // Get results with just vector similarity
+      const vectorResults = await vectorDB.query({
+        indexName: indexNameHybrid,
+        queryVector,
+        topK: 2,
+      });
+
+      // Results should be different when using hybrid search vs just vector
+      expect(results[0].id).not.toBe(vectorResults[0].id);
+
+      // First result should be dog due to sparse vector influence
+      expect(results[0].metadata?.animal).toBe('dog');
+    });
+
+    it('should support sparse vectors as optional parameters', async () => {
+      // Should work with just dense vectors in upsert
+      await vectorDB.upsert({
+        indexName: indexNameHybrid,
+        vectors: [[0.1, 0.2, 0.3]],
+        metadata: [{ test: 'dense only' }],
+      });
+
+      // Should work with just dense vector in query
+      const denseOnlyResults = await vectorDB.query({
+        indexName: indexNameHybrid,
+        queryVector: [0.1, 0.2, 0.3],
+        topK: 1,
+      });
+      expect(denseOnlyResults).toHaveLength(1);
+
+      // Should work with both dense and sparse in query
+      const hybridResults = await vectorDB.query({
+        indexName: indexNameHybrid,
+        queryVector: [0.1, 0.2, 0.3],
+        sparseVector: createSparseVector('test query'),
+        topK: 1,
+      });
+      expect(hybridResults).toHaveLength(1);
+    });
+  });
+
   describe('Deprecation Warnings', () => {
     const indexName = 'testdeprecationwarnings';
 

package/src/vector/index.ts

@@ -6,13 +6,38 @@ import type {
   UpsertVectorParams,
   QueryVectorParams,
   ParamsToArgs,
+  QueryVectorArgs,
+  UpsertVectorArgs,
 } 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 type {
+  IndexStatsDescription,
+  QueryOptions,
+  RecordSparseValues,
+  UpdateOptions,
+} from '@pinecone-database/pinecone';
 
 import { PineconeFilterTranslator } from './filter';
 
+interface PineconeIndexStats extends IndexStats {
+  namespaces?: IndexStatsDescription['namespaces'];
+}
+
+interface PineconeQueryVectorParams extends QueryVectorParams {
+  namespace?: string;
+  sparseVector?: RecordSparseValues;
+}
+
+type PineconeQueryVectorArgs = [...QueryVectorArgs, string?, RecordSparseValues?];
+
+interface PineconeUpsertVectorParams extends UpsertVectorParams {
+  namespace?: string;
+  sparseVectors?: RecordSparseValues[];
+}
+
+type PineconeUpsertVectorArgs = [...UpsertVectorArgs, string?, RecordSparseValues[]?];
+
 export class PineconeVector extends MastraVector {
   private client: Pinecone;
 
@@ -57,12 +82,15 @@ export class PineconeVector extends MastraVector {
     });
   }
 
-  async upsert(...args: ParamsToArgs<UpsertVectorParams>): Promise<string[]> {
-    const params = this.normalizeArgs<UpsertVectorParams>('upsert', args);
+  async upsert(...args: ParamsToArgs<PineconeUpsertVectorParams> | PineconeUpsertVectorArgs): Promise<string[]> {
+    const params = this.normalizeArgs<PineconeUpsertVectorParams, PineconeUpsertVectorArgs>('upsert', args, [
+      'namespace',
+      'sparseVectors',
+    ]);
 
-    const { indexName, vectors, metadata, ids } = params;
+    const { indexName, vectors, metadata, ids, namespace, sparseVectors } = params;
 
-    const index = this.client.Index(indexName);
+    const index = this.client.Index(indexName).namespace(namespace || '');
 
     // Generate IDs if not provided
     const vectorIds = ids || vectors.map(() => crypto.randomUUID());
@@ -70,6 +98,7 @@ export class PineconeVector extends MastraVector {
     const records = vectors.map((vector, i) => ({
       id: vectorIds[i]!,
       values: vector,
+      ...(sparseVectors?.[i] && { sparseValues: sparseVectors?.[i] }),
       metadata: metadata?.[i] || {},
     }));
 
@@ -88,22 +117,32 @@ export class PineconeVector extends MastraVector {
     return translator.translate(filter);
   }
 
-  async query(...args: ParamsToArgs<QueryVectorParams>): Promise<QueryResult[]> {
-    const params = this.normalizeArgs<QueryVectorParams>('query', args);
+  async query(...args: ParamsToArgs<PineconeQueryVectorParams> | PineconeQueryVectorArgs): Promise<QueryResult[]> {
+    const params = this.normalizeArgs<PineconeQueryVectorParams, PineconeQueryVectorArgs>('query', args, [
+      'namespace',
+      'sparseVector',
+    ]);
 
-    const { indexName, queryVector, topK = 10, filter, includeVector = false } = params;
+    const { indexName, queryVector, topK = 10, filter, includeVector = false, namespace, sparseVector } = params;
 
-    const index = this.client.Index(indexName);
+    const index = this.client.Index(indexName).namespace(namespace || '');
 
     const translatedFilter = this.transformFilter(filter) ?? undefined;
 
-    const results = await index.query({
+    const queryParams: QueryOptions = {
       vector: queryVector,
       topK,
-      filter: translatedFilter,
       includeMetadata: true,
       includeValues: includeVector,
-    });
+      filter: translatedFilter,
+    };
+
+    // If sparse vector is provided, use hybrid search
+    if (sparseVector) {
+      queryParams.sparseVector = sparseVector;
+    }
+
+    const results = await index.query(queryParams);
 
     return results.matches.map(match => ({
       id: match.id,
@@ -118,7 +157,7 @@ export class PineconeVector extends MastraVector {
     return indexesResult?.indexes?.map(index => index.name) || [];
   }
 
-  async describeIndex(indexName: string): Promise<IndexStats> {
+  async describeIndex(indexName: string): Promise<PineconeIndexStats> {
     const index = this.client.Index(indexName);
     const stats = await index.describeIndexStats();
     const description = await this.client.describeIndex(indexName);
@@ -127,6 +166,7 @@ export class PineconeVector extends MastraVector {
       dimension: description.dimension,
       count: stats.totalRecordCount || 0,
       metric: description.metric as 'cosine' | 'euclidean' | 'dotproduct',
+      namespaces: stats.namespaces,
     };
   }
 
@@ -145,12 +185,13 @@ export class PineconeVector extends MastraVector {
       vector?: number[];
       metadata?: Record<string, any>;
     },
+    namespace?: string,
   ): Promise<void> {
     if (!update.vector && !update.metadata) {
       throw new Error('No updates provided');
     }
 
-    const index = this.client.Index(indexName);
+    const index = this.client.Index(indexName).namespace(namespace || '');
 
     const updateObj: UpdateOptions = { id };
 
@@ -165,8 +206,8 @@ export class PineconeVector extends MastraVector {
     await index.update(updateObj);
   }
 
-  async deleteIndexById(indexName: string, id: string): Promise<void> {
-    const index = this.client.Index(indexName);
+  async deleteIndexById(indexName: string, id: string, namespace?: string): Promise<void> {
+    const index = this.client.Index(indexName).namespace(namespace || '');
     await index.deleteOne(id);
   }
 }