Azure OpenAI text-embedding-ada-002 — deprecated, reindex to text-embedding-3

"""Evaluation harness — measure v3-small vs v3-large on your data.

Run this ONCE with a representative sample of queries + labeled relevant docs
before committing to a model choice.
"""
import os
from openai import AzureOpenAI
from typing import List

client = AzureOpenAI(api_key="...", azure_endpoint="...", api_version="2024-10-21")

def embed(text: str, deployment: str, dimensions: int = None) -> List[float]:
    kwargs = {"model": deployment, "input": text}
    if dimensions:
        kwargs["dimensions"] = dimensions
    response = client.embeddings.create(**kwargs)
    return response.data[0].embedding

def cosine(a: List[float], b: List[float]) -> float:
    import math
    dot = sum(x * y for x, y in zip(a, b))
    na = math.sqrt(sum(x * x for x in a))
    nb = math.sqrt(sum(x * x for x in b))
    return dot / (na * nb)

def recall_at_k(queries, docs, deployment, k=10, dimensions=None):
    """queries: [(query_text, relevant_doc_ids)]; docs: {doc_id: text}"""
    doc_embs = {i: embed(t, deployment, dimensions) for i, t in docs.items()}
    hits = 0
    for query, relevant in queries:
        qe = embed(query, deployment, dimensions)
        scored = sorted(doc_embs.items(), key=lambda x: cosine(qe, x[1]), reverse=True)[:k]
        if any(doc_id in relevant for doc_id, _ in scored):
            hits += 1
    return hits / len(queries)

# Build eval set from your production data (100-1000 labeled queries is enough)
queries = [...]   # [(query, {relevant_doc_ids})]
docs = {...}      # {doc_id: doc_text}

for cfg in [
    ("text-embedding-3-small", None),
    ("text-embedding-3-small", 512),
    ("text-embedding-3-large", 1536),
    ("text-embedding-3-large", None),  # 3072
]:
    deployment, dims = cfg
    score = recall_at_k(queries, docs, deployment, k=10, dimensions=dims)
    print(f"{deployment} ({dims or 'default'}): recall@10 = {score:.3f}")

"""Dual-write migration from ada-002 to text-embedding-3-large."""
import os
from openai import AzureOpenAI

client = AzureOpenAI(api_key="...", azure_endpoint="...", api_version="2024-10-21")

# Phase flags — controlled via env or feature flag service
DUAL_WRITE = os.getenv("EMBEDDINGS_DUAL_WRITE") == "true"
READ_FROM_NEW = os.getenv("EMBEDDINGS_READ_FROM_NEW") == "true"

# Deployments
DEPLOYMENT_OLD = "ada002-legacy"           # to be retired
DEPLOYMENT_NEW = "text-embedding-3-large"

# Vector DBs (simplified — pinecone, weaviate, etc.)
index_old = ...  # 1536-dim
index_new = ...  # 3072-dim (or 1536 if you use dimensions=1536 on 3-large)

def embed(text: str, deployment: str, dimensions: int = None):
    kwargs = {"model": deployment, "input": text}
    if dimensions:
        kwargs["dimensions"] = dimensions
    return client.embeddings.create(**kwargs).data[0].embedding

def upsert_document(doc_id: str, text: str):
    """Called at write time. In dual-write, writes to both indexes."""
    # Always write to the new index
    emb_new = embed(text, DEPLOYMENT_NEW)  # 3072-dim
    index_new.upsert(doc_id, emb_new, metadata={"text": text})

    if DUAL_WRITE:
        emb_old = embed(text, DEPLOYMENT_OLD)
        index_old.upsert(doc_id, emb_old, metadata={"text": text})

def search(query: str, k: int = 10):
    """Called at read time. Dispatches to the active index."""
    if READ_FROM_NEW:
        qe = embed(query, DEPLOYMENT_NEW)
        return index_new.query(qe, top_k=k)
    else:
        qe = embed(query, DEPLOYMENT_OLD)
        return index_old.query(qe, top_k=k)

# Backfill script — run once per historical batch
def backfill_batch(doc_batch):
    """Backfill new index from historical corpus."""
    texts = [d["text"] for d in doc_batch]
    response = client.embeddings.create(model=DEPLOYMENT_NEW, input=texts)
    for doc, emb in zip(doc_batch, response.data):
        index_new.upsert(doc["id"], emb.embedding, metadata=doc.get("metadata", {}))

from openai import AzureOpenAI

client = AzureOpenAI(api_key="...", azure_endpoint="...", api_version="2024-10-21")

# text-embedding-3-large truncated to 1536 dims
# Beats ada-002 quality, same dimensions, same index schema
def embed_v3_dropin(texts: list) -> list:
    response = client.embeddings.create(
        model="text-embedding-3-large",  # your deployment name for 3-large
        input=texts,
        dimensions=1536,   # match your existing index dimensionality
    )
    return [d.embedding for d in response.data]

# Verify quality parity before switching
sample_texts = ["A dog barks", "A canine vocalises loudly"]
old_vecs = ...   # from ada-002
new_vecs = embed_v3_dropin(sample_texts)

# Cosine similarity between semantically similar sentences should be higher on v3
print("v3-large @1536:", cosine(new_vecs[0], new_vecs[1]))
print("ada-002:      ", cosine(old_vecs[0], old_vecs[1]))