AI Engineering Academy · Lektion

Embeddings mit OpenAI erzeugen

Sie verwenden die Modelle text-embedding-3-small und text-embedding-3-large, um Sätze, Absätze und Dokumente in Embeddings umzuwandeln, und vergleichen deren Zielkonflikte bei Qualität und Kosten.

Lektion 2 von 413 Schritte

Embeddings mit OpenAI erzeugen ist eine kostenlose AI Engineering Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Engineering Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.

Übersicht über die OpenAI-Embedding-Modelle

OpenAI bietet zwei produktionsgeeignete Embedding-Modelle an: text-embedding-3-small und text-embedding-3-large. Das kleinere Modell erzeugt Vektoren mit 1536 Dimensionen und ist pro Token fünfmal günstiger, während das größere Modell Vektoren mit 3072 Dimensionen und eine höhere Genauigkeit in Benchmarks bietet. Für die meisten RAG-Anwendungen ist das kleinere Modell der richtige Ausgangspunkt.

Ihren ersten Embedding-Aufruf ausführen

Die Methode client.embeddings.create() erwartet einen model-Namen sowie eine input-Zeichenkette oder -Liste. Sie gibt ein Antwortobjekt mit einer data-Liste zurück. Jedes Element besitzt ein embedding-Attribut, das den Vektor als Python-Liste von Gleitkommazahlen enthält.

Speichern Sie Ihren API-Schlüssel immer in einer Umgebungsvariablen — tragen Sie ihn niemals fest in Quelldateien ein.

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ['OPENAI_API_KEY'])

response = client.embeddings.create(
    model='text-embedding-3-small',
    input='What is retrieval-augmented generation?'
)

vector = response.data[0].embedding
print(f'Vector length: {len(vector)}')      # 1536
print(f'Type: {type(vector[0])}')           # float
print(f'Sample values: {vector[:3]}')       # [-0.02, 0.01, ...]

Embedding-Batches effizient verarbeiten

Wenn Sie eine Liste von Zeichenketten an input übergeben, werden alle in einem einzigen API-Roundtrip in Embeddings umgewandelt. Das ist der empfohlene Ansatz, wenn Sie einen Dokumentkorpus indizieren. Die Antwortliste data behält die ursprüngliche Reihenfolge bei, sodass Sie einfach ein Nachschlageverzeichnis erstellen können.

Batches sind auf 2048 Elemente pro Anfrage begrenzt, und die Gesamtzahl der Tokens über alle Eingaben hinweg muss innerhalb des Token-Limits des Modells bleiben.

from openai import OpenAI

client = OpenAI()

documents = [
    'RAG stands for Retrieval-Augmented Generation.',
    'Embeddings convert text to numerical vectors.',
    'Pinecone is a managed vector database service.'
]

response = client.embeddings.create(
    model='text-embedding-3-small',
    input=documents
)

embeddings = [item.embedding for item in response.data]
print(f'Got {len(embeddings)} embeddings')
print(f'Each has {len(embeddings[0])} dimensions')

Embedding-Dimensionen reduzieren

Beide text-embedding-3-Modelle unterstützen einen Parameter dimensions, der den Ausgabevektor kürzt. Wenn Sie beispielsweise dimensions=256 festlegen, wird ein Vektor mit 256 Elementen statt mit 1536 zurückgegeben. Kürzere Vektoren benötigen weniger Speicher und Rechenleistung, bringen jedoch einen moderaten Genauigkeitsverlust mit sich.

Das ist nützlich, wenn Sie schnell experimentieren möchten oder Speicherkosten wichtiger sind als eine optimale Qualität beim Retrieval.

from openai import OpenAI

client = OpenAI()

response = client.embeddings.create(
    model='text-embedding-3-small',
    input='Shorter vectors save storage and query time.',
    dimensions=256   # truncate from 1536 to 256
)

print(len(response.data[0].embedding))  # 256

Kodierungsformat: Base64 und Gleitkommaliste

Standardmäßig gibt die API Embeddings als JSON-Array von Gleitkommazahlen zurück (encoding_format='float'). Sie können encoding_format='base64' anfordern, um stattdessen ein kompaktes, Base64-kodiertes Binärblob zu erhalten, das bei großen Batches schneller über das Netzwerk übertragen wird.

Bei Verwendung von Base64 müssen Sie die Daten mit NumPy dekodieren: np.frombuffer(base64.b64decode(b64_str), dtype='float32').

import base64
import numpy as np
from openai import OpenAI

client = OpenAI()

response = client.embeddings.create(
    model='text-embedding-3-small',
    input='Base64 encoding transfers faster.',
    encoding_format='base64'
)

b64 = response.data[0].embedding
vector = np.frombuffer(base64.b64decode(b64), dtype='float32')
print(f'Decoded {len(vector)} floats')

Tokenverbrauch und Kosten verfolgen

Jede Embedding-Antwort enthält ein usage-Objekt mit prompt_tokens. Sie zahlen pro Token: text-embedding-3-small kostet 0,02 $ pro Million Tokens und text-embedding-3-large 0,13 $ pro Million Tokens (Stand Mitte 2024).

Wenn Sie die Nutzung verfolgen, können Sie schätzen, wie viel die Indizierung Ihres gesamten Korpus kostet, bevor Sie einen Produktionslauf starten.

from openai import OpenAI

client = OpenAI()

texts = ['Document one content here.', 'Document two content here.']

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

tokens_used = response.usage.prompt_tokens
cost_usd = tokens_used * 0.00000002  # $0.02 per 1M tokens
print(f'Tokens: {tokens_used}, Cost: ${cost_usd:.6f}')

text-embedding-3-small und large vergleichen

Die Wahl zwischen small und large hängt von Ihren Anforderungen an die Genauigkeit und Ihrem Budget ab:

text-embedding-3-small: 1536D, schneller, fünfmal günstiger und für die meisten RAG-Workloads bestens geeignet
text-embedding-3-large: 3072D, höhere MTEB-Benchmarkwerte und besser für mehrsprachige Inhalte sowie komplexe semantische Aufgaben geeignet

Ein gängiges Vorgehen besteht darin, die Qualität des Retrievals zunächst mit dem kleinen Modell zu prototypisieren und zu validieren und erst dann auf large umzusteigen, wenn die Evaluationsmetriken unter Ihrem Zielwert liegen.

Embeddings für die Dot-Product-Suche normalisieren

OpenAI liefert L2-normalisierte Embeddings zurück, das heißt, jeder Vektor hat bereits eine Länge von 1. Dadurch können Sie das Skalarprodukt als schnelle Näherung der Kosinusähnlichkeit verwenden, ohne eine zusätzliche Normalisierung durchführen zu müssen. Das ist besonders wichtig bei der Suche in Millionen von Vektoren, bei denen sich Mikrooptimierungen summieren.

import numpy as np
from openai import OpenAI

client = OpenAI()

response = client.embeddings.create(
    model='text-embedding-3-small',
    input='Are OpenAI embeddings normalized?'
)

vec = np.array(response.data[0].embedding)
magnitude = np.linalg.norm(vec)
print(f'Vector magnitude: {magnitude:.6f}')  # very close to 1.0

Große Dokumente verarbeiten

Das Modell text-embedding-3-small akzeptiert bis zu 8191 Tokens pro Eingabe. Wenn Ihr Dokument dieses Limit überschreitet, gibt die API einen Fehler zurück. Die übliche Lösung besteht darin, das Dokument zunächst in Abschnitte aufzuteilen (typischerweise 200–500 Tokens pro Abschnitt) und jeden Abschnitt separat zu embedden.

Diese Aufteilung ist nicht nur eine technische Voraussetzung – sie verbessert auch das Retrieval, weil Embeddings kleinerer, fokussierter Abschnitte präzisere Ergebnisse liefern als Embeddings ganzer Seiten.

import tiktoken

enc = tiktoken.encoding_for_model('text-embedding-3-small')

def count_tokens(text):
    return len(enc.encode(text))

max_tokens = 8191
text = 'Very long document content...'  # pretend this is huge

if count_tokens(text) > max_tokens:
    print('Document too long — chunk before embedding')
else:
    print(f'Safe to embed: {count_tokens(text)} tokens')

Asynchrones Embedding für hohen Durchsatz

Wenn Sie Tausende von Dokumenten indizieren, verwenden Sie den asynchronen OpenAI-Client zusammen mit asyncio.gather, um mehrere Embedding-Anfragen gleichzeitig zu senden. Das ist deutlich schneller als sequenzielle Aufrufe, weil der Engpass in der Netzwerklatenz und nicht in der CPU liegt.

Fügen Sie bei gleichzeitigen Anfragen immer eine Behandlung von Rate-Limits mit exponentiellem Backoff hinzu, damit Sie das Limit für Tokens pro Minute nicht überschreiten.

import asyncio
from openai import AsyncOpenAI

async def embed_batch(texts):
    client = AsyncOpenAI()
    response = await client.embeddings.create(
        model='text-embedding-3-small',
        input=texts
    )
    return [item.embedding for item in response.data]

async def main():
    batches = [['doc1', 'doc2'], ['doc3', 'doc4']]
    results = await asyncio.gather(*[embed_batch(b) for b in batches])
    all_embeddings = [emb for batch in results for emb in batch]
    print(f'Embedded {len(all_embeddings)} documents')

asyncio.run(main())

Embeddings zur Kostensenkung cachen

Embeddings für denselben Text mehrfach zu erzeugen, verschwendet Geld und Zeit. Cachen Sie Embeddings in einem Dictionary, dessen Schlüssel der Text (oder ein Hash davon) ist, und speichern Sie diesen Cache zwischen Sitzungen auf der Festplatte.

In Produktionssystemen sollten Sie Embeddings in einer Vektordatenbank speichern, die anhand der Dokument-ID Duplikate erkennt. Erzeugen Sie ein Embedding für ein Dokument nur dann erneut, wenn sich sein Inhalt tatsächlich geändert hat, nicht bei jedem Indizierungslauf.

import json, hashlib, os
from openai import OpenAI

CACHE_FILE = '/tmp/embedding_cache.json'
client = OpenAI()

try:
    cache = json.load(open(CACHE_FILE))
except FileNotFoundError:
    cache = {}

def get_embedding(text):
    key = hashlib.md5(text.encode()).hexdigest()
    if key not in cache:
        r = client.embeddings.create(model='text-embedding-3-small', input=text)
        cache[key] = r.data[0].embedding
        json.dump(cache, open(CACHE_FILE, 'w'))
    return cache[key]

vec = get_embedding('Caching saves API costs.')
print(f'Retrieved {len(vec)}-dim embedding')

Kurzer Test

Testen Sie Ihr Verständnis der in dieser Lektion behandelten Konzepte des AI Engineering.

Beantworte es in der interaktiven Lektion

Zusammenfassung der Lektion

In dieser Lektion haben Sie gelernt: text-embedding-3-small ist für die meisten RAG-Workloads die kosteneffiziente Wahl, das Batch-Embedding mehrerer Texte in einem API-Aufruf ist effizienter als sequenzielle Aufrufe und der Parameter dimensions kann die Vektorgröße reduzieren, um Genauigkeit gegen Einsparungen beim Speicherbedarf abzuwägen. Als Nächstes erstellen wir mit diesen Embeddings und NumPy ein System für die semantische Suche.

Kostenlos starten

Lerne Python mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 30
Lektionen: 120

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Embeddings mit OpenAI erzeugen“ kostenlos?

Ja — der vollständige Text von „Embeddings mit OpenAI erzeugen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Engineering Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Embeddings mit OpenAI erzeugen“?

Sie verwenden die Modelle text-embedding-3-small und text-embedding-3-large, um Sätze, Absätze und Dokumente in Embeddings umzuwandeln, und vergleichen deren Zielkonflikte bei Qualität und Kosten. Du übst AI Engineering Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Engineering Academy zu starten?

Keine Vorkenntnisse erforderlich. AI Engineering Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Embeddings mit OpenAI erzeugen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Engineering Academy-Lektion Code schreiben und ausführen?

Ja. Jede AI Engineering Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu AI Engineering Academy