CrazyrouterDeutschTutorial
Text-Embedding-3-Small API-Tutorial – OpenAI Embedding-Modelleitfaden
Vollständiger Leitfaden zur Verwendung der OpenAI text-embedding-3-small API für semantische Suche, RAG-Systeme und Ähnlichkeitsabgleich. Enthält Beispiele in Python, Node.js und einen Preisvergleich.
C
Crazyrouter Team
January 26, 2026 / 328 views
Share:
Bauen Sie eine semantische Suchmaschine oder ein RAG-System (Retrieval-Augmented Generation)? Text-embedding-3-small ist OpenAIs neuestes Embedding-Modell, das Text in numerische Vektoren umwandelt und so leistungsstarke Ähnlichkeitssuche und Inhaltsabruf ermöglicht.
In diesem Leitfaden lernen Sie:
- Was Text-Embeddings sind und warum sie wichtig sind
- Wie Sie die text-embedding-3-small API verwenden
- Vollständige Codebeispiele in Python und Node.js
- Benutzerdefinierte Dimensionen für optimierte Speicherung
- Preisvergleich und Kostenoptimierung
What is Text-Embedding-3-Small?#
Text-embedding-3-small ist OpenAIs kompaktes Embedding-Modell, das im Januar 2024 veröffentlicht wurde. Es wandelt Text in 1536-dimensionale Vektoren um, die semantische Bedeutung erfassen und Folgendes ermöglichen:
- Semantische Suche: Relevante Dokumente anhand ihrer Bedeutung finden, nicht nur anhand von Keywords
- RAG-Systeme: Kontext für LLM-Antworten abrufen
- Similarity Matching: Textähnlichkeit für Empfehlungen vergleichen
- Clustering: Ähnliche Dokumente gruppieren
- Klassifikation: Text anhand seines Inhalts kategorisieren
Model Specifications#
| Specification | Value |
|---|---|
| Model Name | text-embedding-3-small |
| Default Dimensions | 1536 |
| Custom Dimensions | 256, 512, 1024, 1536 |
| Max Input Tokens | 8,191 |
| Output | Normalized vector |
Quick Start#
Prerequisites#
- Registrieren Sie sich bei Crazyrouter
- Holen Sie sich Ihren API-Schlüssel aus dem Dashboard
- Python 3.8+ oder Node.js 16+
Python Example#
python
from openai import OpenAI
client = OpenAI(
api_key="your-crazyrouter-api-key",
base_url="https://crazyrouter.com/v1"
)
# Generate embedding for a single text
response = client.embeddings.create(
model="text-embedding-3-small",
input="Machine learning is transforming industries worldwide."
)
embedding = response.data[0].embedding
print(f"Dimensions: {len(embedding)}") # Output: 1536
print(f"First 5 values: {embedding[:5]}")
Node.js Example#
javascript
import OpenAI from 'openai';
const client = new OpenAI({
apiKey: 'your-crazyrouter-api-key',
baseURL: 'https://crazyrouter.com/v1'
});
async function getEmbedding(text) {
const response = await client.embeddings.create({
model: 'text-embedding-3-small',
input: text
});
return response.data[0].embedding;
}
// Usage
const embedding = await getEmbedding('Machine learning is amazing');
console.log(`Dimensions: ${embedding.length}`); // Output: 1536
cURL Example#
bash
curl -X POST https://crazyrouter.com/v1/embeddings \
-H "Authorization: Bearer your-api-key" \
-H "Content-Type: application/json" \
-d '{
"model": "text-embedding-3-small",
"input": "Hello world"
}'
Response:
json
{
"object": "list",
"model": "text-embedding-3-small",
"usage": {
"prompt_tokens": 2,
"total_tokens": 2
},
"data": [
{
"object": "embedding",
"index": 0,
"embedding": [-0.0020785425, -0.049085874, 0.02094679, ...]
}
]
}
Batch Embedding#
Verarbeiten Sie mehrere Texte in einem einzigen API-Aufruf für bessere Effizienz:
python
from openai import OpenAI
client = OpenAI(
api_key="your-crazyrouter-api-key",
base_url="https://crazyrouter.com/v1"
)
# Batch embedding - multiple texts at once
texts = [
"Python is a programming language",
"JavaScript runs in browsers",
"Machine learning uses neural networks"
]
response = client.embeddings.create(
model="text-embedding-3-small",
input=texts
)
# Access each embedding
for i, data in enumerate(response.data):
print(f"Text {i}: {len(data.embedding)} dimensions")
# Output:
# Text 0: 1536 dimensions
# Text 1: 1536 dimensions
# Text 2: 1536 dimensions
Custom Dimensions#
Reduzieren Sie Speicherkosten, indem Sie kleinere Dimensionen verwenden. Das Modell unterstützt Dimensionsreduktion bei gleichbleibend hoher Qualität:
python
# Use 512 dimensions instead of 1536
response = client.embeddings.create(
model="text-embedding-3-small",
input="Your text here",
dimensions=512 # Options: 256, 512, 1024, 1536
)
embedding = response.data[0].embedding
print(f"Dimensions: {len(embedding)}") # Output: 512
Dimension Comparison#
| Dimensions | Storage (per vector) | Use Case |
|---|---|---|
| 256 | 1 KB | Mobile-Apps, begrenzter Speicher |
| 512 | 2 KB | Ausgewogene Performance |
| 1024 | 4 KB | Hohe Genauigkeitsanforderungen |
| 1536 | 6 KB | Maximale Genauigkeit |
Building a Semantic Search System#
Hier ist ein vollständiges Beispiel zum Aufbau eines semantischen Suchsystems:
python
import numpy as np
from openai import OpenAI
client = OpenAI(
api_key="your-crazyrouter-api-key",
base_url="https://crazyrouter.com/v1"
)
def get_embedding(text):
"""Get embedding for a single text"""
response = client.embeddings.create(
model="text-embedding-3-small",
input=text
)
return response.data[0].embedding
def cosine_similarity(a, b):
"""Calculate cosine similarity between two vectors"""
return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
# Document database
documents = [
"Python is great for data science and machine learning",
"JavaScript is essential for web development",
"Docker containers simplify deployment",
"Kubernetes orchestrates container workloads",
"PostgreSQL is a powerful relational database"
]
# Pre-compute embeddings for all documents
doc_embeddings = [get_embedding(doc) for doc in documents]
# Search function
def search(query, top_k=3):
query_embedding = get_embedding(query)
# Calculate similarities
similarities = [
cosine_similarity(query_embedding, doc_emb)
for doc_emb in doc_embeddings
]
# Get top results
results = sorted(
zip(documents, similarities),
key=lambda x: x[1],
reverse=True
)[:top_k]
return results
# Example search
results = search("How to deploy applications?")
for doc, score in results:
print(f"Score: {score:.4f} - {doc}")
# Output:
# Score: 0.8234 - Docker containers simplify deployment
# Score: 0.7891 - Kubernetes orchestrates container workloads
# Score: 0.6543 - PostgreSQL is a powerful relational database
Integration with Vector Databases#
Pinecone Integration#
python
import pinecone
from openai import OpenAI
# Initialize clients
client = OpenAI(
api_key="your-crazyrouter-api-key",
base_url="https://crazyrouter.com/v1"
)
pinecone.init(api_key="your-pinecone-key")
index = pinecone.Index("your-index")
def embed_and_upsert(texts, ids):
"""Embed texts and store in Pinecone"""
response = client.embeddings.create(
model="text-embedding-3-small",
input=texts
)
vectors = [
(id, data.embedding)
for id, data in zip(ids, response.data)
]
index.upsert(vectors=vectors)
def search_pinecone(query, top_k=5):
"""Search Pinecone with query embedding"""
response = client.embeddings.create(
model="text-embedding-3-small",
input=query
)
results = index.query(
vector=response.data[0].embedding,
top_k=top_k
)
return results
ChromaDB Integration#
python
import chromadb
from openai import OpenAI
client = OpenAI(
api_key="your-crazyrouter-api-key",
base_url="https://crazyrouter.com/v1"
)
# Initialize ChromaDB
chroma_client = chromadb.Client()
collection = chroma_client.create_collection("documents")
def get_embeddings(texts):
"""Get embeddings for multiple texts"""
response = client.embeddings.create(
model="text-embedding-3-small",
input=texts
)
return [data.embedding for data in response.data]
# Add documents
documents = ["doc1 content", "doc2 content", "doc3 content"]
embeddings = get_embeddings(documents)
collection.add(
embeddings=embeddings,
documents=documents,
ids=["doc1", "doc2", "doc3"]
)
# Query
query_embedding = get_embeddings(["search query"])[0]
results = collection.query(
query_embeddings=[query_embedding],
n_results=3
)
Available Embedding Models#
Crazyrouter bietet Zugriff auf mehrere OpenAI Embedding-Modelle:
| Model | Dimensions | Price Ratio | Best For |
|---|---|---|---|
text-embedding-3-small | 1536 | 0.01 | Allgemeiner Einsatz, bestes Preis-Leistungs-Verhältnis |
text-embedding-3-large | 3072 | 0.065 | Anforderungen mit hoher Präzision |
text-embedding-ada-002 | 1536 | 0.05 | Legacy-Kompatibilität |
Pricing Comparison#
| Provider | Model | Price per 1M tokens |
|---|---|---|
| OpenAI Official | text-embedding-3-small | $0.020 |
| Crazyrouter | text-embedding-3-small | $0.002 |
| OpenAI Official | text-embedding-3-large | $0.130 |
| Crazyrouter | text-embedding-3-large | $0.013 |
Preishinweis: Die angezeigten Preise dienen nur zur Veranschaulichung und können sich ändern. Die tatsächliche Abrechnung basiert auf den Echtzeitpreisen zum Zeitpunkt der Anfrage.
Cost Savings Example:
Für ein RAG-System, das 10M Tokens/Monat verarbeitet:
- OpenAI Official: $200/Monat
- Crazyrouter: $20/Monat
- Ersparnis: 90%
Best Practices#
1. Batch Your Requests#
python
# Good - single API call for multiple texts
response = client.embeddings.create(
model="text-embedding-3-small",
input=["text1", "text2", "text3"] # Up to 2048 texts
)
# Bad - multiple API calls
for text in texts:
response = client.embeddings.create(
model="text-embedding-3-small",
input=text
)
2. Cache Embeddings#
python
import hashlib
import json
embedding_cache = {}
def get_embedding_cached(text):
# Create cache key
cache_key = hashlib.md5(text.encode()).hexdigest()
if cache_key in embedding_cache:
return embedding_cache[cache_key]
response = client.embeddings.create(
model="text-embedding-3-small",
input=text
)
embedding = response.data[0].embedding
embedding_cache[cache_key] = embedding
return embedding
3. Use Appropriate Dimensions#
- 256 dimensions: Mobile-Apps, IoT-Geräte
- 512 dimensions: Webanwendungen mit Speicherbeschränkungen
- 1024 dimensions: Standardanwendungen
- 1536 dimensions: Anforderungen mit maximaler Genauigkeit
Frequently Asked Questions#
Was ist der Unterschied zwischen text-embedding-3-small und text-embedding-3-large?#
Text-embedding-3-small erzeugt 1536-dimensionale Vektoren und ist auf Kosteneffizienz optimiert. Text-embedding-3-large erzeugt 3072-dimensionale Vektoren mit höherer Genauigkeit, aber zu 6,5-fachen Kosten. Für die meisten Anwendungen liefert text-embedding-3-small ausgezeichnete Ergebnisse.
Can I reduce dimensions after generating embeddings?#
Ja, Sie können den Parameter dimensions verwenden, um kleinere Vektoren direkt zu erzeugen. Das ist effizienter, als zunächst vollständige Vektoren zu generieren und diese anschließend zu kürzen.
Wie viele Texte kann ich in einer Anfrage einbetten?#
Sie können bis zu 2048 Texte in einer einzigen API-Anfrage einbetten. Für große Datensätze sollten Sie Ihre Anfragen in Gruppen von 2048 aufteilen.
Are the embeddings normalized?#
Ja, text-embedding-3-small gibt normalisierte Vektoren (Länge 1) zurück, sodass Sie das Skalarprodukt anstelle der Kosinusähnlichkeit für schnellere Berechnungen verwenden können.
Getting Started#
- Registrieren Sie sich bei Crazyrouter
- Holen Sie sich Ihren API-Schlüssel aus dem Dashboard
- Installieren Sie das SDK:
pip install openaiodernpm install openai - Starten Sie mit Embeddings anhand der obigen Codebeispiele
Related Articles:
For questions, contact support@crazyrouter.com
Implementation Guides
Quick Start GuideMake the first Crazyrouter API call and validate your setup.AuthenticationCreate and use API keys with the required authorization headers.Usage Logs and Cost MonitoringUse management APIs to query logs, quota, token usage, and dollar cost.IntroductionUnderstand Crazyrouter's all-in-one AI model API gateway.
Available in other languages:
Topics
Tutorial
