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

package/src/vector/index.test.ts

@@ -1,5 +1,5 @@
 import type { QueryResult, IndexStats } from '@mastra/core/vector';
-import { describe, expect, beforeEach, afterEach, it, beforeAll, afterAll } from 'vitest';
+import { describe, expect, beforeEach, afterEach, it, beforeAll, afterAll, vi } from 'vitest';
 
 import { ChromaVector } from './';
 
@@ -20,7 +20,7 @@ describe('ChromaVector Integration Tests', () => {
     } catch {
       // Ignore errors if index doesn't exist
     }
-    await vectorDB.createIndex(testIndexName, dimension);
+    await vectorDB.createIndex({ indexName: testIndexName, dimension });
   }, 5000);
 
   afterEach(async () => {
@@ -56,7 +56,7 @@ describe('ChromaVector Integration Tests', () => {
 
       for (const metric of metricsToTest) {
         const testIndex = `test-index-${metric}`;
-        await vectorDB.createIndex(testIndex, dimension, metric);
+        await vectorDB.createIndex({ indexName: testIndex, dimension, metric });
 
         const stats = await vectorDB.describeIndex(testIndex);
         expect(stats.metric).toBe(metric);
@@ -76,7 +76,7 @@ describe('ChromaVector Integration Tests', () => {
     const testIds = ['vec1', 'vec2', 'vec3'];
 
     it('should upsert vectors with generated ids', async () => {
-      const ids = await vectorDB.upsert(testIndexName, testVectors);
+      const ids = await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors });
       expect(ids).toHaveLength(testVectors.length);
       ids.forEach(id => expect(typeof id).toBe('string'));
 
@@ -85,14 +85,14 @@ describe('ChromaVector Integration Tests', () => {
     });
 
     it('should upsert vectors with provided ids and metadata', async () => {
-      await vectorDB.upsert(testIndexName, testVectors, testMetadata, testIds);
+      await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors, metadata: testMetadata, ids: testIds });
 
       const stats = await vectorDB.describeIndex(testIndexName);
       expect(stats.count).toBe(testVectors.length);
 
       // Query each vector to verify metadata
       for (let i = 0; i < testVectors.length; i++) {
-        const results = await vectorDB.query(testIndexName, testVectors?.[i]!, 1);
+        const results = await vectorDB.query({ indexName: testIndexName, queryVector: testVectors?.[i]!, topK: 1 });
         expect(results?.[0]?.id).toBe(testIds[i]);
         expect(results?.[0]?.metadata).toEqual(testMetadata[i]);
       }
@@ -100,15 +100,20 @@ describe('ChromaVector Integration Tests', () => {
 
     it('should update existing vectors', async () => {
       // Initial upsert
-      await vectorDB.upsert(testIndexName, testVectors, testMetadata, testIds);
+      await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors, metadata: testMetadata, ids: testIds });
 
       // Update first vector
       const updatedVector = [[0.5, 0.5, 0.0]];
       const updatedMetadata = [{ label: 'updated-x-axis' }];
-      await vectorDB.upsert(testIndexName, updatedVector, updatedMetadata, [testIds?.[0]!]);
+      await vectorDB.upsert({
+        indexName: testIndexName,
+        vectors: updatedVector,
+        metadata: updatedMetadata,
+        ids: [testIds?.[0]!],
+      });
 
       // Verify update
-      const results = await vectorDB.query(testIndexName, updatedVector?.[0]!, 1);
+      const results = await vectorDB.query({ indexName: testIndexName, queryVector: updatedVector?.[0]!, topK: 1 });
       expect(results?.[0]?.id).toBe(testIds[0]);
       expect(results?.[0]?.metadata).toEqual(updatedMetadata[0]);
     });
@@ -124,7 +129,7 @@ describe('ChromaVector Integration Tests', () => {
     const testIds = ['vec1', 'vec2', 'vec3'];
 
     beforeEach(async () => {
-      await vectorDB.upsert(testIndexName, testVectors, testMetadata, testIds);
+      await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors, metadata: testMetadata, ids: testIds });
     });
 
     describe('Basic Queries', () => {
@@ -132,7 +137,7 @@ describe('ChromaVector Integration Tests', () => {
         const queryVector = [1.0, 0.1, 0.1];
         const topK = 2;
 
-        const results: QueryResult[] = await vectorDB.query(testIndexName, queryVector, topK);
+        const results: QueryResult[] = await vectorDB.query({ indexName: testIndexName, queryVector, topK });
 
         expect(results).toHaveLength(topK);
         expect(results?.[0]?.id).toBe(testIds[0]); // Should match x-axis vector most closely
@@ -144,7 +149,7 @@ describe('ChromaVector Integration Tests', () => {
         const queryVector = [1.0, 1.0, 1.0];
         const filter = { label: 'x-axis' };
 
-        const results = await vectorDB.query(testIndexName, queryVector, 3, filter);
+        const results = await vectorDB.query({ indexName: testIndexName, queryVector, topK: 3, filter });
 
         expect(results).toHaveLength(1);
         expect(results?.[0]?.metadata?.label).toBe('x-axis');
@@ -156,7 +161,12 @@ describe('ChromaVector Integration Tests', () => {
         const queryVector = [1.0, 0.1, 0.1];
         const topK = 1;
 
-        const results = await vectorDB.query(testIndexName, queryVector, topK, undefined, true);
+        const results = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector,
+          topK,
+          includeVector: true,
+        });
 
         expect(results).toHaveLength(topK);
         expect(results?.[0]?.vector).toEqual(testVectors[0]);
@@ -166,73 +176,95 @@ describe('ChromaVector Integration Tests', () => {
 
   describe('Error Handling', () => {
     it('should handle non-existent index queries', async () => {
-      await expect(vectorDB.query('non-existent-index-yu', [1, 2, 3])).rejects.toThrow();
+      await expect(vectorDB.query({ indexName: 'non-existent-index-yu', queryVector: [1, 2, 3] })).rejects.toThrow();
     });
 
     it('should handle invalid dimension vectors', async () => {
       const invalidVector = [1, 2, 3, 4]; // 4D vector for 3D index
-      await expect(vectorDB.upsert(testIndexName, [invalidVector])).rejects.toThrow();
+      await expect(vectorDB.upsert({ indexName: testIndexName, vectors: [invalidVector] })).rejects.toThrow();
     });
 
     it('should handle mismatched metadata and vectors length', async () => {
       const vectors = [[1, 2, 3]];
       const metadata = [{}, {}]; // More metadata than vectors
-      await expect(vectorDB.upsert(testIndexName, vectors, metadata)).rejects.toThrow();
+      await expect(vectorDB.upsert({ indexName: testIndexName, vectors, metadata })).rejects.toThrow();
     });
   });
 
   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],
+          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();
     });
 
     it('validates array operator values', async () => {
       await expect(
-        vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          tags: { $in: null },
+        vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: {
+            tags: { $in: null },
+          },
         }),
       ).rejects.toThrow();
     });
 
     it('validates numeric values for comparison operators', async () => {
       await expect(
-        vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          price: { $gt: 'not-a-number' },
+        vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: {
+            price: { $gt: 'not-a-number' },
+          },
         }),
       ).rejects.toThrow();
     });
 
     it('validates value types', async () => {
       await expect(
-        vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          date: { $gt: 'not-a-date' },
+        vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { date: { $gt: 'not-a-date' } },
         }),
       ).rejects.toThrow();
 
       await expect(
-        vectorDB.query(testIndexName, [1, 0, 0], 10, {
-          number: { $lt: 'not-a-number' },
+        vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { number: { $lt: 'not-a-number' } },
         }),
       ).rejects.toThrow();
     });
 
     it('validates array operators', async () => {
-      const invalidValues = [123, 'string', true, { key: 'value' }, null, undefined];
+      const invalidValues = [123, 'string', true, { key: 'value' }, null];
       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();
         }
@@ -245,8 +277,10 @@ describe('ChromaVector 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();
         }
@@ -257,8 +291,10 @@ describe('ChromaVector Integration Tests', () => {
       // Basic equality can accept any non-undefined value
       for (const op of ['$eq', '$ne']) {
         await expect(
-          vectorDB.query(testIndexName, [1, 0, 0], 10, {
-            field: { [op]: undefined },
+          vectorDB.query({
+            indexName: testIndexName,
+            queryVector: [1, 0, 0],
+            filter: { field: { [op]: undefined } },
           }),
         ).rejects.toThrow();
       }
@@ -269,8 +305,10 @@ describe('ChromaVector 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();
         }
@@ -279,29 +317,45 @@ describe('ChromaVector Integration Tests', () => {
 
     it('validates 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('handles empty object filters', async () => {
       // Test empty object at top level
-      await expect(vectorDB.query(testIndexName, [1, 0, 0], 10, { field: { $eq: {} } })).rejects.toThrow();
+      await expect(
+        vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: { field: { $eq: {} } },
+        }),
+      ).rejects.toThrow();
     });
 
     it('handles empty/undefined filters by returning all results', async () => {
       const noFilterCases = [{ field: {} }, { field: undefined }, { field: { $in: undefined } }];
 
       for (const filter of noFilterCases) {
-        await expect(vectorDB.query(testIndexName, [1, 0, 0], 10, filter)).rejects.toThrow();
+        await expect(vectorDB.query({ indexName: testIndexName, queryVector: [1, 0, 0], filter })).rejects.toThrow();
       }
     });
     it('handles empty object filters', async () => {
       // Test empty object at top level
-      await expect(vectorDB.query(testIndexName, [1, 0, 0], 10, {})).rejects.toThrow();
+      await expect(
+        vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1, 0, 0],
+          filter: {},
+        }),
+      ).rejects.toThrow();
     });
   });
 
@@ -313,7 +367,7 @@ describe('ChromaVector Integration Tests', () => {
       } catch {
         // Ignore errors if index doesn't exist
       }
-      await vectorDB.createIndex(testIndexName2, dimension);
+      await vectorDB.createIndex({ indexName: testIndexName2, dimension });
 
       const vectors = [
         [1, 0, 0], // Electronics
@@ -349,7 +403,7 @@ describe('ChromaVector Integration Tests', () => {
         },
       ];
 
-      await vectorDB.upsert(testIndexName2, vectors, metadata);
+      await vectorDB.upsert({ indexName: testIndexName2, vectors, metadata });
       // Wait for indexing
       await new Promise(resolve => setTimeout(resolve, 2000));
     });
@@ -365,8 +419,10 @@ describe('ChromaVector Integration Tests', () => {
 
     describe('Basic Comparison Operators', () => {
       it('filters with $eq operator', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          category: { $eq: 'electronics' },
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { category: { $eq: 'electronics' } },
         });
         expect(results.length).toBe(2);
         results.forEach(result => {
@@ -375,8 +431,10 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('filters with implicit $eq', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          category: 'electronics', // implicit $eq
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { category: 'electronics' }, // implicit $eq
         });
         expect(results.length).toBe(2);
         results.forEach(result => {
@@ -384,8 +442,10 @@ describe('ChromaVector Integration Tests', () => {
         });
       });
       it('filters with $gt operator', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          price: { $gt: 500 },
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { price: { $gt: 500 } },
         });
         expect(results.length).toBe(1);
         results.forEach(result => {
@@ -394,8 +454,10 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('filters with $gte operator', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          price: { $gte: 500 },
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { price: { $gte: 500 } },
         });
         expect(results.length).toBe(2);
         results.forEach(result => {
@@ -404,8 +466,10 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('filters with $lt operator', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          price: { $lt: 100 },
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { price: { $lt: 100 } },
         });
         expect(results.length).toBe(2);
         results.forEach(result => {
@@ -414,8 +478,10 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('filters with $lte operator', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          price: { $lte: 500 },
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { price: { $lte: 500 } },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -424,8 +490,10 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('filters with $gte, $lt, $lte operators', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          price: { $gte: 25, $lte: 500 },
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { price: { $gte: 25, $lte: 500 } },
         });
         expect(results.length).toBe(2);
         results.forEach(result => {
@@ -435,8 +503,10 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('filters with $ne operator', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          category: { $ne: 'electronics' },
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { category: { $ne: 'electronics' } },
         });
         expect(results.length).toBe(2);
         results.forEach(result => {
@@ -445,8 +515,10 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('filters with boolean values', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          inStock: true, // test both implicit
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { inStock: true }, // test both implicit
         });
         expect(results.length).toBe(3);
         results.forEach(result => {
@@ -455,9 +527,10 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('filters with multiple fields', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          category: 'electronics',
-          price: 1000,
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { category: 'electronics', price: 1000 },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -468,8 +541,10 @@ describe('ChromaVector Integration Tests', () => {
 
     describe('Array Operators', () => {
       it('filters with $in operator', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          category: { $in: ['electronics', 'books'] },
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { category: { $in: ['electronics', 'books'] } },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -478,8 +553,10 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('should filter with $in operator for numbers', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          price: { $in: [50, 75, 1000] },
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { price: { $in: [50, 75, 1000] } },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -488,8 +565,10 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('filters with $in operator for booleans', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          inStock: { $in: [true] },
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { inStock: { $in: [true] } },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -500,8 +579,10 @@ describe('ChromaVector Integration Tests', () => {
 
     describe('Logical Operators', () => {
       it('filters with $and operator', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          $and: [{ category: 'electronics' }, { price: { $gt: 500 } }],
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { $and: [{ category: 'electronics' }, { price: { $gt: 500 } }] },
         });
         expect(results.length).toBe(1);
         expect(results[0]?.metadata?.category).toBe('electronics');
@@ -509,8 +590,10 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('should filter with $and operator', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          $and: [{ category: 'electronics' }, { price: { $gt: 700 } }, { inStock: true }],
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { $and: [{ category: 'electronics' }, { price: { $gt: 700 } }, { inStock: true }] },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -521,8 +604,10 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('filters with $or operator', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          $or: [{ price: { $gt: 900 } }, { rating: { $gt: 4.8 } }],
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { $or: [{ price: { $gt: 900 } }, { rating: { $gt: 4.8 } }] },
         });
         expect(results.length).toBe(2);
         results.forEach(result => {
@@ -531,8 +616,10 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('should filter with $or operator', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          $or: [{ price: { $gt: 900 } }, { category: { $in: ['electronics', 'books'] } }],
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { $or: [{ price: { $gt: 900 } }, { category: { $in: ['electronics', 'books'] } }] },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -543,14 +630,18 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('should handle nested logical operators', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          $and: [
-            {
-              $or: [{ category: 'electronics' }, { category: 'books' }],
-            },
-            { price: { $lt: 100 } },
-            { inStock: true },
-          ],
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: {
+            $and: [
+              {
+                $or: [{ category: 'electronics' }, { category: 'books' }],
+              },
+              { price: { $lt: 100 } },
+              { inStock: true },
+            ],
+          },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -561,22 +652,28 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('uses implicit $eq within $or', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          $or: [{ category: 'electronics' }, { price: { $gt: 100 } }],
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { $or: [{ category: 'electronics' }, { price: { $gt: 100 } }] },
         });
         expect(results.length).toBeGreaterThan(0);
       });
 
       it('requires multiple conditions in logical operators', async () => {
         await expect(
-          vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-            $and: [{ category: 'electronics' }],
+          vectorDB.query({
+            indexName: testIndexName2,
+            queryVector: [1, 0, 0],
+            filter: { $and: [{ category: 'electronics' }] },
           }),
         ).rejects.toThrow();
 
         await expect(
-          vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-            $or: [{ price: { $gt: 900 } }],
+          vectorDB.query({
+            indexName: testIndexName2,
+            queryVector: [1, 0, 0],
+            filter: { $or: [{ price: { $gt: 900 } }] },
           }),
         ).rejects.toThrow();
       });
@@ -584,14 +681,18 @@ describe('ChromaVector Integration Tests', () => {
 
     describe('Complex Filter Combinations', () => {
       it('combines multiple operators and conditions', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          $and: [
-            { price: { $gt: 20 } },
-            { inStock: true },
-            {
-              $or: [{ category: { $in: ['books'] } }, { rating: { $gt: 4.5 } }],
-            },
-          ],
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: {
+            $and: [
+              { price: { $gt: 20 } },
+              { inStock: true },
+              {
+                $or: [{ category: { $in: ['books'] } }, { rating: { $gt: 4.5 } }],
+              },
+            ],
+          },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -602,15 +703,19 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('handles complex nested conditions', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          $or: [
-            {
-              $and: [{ category: 'electronics' }, { price: { $gt: 700 } }],
-            },
-            {
-              $and: [{ category: 'books' }, { price: { $lt: 20 } }],
-            },
-          ],
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: {
+            $or: [
+              {
+                $and: [{ category: 'electronics' }, { price: { $gt: 700 } }],
+              },
+              {
+                $and: [{ category: 'books' }, { price: { $lt: 20 } }],
+              },
+            ],
+          },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -623,8 +728,10 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('should combine comparison and array operators', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          $and: [{ price: { $gte: 500 } }, { rating: { $gt: 4.5 } }],
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { $and: [{ price: { $gte: 500 } }, { rating: { $gt: 4.5 } }] },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -634,8 +741,10 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('should handle multiple conditions on same field', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          $and: [{ price: { $gte: 30 } }, { price: { $lte: 800 } }],
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { $and: [{ price: { $gte: 30 } }, { price: { $lte: 800 } }] },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -646,15 +755,19 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('should handle deeply nested logical operators', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          $or: [
-            {
-              $and: [{ category: 'electronics' }, { price: { $gt: 700 } }, { rating: { $gt: 4.5 } }],
-            },
-            {
-              $and: [{ category: 'books' }, { price: { $lt: 50 } }, { rating: { $gt: 4.0 } }],
-            },
-          ],
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: {
+            $or: [
+              {
+                $and: [{ category: 'electronics' }, { price: { $gt: 700 } }, { rating: { $gt: 4.5 } }],
+              },
+              {
+                $and: [{ category: 'books' }, { price: { $lt: 50 } }, { rating: { $gt: 4.0 } }],
+              },
+            ],
+          },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -702,13 +815,19 @@ describe('ChromaVector Integration Tests', () => {
           },
         ];
 
-        await vectorDB.upsert(testIndexName2, vectors, metadata);
+        await vectorDB.upsert({
+          indexName: testIndexName2,
+          vectors,
+          metadata,
+        });
         await new Promise(resolve => setTimeout(resolve, 2000));
       });
 
       it('handles special numeric values', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          $or: [{ zero: 0 }, { negativeZero: 0 }],
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { $or: [{ zero: 0 }, { negativeZero: 0 }] },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -718,15 +837,23 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('handles extreme numeric values', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          $or: [{ maxInt: { $gte: Number.MAX_SAFE_INTEGER } }, { minInt: { $lte: Number.MIN_SAFE_INTEGER } }],
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: {
+            $or: [{ maxInt: { $gte: Number.MAX_SAFE_INTEGER } }, { minInt: { $lte: Number.MIN_SAFE_INTEGER } }],
+          },
         });
         expect(results.length).toBe(1);
       });
 
       it('should handle numeric comparisons with decimals', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          rating: { $gt: 4.5 },
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: {
+            rating: { $gt: 4.5 },
+          },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -735,8 +862,10 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('should handle boolean values', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          inStock: { $eq: false },
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: { inStock: { $eq: false } },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -748,46 +877,78 @@ describe('ChromaVector Integration Tests', () => {
     describe('Additional Validation Tests', () => {
       it('should throw error as date is not supported', async () => {
         await expect(
-          vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-            $and: [
-              { currentDate: { $lte: new Date().toISOString() } },
-              { currentDate: { $gt: new Date(0).toISOString() } },
-            ],
+          vectorDB.query({
+            indexName: testIndexName2,
+            queryVector: [1, 0, 0],
+            filter: {
+              $and: [
+                { currentDate: { $lte: new Date().toISOString() } },
+                { currentDate: { $gt: new Date(0).toISOString() } },
+              ],
+            },
           }),
         ).rejects.toThrow();
       });
       it('should throw error as empty array in $in operator is not supported', async () => {
         await expect(
-          vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-            category: { $in: [] },
+          vectorDB.query({
+            indexName: testIndexName2,
+            queryVector: [1, 0, 0],
+            filter: {
+              category: { $in: [] },
+            },
           }),
         ).rejects.toThrow();
       });
       it('should reject non-numeric values in numeric comparisons', async () => {
         await expect(
-          vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-            price: { $gt: '500' }, // string instead of number
+          vectorDB.query({
+            indexName: testIndexName2,
+            queryVector: [1, 0, 0],
+            filter: {
+              price: { $gt: '500' }, // string instead of number
+            },
           }),
         ).rejects.toThrow();
       });
 
       it('should reject mixed types in $in operator', async () => {
         await expect(
-          vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-            field: { $in: ['string', 123] }, // mixed string and number
+          vectorDB.query({
+            indexName: testIndexName2,
+            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(testIndexName2, [1, 0, 0], 10, undefined);
-        const results2 = await vectorDB.query(testIndexName2, [1, 0, 0], 10);
+        const results1 = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: undefined,
+        });
+        const results2 = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: undefined,
+        });
         expect(results1).toEqual(results2);
         expect(results1.length).toBeGreaterThan(0);
       });
 
       it('should handle null filter', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, null as any);
-        const results2 = await vectorDB.query(testIndexName2, [1, 0, 0], 10);
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: null,
+        });
+        const results2 = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: undefined,
+        });
         expect(results).toEqual(results2);
         expect(results.length).toBeGreaterThan(0);
       });
@@ -795,8 +956,12 @@ describe('ChromaVector Integration Tests', () => {
 
     describe('Additional Edge Cases', () => {
       it('should handle exact boundary conditions', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          $and: [{ price: { $gte: 25 } }, { price: { $lte: 1000 } }],
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: {
+            $and: [{ price: { $gte: 25 } }, { price: { $lte: 1000 } }],
+          },
         });
         expect(results.length).toBeGreaterThan(0);
         expect(results.some(r => r.metadata?.price === 25)).toBe(true);
@@ -806,15 +971,19 @@ describe('ChromaVector Integration Tests', () => {
 
     describe('Additional Complex Logical Combinations', () => {
       it('should handle deeply nested $or conditions', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          $or: [
-            {
-              $and: [{ category: 'electronics' }, { $or: [{ price: { $gt: 900 } }, { rating: { $gt: 4.8 } }] }],
-            },
-            {
-              $and: [{ category: 'books' }, { $or: [{ price: { $lt: 30 } }, { rating: { $gt: 4.5 } }] }],
-            },
-          ],
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: {
+            $or: [
+              {
+                $and: [{ category: 'electronics' }, { $or: [{ price: { $gt: 900 } }, { rating: { $gt: 4.8 } }] }],
+              },
+              {
+                $and: [{ category: 'books' }, { $or: [{ price: { $lt: 30 } }, { rating: { $gt: 4.5 } }] }],
+              },
+            ],
+          },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -827,8 +996,12 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('should handle multiple field comparisons with same value', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          $or: [{ price: { $gt: 500 } }, { rating: { $gt: 4.5 } }],
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          queryVector: [1, 0, 0],
+          filter: {
+            $or: [{ price: { $gt: 500 } }, { rating: { $gt: 4.5 } }],
+          },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -839,12 +1012,16 @@ describe('ChromaVector Integration Tests', () => {
 
     describe('Performance Edge Cases', () => {
       it('should handle filters with many conditions', async () => {
-        const results = await vectorDB.query(testIndexName2, [1, 0, 0], 10, {
-          $and: Array(10)
-            .fill(null)
-            .map(() => ({
-              $or: [{ price: { $gt: 100 } }, { rating: { $gt: 4.0 } }],
-            })),
+        const results = await vectorDB.query({
+          indexName: testIndexName2,
+          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 => {
@@ -853,12 +1030,20 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('should handle deeply nested conditions efficiently', async () => {
-        const results = await vectorDB.query(testIndexName2, [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: testIndexName2,
+          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 => {
@@ -869,19 +1054,23 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('should handle large number of $or conditions', async () => {
-        const results = await vectorDB.query(testIndexName2, [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: testIndexName2,
+          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);
       });
@@ -901,7 +1090,7 @@ describe('ChromaVector Integration Tests', () => {
       } catch {
         // Ignore errors if index doesn't exist
       }
-      await vectorDB.createIndex(testIndexName3, dimension);
+      await vectorDB.createIndex({ indexName: testIndexName3, dimension });
 
       const testVectors = [
         [1.0, 0.0, 0.0],
@@ -916,7 +1105,13 @@ describe('ChromaVector Integration Tests', () => {
       ];
       const testIds = ['doc1', 'doc2', 'doc3'];
 
-      await vectorDB.upsert(testIndexName3, testVectors, testMetadata, testIds, testDocuments);
+      await vectorDB.upsert({
+        indexName: testIndexName3,
+        vectors: testVectors,
+        documents: testDocuments,
+        metadata: testMetadata,
+        ids: testIds,
+      });
 
       // Wait for indexing
       await new Promise(resolve => setTimeout(resolve, 2000));
@@ -933,29 +1128,39 @@ describe('ChromaVector Integration Tests', () => {
 
     describe('Basic Document Operations', () => {
       it('should store and retrieve documents', async () => {
-        const results = await vectorDB.query(testIndexName3, [1.0, 0.0, 0.0], 3);
+        const results = await vectorDB.query({ indexName: testIndexName3, queryVector: [1.0, 0.0, 0.0], topK: 3 });
         expect(results).toHaveLength(3);
         // Verify documents are returned
         expect(results[0].document).toBe(testDocuments[0]);
       });
 
       it('should filter documents using $contains', async () => {
-        const results = await vectorDB.query(testIndexName3, [1.0, 0.0, 0.0], 3, undefined, false, {
-          $contains: 'quick',
+        const results = await vectorDB.query({
+          indexName: testIndexName3,
+          queryVector: [1.0, 0.0, 0.0],
+          topK: 3,
+          documentFilter: { $contains: 'quick' },
         });
         expect(results).toHaveLength(2);
       });
 
       it('should filter with $not_contains', async () => {
-        const results = await vectorDB.query(testIndexName3, [1.0, 0.0, 0.0], 3, undefined, false, {
-          $not_contains: 'fox',
+        const results = await vectorDB.query({
+          indexName: testIndexName3,
+          queryVector: [1.0, 0.0, 0.0],
+          topK: 3,
+          documentFilter: { $not_contains: 'fox' },
         });
         expect(results.every(r => !r.document?.includes('fox'))).toBe(true);
       });
 
       it('should combine metadata and document filters', async () => {
-        const results = await vectorDB.query(testIndexName3, [1.0, 0.0, 0.0], 3, { source: 'pangram1' }, false, {
-          $contains: 'fox',
+        const results = await vectorDB.query({
+          indexName: testIndexName3,
+          queryVector: [1.0, 0.0, 0.0],
+          topK: 3,
+          filter: { source: 'pangram1' },
+          documentFilter: { $contains: 'fox' },
         });
         expect(results).toHaveLength(1);
         expect(results[0].metadata?.source).toBe('pangram1');
@@ -965,8 +1170,11 @@ describe('ChromaVector Integration Tests', () => {
 
     describe('Complex Document Filtering', () => {
       it('should handle $and conditions', async () => {
-        const results = await vectorDB.query(testIndexName3, [1.0, 0.0, 0.0], 3, undefined, false, {
-          $and: [{ $contains: 'quick' }, { $not_contains: 'fox' }],
+        const results = await vectorDB.query({
+          indexName: testIndexName3,
+          queryVector: [1.0, 0.0, 0.0],
+          topK: 3,
+          documentFilter: { $and: [{ $contains: 'quick' }, { $not_contains: 'fox' }] },
         });
         expect(results).toHaveLength(1);
         expect(results[0].document).toContain('quick');
@@ -974,62 +1182,84 @@ describe('ChromaVector Integration Tests', () => {
       });
 
       it('should handle $or conditions', async () => {
-        const results = await vectorDB.query(testIndexName3, [1.0, 0.0, 0.0], 3, undefined, false, {
-          $or: [{ $contains: 'fox' }, { $contains: 'zebras' }],
+        const results = await vectorDB.query({
+          indexName: testIndexName3,
+          queryVector: [1.0, 0.0, 0.0],
+          topK: 3,
+          documentFilter: { $or: [{ $contains: 'fox' }, { $contains: 'zebras' }] },
         });
         expect(results).toHaveLength(2);
+        expect(results[0].document).toContain('fox');
+        expect(results[1].document).toContain('zebras');
       });
     });
 
     describe('Edge Cases and Validation', () => {
       it('should reject empty string in $contains', async () => {
         await expect(
-          vectorDB.query(testIndexName3, [1.0, 0.0, 0.0], 3, undefined, false, { $contains: '' }),
+          vectorDB.query({
+            indexName: testIndexName3,
+            queryVector: [1.0, 0.0, 0.0],
+            topK: 3,
+            documentFilter: { $contains: '' },
+          }),
         ).rejects.toThrow('Expected where document operand value for operator $contains to be a non-empty str');
       });
 
       it('should be case sensitive', async () => {
         // First verify lowercase works
-        const lowerResults = await vectorDB.query(testIndexName3, [1.0, 0.0, 0.0], 3, undefined, false, {
-          $contains: 'quick',
+        const lowerResults = await vectorDB.query({
+          indexName: testIndexName3,
+          queryVector: [1.0, 0.0, 0.0],
+          topK: 3,
+          documentFilter: { $contains: 'quick' },
         });
         expect(lowerResults.length).toBe(2);
 
         // Then verify uppercase doesn't match
-        const upperResults = await vectorDB.query(testIndexName3, [1.0, 0.0, 0.0], 3, undefined, false, {
-          $contains: 'QUICK',
+        const upperResults = await vectorDB.query({
+          indexName: testIndexName3,
+          queryVector: [1.0, 0.0, 0.0],
+          topK: 3,
+          documentFilter: { $contains: 'QUICK' },
         });
         expect(upperResults.length).toBe(0);
 
-        const upperResults2 = await vectorDB.query(testIndexName3, [1.0, 0.0, 0.0], 3, undefined, false, {
-          $contains: 'JUMP',
+        const upperResults2 = await vectorDB.query({
+          indexName: testIndexName3,
+          queryVector: [1.0, 0.0, 0.0],
+          topK: 3,
+          documentFilter: { $contains: 'JUMP' },
         });
         expect(upperResults2.length).toBe(1);
       });
 
       it('should handle exact string matches', async () => {
-        const results = await vectorDB.query(
-          testIndexName3,
-          [1.0, 0.0, 0.0],
-          3,
-          undefined,
-          false,
-          { $contains: 'quick brown' }, // Test multi-word match
-        );
+        const results = await vectorDB.query({
+          indexName: testIndexName3,
+          queryVector: [1.0, 0.0, 0.0],
+          topK: 3,
+          documentFilter: { $contains: 'quick brown' }, // Test multi-word match
+        });
         expect(results.length).toBe(1);
         expect(results[0].document).toContain('quick brown');
       });
 
       it('should handle deeply nested logical operators', async () => {
-        const results = await vectorDB.query(testIndexName3, [1.0, 0.0, 0.0], 3, undefined, false, {
-          $or: [
-            {
-              $and: [{ $contains: 'quick' }, { $not_contains: 'fox' }],
-            },
-            {
-              $and: [{ $contains: 'box' }, { $not_contains: 'quick' }],
-            },
-          ],
+        const results = await vectorDB.query({
+          indexName: testIndexName3,
+          queryVector: [1.0, 0.0, 0.0],
+          topK: 3,
+          documentFilter: {
+            $or: [
+              {
+                $and: [{ $contains: 'quick' }, { $not_contains: 'fox' }],
+              },
+              {
+                $and: [{ $contains: 'box' }, { $not_contains: 'quick' }],
+              },
+            ],
+          },
         });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
@@ -1042,4 +1272,113 @@ describe('ChromaVector Integration Tests', () => {
       });
     });
   });
+  describe('Deprecation Warnings', () => {
+    const indexName = 'testdeprecationwarnings';
+
+    const indexName2 = 'testdeprecationwarnings2';
+
+    let warnSpy;
+
+    beforeAll(async () => {
+      await vectorDB.createIndex({ indexName: indexName, dimension: 3 });
+    });
+
+    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
+      }
+    });
+
+    beforeEach(async () => {
+      warnSpy = vi.spyOn(vectorDB['logger'], 'warn');
+    });
+
+    afterEach(async () => {
+      warnSpy.mockRestore();
+      try {
+        await vectorDB.deleteIndex(indexName2);
+      } catch {
+        // Ignore errors if index doesn't exist
+      }
+    });
+
+    it('should show deprecation warning when using individual args for createIndex', async () => {
+      await vectorDB.createIndex(indexName2, 3, 'cosine');
+
+      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: indexName2,
+        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(indexName2, 3, 'cosine')).resolves.not.toThrow();
+
+      // Upsert
+      const upsertResults = await vectorDB.upsert({
+        indexName,
+        vectors: [[1, 2, 3]],
+        metadata: [{ test: 'data' }],
+      });
+      expect(Array.isArray(upsertResults)).toBe(true);
+      expect(upsertResults).toHaveLength(1);
+    });
+  });
 });