from openai import OpenAI

client = OpenAI()

def embed_text(text: str) -> list[float]:
    response = client.embeddings.create(
        model="text-embedding-3-large",
        input=text
    )
    return response.data[0].embedding  # 3072-dimensional vector

# Example
vector = embed_text("Kubernetes pod scheduling strategies")
print(f"Vector dimensions: {len(vector)}")  # 3072
print(f"First 5 values: {vector[:5]}")
# [0.0123, -0.0456, 0.0789, -0.0234, 0.0567]

import psycopg2
from openai import OpenAI
from typing import Any

client = OpenAI()

def chunk_text(text: str, chunk_size: int = 512, overlap: int = 64) -> list[str]:
    """Split text into overlapping chunks."""
    words = text.split()
    chunks = []
    for i in range(0, len(words), chunk_size - overlap):
        chunk = " ".join(words[i:i + chunk_size])
        chunks.append(chunk)
    return chunks

def embed_batch(texts: list[str]) -> list[list[float]]:
    """Embed multiple texts in one API call."""
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=texts
    )
    return [item.embedding for item in response.data]

def ingest_document(conn, content: str, metadata: dict[str, Any]):
    """Chunk, embed, and store a document."""
    chunks = chunk_text(content)
    embeddings = embed_batch(chunks)
    
    with conn.cursor() as cur:
        for chunk, embedding in zip(chunks, embeddings):
            cur.execute(
                """INSERT INTO documents (content, metadata, embedding) 
                   VALUES (%s, %s, %s)""",
                (chunk, psycopg2.extras.Json(metadata), embedding)
            )
    conn.commit()
    print(f"Ingested {len(chunks)} chunks")

def retrieve(conn, query: str, top_k: int = 5) -> list[dict]:
    """Find semantically similar chunks."""
    query_embedding = embed_batch([query])[0]
    
    with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
        cur.execute(
            """SELECT content, metadata,
                      1 - (embedding <=> %s::vector) AS similarity
               FROM documents
               ORDER BY embedding <=> %s::vector
               LIMIT %s""",
            (query_embedding, query_embedding, top_k)
        )
        return cur.fetchall()

def answer_question(conn, question: str) -> str:
    """RAG: Retrieve relevant context, then generate answer."""
    # 1. Retrieve
    chunks = retrieve(conn, question, top_k=5)
    
    context = "\n\n---\n\n".join([
        f"[Source: {c['metadata'].get('source', 'Unknown')}]\n{c['content']}"
        for c in chunks
    ])
    
    # 2. Generate
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": "Answer questions based on the provided context. "
                           "If the answer isn't in the context, say so."
            },
            {
                "role": "user",
                "content": f"Context:\n{context}\n\nQuestion: {question}"
            }
        ]
    )
    return response.choices[0].message.content

# Using Weaviate's hybrid search
import weaviate

client = weaviate.connect_to_cloud(
    cluster_url="your-cluster.weaviate.network",
    auth_credentials=weaviate.auth.AuthApiKey("your-api-key"),
)

collection = client.collections.get("Documents")

# Hybrid: combines BM25 + vector search with configurable alpha
results = collection.query.hybrid(
    query="kubernetes pod eviction policy",
    alpha=0.75,       # 0 = pure BM25, 1 = pure vector, 0.75 = mostly vector
    limit=10,
    return_metadata=["score", "explain_score"]
)

for obj in results.objects:
    print(f"Score: {obj.metadata.score:.3f}")
    print(f"Content: {obj.properties['content'][:200]}")
    print()

# Qdrant: payload filtering during vector search
from qdrant_client import QdrantClient
from qdrant_client.models import Filter, FieldCondition, Range, MatchValue

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

results = qdrant.search(
    collection_name="documents",
    query_vector=query_embedding,
    query_filter=Filter(
        must=[
            FieldCondition(
                key="user_id",
                match=MatchValue(value="user_123")
            ),
            FieldCondition(
                key="created_at",
                range=Range(
                    gte=1700000000,  # Unix timestamp
                    lte=1800000000
                )
            ),
            FieldCondition(
                key="doc_type",
                match=MatchValue(value="technical")
            )
        ]
    ),
    limit=10
)

# Qdrant scalar quantization — 4× memory reduction, ~5% recall loss
from qdrant_client.models import VectorParams, ScalarQuantizationConfig, Distance

qdrant.create_collection(
    collection_name="large_corpus",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE),
    quantization_config=ScalarQuantizationConfig(
        type="scalar",
        quantile=0.99,
        always_ram=True  # Keep quantized index in RAM, raw on disk
    )
)

# Namespace per tenant in Pinecone
index.upsert(
    vectors=[{"id": "doc1", "values": embedding, "metadata": {"text": "..."}}],
    namespace=f"tenant_{user_id}"  # Isolated per tenant
)

# Query only within tenant namespace
results = index.query(
    vector=query_embedding,
    namespace=f"tenant_{user_id}",
    top_k=10,
    include_metadata=True
)