Bouw eerst exact zoeken en meet daarna de benadering

import numpy as np

def normalize_rows(vectors):
    try:
        raw_vectors = np.asarray(vectors)
        if np.iscomplexobj(raw_vectors):
            raise ValueError('Vectorwaarden moeten reëel zijn')
        vectors = np.asarray(raw_vectors, dtype=float)
    except (TypeError, OverflowError) as error:
        raise ValueError('Geen geldige reële vectorinvoer') from error
    if vectors.ndim != 2 or not 1 <= vectors.shape[0] <= 1000 or not 1 <= vectors.shape[1] <= 512 or not np.isfinite(vectors).all() or np.any(np.abs(vectors) > 1e6):
        raise ValueError('Geef een eindige begrensde matrix met maximaal 1000×512 waarden')
    norms = np.linalg.norm(vectors, axis=1, keepdims=True)
    if np.any(norms < 1e-12):
        raise ValueError('Een nulvector heeft geen richting; vrijwel nul wordt hier geweigerd')
    return vectors / norms

def cosine_search(vectors, query, ids, k):
    vectors = normalize_rows(vectors)
    try:
        raw_query = np.asarray(query)
        if np.iscomplexobj(raw_query):
            raise ValueError('Vectorwaarden moeten reëel zijn')
        query = np.asarray(raw_query, dtype=float)
    except (TypeError, OverflowError) as error:
        raise ValueError('Geen geldige reële vectorinvoer') from error
    if query.shape != (vectors.shape[1],):
        raise ValueError('Query en corpus moeten dezelfde dimensie hebben')
    query = normalize_rows(query[None, :])[0]
    if not isinstance(ids, list) or len(ids) != len(vectors) or any(not isinstance(i, str) or not 1 <= len(i) <= 100 for i in ids) or len(set(ids)) != len(ids):
        raise ValueError('Unieke niet-lege IDs vereist')
    if type(k) is not int or not 1 <= k <= len(ids):
        raise ValueError('Kies 1 tot N resultaten')
    scores = vectors @ query
    order = sorted(range(len(ids)), key=lambda i: (-scores[i], ids[i]))[:k]
    return [{'id': ids[i], 'score': float(scores[i])} for i in order]

def build_flat_index(ids, vectors, space):
    normalized = normalize_rows(vectors)
    if not isinstance(ids, list) or len(ids) != len(normalized) or any(not isinstance(i, str) or not 1 <= len(i) <= 100 for i in ids) or len(set(ids)) != len(ids):
        raise ValueError('Unieke begrensde IDs vereist')
    if not isinstance(space, str) or not space.strip() or len(space) > 300:
        raise ValueError('Geef een niet-lege embeddingruimte-ID van maximaal 300 tekens')
    return {'ids': list(ids), 'vectors': normalized.copy(), 'space': space}

def search_flat(index, query, space, k):
    if not isinstance(index, dict) or set(index) != {'ids', 'vectors', 'space'}:
        raise ValueError('Geef een flat index')
    checked = build_flat_index(index['ids'], index['vectors'], index['space'])
    if not isinstance(space, str) or space != checked['space']:
        raise ValueError('Query en index horen bij verschillende embeddingruimtes')
    return cosine_search(checked['vectors'], query, checked['ids'], k)

def build_coarse_index(flat, centroids):
    if not isinstance(flat, dict) or set(flat) != {'ids', 'vectors', 'space'}:
        raise ValueError('Geef een flat index')
    flat = build_flat_index(flat['ids'], flat['vectors'], flat['space'])
    centers = normalize_rows(centroids)
    if not 1 <= len(centers) <= min(32, len(flat['ids'])) or centers.shape[1] != flat['vectors'].shape[1]:
        raise ValueError('Geef 1 tot min(32,N) passende centroidvectoren')
    labels = np.argmax(flat['vectors'] @ centers.T, axis=1)
    buckets = [np.flatnonzero(labels == i).tolist() for i in range(len(centers))]
    return {**flat, 'centroids': centers.copy(), 'buckets': buckets}

def search_coarse(index, query, space, k, nprobe):
    if not isinstance(index, dict) or set(index) != {'ids', 'vectors', 'space', 'centroids', 'buckets'}:
        raise ValueError('Geef een coarse index uit build_coarse_index')
    # The index is an internal in-memory object, not an untrusted serialized file.
    if not isinstance(space, str) or space != index['space']:
        raise ValueError('Embeddingruimte verschilt')
    if type(k) is not int or not 1 <= k <= len(index['ids']) or type(nprobe) is not int or not 1 <= nprobe <= len(index['centroids']):
        raise ValueError('Ongeldige k of nprobe')
    try:
        raw_query = np.asarray(query)
        if np.iscomplexobj(raw_query):
            raise ValueError('Vectorwaarden moeten reëel zijn')
        query = np.asarray(raw_query, dtype=float)
    except (TypeError, OverflowError) as error:
        raise ValueError('Geen geldige reële vectorinvoer') from error
    if query.shape != (index['vectors'].shape[1],):
        raise ValueError('Verkeerde querydimensie')
    query = normalize_rows(query[None, :])[0]
    center_scores = index['centroids'] @ query
    probes = sorted(range(len(center_scores)), key=lambda i: (-center_scores[i], i))[:nprobe]
    candidates = sorted({i for c in probes for i in index['buckets'][c]})
    scores = index['vectors'][candidates] @ query
    ranked = sorted(zip(candidates, scores), key=lambda item: (-item[1], index['ids'][item[0]]))[:k]
    return {'probed': probes, 'candidates': len(candidates),
            'hits': [{'id': index['ids'][i], 'score': float(score)} for i, score in ranked]}

Voer de code uit en verklaar voor jezelf waarom elke stap werkt.