Types

import { CreateIndexRequest, IndexIVF } from 'cyborgdb';

const createRequest: CreateIndexRequest = {
    indexConfig: {
        type: 'ivf',
        dimension: 768,
        nLists: 1024,
        metric: 'cosine'
    },
    indexKey: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef', // 64 hex chars (32 bytes)
    indexName: 'my-vector-index',
    embeddingModel: 'text-embedding-3-small'
};

import { IndexOperationRequest } from 'cyborgdb';

const operationRequest: IndexOperationRequest = {
    indexKey: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
    indexName: 'my-vector-index'
};

import { UpsertRequest, VectorItem } from 'cyborgdb';

const upsertRequest: UpsertRequest = {
    indexKey: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
    indexName: 'my-vector-index',
    items: [
        {
            id: 'doc1',
            vector: [0.1, 0.2, 0.3, /* ... */],
            contents: 'Document content',
            metadata: { title: 'Document 1', category: 'research' }
        }
    ]
};

import { QueryRequest } from 'cyborgdb';

const queryRequest: QueryRequest = {
    indexKey: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
    indexName: 'my-vector-index',
    queryVector: [0.1, 0.2, 0.3, /* ... */],
    topK: 10,
    nProbes: 5,
    greedy: false,
    filters: { category: 'research' },
    include: ['distance', 'metadata', 'vector']
};

import { BatchQueryRequest } from 'cyborgdb';

const batchQueryRequest: BatchQueryRequest = {
    indexKey: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
    indexName: 'my-vector-index',
    queryVectors: [
        [0.1, 0.2, 0.3, /* ... */],
        [0.4, 0.5, 0.6, /* ... */],
        [0.7, 0.8, 0.9, /* ... */]
    ],
    topK: 5,
    nProbes: 3,
    filters: { status: 'published' },
    include: ['distance', 'metadata']
};

import { TrainRequest } from 'cyborgdb';

const trainRequest: TrainRequest = {
    indexKey: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
    indexName: 'my-vector-index',
    batchSize: 4096,
    maxIters: 150,
    tolerance: 1e-8,
    maxMemory: 8192
};

import { DeleteRequest } from 'cyborgdb';

const deleteRequest: DeleteRequest = {
    indexKey: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
    indexName: 'my-vector-index',
    ids: ['doc1', 'doc2', 'doc3']
};

import { GetRequest } from 'cyborgdb';

const getRequest: GetRequest = {
    indexKey: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
    indexName: 'my-vector-index',
    ids: ['doc1', 'doc2'],
    include: ['vector', 'metadata']
};

import { VectorItem } from 'cyborgdb';

const vectorItem: VectorItem = {
    id: 'article_123',
    vector: [0.1, 0.2, 0.3, /* ... 768 dimensions */],
    contents: 'This is the content of the article...',
    metadata: {
        title: 'Introduction to Vector Databases',
        author: 'Dr. Smith',
        published_date: '2024-01-15',
        category: 'technology',
        tags: ['vectors', 'database', 'ai']
    }
};

import { IndexIVF } from 'cyborgdb';

const ivfConfig: IndexIVF = {
    type: 'ivf',
    dimension: 768,
    nLists: 1024,
    metric: 'cosine'
};

import { IndexIVFFlat } from 'cyborgdb';

const flatConfig: IndexIVFFlat = {
    type: 'ivfflat',
    dimension: 512,
    nLists: 256,
    metric: 'euclidean'
};

import { IndexIVFPQ } from 'cyborgdb';

const pqConfig: IndexIVFPQ = {
    type: 'ivfpq',
    dimension: 1536,
    nLists: 2048,
    metric: 'cosine',
    pqDim: 64,
    pqBits: 8
};

import { QueryResponse } from 'cyborgdb';

function processQueryResults(response: QueryResponse) {
    if (response.isBatchResponse()) {
        // Handle batch results
        const batchResults = response.results as QueryResultItem[][];
        batchResults.forEach((batch, index) => {
            console.log(`Batch ${index}:`, batch);
        });
    } else {
        // Handle single query results
        const singleResults = response.results as QueryResultItem[];
        console.log('Results:', singleResults);
    }
    
    // Always get first result set
    const firstResults = response.getFirstResultSet();
    console.log('First result:', firstResults[0]);
}

// Simple equality filter
const simpleFilter = { "category": "research" };

// Range filter
const rangeFilter = { 
    "published_year": { "$gte": 2020, "$lte": 2024 } 
};

// Complex compound filter
const complexFilter = {
    "$and": [
        { "category": "research" },
        { "confidence": { "$gte": 0.9 } },
        { "$or": [
            { "language": "en" },
            { "translated": true }
        ]}
    ]
};

// Include only metadata (efficient for existence checks)
const metadataOnly = { include: ['metadata'] };

// Include vectors and distances (for similarity analysis)
const vectorsAndDistances = { include: ['vector', 'distance'] };

// Include all available fields
const allFields = { include: ['vector', 'contents', 'metadata', 'distance'] };