Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Embeddings-API:n: Modeller och dimensioner

Lektion 2 av 22 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Mål
  2. Det grundläggande anropet
  3. De två tillgängliga modellerna
  4. Batch-embeddings
  5. Dimensionsreducering
  6. Tokenhantering
  7. Viktiga punkter

Mål

  • Bemästra anropet client.embeddings.create()
  • Förstå skillnaderna mellan embeddings-modeller
  • Använda dimensionsreducering

Det grundläggande anropet

Hela OpenAIs Embeddings-API ryms i en enda metod: client.embeddings.create(). Du skickar in en textsträng och ett modellnamn:

from openai import OpenAI

client = OpenAI()

response = client.embeddings.create(
    input="Hello, how are you?",
    model="text-embedding-3-large"
)

embedding = response.data[0].embedding
print(f"Type: {type(embedding)}")        # list
print(f"Length: {len(embedding)}")      # 3072
print(f"Snippet: {embedding[:3]}")        # [0.023, -0.041, 0.012]

Det returnerade objektet är inte själva vektorn utan en wrapper som innehåller flera vektorer, eftersom API:t är designat för att hantera batchar. Inuti hittar du data, en lista med objekt där varje objekt har ett fält embedding (vektorn) och ett fält index (dess position i den skickade batchen); model, den faktiska modell som användes; och usage.prompt_tokens, antalet debiterade tokens. Du bör logga detta sista fält från dag ett: det är det enda tillförlitliga måttet på vad din indexering kostar.

De två tillgängliga modellerna

text-embedding-3-large är högprestandamodellen. Dess 3 072 dimensioner fångar de finaste semantiska nyanserna, vilket gör den idealisk för sökning i stora korpusar, krävande RAG-pipelines och generellt alla fall där precision väger tyngre än kostnad. Om en användare ställer frågor indirekt eller dina dokument täcker ett dense tekniskt område, kommer du att se skillnaden i hur resultaten rankas.

text-embedding-3-small är mer kompakt med 1 536 dimensioner och erbjuder ett utmärkt pris-prestanda-förhållande. Det är rätt val för textklassificering, rekommendationer, snabb prototypframtagning och applikationer med hög volym där målet inte är att skilja mellan två nästan identiska dokument utan att separera tydligt olika teman. En enkel loop verifierar vad varje modell returnerar:

# Jämför de två modellerna
for model_name in ["text-embedding-3-small", "text-embedding-3-large"]:
    resp = client.embeddings.create(
        input="Artificial intelligence",
        model=model_name
    )
    vec = resp.data[0].embedding
    print(f"{model_name}: {len(vec)} dimensions")

Batch-embeddings

Du indexerar inte en riktig korpus en text i taget: varje HTTP-anrop kostar en nätverksroundtrip, och att bearbeta tusen dokument individuellt innebär att du ackumulerar tusen latenser. API:t accepterar upp till 2 048 texter i ett enda anrop, och fältet index låter dig mappa varje vektor tillbaka till rätt dokument.

texts = [
    "Machine learning is advancing rapidly",
    "Deep learning is revolutionizing computer vision",
    "Vector databases store embeddings",
    "Python is the preferred language for data scientists"
]

response = client.embeddings.create(
    input=texts,
    model="text-embedding-3-large"
)

for item in response.data:
    print(f"Text {item.index}: vector of {len(item.embedding)} dimensions")

print(f"Tokens consumed: {response.usage.prompt_tokens}")

I praktiken grupperar du dina texter i batchar om 100 till 2 048 beroende på din volym: mindre batchar gör återhämtning efter fel enklare, medan större minskar antalet anrop. Övervaka usage.prompt_tokens vid varje iteration för att uppskatta kostnader löpande istället för att upptäcka dem på fakturan, och implementera exponentiell backoff för återförsök: en överskriden hastighetsbegränsning är ett övergående fel, inte en anledning att avbryta ett tre timmar långt indexeringsjobb.

Dimensionsreducering

Modellerna text-embedding-3-* accepterar en parameter dimensions som returnerar vektorer kortare än deras ursprungliga storlek:

# Full vektor: 3072 dimensioner
full = client.embeddings.create(
    input="Reduction test",
    model="text-embedding-3-large"
)

# Reducerad vektor: 256 dimensioner
reduced = client.embeddings.create(
    input="Reduction test",
    model="text-embedding-3-large",
    dimensions=256
)

print(f"Full: {len(full.data[0].embedding)} dim")    # 3072
print(f"Reduced: {len(reduced.data[0].embedding)} dim")  # 256

Mekanismen är enkel: reducering trunkerar vektorn och normaliserar den sedan. Eftersom de första dimensionerna bär mest information sker försämringen mycket gradvis. Tabellen nedan ger standardriktmärken för att väga kvalitet mot lagring.

DimensionerRelativ kvalitetLagringAnvändningsområde
3 072100 %~24 KBSökning med hög precision
1 536~98 %~12 KBBra allmän kompromiss
512~93 %~4 KBHög volym, reducerad kostnad
256~88 %~2 KBPrototyper, enkel klassificering

Kom ihåg att ditt val av dimensioner binder dig: alla vektorer i ett givet index måste ha samma storlek, och att ändra sig kräver att allt beräknas om.

Tokenhantering

Embeddings-modeller har ett tak på 8 191 tokens per text, och API:t returnerar ett fel om du överskrider detta. Det är bättre att mäta innan du skickar än att fånga ett undantag mitt i en batch:

import tiktoken

encoder = tiktoken.get_encoding("cl100k_base")

text = "A potentially long text..."
tokens = encoder.encode(text)

if len(tokens) > 8191:
    # Trunkera
    truncated_text = encoder.decode(tokens[:8191])
    print(f"Text truncated from {len(tokens)} to 8191 tokens")

Trunkering är ett säkerhetsnät, inte en strategi: ett trunkerat långt dokument förlorar sin slutdel, och slutet innehåller ofta svaret du letar efter. Korrekt hantering av stora dokument innebär chunking, vilket vi kommer att behandla senare i kursen.

Viktiga punkter

  • client.embeddings.create() accepterar en enskild text eller en lista med texter
  • Använd text-embedding-3-large (3 072 dim) för precision, text-embedding-3-small (1 536 dim) för kostnadseffektivitet
  • Parametern dimensions låter dig reducera vektorns storlek
  • Batchning av texter är mer effektivt än individuella anrop
  • Gräns på 8 191 tokens per text