Vector Databases

import chromadb
from chromadb.utils import embedding_functions

# --- Setup ---
# Persistent storage (survives restarts)
client = chromadb.PersistentClient(path="./chroma_db")

# Use OpenAI embeddings (or default all-MiniLM-L6-v2)
openai_ef = embedding_functions.OpenAIEmbeddingFunction(
    api_key="sk-...",
    model_name="text-embedding-3-small"
)

# Create or get a collection
collection = client.get_or_create_collection(
    name="knowledge_base",
    embedding_function=openai_ef,
    metadata={"hnsw:space": "cosine"}  # distance metric
)

print(f"Collection has {collection.count()} documents")

# --- Ingestion ---
documents = [
    "Python was created by Guido van Rossum in 1991",
    "JavaScript was created by Brendan Eich in 1995",
    "Rust focuses on memory safety without garbage collection",
    "Go was designed at Google for concurrent systems",
    "TypeScript adds static types to JavaScript",
    "React is a JavaScript library for building user interfaces",
    "FastAPI is a modern Python web framework",
    "Docker containers package applications with dependencies",
]

# Add documents with metadata
collection.add(
    documents=documents,
    ids=[f"doc_{i}" for i in range(len(documents))],
    metadatas=[
        {"category": "language", "year": 1991},
        {"category": "language", "year": 1995},
        {"category": "language", "year": 2010},
        {"category": "language", "year": 2009},
        {"category": "language", "year": 2012},
        {"category": "framework", "year": 2013},
        {"category": "framework", "year": 2018},
        {"category": "tool", "year": 2013},
    ]
)

print(f"Added {len(documents)} documents")

# --- Query: Basic Similarity Search ---
results = collection.query(
    query_texts=["What languages focus on safety?"],
    n_results=3
)

print("Top 3 results:")
for doc, dist in zip(results["documents"][0], results["distances"][0]):
    print(f"  [{1 - dist:.3f}] {doc}")

# Output:
#   [0.847] Rust focuses on memory safety without garbage collection
#   [0.712] Go was designed at Google for concurrent systems
#   [0.634] TypeScript adds static types to JavaScript

# --- Query: Filtered Search ---
# Only search within frameworks
results = collection.query(
    query_texts=["web development tools"],
    n_results=3,
    where={"category": "framework"}  # metadata filter
)

print("Frameworks for web dev:")
for doc in results["documents"][0]:
    print(f"  • {doc}")

# --- Query: Combined Filters ---
# Languages created after 2008
results = collection.query(
    query_texts=["modern programming"],
    n_results=5,
    where={
        "$and": [
            {"category": "language"},
            {"year": {"$gte": 2008}}
        ]
    }
)

# --- Update a document ---
collection.update(
    ids=["doc_0"],
    documents=["Python was created by Guido van Rossum in 1991. It emphasizes readability."],
    metadatas=[{"category": "language", "year": 1991, "updated": True}]
)

# --- Delete documents ---
collection.delete(ids=["doc_7"])

from qdrant_client import QdrantClient
from qdrant_client.models import (
    VectorParams, Distance, PointStruct,
    Filter, FieldCondition, MatchValue
)
from openai import OpenAI

# Connect (local Docker: docker run -p 6333:6333 qdrant/qdrant)
qdrant = QdrantClient(host="localhost", port=6333)
openai_client = OpenAI()

# Create collection
qdrant.create_collection(
    collection_name="documents",
    vectors_config=VectorParams(
        size=1536,       # text-embedding-3-small dimensions
        distance=Distance.COSINE
    )
)

# Helper: embed text
def embed(texts):
    response = openai_client.embeddings.create(
        input=texts, model="text-embedding-3-small"
    )
    return [d.embedding for d in response.data]

# Insert
texts = ["Python is great for AI", "Rust is fast and safe"]
vectors = embed(texts)

qdrant.upsert(
    collection_name="documents",
    points=[
        PointStruct(id=i, vector=v, payload={"text": t, "lang": "en"})
        for i, (v, t) in enumerate(zip(vectors, texts))
    ]
)

# Search with filter
query_vector = embed(["systems programming"])[0]
results = qdrant.search(
    collection_name="documents",
    query_vector=query_vector,
    query_filter=Filter(
        must=[FieldCondition(key="lang", match=MatchValue(value="en"))]
    ),
    limit=5
)

for hit in results:
    print(f"[{hit.score:.3f}] {hit.payload['text']}")