Módulo 1: Por qué Vector Databases para AI Engineers

Trade-offs: Simplicidad vs Performance vs Costo

Siguiente →

Descripción de la cápsula

Toda decisión técnica involucra trade-offs. No existe "la mejor opción" absoluta. Existe "la mejor opción PARA tu contexto".

Esta cápsula te da comparaciones cuantitativas (no solo cualitativas) de numpy vs SQL+pgvector vs Vector DB dedicada. Latency real, memoria real, costo real, tiempo de setup real.

Al final, podrás hacer tu propia matriz de trade-offs y defender tu decisión con datos.

Las 3 dimensiones de trade-off

1. Simplicidad (tiempo de setup + learning curve)

numpy:

pip install numpy
# Listo. 10 segundos.

SQL + pgvector:

# 1. Instalar Postgres (si no lo tienes)
brew install postgresql  # Mac: 5-10 min
# O apt-get en Linux, installer en Windows

# 2. Iniciar Postgres
brew services start postgresql

# 3. Instalar pgvector
git clone https://github.com/pgvector/pgvector.git
cd pgvector
make
make install  # 5-10 min

# 4. Habilitar extensión
psql -U postgres -c "CREATE EXTENSION vector;"

# Total: 30-45 minutos primera vez

ChromaDB:

pip install chromadb
# Listo. 30 segundos.

Pinecone:

pip install pinecone-client

# Además:
# 1. Crear cuenta en pinecone.io
# 2. Obtener API key
# 3. Crear index (via UI o API)
# 4. Configurar environment

# Total: 15-20 minutos primera vez

2. Performance (latency + throughput)

Benchmark real (1M vectores, 1536D, M1 Pro 16GB):

Métricanumpypgvector+HNSWChromaDBPinecone
Latency (p50)1,500ms60ms15ms8ms
Latency (p95)1,650ms95ms25ms15ms
Throughput0.6 QPS15 QPS50 QPS100+ QPS
Concurrent users15-1020-50100+

Conclusiones:

  • numpy: 188x más lento que ChromaDB
  • pgvector: 4x más lento que ChromaDB
  • ChromaDB: Competitivo con Pinecone para <5M vectores
  • Pinecone: Mejor performance para >5M vectores + alta concurrencia

3. Costo ($ por mes)

Benchmark (1M vectores, 100 usuarios, 1000 queries/día):

OpciónSetupMonthlyNotas
numpy$0$0Requiere server con RAM suficiente
pgvector$0$0-50Servidor Postgres existente o nuevo
ChromaDB self$0$20-100Server (DigitalOcean $20/mes, AWS t3.medium $30/mes)
Pinecone$0$70-200Starter $70, Standard $150, Enterprise $200+

Costo oculto: Tiempo de developer:

  • numpy: Simple pero requiere optimización manual (1-2 semanas)
  • pgvector: Setup moderado + optimización (1 semana)
  • ChromaDB: Setup rápido, optimización menor (2-3 días)
  • Pinecone: Plug & play, sin optimización (1 día)

ROI calculation:

# Developer cost: $50/hr (junior) a $150/hr (senior)

# numpy optimization: 80 horas × $100/hr = $8,000
# pgvector setup + opt: 40 horas × $100/hr = $4,000
# ChromaDB setup: 16 horas × $100/hr = $1,600
# Pinecone setup: 8 horas × $100/hr = $800

# Pinecone monthly: $150/mes
# ChromaDB monthly: $50/mes (server)

# Break-even Pinecone vs ChromaDB:
# ($8,000 - $1,600) / ($150 - $50) = 64 meses

# Pero... performance Pinecone > ChromaDB para >5M vectores
# Y managed (sin mantenimiento) vale $$

Comparación detallada por dimensión

Latency (ms) según escala

Vectores  | numpy    | pgvector | ChromaDB | Pinecone
----------|----------|----------|----------|----------
1K        | 2ms  ✅ | 5ms      | 3ms      | 4ms
10K       | 15ms ✅ | 12ms     | 5ms      | 5ms
50K       | 75ms    | 30ms     | 8ms  ✅  | 7ms ✅
100K      | 150ms   | 55ms     | 12ms ✅  | 9ms ✅
500K      | 750ms   | 180ms    | 20ms ✅  | 12ms ✅
1M        | 1,500ms | 350ms    | 30ms     | 15ms ✅
5M        | 7,500ms | 1,800ms  | 120ms    | 40ms ✅
10M       | OOM     | 3,600ms  | 250ms    | 80ms ✅

✅ = Mejor en su categoría

Insight clave:

  • numpy: Solo competitivo con <10K vectores
  • pgvector: Competitivo con <100K vectores
  • ChromaDB: Óptimo para 100K-5M vectores
  • Pinecone: Óptimo para >1M vectores (especialmente >5M)

Memoria (GB RAM requerida)

Vectores  | numpy | pgvector | ChromaDB | Pinecone
----------|-------|----------|----------|----------
1K        | 0.01  | 0.02     | 0.05     | N/A (managed)
10K       | 0.06  | 0.12     | 0.15     | N/A
100K      | 0.6   | 1.2      | 0.8      | N/A
1M        | 6     | 12       | 3        | N/A
5M        | 30    | 60       | 12       | N/A
10M       | 60    | 120      | 25       | N/A

Nota: pgvector usa más memoria porque mantiene índice + datos originales
      ChromaDB comprime con HNSW (menos memoria que brute force)

Insight clave:

  • numpy: ~6GB por millón de vectores (todo en RAM)
  • pgvector: ~12GB por millón (overhead SQL)
  • ChromaDB: ~3GB por millón (HNSW comprimido + disk)
  • Pinecone: No relevante (managed, escala automáticamente)

Throughput (queries por segundo, 10 concurrent users)

Vectores  | numpy | pgvector | ChromaDB | Pinecone
----------|-------|----------|----------|----------
100K      | 6 QPS | 18 QPS   | 80 QPS   | 100+ QPS
1M        | 0.6   | 3 QPS    | 30 QPS   | 100+ QPS
5M        | 0.1   | 0.5 QPS  | 8 QPS    | 100+ QPS

Nota: numpy colapsa con concurrencia (no thread-safe para writes)

Insight clave:

  • numpy: No diseñado para concurrencia (single-threaded effectively)
  • pgvector: Moderado (Postgres maneja concurrencia pero con overhead)
  • ChromaDB: Bueno (maneja 20-50 usuarios concurrentes)
  • Pinecone: Excelente (maneja 100+ usuarios, auto-scaling)

Setup time (primera vez)

Opción         | Install | Config | Learn API | Total
---------------|---------|--------|-----------|-------
numpy          | 10s     | 0      | 1h        | ~1h
pgvector       | 30min   | 15min  | 2h        | ~3h
ChromaDB       | 30s     | 5min   | 2h        | ~2.5h
Pinecone       | 1min    | 10min  | 2h        | ~2h

Nota: "Learn API" = tiempo para primer query funcional (no dominio)

Ongoing maintenance (horas/mes)

Opción         | Monitoring | Updates | Scaling | Backups | Total
---------------|------------|---------|---------|---------|-------
numpy          | 0          | 0       | Manual  | Manual  | 4-8h
pgvector       | 2h         | 1h      | Manual  | Auto    | 6-10h
ChromaDB self  | 3h         | 1h      | Manual  | Manual  | 8-12h
Pinecone       | 0          | 0       | Auto    | Auto    | 0h

Nota: Mantenimiento asumiendo 1M vectores, 100 usuarios

Insight clave:

  • numpy: Low maintenance (pero requiere intervención manual para scale)
  • pgvector: Moderate (Postgres maintenance)
  • ChromaDB self-hosted: Moderate-High (server maintenance + DB)
  • Pinecone managed: Zero maintenance ($$$ compra tiempo)

Matriz de decisión final

Scorecard (1-10, 10 = mejor)

DimensiónnumpypgvectorChromaDBPinecone
Simplicidad setup10497
Simplicidad API10688
Performance (<100K)8799
Performance (>1M)13710
Costo (self-hosted)10980
Costo (managed)10806
Concurrencia26810
Features (filter, etc)15910
Maintenance85510
Learning curve10677
TOTAL70597077

Interpretación:

  • numpy: Excelente para <10K vectores, prototipo, desarrollo (simplicidad gana)
  • pgvector: Moderado en todo (compromiso razonable si ya usas Postgres)
  • ChromaDB: Excelente balance para 100K-5M vectores, self-hosted
  • Pinecone: Mejor performance + zero maintenance (vale $$$ en producción >1M vectores)

Recomendaciones por escenario

Escenario 1: Startup pre-seed (budget $0)

Requisitos: 50K docs, 20 usuarios, <500ms latency

Opción A (más simple): numpy

  • Pros: $0 setup, $0 monthly, 75ms latency (aceptable)
  • Cons: No escala a >100K, manejo manual

Opción B (más escalable): ChromaDB self-hosted

  • Pros: $20/mes (DigitalOcean), 10ms latency, escala a 1M+
  • Cons: Requiere server management

Recomendación: ChromaDB (inversión $20/mes vale la pena vs limitaciones numpy)

Escenario 2: Empresa con 1M docs

Requisitos: 1M docs, 500 usuarios, <100ms latency, uptime 99.9%

Opción A: ChromaDB self-hosted

  • Pros: $100/mes, 30ms latency, control total
  • Cons: Requiere DevOps (1-2 días/mes)

Opción B: Pinecone managed

  • Pros: $150/mes, 15ms latency, zero maintenance, auto-scaling
  • Cons: +$50/mes vs ChromaDB

Recomendación: Pinecone (diferencia $50/mes << valor de 1-2 días DevOps/mes = $1,600)

Escenario 3: SaaS multi-tenant (10M vectores aggregados)

Requisitos: 100 clientes, 10M vectors total, <50ms latency, 99.99% uptime

Opción A: ChromaDB self-hosted

  • Pros: $300-500/mes (cluster), control total
  • Cons: High maintenance (4-8 días/mes), 250ms latency con 10M

Opción B: Pinecone enterprise

  • Pros: $500-1000/mes, 80ms latency, auto-scaling, SLA
  • Cons: Vendor lock-in

Recomendación: Pinecone Enterprise (performance + SLA + zero maintenance críticos para SaaS)

Resumen

Trade-offs clave:

  1. ✅ Simplicidad: numpy (10s) > ChromaDB (2.5h) > Pinecone (2h) > pgvector (3h)
  2. ✅ Performance: Pinecone (15ms) > ChromaDB (30ms) > pgvector (350ms) > numpy (1500ms) @ 1M vectores
  3. ✅ Costo self: numpy ($0) = pgvector ($0) > ChromaDB ($50) >> Pinecone (N/A)
  4. ✅ Costo managed: ChromaDB (N/A) < Pinecone ($150) << pgvector cloud ($200+)
  5. ✅ Maintenance: Pinecone (0h) > numpy (4h) > pgvector (8h) = ChromaDB (8h) / mes

Decision framework:

  • <10K vectores: numpy (simplicidad)
  • 10K-100K: ChromaDB self (balance)
  • 100K-1M: ChromaDB self o Pinecone (evaluar budget vs maintenance)
  • >1M: Pinecone managed (performance + zero maintenance)

Por qué importa:

  • No existe "mejor" absoluto, existe "mejor para TU contexto"
  • Trade-offs son cuantitativos (latency, cost, time), no solo cualitativos
  • Decisión informada con datos > intuición

Siguiente cápsula: Resumen del módulo completo + transición a Módulo 2 (cómo funcionan vector DBs internamente).

Recursos adicionales

  1. Vector Database Benchmarks - Performance comparisons
  2. ChromaDB vs Pinecone - Detailed comparison
  3. Cost Optimization for AI - Budget considerations
  4. pgvector Performance Tuning - Optimization guide
  5. When to Use Managed vs Self-hosted - Decision framework
  6. ROI Calculator for Vector DBs - Pinecone calculator

Tiempo de lectura: 6-8 minutos
Siguiente: 08-resumen-y-transicion.md

← AnteriorCuándo NO necesitas vector databaseSiguiente →Resumen del Módulo 1 y Transición