Query

async query(
    ...args: [number[] | number[][], number?, number?, boolean?, object?, string[]?] | [QueryRequest]
): Promise<QueryResponse>

async query(
    queryVector: number[] | number[][],
    topK?: number = 100,
    nProbes?: number = 1,
    greedy?: boolean = false,
    filters?: object = {},
    include?: string[] = ["distance", "metadata"]
): Promise<QueryResponse>

async query(request: QueryRequest): Promise<QueryResponse>

import { Client, IndexIVFModel } from 'cyborgdb';

const client = new Client('http://localhost:8000', 'your-api-key');

// Create and populate index
const indexKey = crypto.getRandomValues(new Uint8Array(32));
const config: IndexIVFModel = {
    dimension: 768,
    nLists: 1024,
    metric: 'cosine'
};

const index = await client.createIndex('my-vectors', indexKey, config);

// Add some vectors
await index.upsert([
    { 
        id: 'doc1', 
        vector: [0.1, 0.2, 0.3, /* ... 768 dimensions */], 
        metadata: { title: 'Document 1', category: 'research' }
    },
    { 
        id: 'doc2', 
        vector: [0.4, 0.5, 0.6, /* ... 768 dimensions */], 
        metadata: { title: 'Document 2', category: 'tutorial' }
    }
]);

// Train the index for optimal performance
await index.train();

// Search for similar vectors
const queryVector = [0.15, 0.25, 0.35, /* ... 768 dimensions */];

try {
    const results = await index.query(queryVector, 5);
    
    // Single vector query returns flat array
    const items = results.results as QueryResultItem[];
    
    items.forEach((item, i) => {
        console.log(`Result ${i + 1}:`);
        console.log(`  ID: ${item.id}`);
        console.log(`  Distance: ${item.distance}`);
        console.log(`  Metadata: ${JSON.stringify(item.metadata)}`);
    });
    
} catch (error) {
    console.error('Query failed:', error.message);
}

const queryVector = [0.1, 0.2, 0.3, /* ... */];

const results = await index.query(
    queryVector,
    10,        // topK: return top 10 results
    5,         // nProbes: probe 5 lists for better accuracy
    true,      // greedy: use greedy search
    { category: 'research' },  // filters: only research documents
    ['distance', 'metadata', 'contents']  // include: return distance, metadata, and contents
);

const items = results.results as QueryResultItem[];
items.forEach(item => {
    console.log(`${item.id}: distance=${item.distance}, category=${item.metadata?.category}`);
    console.log(`Contents: ${item.contents}`);
});

// Query multiple vectors at once
const queryVectors = [
    [0.1, 0.2, 0.3, /* ... */],  // First query vector
    [0.4, 0.5, 0.6, /* ... */],  // Second query vector
    [0.7, 0.8, 0.9, /* ... */]   // Third query vector
];

const batchResults = await index.query(queryVectors, 3);

// Batch query returns nested arrays
const allResults = batchResults.results as QueryResultItem[][];

allResults.forEach((queryResults, queryIndex) => {
    console.log(`Results for query ${queryIndex + 1}:`);
    queryResults.forEach((item, resultIndex) => {
        console.log(`  ${resultIndex + 1}. ${item.id} (distance: ${item.distance})`);
    });
    console.log('---');
});

// Filter by single field
const categoryResults = await index.query(
    queryVector, 
    10, 
    1, 
    false, 
    { category: 'research' }
);

// Filter by multiple fields
const complexResults = await index.query(
    queryVector, 
    10, 
    1, 
    false, 
    { 
        category: 'research', 
        published: true,
        year: 2024 
    }
);

// Range filter (if supported by your metadata structure)
const dateResults = await index.query(
    queryVector, 
    10, 
    1, 
    false, 
    { 
        created_date: { 
            $gte: '2024-01-01',
            $lte: '2024-12-31'
        } 
    }
);