Embeddings and similarity

from openai import OpenAI

client = OpenAI()

texts = [
    "Refunds are issued within 30 days for annual plans.",
    "How do I get my money back?",
    "Backups run every night at 2 AM.",
]

response = client.embeddings.create(model="text-embedding-3-small", input=texts)
vectors = [item.embedding for item in response.data]

print(len(vectors), "vectors of", len(vectors[0]), "dimensions")
print("tokens used:", response.usage.total_tokens)

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("all-MiniLM-L6-v2")      # ~90 MB, 384 dimensions

texts = ["Refunds are issued within 30 days.", "How do I get my money back?", "Backups run nightly."]
vectors = model.encode(texts, normalize_embeddings=True)

print(vectors.shape)
print((vectors @ vectors.T).round(2))     # cosine similarity matrix

import hashlib
import re

import numpy as np

STOPWORDS = {"a", "an", "the", "is", "are", "be", "can", "do", "does", "i", "my", "to",
             "of", "in", "on", "for", "and", "or", "what", "how", "it", "you", "your", "at"}


def words(text: str) -> list[str]:
    """Lowercase, drop stopwords, and strip a few suffixes (refunded -> refund)."""
    out = []
    for w in re.findall(r"[a-z0-9-]+", text.lower()):
        if w in STOPWORDS:
            continue
        for suffix in ("ing", "ed", "s"):
            if w.endswith(suffix) and len(w) > len(suffix) + 3:
                w = w[: -len(suffix)]
                break
        out.append(w)
    return out


def embed(text: str, dim: int = 256) -> np.ndarray:
    """Toy embedding: hashed bag of words, L2-normalised. Real models capture meaning."""
    vec = np.zeros(dim, dtype=np.float32)
    for word in words(text):
        bucket = int(hashlib.md5(word.encode()).hexdigest(), 16) % dim
        vec[bucket] += 1.0
    norm = np.linalg.norm(vec)
    return vec / norm if norm else vec


docs = [
    "Annual plans can be refunded within 30 days of purchase.",
    "Backups run every night and files are kept for 90 days.",
    "Admins must enable two-factor authentication.",
]
doc_vecs = np.stack([embed(d) for d in docs])

for query in ["refund for annual plan", "how long are files kept", "pizza recipe"]:
    scores = doc_vecs @ embed(query)
    best = int(np.argmax(scores))
    print(f"{query!r:<26} best={best}  scores={[round(float(s), 2) for s in scores]}")

import hashlib

CACHE: dict[str, list[float]] = {}
api_calls = {"count": 0}


def fake_embed_batch(texts: list[str]) -> list[list[float]]:
    api_calls["count"] += 1
    return [[float(len(t))] for t in texts]          # stand-in vectors


def embed_with_cache(texts: list[str], model: str = "text-embedding-3-small") -> list[list[float]]:
    keys = [hashlib.sha256(f"{model}:{t}".encode()).hexdigest() for t in texts]
    missing = [t for t, k in zip(texts, keys) if k not in CACHE]
    if missing:
        for t, vec in zip(missing, fake_embed_batch(missing)):
            CACHE[hashlib.sha256(f"{model}:{t}".encode()).hexdigest()] = vec
    return [CACHE[k] for k in keys]


embed_with_cache(["chunk A", "chunk B"])
embed_with_cache(["chunk A", "chunk B", "chunk C"])     # only C is new
print("API calls:", api_calls["count"], "| cached vectors:", len(CACHE))