Textinbäddningar för RAG och sökning – Python, Ollama, OpenAI-kompatibla API:er

Om du arbetar med retrieval-augmented generation (RAG), går detta avsnitt igenom textembeddings i enkla termer – vad de är, hur de passar in i sökning och hämtning, och hur du anropar två vanliga lokala konfigurationer från Python med hjälp av Ollama eller en OpenAI-kompatibel HTTP-API (vilket många llama.cpp-baserade servrar exponerar).

För Go-klienter och SDK-jämförelser för Ollama, se Go SDK för Ollama — jämförelse med exempel.

Vad är en textembedding?

En textembedding är en vektor (en lista med flyttal) som produceras av en embeddingsmodell. Modellen mappar text med variabel längd till ett fast-dimensionellt utrymme så att texter med liknande betydning tenderar att hamna nära varandra under ett avstånds- eller likhetsmått (ofta kosinuslikhet på L2-normaliserade vektorer).

Embeddings är inte samma sak som token-ID:n och inte heller samma som en chattkomplettering. De är ett representationslager som du använder för sökning, klusteranalys, avdubling och – i RAG – hämtning.

Vanliga användningsområden

För multimodala miljöer (bild–text och relaterade idéer), se Cross-modal embeddings.

Embeddings i ett RAG-flöde

En typisk offline-väg är:

1. Dela upp dokument (storlek, överlappning och struktur spelar roll — se Strategier för delning i RAG).
2. Embeddiera varje bit; lagring av metadata (käll-ID, avsnitt, ACL) är valfritt.
3. Indexera vektorer i minnet, ett biblioteksindex eller en vektordatabas (avvägningar i Vektorlagring för RAG — jämförelse).

Vid frågestillning:

1. Embeddiera användarens fråga (en kort sträng eller en liten batch).
2. Hämta de k bäst liknande bitarna genom vektorsökning (valfritt med nyckelords- eller hybrid-sökning).
3. Bygg en prompt från de hämtade rena textbitarna och anropa din chatt-modell.

Viktig nyans – stora språkmodeller i chatt-API:er konsumerar text (och verktyg), inte godtyckliga embedding-tensoarer. Du använder embeddings för att välja vilken text som ska injiceras. Om du ser “fråga LLM:n med förberäknade embeddings”, betyder det i praktiken hämta med embeddings, skicka sedan den valda texten till LLM:n.

Hämta embeddings med Ollama (Python)

Ollama exponerar ett HTTP-API. För embeddings, anropa POST /api/embed på din Ollama-värd (standard http://127.0.0.1:11434). JSON-kroppen innehåller ett model-namn och input (en sträng eller en lista med strängar). Svaret innehåller embeddings, en lista med vektorer som är utjämnade med dina indata.

Installera httpx (eller använd requests på samma sätt).

import httpx

OLLAMA = "http://127.0.0.1:11434"
MODEL = "nomic-embed-text"  # ersätt med en embeddingsmodell du har hämtat

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 = "Vad är retrieval-augmented generation?"
    chunks = [
        "RAG kombinerar hämtning med generering.",
        "Embeddings mappar text till vektorrum för likhetssökning.",
    ]
    qv = embed_ollama([q])[0]
    doc_vs = embed_ollama(chunks)
    print(len(qv), len(doc_vs), len(doc_vs[0]))

Operativa anteckningar

• Hämta modellen först (ollama pull … för din valda tagg). För Qwen3-liknande modeller på Ollama, se Qwen3 Embedding & Reranker Models on Ollama.
• Vid belastning interagerar embeddingsgenomströmning med hur Ollama schemalägger arbete — se Hur Ollama hanterar parallella förfrågningar.

Hämta embeddings med en OpenAI-kompatibel server (Python)

Många lokala servrar (inklusive vanliga llama.cpp-HTTP-konfigurationer) exponerar OpenAI-kompatibla rutiner som POST /v1/embeddings. Du kan använda det officiella openai-paketet för Python och peka base_url mot din servers …/v1-rot.

from openai import OpenAI

# Exempel — ersätt värd, port och modell-ID med din servers värden
client = OpenAI(
    base_url="http://127.0.0.1:8080/v1",
    api_key="not-needed",  # många lokala servrar ignorerar detta
)

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("hello from llama.cpp", "your-embedding-model-id")
    print(len(v))

Varför hålla båda mönstren på en sida? Koncepten (del, embeddiera, indexera, fråga, hämta text) är identiska; bara HTTP-ytan ändras. En artikel i workshop-stil undviker att duplicera samma berättelse under två URL:er.

Persistera vektorer och fråga dem

I minst måste du lagra tre saker per bit — vektor, text och metadata (käll-ID, offset, ACL). För en snabb prototyp kan du hålla allt i en Python-lista och använda kosinuslikhet med NumPy eller scikit-learn. För växande data, använd en vektordatabas eller ett biblioteksindex (FAISS, etc.); se Vektorlagring för RAG — jämförelse för produktnivå-avvägningar.

Konceptuell frågelopp:

1. query_vec = embed(query)
2. neighbors = index.search(query_vec, k)
3. context = "\n\n".join(chunk.text for chunk in neighbors)
4. Skicka context och användarens fråga till ditt chatt-API.

Omrangering efter hämtning

En reranker (ofta en cross-encoder eller en andra poängsättningsmodell) kan omordna de bästa kandidaterna efter vektorhämtning. Denna sida har Python- och Go-exempel, inklusive Omrangering med embeddingsmodeller och Omrangering med Ollama och Qwen3-embedding i Go.

På denna sida — relaterade artiklar

Användbara länkar

• Ollama — modeller och runtime
• Ollama API — embed — upstream-API-referens för /api/embed
• OpenAI Python-bibliotek — fungerar med vilken OpenAI-kompatibel base_url som helst