Vector Databases Explained

What is a Vector Database?

A vector database is a specialized database designed to store, index, and query high-dimensional vectors (embeddings). Unlike traditional databases that work with rows and columns, vector databases excel at finding similar items based on their semantic meaning.

When you convert text, images, or other data into embeddings using AI models, these embeddings capture the semantic meaning of the content. Vector databases let you search through millions of these embeddings in milliseconds.

How Vector Databases Work

1. Embeddings

Data is converted to vectors (lists of numbers) using embedding models:

# Text to embedding
"The quick brown fox" → [0.023, -0.041, 0.089, ..., 0.012]
                         ↑ 1536 dimensions (OpenAI)

# Similar text = similar vectors
"A fast brown fox"    → [0.021, -0.038, 0.091, ..., 0.014]
"Pizza recipe"        → [0.892, 0.234, -0.567, ..., 0.445]

2. Indexing

Vector databases use specialized algorithms to index vectors for fast similarity search:

• HNSW (Hierarchical Navigable Small World): Graph-based, excellent accuracy
• IVF (Inverted File Index): Cluster-based, good for large datasets
• PQ (Product Quantization): Compression for memory efficiency
• Flat: Brute force, perfect accuracy but slow

3. Similarity Search

Finding similar vectors using distance metrics:

# Common distance metrics

# Cosine Similarity (most common for text)
# Range: -1 to 1 (1 = identical)
cosine_sim = dot(A, B) / (norm(A) * norm(B))

# Euclidean Distance (L2)
# Range: 0 to infinity (0 = identical)
euclidean = sqrt(sum((A - B)^2))

# Dot Product
# For normalized vectors, same as cosine
dot_product = sum(A * B)

Popular Vector Databases Compared

import pinecone

pinecone.init(api_key="xxx")
index = pinecone.Index("my-index")

# Upsert vectors
index.upsert([
    ("id1", [0.1, 0.2, ...], {"text": "doc1"})
])

# Query
results = index.query(
    vector=[0.1, 0.2, ...],
    top_k=5,
    include_metadata=True
)

import chromadb

client = chromadb.Client()
collection = client.create_collection("docs")

# Add documents (auto-embeds!)
collection.add(
    documents=["doc1", "doc2"],
    ids=["id1", "id2"]
)

# Query with text
results = collection.query(
    query_texts=["search query"],
    n_results=5
)

import weaviate

client = weaviate.Client("http://localhost:8080")

# Query with GraphQL
result = client.query.get(
    "Document", ["content", "title"]
).with_near_text({
    "concepts": ["machine learning"]
}).with_limit(5).do()

from qdrant_client import QdrantClient

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

# Search with filtering
results = client.search(
    collection_name="docs",
    query_vector=[0.1, 0.2, ...],
    query_filter=Filter(
        must=[FieldCondition(
            key="category",
            match=MatchValue(value="tech")
        )]
    ),
    limit=5
)

-- Enable extension
CREATE EXTENSION vector;

-- Create table with vector column
CREATE TABLE documents (
  id SERIAL PRIMARY KEY,
  content TEXT,
  embedding vector(1536)
);

-- Similarity search
SELECT * FROM documents
ORDER BY embedding <-> '[0.1, 0.2, ...]'
LIMIT 5;

Choosing the Right Vector Database

Using Vector DBs with LangChain

LangChain provides a unified interface for all major vector databases:

from langchain_openai import OpenAIEmbeddings
from langchain.text_splitter import CharacterTextSplitter

# Common setup
embeddings = OpenAIEmbeddings()
texts = ["doc1", "doc2", "doc3"]

# Pinecone
from langchain_pinecone import PineconeVectorStore
vectorstore = PineconeVectorStore.from_texts(texts, embeddings, index_name="my-index")

# ChromaDB
from langchain_chroma import Chroma
vectorstore = Chroma.from_texts(texts, embeddings, persist_directory="./chroma")

# Qdrant
from langchain_qdrant import Qdrant
vectorstore = Qdrant.from_texts(texts, embeddings, url="http://localhost:6333")

# Same interface for all!
results = vectorstore.similarity_search("query", k=5)
retriever = vectorstore.as_retriever()

Best Practices

• Choose the right embedding model: OpenAI's text-embedding-3-small/large, Cohere, or open-source alternatives
• Normalize your vectors: Most databases work best with normalized vectors
• Store metadata: Keep original text and context with your vectors
• Use appropriate chunk sizes: 500-1000 tokens usually works well
• Index wisely: HNSW for accuracy, IVF for scale, Flat for small datasets
• Monitor performance: Track query latency and recall metrics
• Consider hybrid search: Combine vector + keyword search for better results

Related Articles