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

package/src/vector/index.test.ts

@@ -1,5 +1,5 @@
 import dotenv from 'dotenv';
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { describe, it, expect, beforeAll, afterAll, beforeEach, vi, afterEach } from 'vitest';
 
 import { PineconeVector } from './';
 
@@ -59,7 +59,7 @@ describe.skip('PineconeVector Integration Tests', () => {
   beforeAll(async () => {
     vectorDB = new PineconeVector(PINECONE_API_KEY);
     // Create test index
-    await vectorDB.createIndex(testIndexName, dimension);
+    await vectorDB.createIndex({ indexName: testIndexName, dimension });
     await waitUntilReady(vectorDB, testIndexName);
   }, 500000);
 
@@ -92,7 +92,7 @@ describe.skip('PineconeVector Integration Tests', () => {
     let vectorIds: string[];
 
     it('should upsert vectors with metadata', async () => {
-      vectorIds = await vectorDB.upsert(testIndexName, testVectors, testMetadata);
+      vectorIds = await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors, metadata: testMetadata });
       expect(vectorIds).toHaveLength(3);
       // Wait for vectors to be indexed
       await waitUntilVectorsIndexed(vectorDB, testIndexName, 3);
@@ -100,7 +100,7 @@ describe.skip('PineconeVector Integration Tests', () => {
 
     it.skip('should query vectors and return nearest neighbors', async () => {
       const queryVector = [1.0, 0.1, 0.1];
-      const results = await vectorDB.query(testIndexName, queryVector, 3);
+      const results = await vectorDB.query({ indexName: testIndexName, queryVector, topK: 3 });
 
       expect(results).toHaveLength(3);
       expect(results[0]!.score).toBeGreaterThan(0);
@@ -111,7 +111,7 @@ describe.skip('PineconeVector Integration Tests', () => {
       const queryVector = [0.0, 1.0, 0.0];
       const filter = { label: 'y-axis' };
 
-      const results = await vectorDB.query(testIndexName, queryVector, 1, filter);
+      const results = await vectorDB.query({ indexName: testIndexName, queryVector, topK: 1, filter });
 
       expect(results).toHaveLength(1);
       expect(results?.[0]?.metadata?.label).toBe('y-axis');
@@ -119,7 +119,7 @@ describe.skip('PineconeVector Integration Tests', () => {
 
     it('should query vectors and return vectors in results', async () => {
       const queryVector = [0.0, 1.0, 0.0];
-      const results = await vectorDB.query(testIndexName, queryVector, 1, undefined, true);
+      const results = await vectorDB.query({ indexName: testIndexName, queryVector, topK: 1, includeVector: true });
 
       expect(results).toHaveLength(1);
       expect(results?.[0]?.vector).toBeDefined();
@@ -130,12 +130,12 @@ describe.skip('PineconeVector Integration Tests', () => {
   describe('Error Handling', () => {
     it('should handle non-existent index query gracefully', async () => {
       const nonExistentIndex = 'non-existent-index';
-      await expect(vectorDB.query(nonExistentIndex, [1, 0, 0])).rejects.toThrow();
+      await expect(vectorDB.query({ indexName: nonExistentIndex, queryVector: [1, 0, 0] })).rejects.toThrow();
     }, 500000);
 
     it('should handle incorrect dimension vectors', async () => {
       const wrongDimVector = [[1, 0]]; // 2D vector for 3D index
-      await expect(vectorDB.upsert(testIndexName, wrongDimVector)).rejects.toThrow();
+      await expect(vectorDB.upsert({ indexName: testIndexName, vectors: wrongDimVector })).rejects.toThrow();
     }, 500000);
   });
 
@@ -152,7 +152,7 @@ describe.skip('PineconeVector Integration Tests', () => {
       const metadata = vectors.map((_, i) => ({ id: i }));
 
       const start = Date.now();
-      const ids = await vectorDB.upsert(testIndexName, vectors, metadata);
+      const ids = await vectorDB.upsert({ indexName: testIndexName, vectors, metadata });
       const duration = Date.now() - start;
 
       expect(ids).toHaveLength(batchSize);
@@ -166,7 +166,7 @@ describe.skip('PineconeVector Integration Tests', () => {
       const start = Date.now();
       const promises = Array(numQueries)
         .fill(null)
-        .map(() => vectorDB.query(testIndexName, queryVector));
+        .map(() => vectorDB.query({ indexName: testIndexName, queryVector }));
 
       const results = await Promise.all(promises);
       const duration = Date.now() - start;
@@ -179,14 +179,14 @@ describe.skip('PineconeVector Integration Tests', () => {
   describe('Filter Validation in Queries', () => {
     it('rejects queries with null values', async () => {
       await expect(
-        vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          field: null,
-        }),
+        vectorDB.query({ indexName: testIndexName, queryVector: [1, 0, 0], topK: 10, filter: { field: null } }),
       ).rejects.toThrow();
 
       await expect(
-        vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          other: { $eq: null },
+        vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { other: { $eq: null } },
         }),
       ).rejects.toThrow('the $eq operator must be followed by a string, boolean or a number, got null instead');
     });
@@ -197,8 +197,10 @@ describe.skip('PineconeVector Integration Tests', () => {
       for (const op of ['$in', '$nin']) {
         for (const val of invalidValues) {
           await expect(
-            vectorDB.query(testIndexName, [1, 0, 0], 10, {
-              field: { [op]: val },
+            vectorDB.query({
+              indexName: testIndexName,
+              queryVector: [1, 0, 0],
+              filter: { field: { [op]: val } },
             }),
           ).rejects.toThrow(`the ${op} operator must be followed by a list of strings or a list of numbers`);
         }
@@ -211,8 +213,10 @@ describe.skip('PineconeVector Integration Tests', () => {
       for (const op of numOps) {
         for (const val of invalidNumericValues) {
           await expect(
-            vectorDB.query(testIndexName, [1, 0, 0], 10, {
-              field: { [op]: val },
+            vectorDB.query({
+              indexName: testIndexName,
+              queryVector: [1, 0, 0],
+              filter: { field: { [op]: val } },
             }),
           ).rejects.toThrow(`the ${op} operator must be followed by a number`);
         }
@@ -221,39 +225,49 @@ describe.skip('PineconeVector Integration Tests', () => {
 
     it('rejects multiple invalid values', async () => {
       await expect(
-        vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          field1: { $in: 'not-array' },
-          field2: { $exists: 'not-boolean' },
-          field3: { $gt: 'not-number' },
+        vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { field1: { $in: 'not-array' }, field2: { $exists: 'not-boolean' }, field3: { $gt: 'not-number' } },
         }),
       ).rejects.toThrow();
     });
 
     it('rejects invalid array values', async () => {
       await expect(
-        vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          field: { $in: [null] },
+        vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { field: { $in: [null] } },
         }),
       ).rejects.toThrow('the $in operator must be followed by a list of strings or a list of numbers');
 
       await expect(
-        vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          field: { $in: [undefined] },
+        vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { field: { $in: [undefined] } },
         }),
       ).rejects.toThrow('the $in operator must be followed by a list of strings or a list of numbers');
 
       await expect(
-        vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          field: { $all: 'not-an-array' },
+        vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { field: { $all: 'not-an-array' } },
         }),
       ).rejects.toThrow('A non-empty array is required for the $all operator');
     });
 
     it('handles empty object filters', async () => {
       // Test empty object at top level
-      await expect(vectorDB.query(testIndexName, [1, 0, 0], 10, { field: { $eq: {} } })).rejects.toThrow(
-        'the $eq operator must be followed by a string, boolean or a number, got {} instead',
-      );
+      await expect(
+        vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { field: { $eq: {} } },
+        }),
+      ).rejects.toThrow('the $eq operator must be followed by a string, boolean or a number, got {} instead');
     });
 
     it('handles empty/undefined filters by returning all results', async () => {
@@ -262,15 +276,23 @@ describe.skip('PineconeVector Integration Tests', () => {
       const noFilterCases = [{ field: {} }, { field: undefined }, { field: { $in: undefined } }];
 
       for (const filter of noFilterCases) {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, filter);
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter,
+        });
         expect(results.length).toBeGreaterThan(0);
       }
     });
     it('handles empty object filters', async () => {
       // Test empty object at top level
-      await expect(vectorDB.query(testIndexName, [1, 0, 0], 10, {})).rejects.toThrow(
-        'You must enter a `filter` object with at least one key-value pair.',
-      );
+      await expect(
+        vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: {},
+        }),
+      ).rejects.toThrow('You must enter a `filter` object with at least one key-value pair.');
     });
   });
 
@@ -298,15 +320,17 @@ describe.skip('PineconeVector Integration Tests', () => {
     ];
 
     beforeAll(async () => {
-      await vectorDB.upsert(testIndexName, testVectors, testMetadata);
+      await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors, metadata: testMetadata });
       // Wait for vectors to be indexed
       await waitUntilVectorsIndexed(vectorDB, testIndexName, testVectors.length);
     }, 500000);
 
     describe('Comparison Operators', () => {
       it('should filter with implict $eq', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          category: 'electronics',
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { category: 'electronics' },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -314,8 +338,10 @@ describe.skip('PineconeVector Integration Tests', () => {
         });
       });
       it('should filter with $eq operator', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          category: { $eq: 'electronics' },
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { category: { $eq: 'electronics' } },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -324,8 +350,10 @@ describe.skip('PineconeVector Integration Tests', () => {
       });
 
       it('should filter with $gt operator', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          price: { $gt: 500 },
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { price: { $gt: 500 } },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -334,8 +362,10 @@ describe.skip('PineconeVector Integration Tests', () => {
       });
 
       it('should filter with $gte operator', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          price: { $gte: 500 },
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { price: { $gte: 500 } },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -344,8 +374,10 @@ describe.skip('PineconeVector Integration Tests', () => {
       });
 
       it('should filter with $lt operator', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          price: { $lt: 100 },
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { price: { $lt: 100 } },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -354,8 +386,10 @@ describe.skip('PineconeVector Integration Tests', () => {
       });
 
       it('should filter with $lte operator', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          price: { $lte: 50 },
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { price: { $lte: 50 } },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -364,8 +398,10 @@ describe.skip('PineconeVector Integration Tests', () => {
       });
 
       it('should filter with $ne operator', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          category: { $ne: 'electronics' },
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { category: { $ne: 'electronics' } },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -374,8 +410,10 @@ describe.skip('PineconeVector Integration Tests', () => {
       });
 
       it('filters with $gte, $lt, $lte operators', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          price: { $gte: 25, $lte: 30 },
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { price: { $gte: 25, $lte: 30 } },
         });
         expect(results.length).toBe(2);
         results.forEach(result => {
@@ -387,8 +425,10 @@ describe.skip('PineconeVector Integration Tests', () => {
 
     describe('Array Operators', () => {
       it('should filter with $in operator for strings', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          category: { $in: ['electronics', 'books'] },
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { category: { $in: ['electronics', 'books'] } },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -397,8 +437,10 @@ describe.skip('PineconeVector Integration Tests', () => {
       });
 
       it('should filter with $in operator for numbers', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          price: { $in: [50, 75, 1000] },
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { price: { $in: [50, 75, 1000] } },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -407,8 +449,10 @@ describe.skip('PineconeVector Integration Tests', () => {
       });
 
       it('should filter with $nin operator', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          category: { $nin: ['electronics', 'books'] },
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { category: { $nin: ['electronics', 'books'] } },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -417,8 +461,10 @@ describe.skip('PineconeVector Integration Tests', () => {
       });
 
       it('should filter with $all operator', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          tags: { $all: ['premium', 'new'] },
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { tags: { $all: ['premium', 'new'] } },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -430,10 +476,10 @@ describe.skip('PineconeVector Integration Tests', () => {
 
     describe('Logical Operators', () => {
       it('should filter with implict $and', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          category: 'electronics',
-          price: { $gt: 700 },
-          inStock: true,
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { category: 'electronics', price: { $gt: 700 }, inStock: true },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -443,8 +489,10 @@ describe.skip('PineconeVector Integration Tests', () => {
         });
       });
       it('should filter with $and operator', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          $and: [{ category: 'electronics' }, { price: { $gt: 700 } }, { inStock: true }],
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { $and: [{ category: 'electronics' }, { price: { $gt: 700 } }, { inStock: true }] },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -455,8 +503,10 @@ describe.skip('PineconeVector Integration Tests', () => {
       });
 
       it('should filter with $or operator', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          $or: [{ price: { $gt: 900 } }, { tags: { $all: ['bestseller'] } }],
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { $or: [{ price: { $gt: 900 } }, { tags: { $all: ['bestseller'] } }] },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -467,14 +517,18 @@ describe.skip('PineconeVector Integration Tests', () => {
       });
 
       it('should handle nested logical operators', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          $and: [
-            {
-              $or: [{ category: 'electronics' }, { category: 'books' }],
-            },
-            { price: { $lt: 100 } },
-            { inStock: true },
-          ],
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: {
+            $and: [
+              {
+                $or: [{ category: 'electronics' }, { category: 'books' }],
+              },
+              { price: { $lt: 100 } },
+              { inStock: true },
+            ],
+          },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -487,8 +541,10 @@ describe.skip('PineconeVector Integration Tests', () => {
 
     describe('Complex Filter Combinations', () => {
       it('should combine comparison and array operators', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          $and: [{ price: { $gte: 500 } }, { tags: { $in: ['premium', 'refurbished'] } }],
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { $and: [{ price: { $gte: 500 } }, { tags: { $in: ['premium', 'refurbished'] } }] },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -498,8 +554,10 @@ describe.skip('PineconeVector Integration Tests', () => {
       });
 
       it('should handle multiple conditions on same field', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          $and: [{ price: { $gte: 30 } }, { price: { $lte: 800 } }],
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { $and: [{ price: { $gte: 30 } }, { price: { $lte: 800 } }] },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -510,15 +568,19 @@ describe.skip('PineconeVector Integration Tests', () => {
       });
 
       it('should handle complex nested conditions', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          $or: [
-            {
-              $and: [{ category: 'electronics' }, { price: { $gt: 700 } }, { tags: { $all: ['premium'] } }],
-            },
-            {
-              $and: [{ category: 'books' }, { price: { $lt: 50 } }, { tags: { $in: ['paperback'] } }],
-            },
-          ],
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: {
+            $or: [
+              {
+                $and: [{ category: 'electronics' }, { price: { $gt: 700 } }, { tags: { $all: ['premium'] } }],
+              },
+              {
+                $and: [{ category: 'books' }, { price: { $lt: 50 } }, { tags: { $in: ['paperback'] } }],
+              },
+            ],
+          },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -537,8 +599,10 @@ describe.skip('PineconeVector Integration Tests', () => {
       });
 
       it('combines existence checks with other operators', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          $and: [{ category: 'clothing' }, { optionalField: { $exists: false } }],
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { $and: [{ category: 'clothing' }, { optionalField: { $exists: false } }] },
         });
         expect(results.length).toBe(2);
         expect(results[0]!.metadata!.category).toBe('clothing');
@@ -548,8 +612,10 @@ describe.skip('PineconeVector Integration Tests', () => {
 
     describe('Edge Cases', () => {
       it('should handle numeric comparisons with decimals', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          rating: { $gt: 4.5 },
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { rating: { $gt: 4.5 } },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -558,8 +624,10 @@ describe.skip('PineconeVector Integration Tests', () => {
       });
 
       it('should handle boolean values', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          inStock: { $eq: false },
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { inStock: { $eq: false } },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -568,15 +636,19 @@ describe.skip('PineconeVector Integration Tests', () => {
       });
 
       it('should handle empty array in $in operator', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          category: { $in: [] },
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { category: { $in: [] } },
         });
         expect(results).toHaveLength(0);
       });
 
       it('should handle single value in $all operator', async () => {
-        const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          tags: { $all: ['premium'] },
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { tags: { $all: ['premium'] } },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -589,37 +661,57 @@ describe.skip('PineconeVector Integration Tests', () => {
   describe('Additional Validation Tests', () => {
     it('should reject non-numeric values in numeric comparisons', async () => {
       await expect(
-        vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          price: { $gt: '500' }, // string instead of number
+        vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { price: { $gt: '500' } }, // string instead of number
         }),
       ).rejects.toThrow('the $gt operator must be followed by a number');
     });
 
     it('should reject invalid types in $in operator', async () => {
       await expect(
-        vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          price: { $in: [true, false] }, // booleans instead of numbers
+        vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { price: { $in: [true, false] } }, // booleans instead of numbers
         }),
       ).rejects.toThrow('the $in operator must be followed by a list of strings or a list of numbers');
     });
 
     it('should reject mixed types in $in operator', async () => {
       await expect(
-        vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          field: { $in: ['string', 123] }, // mixed string and number
+        vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { field: { $in: ['string', 123] } }, // mixed string and number
         }),
       ).rejects.toThrow();
     });
     it('should handle undefined filter', async () => {
-      const results1 = await vectorDB.query(testIndexName, [1, 0, 0], 10, undefined);
-      const results2 = await vectorDB.query(testIndexName, [1, 0, 0], 10);
+      const results1 = await vectorDB.query({
+        indexName: testIndexName,
+        queryVector: [1, 0, 0],
+        filter: undefined,
+      });
+      const results2 = await vectorDB.query({
+        indexName: testIndexName,
+        queryVector: [1, 0, 0],
+      });
       expect(results1).toEqual(results2);
       expect(results1.length).toBeGreaterThan(0);
     });
 
     it('should handle null filter', async () => {
-      const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, null as any);
-      const results2 = await vectorDB.query(testIndexName, [1, 0, 0], 10);
+      const results = await vectorDB.query({
+        indexName: testIndexName,
+        queryVector: [1, 0, 0],
+        filter: null,
+      });
+      const results2 = await vectorDB.query({
+        indexName: testIndexName,
+        queryVector: [1, 0, 0],
+      });
       expect(results).toEqual(results2);
       expect(results.length).toBeGreaterThan(0);
     });
@@ -628,11 +720,10 @@ describe.skip('PineconeVector Integration Tests', () => {
   describe('Additional Edge Cases', () => {
     it('should handle exact boundary conditions', async () => {
       // Test exact boundary values from our test data
-      const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-        $and: [
-          { price: { $gte: 25 } }, // lowest price in our data
-          { price: { $lte: 1000 } }, // highest price in our data
-        ],
+      const results = await vectorDB.query({
+        indexName: testIndexName,
+        queryVector: [1, 0, 0],
+        filter: { $and: [{ price: { $gte: 25 } }, { price: { $lte: 1000 } }] },
       });
       expect(results.length).toBeGreaterThan(0);
       // Should include both boundary values
@@ -641,8 +732,10 @@ describe.skip('PineconeVector Integration Tests', () => {
     });
 
     it('should handle multiple $all conditions on same array field', async () => {
-      const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-        $and: [{ tags: { $all: ['premium'] } }, { tags: { $all: ['new'] } }],
+      const results = await vectorDB.query({
+        indexName: testIndexName,
+        queryVector: [1, 0, 0],
+        filter: { $and: [{ tags: { $all: ['premium'] } }, { tags: { $all: ['new'] } }] },
       });
       expect(results.length).toBeGreaterThan(0);
       results.forEach(result => {
@@ -652,8 +745,10 @@ describe.skip('PineconeVector Integration Tests', () => {
     });
 
     it('should handle multiple array operator combinations', async () => {
-      const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-        $and: [{ tags: { $all: ['premium'] } }, { tags: { $in: ['new', 'refurbished'] } }],
+      const results = await vectorDB.query({
+        indexName: testIndexName,
+        queryVector: [1, 0, 0],
+        filter: { $and: [{ tags: { $all: ['premium'] } }, { tags: { $in: ['new', 'refurbished'] } }] },
       });
       expect(results.length).toBeGreaterThan(0);
       results.forEach(result => {
@@ -665,15 +760,19 @@ describe.skip('PineconeVector Integration Tests', () => {
 
   describe('Additional Complex Logical Combinations', () => {
     it('should handle deeply nested $or conditions', async () => {
-      const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-        $or: [
-          {
-            $and: [{ category: 'electronics' }, { $or: [{ price: { $gt: 900 } }, { tags: { $all: ['premium'] } }] }],
-          },
-          {
-            $and: [{ category: 'books' }, { $or: [{ price: { $lt: 30 } }, { tags: { $all: ['bestseller'] } }] }],
-          },
-        ],
+      const results = await vectorDB.query({
+        indexName: testIndexName,
+        queryVector: [1, 0, 0],
+        filter: {
+          $or: [
+            {
+              $and: [{ category: 'electronics' }, { $or: [{ price: { $gt: 900 } }, { tags: { $all: ['premium'] } }] }],
+            },
+            {
+              $and: [{ category: 'books' }, { $or: [{ price: { $lt: 30 } }, { tags: { $all: ['bestseller'] } }] }],
+            },
+          ],
+        },
       });
       expect(results.length).toBeGreaterThan(0);
       results.forEach(result => {
@@ -686,8 +785,10 @@ describe.skip('PineconeVector Integration Tests', () => {
     });
 
     it('should handle multiple field comparisons with same value', async () => {
-      const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-        $or: [{ price: { $gt: 500 } }, { rating: { $gt: 4.5 } }],
+      const results = await vectorDB.query({
+        indexName: testIndexName,
+        queryVector: [1, 0, 0],
+        filter: { $or: [{ price: { $gt: 500 } }, { rating: { $gt: 4.5 } }] },
       });
       expect(results.length).toBeGreaterThan(0);
       results.forEach(result => {
@@ -696,11 +797,15 @@ describe.skip('PineconeVector Integration Tests', () => {
     });
 
     it('should handle combination of array and numeric comparisons', async () => {
-      const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-        $and: [
-          { tags: { $in: ['premium', 'bestseller'] } },
-          { $or: [{ price: { $gt: 500 } }, { rating: { $gt: 4.5 } }] },
-        ],
+      const results = await vectorDB.query({
+        indexName: testIndexName,
+        queryVector: [1, 0, 0],
+        filter: {
+          $and: [
+            { tags: { $in: ['premium', 'bestseller'] } },
+            { $or: [{ price: { $gt: 500 } }, { rating: { $gt: 4.5 } }] },
+          ],
+        },
       });
       expect(results.length).toBeGreaterThan(0);
       results.forEach(result => {
@@ -712,12 +817,16 @@ describe.skip('PineconeVector Integration Tests', () => {
 
   describe('Performance Edge Cases', () => {
     it('should handle filters with many conditions', async () => {
-      const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-        $and: Array(10)
-          .fill(null)
-          .map(() => ({
-            $or: [{ price: { $gt: 100 } }, { rating: { $gt: 4.0 } }],
-          })),
+      const results = await vectorDB.query({
+        indexName: testIndexName,
+        queryVector: [1, 0, 0],
+        filter: {
+          $and: Array(10)
+            .fill(null)
+            .map(() => ({
+              $or: [{ price: { $gt: 100 } }, { rating: { $gt: 4.0 } }],
+            })),
+        },
       });
       expect(results.length).toBeGreaterThan(0);
       results.forEach(result => {
@@ -726,12 +835,16 @@ describe.skip('PineconeVector Integration Tests', () => {
     });
 
     it('should handle deeply nested conditions efficiently', async () => {
-      const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-        $or: Array(5)
-          .fill(null)
-          .map(() => ({
-            $and: [{ category: { $in: ['electronics', 'books'] } }, { price: { $gt: 50 } }, { rating: { $gt: 4.0 } }],
-          })),
+      const results = await vectorDB.query({
+        indexName: testIndexName,
+        queryVector: [1, 0, 0],
+        filter: {
+          $or: Array(5)
+            .fill(null)
+            .map(() => ({
+              $and: [{ category: { $in: ['electronics', 'books'] } }, { price: { $gt: 50 } }, { rating: { $gt: 4.0 } }],
+            })),
+        },
       });
       expect(results.length).toBeGreaterThan(0);
       results.forEach(result => {
@@ -742,21 +855,164 @@ describe.skip('PineconeVector Integration Tests', () => {
     });
 
     it('should handle large number of $or conditions', async () => {
-      const results = await vectorDB.query(testIndexName, [1, 0, 0], 10, {
-        $or: [
-          ...Array(5)
-            .fill(null)
-            .map((_, i) => ({
-              price: { $gt: i * 100 },
-            })),
-          ...Array(5)
-            .fill(null)
-            .map((_, i) => ({
-              rating: { $gt: 4.0 + i * 0.1 },
-            })),
-        ],
+      const results = await vectorDB.query({
+        indexName: testIndexName,
+        queryVector: [1, 0, 0],
+        filter: {
+          $or: [
+            ...Array(5)
+              .fill(null)
+              .map((_, i) => ({
+                price: { $gt: i * 100 },
+              })),
+            ...Array(5)
+              .fill(null)
+              .map((_, i) => ({
+                rating: { $gt: 4.0 + i * 0.1 },
+              })),
+          ],
+        },
       });
       expect(results.length).toBeGreaterThan(0);
     });
   });
+  describe('Deprecation Warnings', () => {
+    const indexName = 'testdeprecationwarnings';
+
+    const indexName2 = 'testdeprecationwarnings2';
+
+    const indexName3 = 'testdeprecationwarnings3';
+
+    const indexName4 = 'testdeprecationwarnings4';
+
+    let warnSpy;
+
+    beforeAll(async () => {
+      try {
+        await vectorDB.deleteIndex(indexName);
+      } catch {
+        // Ignore errors if index doesn't exist
+      }
+      try {
+        await vectorDB.deleteIndex(indexName2);
+      } catch {
+        // Ignore errors if index doesn't exist
+      }
+      try {
+        await vectorDB.deleteIndex(indexName3);
+      } catch {
+        // Ignore errors if index doesn't exist
+      }
+      try {
+        await vectorDB.deleteIndex(indexName4);
+      } catch {
+        // Ignore errors if index doesn't exist
+      }
+      await vectorDB.createIndex({ indexName: indexName, dimension: 3 });
+      await waitUntilReady(vectorDB, indexName);
+    });
+
+    afterAll(async () => {
+      try {
+        await vectorDB.deleteIndex(indexName);
+      } catch {
+        // Ignore errors if index doesn't exist
+      }
+      try {
+        await vectorDB.deleteIndex(indexName2);
+      } catch {
+        // Ignore errors if index doesn't exist
+      }
+      try {
+        await vectorDB.deleteIndex(indexName3);
+      } catch {
+        // Ignore errors if index doesn't exist
+      }
+      try {
+        await vectorDB.deleteIndex(indexName4);
+      } catch {
+        // Ignore errors if index doesn't exist
+      }
+    });
+
+    beforeEach(async () => {
+      warnSpy = vi.spyOn(vectorDB['logger'], 'warn');
+    });
+
+    afterEach(async () => {
+      warnSpy.mockRestore();
+    });
+
+    it('should show deprecation warning when using individual args for createIndex', async () => {
+      await vectorDB.createIndex(indexName2, 3, 'cosine');
+      await waitUntilReady(vectorDB, indexName2);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Deprecation Warning: Passing individual arguments to createIndex() is deprecated'),
+      );
+    });
+
+    it('should show deprecation warning when using individual args for upsert', async () => {
+      await vectorDB.upsert(indexName, [[1, 2, 3]], [{ test: 'data' }]);
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Deprecation Warning: Passing individual arguments to upsert() is deprecated'),
+      );
+    });
+
+    it('should show deprecation warning when using individual args for query', async () => {
+      await vectorDB.query(indexName, [1, 2, 3], 5);
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Deprecation Warning: Passing individual arguments to query() is deprecated'),
+      );
+    });
+
+    it('should not show deprecation warning when using object param for query', async () => {
+      await vectorDB.query({
+        indexName,
+        queryVector: [1, 2, 3],
+        topK: 5,
+      });
+
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+
+    it('should not show deprecation warning when using object param for createIndex', async () => {
+      await vectorDB.createIndex({
+        indexName: indexName3,
+        dimension: 3,
+        metric: 'cosine',
+      });
+
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+
+    it('should not show deprecation warning when using object param for upsert', async () => {
+      await vectorDB.upsert({
+        indexName,
+        vectors: [[1, 2, 3]],
+        metadata: [{ test: 'data' }],
+      });
+
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+
+    it('should maintain backward compatibility with individual args', async () => {
+      // Query
+      const queryResults = await vectorDB.query(indexName, [1, 2, 3], 5);
+      expect(Array.isArray(queryResults)).toBe(true);
+
+      // CreateIndex
+      await expect(vectorDB.createIndex(indexName4, 3, 'cosine')).resolves.not.toThrow();
+      await waitUntilReady(vectorDB, indexName4);
+      // Upsert
+      const upsertResults = await vectorDB.upsert({
+        indexName,
+        vectors: [[1, 2, 3]],
+        metadata: [{ test: 'data' }],
+      });
+      expect(Array.isArray(upsertResults)).toBe(true);
+      expect(upsertResults).toHaveLength(1);
+    });
+  });
 });