Vector Database Comparison 2025: Complete Guide to Pinecone vs Weaviate vs Chroma vs Qdrant

// Traditional database query
SELECT * FROM products WHERE category = 'electronics' AND price < 100;

// Vector database query (conceptual)
FIND 10 NEAREST vectors TO [0.1, -0.5, 0.8, ...] 
WHERE metadata.category = 'electronics'

import { PineconeClient } from '@pinecone-database/pinecone';

// Initialize Pinecone
const pinecone = new PineconeClient();
await pinecone.init({
  apiKey: process.env.PINECONE_API_KEY,
  environment: process.env.PINECONE_ENVIRONMENT,
});

// Create or get index
const indexName = 'product-embeddings';
const index = pinecone.Index(indexName);

// Upsert vectors with metadata
await index.upsert({
  upsertRequest: {
    vectors: [
      {
        id: 'product-1',
        values: [0.1, 0.2, 0.3, ...], // 1536-dim embedding
        metadata: {
          category: 'electronics',
          price: 99.99,
          brand: 'TechCorp'
        }
      }
    ]
  }
});

// Query with metadata filter
const queryResponse = await index.query({
  queryRequest: {
    vector: [0.15, 0.25, 0.35, ...],
    topK: 10,
    filter: {
      category: { $eq: 'electronics' },
      price: { $lte: 100 }
    },
    includeMetadata: true
  }
});

// Pinecone pricing calculator
function calculatePineconeCost(vectors: number, dimensions: number, queries: number) {
  const storageGB = (vectors * dimensions * 4) / (1024 ** 3); // 4 bytes per float
  const storageCost = storageGB * 0.025; // $0.025 per GB/hour
  
  const queryCost = (queries / 1_000_000) * 2.00; // $2 per million queries
  
  return {
    monthly: (storageCost * 730) + queryCost,
    breakdown: {
      storage: storageCost * 730,
      queries: queryCost
    }
  };
}

import weaviate from 'weaviate-ts-client';

// Initialize Weaviate client
const client = weaviate.client({
  scheme: 'http',
  host: 'localhost:8080',
});

// Create schema
await client.schema
  .classCreator()
  .withClass({
    class: 'Product',
    properties: [
      {
        name: 'name',
        dataType: ['text'],
      },
      {
        name: 'description',
        dataType: ['text'],
      },
      {
        name: 'price',
        dataType: ['number'],
      },
    ],
    vectorizer: 'text2vec-openai',
  })
  .do();

// Add data with automatic vectorization
await client.data
  .creator()
  .withClassName('Product')
  .withProperties({
    name: 'Smart Watch',
    description: 'Advanced fitness tracking with heart rate monitor',
    price: 299.99,
  })
  .do();

// Semantic search with GraphQL
const result = await client.graphql
  .get()
  .withClassName('Product')
  .withFields('name description price _additional { distance }')
  .withNearText({
    concepts: ['fitness tracker'],
    certainty: 0.7,
  })
  .withLimit(5)
  .do();

# docker-compose.yml
version: '3.4'
services:
  weaviate:
    image: semitechnologies/weaviate:latest
    ports:
      - "8080:8080"
    environment:
      QUERY_DEFAULTS_LIMIT: 25
      AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: 'true'
      PERSISTENCE_DATA_PATH: '/var/lib/weaviate'
      DEFAULT_VECTORIZER_MODULE: 'text2vec-openai'
      ENABLE_MODULES: 'text2vec-openai'
      OPENAI_APIKEY: ${OPENAI_API_KEY}
    volumes:
      - weaviate_data:/var/lib/weaviate

import chromadb
from chromadb.config import Settings

# Initialize Chroma
client = chromadb.Client(Settings(
    chroma_db_impl="duckdb+parquet",
    persist_directory="./chroma_db"
))

# Create or get collection
collection = client.create_collection(
    name="products",
    metadata={"hnsw:space": "cosine"}
)

# Add documents with embeddings
collection.add(
    embeddings=[[0.1, 0.2, 0.3, ...], [0.4, 0.5, 0.6, ...]],
    documents=["Product description 1", "Product description 2"],
    metadatas=[{"price": 99.99}, {"price": 149.99}],
    ids=["id1", "id2"]
)

# Query
results = collection.query(
    query_embeddings=[[0.15, 0.25, 0.35, ...]],
    n_results=5,
    where={"price": {"$lte": 100}}
)

import { QdrantClient } from '@qdrant/js-client-rest';

// Initialize Qdrant client
const client = new QdrantClient({
  host: 'localhost',
  port: 6333,
});

// Create collection
await client.createCollection('products', {
  vectors: {
    size: 1536,
    distance: 'Cosine',
  },
  optimizers_config: {
    default_segment_number: 2,
  },
});

// Create payload index for filtering
await client.createFieldIndex('products', {
  field_name: 'price',
  field_schema: 'float',
});

// Insert vectors
await client.upsert('products', {
  wait: true,
  points: [
    {
      id: 1,
      vector: [0.1, 0.2, 0.3, ...],
      payload: {
        name: 'Product 1',
        price: 99.99,
        category: 'electronics',
      },
    },
  ],
});

// Search with filtering
const searchResult = await client.search('products', {
  vector: [0.15, 0.25, 0.35, ...],
  limit: 5,
  filter: {
    must: [
      {
        key: 'price',
        range: {
          lte: 100,
        },
      },
    ],
  },
  with_payload: true,
});

-- Enable pgvector extension in Supabase
CREATE EXTENSION IF NOT EXISTS vector;

-- Create products table with vector column
CREATE TABLE products (
  id SERIAL PRIMARY KEY,
  name TEXT NOT NULL,
  description TEXT,
  price DECIMAL(10, 2),
  category TEXT,
  embedding vector(1536),
  created_at TIMESTAMP DEFAULT NOW()
);

-- Create indexes for performance
CREATE INDEX ON products USING ivfflat (embedding vector_cosine_ops)
WITH (lists = 100);

CREATE INDEX idx_products_category ON products(category);
CREATE INDEX idx_products_price ON products(price);

-- Function for similarity search
CREATE OR REPLACE FUNCTION search_products(
  query_embedding vector(1536),
  match_count INT DEFAULT 10,
  price_max DECIMAL DEFAULT NULL,
  category_filter TEXT DEFAULT NULL
)
RETURNS TABLE (
  id INT,
  name TEXT,
  description TEXT,
  price DECIMAL,
  similarity FLOAT
)
LANGUAGE plpgsql
AS $$
BEGIN
  RETURN QUERY
  SELECT
    p.id,
    p.name,
    p.description,
    p.price,
    1 - (p.embedding <=> query_embedding) AS similarity
  FROM products p
  WHERE 
    (price_max IS NULL OR p.price <= price_max) AND
    (category_filter IS NULL OR p.category = category_filter)
  ORDER BY p.embedding <=> query_embedding
  LIMIT match_count;
END;
$$;

import { createClient } from '@supabase/supabase-js';

// Initialize Supabase client
const supabase = createClient(
  process.env.SUPABASE_URL!,
  process.env.SUPABASE_ANON_KEY!
);

// Insert product with embedding
async function addProduct(product: any, embedding: number[]) {
  const { data, error } = await supabase
    .from('products')
    .insert({
      name: product.name,
      description: product.description,
      price: product.price,
      category: product.category,
      embedding: JSON.stringify(embedding), // Supabase handles conversion
    });
    
  return { data, error };
}

// Search similar products
async function searchProducts(
  queryEmbedding: number[],
  filters?: {
    maxPrice?: number;
    category?: string;
  }
) {
  const { data, error } = await supabase
    .rpc('search_products', {
      query_embedding: JSON.stringify(queryEmbedding),
      match_count: 10,
      price_max: filters?.maxPrice,
      category_filter: filters?.category,
    });
    
  return { data, error };
}

// Real-time updates with Supabase
supabase
  .channel('products')
  .on('postgres_changes', {
    event: 'INSERT',
    schema: 'public',
    table: 'products',
  }, (payload) => {
    console.log('New product added:', payload.new);
  })
  .subscribe();

interface BenchmarkConfig {
  vectorDimensions: 1536;
  datasetSize: 1_000_000;
  queryBatchSize: 1000;
  topK: 10;
}

// Benchmark results (operations/second)
const benchmarkResults = {
  insertion: {
    pinecone: 50_000,
    weaviate: 35_000,
    chroma: 25_000,
    qdrant: 45_000,
    pgvector: 30_000,
  },
  query: {
    pinecone: 5_000,
    weaviate: 3_500,
    chroma: 2_000,
    qdrant: 4_500,
    pgvector: 3_000,
  },
  filteredQuery: {
    pinecone: 4_000,
    weaviate: 2_500,
    chroma: 1_000,
    qdrant: 4_000,
    pgvector: 2_000,
  },
};

// Ideal use case: Production RAG system
const pineconeConfig = {
  pros: ['Zero ops', 'Reliable', 'Fast'],
  cons: ['Cost', 'Vendor lock-in'],
  bestFor: 'Enterprise production workloads',
};

// Ideal use case: Multi-modal search platform
const weaviateConfig = {
  pros: ['Feature-rich', 'Multi-modal', 'Open source'],
  cons: ['Complex setup', 'Resource intensive'],
  bestFor: 'Advanced search applications',
};

// Ideal use case: RAG prototype
const chromaConfig = {
  pros: ['Simple', 'Lightweight', 'Great DX'],
  cons: ['Limited scale', 'Fewer features'],
  bestFor: 'Prototypes and small applications',
};

// Ideal use case: High-performance search
const qdrantConfig = {
  pros: ['Fast', 'Efficient', 'Great filtering'],
  cons: ['Smaller ecosystem', 'Self-hosted complexity'],
  bestFor: 'Performance-critical applications',
};

// Ideal use case: Hybrid applications
const pgvectorConfig = {
  pros: ['SQL interface', 'ACID', 'Supabase features'],
  cons: ['Limited dimensions', 'PostgreSQL overhead'],
  bestFor: 'Applications with mixed data needs',
};

// Combining vector search with traditional filtering
class HybridSearchEngine {
  constructor(
    private vectorDB: any,
    private postgresDB: any
  ) {}

  async search(query: string, filters: any) {
    // Step 1: Traditional DB filtering
    const candidateIds = await this.postgresDB.query(`
      SELECT id FROM products 
      WHERE price BETWEEN $1 AND $2
      AND category = $3
    `, [filters.minPrice, filters.maxPrice, filters.category]);

    // Step 2: Vector search on filtered candidates
    const embedding = await this.generateEmbedding(query);
    const results = await this.vectorDB.search({
      vector: embedding,
      filter: { id: { $in: candidateIds } },
      topK: 10,
    });

    return results;
  }
}

// Using multiple indexes for different data types
class MultiIndexManager {
  private indexes = new Map<string, any>();

  async addIndex(name: string, config: IndexConfig) {
    const index = await this.createIndex(config);
    this.indexes.set(name, index);
  }

  async search(indexName: string, query: any) {
    const index = this.indexes.get(indexName);
    if (!index) throw new Error(`Index ${indexName} not found`);
    
    return index.search(query);
  }

  async multiSearch(queries: Array<{index: string, query: any}>) {
    const results = await Promise.all(
      queries.map(q => this.search(q.index, q.query))
    );
    
    return this.mergeResults(results);
  }
}

// Vector database migration utility
class VectorDBMigrator {
  async migrate(source: any, target: any, batchSize = 1000) {
    let offset = 0;
    let migrated = 0;

    while (true) {
      // Fetch batch from source
      const batch = await source.fetch({
        limit: batchSize,
        offset: offset,
      });

      if (batch.length === 0) break;

      // Transform if needed
      const transformed = batch.map(item => ({
        id: item.id,
        vector: item.values || item.embedding,
        metadata: item.metadata || item.payload,
      }));

      // Insert into target
      await target.upsert(transformed);

      migrated += batch.length;
      offset += batchSize;

      console.log(`Migrated ${migrated} vectors...`);
    }

    return { total: migrated };
  }
}

interface CostAnalysis {
  database: string;
  monthlyVectors: number;
  monthlyQueries: number;
  estimatedCost: number;
}

function calculateTCO(config: any): CostAnalysis[] {
  const vectors = 10_000_000; // 10M vectors
  const queries = 1_000_000;  // 1M queries/month
  
  return [
    {
      database: 'Pinecone',
      monthlyVectors: vectors,
      monthlyQueries: queries,
      estimatedCost: 675, // ~$675/month
    },
    {
      database: 'Weaviate (self-hosted)',
      monthlyVectors: vectors,
      monthlyQueries: queries,
      estimatedCost: 200, // Infrastructure costs
    },
    {
      database: 'Supabase + pgvector',
      monthlyVectors: vectors,
      monthlyQueries: queries,
      estimatedCost: 250, // Supabase Pro plan
    },
  ];
}

class VectorDatabaseMigrator {
  constructor(
    private source: VectorDB,
    private target: VectorDB,
    private config: MigrationConfig = {
      batchSize: 1000,
      parallelWorkers: 4,
      transformFn: null,
    }
  ) {}

  async migrate(): Promise<MigrationResult> {
    const startTime = Date.now();
    let totalMigrated = 0;
    let errors = 0;

    try {
      // Step 1: Estimate total vectors
      const totalVectors = await this.source.count();
      console.log(`Starting migration of ${totalVectors} vectors...`);

      // Step 2: Create batches
      const batches = Math.ceil(totalVectors / this.config.batchSize);
      
      // Step 3: Parallel migration
      const workers = Array(this.config.parallelWorkers).fill(null).map((_, i) => 
        this.migrateWorker(i, batches)
      );
      
      const results = await Promise.all(workers);
      totalMigrated = results.reduce((sum, r) => sum + r.migrated, 0);
      errors = results.reduce((sum, r) => sum + r.errors, 0);
      
    } catch (error) {
      console.error('Migration failed:', error);
      throw error;
    }

    return {
      duration: Date.now() - startTime,
      totalMigrated,
      errors,
      success: errors === 0,
    };
  }

  private async migrateWorker(workerId: number, totalBatches: number) {
    let migrated = 0;
    let errors = 0;

    for (let batch = workerId; batch < totalBatches; batch += this.config.parallelWorkers) {
      try {
        const offset = batch * this.config.batchSize;
        const vectors = await this.source.fetch({
          limit: this.config.batchSize,
          offset,
        });

        if (vectors.length === 0) continue;

        // Transform if needed
        const transformed = this.config.transformFn 
          ? vectors.map(this.config.transformFn)
          : vectors;

        // Insert into target
        await this.target.batchUpsert(transformed);
        migrated += vectors.length;

        console.log(`Worker ${workerId}: Migrated batch ${batch + 1}/${totalBatches}`);
      } catch (error) {
        console.error(`Worker ${workerId}: Error in batch ${batch}:`, error);
        errors++;
      }
    }

    return { migrated, errors };
  }
}

// Example: Migrate from Chroma to Pinecone
const migrator = new VectorDatabaseMigrator(chromaDB, pineconeDB, {
  batchSize: 500,
  parallelWorkers: 8,
  transformFn: (vector) => ({
    id: vector.id,
    values: vector.embedding,
    metadata: {
      ...vector.metadata,
      source: 'chroma_migration',
      migrated_at: new Date().toISOString(),
    },
  }),
});

const result = await migrator.migrate();
console.log(`Migration completed in ${result.duration}ms`);

class ZeroDowntimeMigration {
  async execute() {
    // 1. Set up dual-write to both databases
    const dualWriter = new DualWriter(oldDB, newDB);
    
    // 2. Start background migration
    const migrationJob = this.startBackgroundMigration();
    
    // 3. Verify data consistency
    await this.verifyConsistency();
    
    // 4. Switch read traffic gradually
    await this.gradualTrafficSwitch();
    
    // 5. Stop dual-write
    await dualWriter.stop();
    
    // 6. Decommission old database
    await this.decommissionOldDB();
  }

  private async gradualTrafficSwitch() {
    const stages = [0.1, 0.25, 0.5, 0.75, 1.0];
    
    for (const percentage of stages) {
      await this.setTrafficSplit(percentage);
      await this.monitorErrors(30 * 60 * 1000); // 30 minutes
      
      if (await this.hasErrors()) {
        await this.rollback();
        throw new Error('Migration failed during traffic switch');
      }
    }
  }
}

class VectorCacheLayer {
  private cache = new Map<string, CachedResult>();
  private cacheHits = 0;
  private cacheMisses = 0;

  constructor(
    private vectorDB: any,
    private ttl: number = 3600000 // 1 hour
  ) {}

  async search(query: number[], k: number = 10): Promise<SearchResult> {
    const cacheKey = this.generateCacheKey(query, k);
    
    // Check cache
    const cached = this.cache.get(cacheKey);
    if (cached && Date.now() - cached.timestamp < this.ttl) {
      this.cacheHits++;
      return cached.result;
    }

    // Cache miss - query database
    this.cacheMisses++;
    const result = await this.vectorDB.search(query, k);
    
    // Store in cache
    this.cache.set(cacheKey, {
      result,
      timestamp: Date.now(),
    });

    // Cleanup old entries
    if (this.cache.size > 10000) {
      this.evictOldEntries();
    }

    return result;
  }

  getCacheStats() {
    const total = this.cacheHits + this.cacheMisses;
    return {
      hits: this.cacheHits,
      misses: this.cacheMisses,
      hitRate: total > 0 ? this.cacheHits / total : 0,
      size: this.cache.size,
    };
  }
}

class VectorDBFailover {
  private currentDB = 0;
  private healthChecks = new Map<number, boolean>();

  constructor(
    private databases: VectorDB[],
    private healthCheckInterval = 30000 // 30 seconds
  ) {
    this.startHealthChecks();
  }

  async search(query: any): Promise<any> {
    let lastError;
    
    // Try current database first
    try {
      return await this.databases[this.currentDB].search(query);
    } catch (error) {
      lastError = error;
      console.error(`Primary DB failed:`, error);
    }

    // Failover to other databases
    for (let i = 0; i < this.databases.length; i++) {
      if (i === this.currentDB) continue;
      
      try {
        const result = await this.databases[i].search(query);
        // Switch primary if successful
        this.currentDB = i;
        return result;
      } catch (error) {
        lastError = error;
        console.error(`Failover DB ${i} failed:`, error);
      }
    }

    throw new Error(`All databases failed. Last error: ${lastError}`);
  }

  private startHealthChecks() {
    setInterval(async () => {
      for (let i = 0; i < this.databases.length; i++) {
        try {
          await this.databases[i].health();
          this.healthChecks.set(i, true);
        } catch {
          this.healthChecks.set(i, false);
        }
      }
    }, this.healthCheckInterval);
  }
}

// 1. Optimize index configuration
// For pgvector
CREATE INDEX ON items USING ivfflat (embedding vector_cosine_ops)
WITH (lists = 100); -- Increase lists for larger datasets

// 2. Implement query optimization
class QueryOptimizer {
  async optimizedSearch(query: number[], k: number) {
    // Pre-filter candidates
    const candidates = await this.preFilter();
    
    // Use approximate search for large datasets
    if (candidates.length > 100000) {
      return this.approximateSearch(query, k, candidates);
    }
    
    // Exact search for smaller datasets
    return this.exactSearch(query, k, candidates);
  }
}

// 3. Add caching layer
const cachedDB = new VectorCacheLayer(vectorDB);

// 1. Implement streaming for large operations
class StreamingVectorDB {
  async *streamSearch(query: number[], batchSize = 100) {
    let offset = 0;
    
    while (true) {
      const batch = await this.db.search(query, {
        limit: batchSize,
        offset,
      });
      
      if (batch.length === 0) break;
      
      yield* batch;
      offset += batchSize;
    }
  }
}

// 2. Use memory-mapped files (Chroma example)
const client = new ChromaClient({
  path: "./chroma_db",
  settings: {
    anonymized_telemetry: false,
    persist_directory: "./chroma_db",
    chroma_db_impl: "duckdb+parquet", // More memory efficient
  },
});

// 1. Use deterministic settings
const deterministicConfig = {
  seed: 42, // Fixed seed for reproducibility
  efSearch: 200, // Higher value for more consistent results
  exact: true, // Use exact search for critical queries
};

// 2. Implement result validation
class ResultValidator {
  validateConsistency(results1: any[], results2: any[]) {
    const ids1 = new Set(results1.map(r => r.id));
    const ids2 = new Set(results2.map(r => r.id));
    
    const overlap = [...ids1].filter(id => ids2.has(id)).length;
    const consistency = overlap / Math.max(ids1.size, ids2.size);
    
    if (consistency < 0.8) {
      console.warn(`Low consistency: ${consistency}`);
    }
    
    return consistency;
  }
}

import { metrics } from '@opentelemetry/api-metrics';

class VectorDBMonitor {
  private meter = metrics.getMeter('vector-db');
  private queryLatency = this.meter.createHistogram('query_latency_ms');
  private indexSize = this.meter.createObservableGauge('index_size');
  
  async trackQuery(fn: () => Promise<any>) {
    const start = Date.now();
    try {
      const result = await fn();
      const duration = Date.now() - start;
      
      this.queryLatency.record(duration, {
        status: 'success',
        db_type: 'pinecone',
      });
      
      return result;
    } catch (error) {
      this.queryLatency.record(Date.now() - start, {
        status: 'error',
        error_type: error.name,
      });
      throw error;
    }
  }
}

// Yes! Here's a multi-DB strategy
class MultiVectorDB {
  constructor(
    private primaryDB: VectorDB,    // For critical queries
    private secondaryDB: VectorDB,  // For analytics
    private cacheDB: VectorDB       // For frequent queries
  ) {}

  async query(vector: number[], purpose: 'critical' | 'analytics' | 'cache') {
    switch(purpose) {
      case 'critical': return this.primaryDB.search(vector);
      case 'analytics': return this.secondaryDB.search(vector);
      case 'cache': return this.cacheDB.search(vector);
    }
  }
}

// Hybrid approach
class HybridDataStore {
  constructor(
    private postgres: PostgresDB,     // Structured data
    private vectorDB: VectorDB,       // Embeddings
    private redis: RedisDB           // Cache
  ) {}

  async hybridQuery(userId: string, searchVector: number[]) {
    // Get user preferences from PostgreSQL
    const userPrefs = await this.postgres.getUserPreferences(userId);
    
    // Search with vector DB
    const results = await this.vectorDB.search(searchVector, {
      filter: { category: userPrefs.interests }
    });
    
    // Cache results
    await this.redis.cache(userId, results);
    
    return results;
  }
}