Tekst-embeddings voor RAG en zoekfuncties - Python, Ollama, OpenAI-compatibele API's

Als u werkt aan generatie versterkt met ophalen (RAG), leidt dit gedeelte u in eenvoudige taal door tekst-embeddings: wat ze zijn, hoe ze passen binnen zoeken en ophalen, en hoe u twee veelvoorkomende lokale opstellingen in Python kunt aanroepen via Ollama of een OpenAI-compatibele HTTP-API (zoals veel op llama.cpp gebaseerde servers exposen).

Voor Go-clients en SDK-vergelijkingen voor Ollama, zie Go SDK’s voor Ollama — vergelijking met voorbeelden.

Wat is een tekst-embedding?

Een tekst-embedding is een vector (een lijst van floats) die wordt gegenereerd door een embedding-model. Het model mappingt tekst met variabele lengte naar een vast-dimensionale ruimte, zodat teksten met een vergelijkbare betekenis onder een afstand- of similariteitsmeting (vaak cosinewijs similariteit op L2-genormaliseerde vectoren) dicht bij elkaar zitten.

Embeddings zijn niet hetzelfde als token-IDs en ook niet hetzelfde als een chat-completie. Het is een representatielaag die u gebruikt voor zoeken, clustering, duplicatieverwijdering en — in RAG — ophalen.

Veelvoorkomende gebruiksscenario’s

Voor multimodale instellingen (beeld–tekst en gerelateerde ideeën), zie Cross-modale embeddings.

Embeddings binnen een RAG-pipeline

Een typische offline-route is:

1. Chunk documenten (grootte, overlap en structuur zijn van belang — zie Chunking-strategieën in RAG).
2. Embed elk fragment; sla optioneel metadata op (bron-ID, sectie, ACL).
3. Indexeer vectoren in het geheugen, een bibliotheek-index of een vectordatabase (afwegingen in Vectoropslag voor RAG — vergelijking).

Op het moment van query:

1. Embed de gebruikersquery (één korte string of een kleine batch).
2. Haal de top‑k meest vergelijkbare fragmenten op via vectorzoeken (optioneel plus trefwoord/hybride zoeken).
3. Bouw een prompt op basis van de opgehaalde plaine tekst-fragmenten en roep uw chat-model aan.

Belangrijke nuance — grote taalmodellen in chat-API’s verbruiken tekst (en hulpmiddelen), geen willekeurige embedding-tensors. U gebruikt embeddings om te kiezen welke tekst u moet injecteren. Als u “query de LLM met vooraf berekende embeddings” ziet, betekent dit in de praktijk: haal op met embeddings, en stuur de geselecteerde tekst naar de LLM.

Embeddings ophalen met Ollama (Python)

Ollama exposeert een HTTP-API. Voor embeddings, roep POST /api/embed aan op uw Ollama-host (standaard http://127.0.0.1:11434). Het JSON-lichaam bevat een model-naam en input (een string of een lijst van strings). Het antwoord bevat embeddings, een lijst van vectoren die uitgelijnd zijn met uw inputs.

Installeer httpx (of gebruik requests op dezelfde manier).

import httpx

OLLAMA = "http://127.0.0.1:11434"
MODEL = "nomic-embed-text"  # vervang door een embedding-model dat u hebt opgehaald

def embed_ollama(texts: list[str]) -> list[list[float]]:
    r = httpx.post(
        f"{OLLAMA}/api/embed",
        json={"model": MODEL, "input": texts},
        timeout=120.0,
    )
    r.raise_for_status()
    data = r.json()
    return data["embeddings"]

if __name__ == "__main__":
    q = "Wat is retrieval-augmented generation?"
    chunks = [
        "RAG combineert ophalen met generatie.",
        "Embeddings mappen tekst naar vectorruimte voor similariteit zoeken.",
    ]
    qv = embed_ollama([q])[0]
    doc_vs = embed_ollama(chunks)
    print(len(qv), len(doc_vs), len(doc_vs[0]))

Operationele notities

• Haal het model eerst op (ollama pull … voor uw gekozen tag). Voor Qwen3-klasse modellen op Ollama, zie Qwen3 Embedding & Reranker Modellen op Ollama.
• Onder belasting wisselt de embedding-doorsnee interactie met hoe Ollama werk scheduleert — zie Hoe Ollama parallelle verzoeken afhandelt.

Embeddings ophalen met een OpenAI-compatibele server (Python)

Veel lokale servers (waaronder veelvoorkomende llama.cpp HTTP-opstellingen) exposen OpenAI-compatibele routes zoals POST /v1/embeddings. U kunt het officiële openai Python-pakket gebruiken en base_url wijzen op het …/v1-root van uw server.

from openai import OpenAI

# Voorbeeld — vervang host, poort en model-id door de waarden van uw server
client = OpenAI(
    base_url="http://127.0.0.1:8080/v1",
    api_key="not-needed",  # veel lokale servers negeren dit
)

def embed_openai_compatible(text: str, model: str) -> list[float]:
    r = client.embeddings.create(model=model, input=text)
    return r.data[0].embedding

if __name__ == "__main__":
    v = embed_openai_compatible("hallo van llama.cpp", "your-embedding-model-id")
    print(len(v))

Waarom beide patronen op één pagina houden? De concepten (chunk, embed, index, query, haal tekst op) zijn identiek; alleen de HTTP-interface verandert. Een artikel in workshop-stijl voorkomt het dupliceren van hetzelfde verhaal onder twee URL’s.

Vectoren opslaan en queryen

U moet minimaal drie dingen per fragment opslaan — vector, tekst en metadata (bron-ID, offsets, ACL). Voor een snelle prototype kunt u alles in een Python-lijst houden en cosinewijs similariteit gebruiken met NumPy of scikit-learn. Voor groeiende data, gebruik een vectordatabase of een bibliotheek-index (FAISS, enz.); zie Vectoropslag voor RAG — vergelijking voor productniveau-afwegingen.

Conceptuele query-lus:

1. query_vec = embed(query)
2. neighbors = index.search(query_vec, k)
3. context = "\n\n".join(chunk.text for chunk in neighbors)
4. Stuur context en de gebruikersvraag naar uw chat-API.

Reranking na ophalen

Een reranker (vaak een cross-encoder of een tweede scoremodel) kan de beste kandidaten opnieuw sorteren na vector-ophalen. Deze site bevat Python- en Go-voorbeelden, inclusief Reranking met embedding-modellen en Reranking met Ollama en Qwen3 Embedding in Go.

Op deze site — gerelateerde artikelen

Nuttige links

• Ollama — modellen en runtime
• Ollama API — embed — upstream API-referentie voor /api/embed
• OpenAI Python-bibliotheek — werkt met elke OpenAI-compatibele base_url