# Traditional query: exact match
SELECT * FROM products WHERE category = 'electronics';

# Vector query: semantic similarity
# "Find products similar to this description"
query_embedding = embed("wireless headphones with noise cancellation")
results = vector_db.query(
    vector=query_embedding,
    top_k=10,
    filter={"in_stock": True}
)

from openai import OpenAI
import psycopg
import json

client = OpenAI()

def embed(text: str) -> list[float]:
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )
    return response.data[0].embedding

async def ingest_documents(documents: list[dict]):
    conn = await psycopg.AsyncConnection.connect(DATABASE_URL)
    
    # Batch embed for efficiency
    texts = [doc["content"] for doc in documents]
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=texts
    )
    embeddings = [r.embedding for r in response.data]
    
    async with conn.transaction():
        await conn.executemany(
            """
            INSERT INTO documents (content, metadata, embedding)
            VALUES (%s, %s, %s::vector)
            ON CONFLICT DO NOTHING
            """,
            [
                (doc["content"], json.dumps(doc.get("metadata", {})), str(emb))
                for doc, emb in zip(documents, embeddings)
            ]
        )

from qdrant_client import QdrantClient
from qdrant_client.models import (
    Distance, VectorParams, PointStruct,
    HnswConfigDiff, OptimizersConfigDiff,
    Filter, FieldCondition, MatchValue
)

client = QdrantClient(url="http://localhost:6333")

# Create collection with HNSW tuning
client.create_collection(
    collection_name="documents",
    vectors_config=VectorParams(
        size=1536,
        distance=Distance.COSINE,
        hnsw_config=HnswConfigDiff(
            m=16,
            ef_construct=100,
            full_scan_threshold=10000,
        ),
    ),
    optimizers_config=OptimizersConfigDiff(
        indexing_threshold=20000,  # vectors before indexing
        memmap_threshold=50000,    # switch to mmap after this
    ),
)

# Batch upsert
client.upsert(
    collection_name="documents",
    points=[
        PointStruct(
            id=doc["id"],
            vector=doc["embedding"],
            payload={
                "content": doc["content"],
                "source": doc["source"],
                "created_at": doc["created_at"],
                "tags": doc["tags"],
            }
        )
        for doc in documents
    ]
)

# Search with complex filters
results = client.search(
    collection_name="documents",
    query_vector=query_embedding,
    query_filter=Filter(
        must=[
            FieldCondition(key="tags", match=MatchValue(value="python")),
        ],
        must_not=[
            FieldCondition(key="source", match=MatchValue(value="spam")),
        ],
        should=[
            FieldCondition(key="tags", match=MatchValue(value="tutorial")),
            FieldCondition(key="tags", match=MatchValue(value="beginner")),
        ],
    ),
    limit=10,
    with_payload=True,
    score_threshold=0.75,
)

# Sparse + dense hybrid search (Qdrant native)
results = client.query_points(
    collection_name="documents",
    prefetch=[
        Prefetch(query=SparseVector(indices=sparse_indices, values=sparse_values), using="sparse", limit=100),
        Prefetch(query=dense_embedding, using="dense", limit=100),
    ],
    query=FusionQuery(fusion=Fusion.RRF),  # Reciprocal Rank Fusion
    limit=10,
)

from pinecone import Pinecone, ServerlessSpec

pc = Pinecone(api_key=os.environ["PINECONE_API_KEY"])

# Create serverless index
pc.create_index(
    name="documents",
    dimension=1536,
    metric="cosine",
    spec=ServerlessSpec(
        cloud="aws",
        region="us-east-1"
    )
)

index = pc.Index("documents")

# Upsert with metadata
index.upsert(
    vectors=[
        {
            "id": doc["id"],
            "values": doc["embedding"],
            "metadata": {
                "content": doc["content"][:1000],  # metadata size limit
                "source": doc["source"],
                "tags": doc["tags"],
            }
        }
        for doc in documents
    ],
    batch_size=100,
    namespace="production"  # namespaces for multi-tenancy
)

results = index.query(
    vector=query_embedding,
    top_k=10,
    filter={
        "$and": [
            {"tags": {"$in": ["python", "javascript"]}},
            {"created_at": {"$gte": "2025-01-01"}},
        ]
    },
    include_metadata=True,
    namespace="production"
)

import asyncio
from anthropic import Anthropic
from qdrant_client import AsyncQdrantClient
from openai import AsyncOpenAI

class RAGSystem:
    def __init__(self):
        self.anthropic = Anthropic()
        self.openai = AsyncOpenAI()
        self.qdrant = AsyncQdrantClient(url=QDRANT_URL)
    
    async def retrieve(self, query: str, top_k: int = 5) -> list[dict]:
        # Embed query
        response = await self.openai.embeddings.create(
            model="text-embedding-3-small",
            input=query
        )
        query_embedding = response.data[0].embedding
        
        # Search
        results = await self.qdrant.search(
            collection_name="documents",
            query_vector=query_embedding,
            limit=top_k,
            score_threshold=0.7,
            with_payload=True,
        )
        
        return [
            {"content": r.payload["content"], "score": r.score, "source": r.payload["source"]}
            for r in results
        ]
    
    async def answer(self, query: str) -> str:
        # Retrieve relevant documents
        docs = await self.retrieve(query)
        
        if not docs:
            return "I couldn't find relevant information to answer this question."
        
        # Build context
        context = "\n\n".join([
            f"[Source: {d['source']}]\n{d['content']}"
            for d in docs
        ])
        
        # Generate answer
        response = self.anthropic.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=1024,
            system="""You are a helpful assistant. Answer questions based strictly on the provided context.
If the context doesn't contain enough information, say so clearly.
Always cite your sources.""",
            messages=[
                {
                    "role": "user",
                    "content": f"Context:\n{context}\n\nQuestion: {query}"
                }
            ]
        )
        
        return response.content[0].text

# Usage
rag = RAGSystem()
answer = await rag.answer("What are the benefits of TypeScript decorators?")