COMPLETE REFERENCE GUIDE

6 Must-Know
VECTOR
DATABASES
Every RAG Engineer Should Know

Pinecone Chroma Weaviate Qdrant FAISS Redis Vector

■ Production Scale ■ Local Prototyping ■ Multimodal RAG

Pinecone Chroma Weaviate

■ High Performance ■ Offline Research ■ Low Latency

Qdrant FAISS Redis Vector

© 2025 Vector DB Reference Guide

Vector Databases: Complete Reference Guide RAG Engineering Series

1. What Is a Vector Database?

A vector database is a specialized data store optimized for storing, indexing, and searching high-dimensional
vectors — numerical representations of data produced by ML embedding models. Unlike traditional databases
that match exact values, vector databases retrieve data by semantic similarity, enabling AI applications to find
conceptually related content even when no keywords match.

How Embeddings Work

When text passes through a model like OpenAI's text-embedding-3-small, it outputs a vector of floats (e.g.,
1536 dimensions). Semantically similar sentences cluster close together in this high-dimensional space. A
vector DB indexes these vectors and retrieves the k nearest neighbors to a query vector using algorithms like
HNSW, IVF, or PQ.

Why Vector DBs Matter for RAG

Retrieval-Augmented Generation (RAG) augments LLMs by fetching relevant context from external knowledge
bases at inference time. The retrieval step depends entirely on fast, accurate vector search — making your
choice of vector database a foundational architectural decision.

■ Document / ■ Embedding ■ Vector ■ LLM +

Query → Model → Database → Response

© 2025 Vector DB Reference Guide · For RAG Engineers Page 2

Vector Databases: Complete Reference Guide RAG Engineering Series

2. The 6 Vector Databases — In Depth

Pinecone — Fully managed, production-grade

What it does A fully managed, serverless vector database built for production workloads. It
abstracts away all infrastructure — no servers to provision, no indexes to tune —
while delivering enterprise SLA reliability.

Key ■ Serverless: zero infrastructure, scales automatically

Strengths ■ Real-time index updates at any scale without downtime
■ Metadata filtering: combine vector similarity with structured filters
■ Namespaces for multi-tenant isolation within one index
■ SOC 2 Type II compliant, GDPR ready

Pipeline
Vectors → Pinecone Cloud → Query Results

Best For ■ PRODUCTION SCALE — enterprise chatbots, large-scale semantic search

Example — Customer Support Chatbot (100K+ users)

import pinecone
from openai import OpenAI

pc = [Link](api_key='YOUR_KEY')
index = [Link]('support-kb')
client = OpenAI()

def search_support(query, top_k=5):

emb = [Link](
input=query, model='text-embedding-3-small'
).data[0].embedding
results = [Link](
vector=emb, top_k=top_k,
filter={'category': {'$eq': 'billing'}},
include_metadata=True
)
return [r['metadata']['answer'] for r in results['matches']]

© 2025 Vector DB Reference Guide · For RAG Engineers Page 3

Vector Databases: Complete Reference Guide RAG Engineering Series

Chroma — Open-source, local-first

What it does An open-source, embedded vector database for fast local RAG development. Runs
in-process with your Python application — no server setup, no Docker, no
configuration.

Key ■ Runs in-process: no separate server, minimal dependencies

Strengths ■ Python-native: start with 3 lines of code
■ Persistent or ephemeral storage modes
■ Built-in embedding functions (OpenAI, Cohere, HuggingFace)
■ Ideal for Jupyter notebooks and rapid prototyping

Pipeline
Python App → Chroma Local → Top-K Chunks

Best For ■ LOCAL PROTOTYPING — quick experiments, notebooks, dev environments

Example — Local Document Q&A; in 3 Lines

import chromadb
from [Link] import embedding_functions

client = [Link](path='./chroma_store')
ef = embedding_functions.OpenAIEmbeddingFunction(
api_key='YOUR_KEY', model_name='text-embedding-3-small'
)
collection = client.get_or_create_collection('my_docs', embedding_function=ef)

# Ingest
[Link](
documents=['RAG = Retrieval-Augmented Generation'],
metadatas=[{'source': '[Link]'}], ids=['doc1']
)

# Query
results = [Link](query_texts=['What is RAG?'], n_results=3)

© 2025 Vector DB Reference Guide · For RAG Engineers Page 4

Vector Databases: Complete Reference Guide RAG Engineering Series

Weaviate — Open-source, multimodal powerhouse

What it does An open-source vector database natively supporting text, images, and structured
data in a single unified store. Its GraphQL interface and hybrid search make it ideal
for complex multimodal retrieval.

Key ■ Native multimodal vector support (text, images, audio)

Strengths ■ GraphQL + BM25 hybrid search out of the box
■ Module ecosystem: text2vec-openai, img2vec-neural, reranker
■ Horizontal scalability with sharding and replication
■ Schema-driven with strong typing and cross-references

Pipeline
Text + Images → Weaviate → Unified Results

Best For ■ MULTIMODAL RAG — image+text combined search, knowledge graphs

Example — E-commerce Image + Text Hybrid Search

import weaviate

client = [Link]('[Link]

# Hybrid search: semantic + keyword

result = [Link](
'Product', ['name', 'description', 'imageUrl']
).with_hybrid(
query='red running shoes under $100',
alpha=0.75 # 0=BM25 only, 1=vector only
).with_near_image(
{'image': base64_image}, encode=False
).with_limit(10).do()

products = result['data']['Get']['Product']

© 2025 Vector DB Reference Guide · For RAG Engineers Page 5

Vector Databases: Complete Reference Guide RAG Engineering Series

Qdrant — Rust-built, high-performance

What it does A high-performance vector search engine written in Rust, optimized for maximum
speed and efficiency. Provides rich payload filtering at query time and the fastest
CPU-bound vector workloads.

Key ■ Rust core: fastest CPU performance in open-source

Strengths ■ Payload filtering at query time (filter-then-rank, not post-filter)
■ Sparse vector support for hybrid dense+sparse retrieval
■ Quantization for memory-efficient large-scale deployments
■ REST + gRPC APIs for high-throughput scenarios

Pipeline
Query → Qdrant Engine → Filtered Results

Best For ■ HIGH PERFORMANCE — production self-hosted, CPU-intensive filtered

search

Example — Product Catalog Search with Payload Filters

from qdrant_client import QdrantClient
from qdrant_client.models import Filter, FieldCondition, Range

client = QdrantClient('localhost', port=6333)

results = [Link](
collection_name='products',
query_vector=query_embedding,
query_filter=Filter(
must=[
FieldCondition(key='price', range=Range(gte=10, lte=100)),
FieldCondition(key='in_stock', match={'value': True}),
]
),
limit=20, with_payload=True
)

© 2025 Vector DB Reference Guide · For RAG Engineers Page 6

Vector Databases: Complete Reference Guide RAG Engineering Series

FAISS — Meta's GPU-accelerated library

What it does A C++ library with Python bindings from Meta, designed for maximum similarity
search throughput on static datasets. Leverages GPU acceleration and advanced
indexing (IVF, PQ, HNSW) to handle billions of vectors.

Key ■ GPU-native: runs on CUDA for massive throughput

Strengths ■ No server: pure Python/C++ library, zero infrastructure
■ Best for static offline datasets — batch ingestion
■ Multiple index types: Flat, IVF, PQ, HNSW with trade-off control
■ The gold standard for ML research benchmarks

Pipeline
Embeddings → FAISS Index → Nearest Neighbors

Best For ■ OFFLINE / RESEARCH — ML research, batch processing, static corpora

Example — Billion-Scale Nearest Neighbor Search

import faiss
import numpy as np

d = 1536 # embedding dimension

nlist = 100 # number of clusters

# Build IVF index

quantizer = faiss.IndexFlatL2(d)
index = [Link](quantizer, d, nlist, faiss.METRIC_L2)

# Move to GPU
res = [Link]()
gpu_index = faiss.index_cpu_to_gpu(res, 0, index)

gpu_index.train(train_vectors)
gpu_index.add(all_vectors)

gpu_index.nprobe = 10 # accuracy vs speed

D, I = gpu_index.search(query_vectors, k=5)

© 2025 Vector DB Reference Guide · For RAG Engineers Page 7

Vector Databases: Complete Reference Guide RAG Engineering Series

Redis Vector — In-memory, sub-millisecond latency

What it does Extends the battle-tested Redis in-memory store with vector similarity search.
Combines cache, structured data, and vector search in a single layer — delivering
sub-millisecond query speeds.

Key ■ Sub-millisecond query speed: data lives in RAM

Strengths ■ Combines caching + vector search in one infrastructure layer
■ Supports HNSW and Flat indexing with hybrid filters
■ Native Redis data structures (hashes, sets) alongside vectors
■ RedisAI module for co-located model serving

Pipeline
Live Query → Redis Memory → Instant Results

Best For ■ LOW LATENCY APPS — real-time recommendations, live search, gaming

Example — Real-Time Product Recommendations

import redis
from [Link] import VectorField, TextField
from [Link] import Query
import numpy as np

r = [Link](host='localhost', port=6379)

schema = [
TextField('$.name', as_name='name'),
VectorField('$.embedding', 'HNSW', {
'TYPE': 'FLOAT32', 'DIM': 1536,
'DISTANCE_METRIC': 'COSINE'
}, as_name='embedding')
]
[Link]('products').create_index(schema)

query_vec = [Link](embedding, dtype=np.float32).tobytes()

q = Query('*=>[KNN 10 @embedding $vec AS score]').sort_by('score').dialect(2)
results = [Link]('products').search(q, query_params={'vec': query_vec})

© 2025 Vector DB Reference Guide · For RAG Engineers Page 8

Vector Databases: Complete Reference Guide RAG Engineering Series

3. Feature Comparison Matrix

Redis
Feature Pinecone Chroma Weaviate Qdrant FAISS
Vector

Managed In-memory
Type Open-source Open-source Open-source Library
Cloud DB

Multimodal Offline/Rese
Best For Production Prototyping High Perf. Low Latency
RAG arch

Hosting Serverless Local Self/Cloud Self/Cloud No server Self/Cloud

GPU Support No No No Partial Yes (native) No

Yes
Hybrid Search Limited No Yes No Yes
(GraphQL)

Multimodal No No Yes No No No

Ease of Use ■■■■■ ■■■■■ ■■■■ ■■■ ■■■ ■■■■

Scalability ■■■■■ ■■ ■■■■ ■■■■■ ■■ ■■■■

Free Tier Yes (limited) Free Free Free Free Free (OSS)

No (RAM Yes
Persistence Yes (cloud) Yes (local) Yes Yes
only) (AOF/RDB)

Real-time Index Yes Limited Yes Yes No Yes

Languages REST/SDK Python first Multi-lang Rust/Py/JS Python/C++ Multi-lang

© 2025 Vector DB Reference Guide · For RAG Engineers Page 9

Vector Databases: Complete Reference Guide RAG Engineering Series

4. When to Use Which — Decision Guide

Choosing a vector database is a system design decision, not a tutorial recommendation. The right choice
depends on your deployment model, throughput requirements, data modality, and operational constraints.

Decision Flowchart
■ Do you need ZERO infrastructure management? → Pinecone fully managed, serverless, enterprise SLA

■ Are you prototyping locally / in a notebook? → Chroma 3-line setup, no server, runs in-process

■ Need image + text combined search? → Weaviate native multimodal, GraphQL hybrid search

■ Need fastest CPU self-hosted performance? → Qdrant Rust engine, payload filtering at query time

■ Static datasets, need GPU search throughput? → FAISS Meta library, GPU-native, no server overhead

■ Need sub-millisecond real-time queries? → Redis Vector in-memory, combines cache + vector search

Use-Case Mapping Table

Scenario Recommended DB Why

Enterprise chatbot at scale Pinecone Managed infra, zero ops, SLA guarantees

Local RAG prototype in Python Chroma 3-line setup, no server, fast iteration

Image + text combined search Weaviate Native multimodal + GraphQL hybrid

High-throughput filtered search Qdrant Fastest CPU, payload filter at query time

Academic similarity research FAISS GPU-accelerated, static index, no overhead

Real-time recommendation
Redis Vector Sub-ms latency, cache + search in one layer
engine

Regulated / compliance
Weaviate / Qdrant Full data control, on-premise deployment
environment

Startup MVP needing quick

Pinecone or Chroma Managed or free local — zero friction start
deploy

© 2025 Vector DB Reference Guide · For RAG Engineers Page 10

Vector Databases: Complete Reference Guide RAG Engineering Series

5. Architecture Patterns
Pattern A: Naive RAG (Chroma / Pinecone)
The simplest pattern: embed all documents once, store in a vector DB, query at inference time.

User Query → Embed (OpenAI) → Vector Search → Top-K Chunks → Prompt + LLM →
Answer

Pattern B: Agentic RAG (Weaviate / Qdrant)

An agent decides when and what to retrieve, supporting multi-hop reasoning and tool use.

Agent → Query Planner → Sub-queries → DB (filtered) → Re-ranker → Synthesize →

LLM → Answer

Pattern C: Real-Time Personalization (Redis Vector)

User actions trigger live embedding updates. Redis serves both session cache and vector search in one
round-trip.

User Action → Update Session (Redis Hash) → Embed Preference → KNN Search →
Recommendations (< 5ms)

Pattern D: Offline Research Pipeline (FAISS)

Batch-process millions of documents, build a FAISS index, serve queries from a static snapshot.

Documents → Batch Embed (GPU) → FAISS Index → Serialize to disk → Load → KNN
Search

© 2025 Vector DB Reference Guide · For RAG Engineers Page 11

Vector Databases: Complete Reference Guide RAG Engineering Series

6. Key Concepts Glossary

Embedding A dense numerical vector representing the semantic meaning of data, produced by a
neural network. E.g., [0.12, -0.87, …] with 768–1536 dimensions.

ANN Approximate Nearest Neighbor — finds vectors approximately closest to a query,

trading perfect accuracy for massive speed improvements.

HNSW Hierarchical Navigable Small World — a graph-based ANN algorithm with O(log n)
query complexity. Used by Qdrant, Redis, Weaviate.

IVF Inverted File Index — clusters vectors into nlist buckets; only searches nprobe
buckets per query. Used by FAISS for billion-scale datasets.

PQ (Product Compresses vectors into compact codes to reduce memory footprint by 8–32×, at a
Quantization) small accuracy cost.

Hybrid Search Combines dense vector similarity with sparse keyword (BM25) search. Supported
natively by Weaviate and Qdrant.

Metadata Filtering Applying structured conditions (e.g., price < 100) alongside vector similarity.
Pre-filtering is faster than post-filtering.

RAG Retrieval-Augmented Generation — feeding retrieved context chunks into an LLM

prompt to improve factual accuracy and reduce hallucinations.

Top-K The K most similar vectors returned by a query, ranked by cosine similarity or L2
distance.

Cosine Similarity Measures the angle between two vectors, ignoring magnitude. Most common metric
for text embeddings (range: -1 to 1).

© 2025 Vector DB Reference Guide · For RAG Engineers Page 12

Vector Databases: Complete Reference Guide RAG Engineering Series

7. Quick-Start Cheatsheet
Database Install Minimal Usage

Pinecone pip install pinecone pc = Pinecone(api_key=KEY)

index = [Link]('name')

Chroma pip install chromadb client = [Link]()

col = client.create_collection('x')

Weaviate pip install weaviate-client client = [Link](url)

[Link](...).do()

Qdrant pip install qdrant-client client = QdrantClient('localhost')

[Link](col, vec, limit=10)

FAISS pip install faiss-cpu index = faiss.IndexFlatL2(dim)

(faiss-gpu for GPU) [Link](vectors)
D,I = [Link](q, k)

Redis Vector pip install redis r = [Link]()

+ RedisSearch module [Link]('idx').search(Query(...))

"The right vector DB is a system decision. Not a tutorial

recommendation."

© 2025 Vector DB Reference Guide · For RAG Engineers Page 13