FrançaisTutorial

Tutoriel API Text-Embedding-3-Small - Guide du Modèle d'Embedding OpenAI

Guide complet pour utiliser l’API OpenAI text-embedding-3-small pour la recherche sémantique, les systèmes RAG et la mise en correspondance par similarité.

Crazyrouter Team

January 26, 2026 / 467 views

Tutoriel API Text-Embedding-3-Small - Guide du Modèle d'Embedding OpenAI

Crazyrouter

Read the docs Check live pricing Open image tool Create account

Vous construisez un moteur de recherche sémantique ou un système RAG (Retrieval-Augmented Generation) ? Text-embedding-3-small est le dernier modèle d'embedding d’OpenAI qui convertit le texte en vecteurs numériques, permettant une recherche par similarité et une récupération de contenu puissantes.

Dans ce guide, vous apprendrez :

Ce que sont les embeddings de texte et pourquoi ils sont importants
Comment utiliser l’API text-embedding-3-small
Des exemples de code complets en Python et Node.js
Des dimensions personnalisées pour un stockage optimisé
Une comparaison des prix et des stratégies de réduction des coûts

Qu'est-ce que Text-Embedding-3-Small ?#

Text-embedding-3-small est le modèle d'embedding compact d’OpenAI, publié en janvier 2024. Il convertit le texte en vecteurs de dimension 1536 qui capturent le sens sémantique, permettant :

Recherche sémantique : Trouver des documents pertinents selon le sens, et pas seulement les mots-clés
Systèmes RAG : Récupérer du contexte pour les réponses des LLM
Mise en correspondance par similarité : Comparer la similarité de textes pour des recommandations
Clustering : Regrouper des documents similaires
Classification : Catégoriser du texte en fonction de son contenu

Spécifications du modèle#

Spécification	Valeur
Nom du modèle	`text-embedding-3-small`
Dimensions par défaut	1536
Dimensions personnalisées	256, 512, 1024, 1536
Nombre maximal de tokens en entrée	8,191
Sortie	Vecteur normalisé

Démarrage rapide#

Prérequis#

Inscrivez-vous sur Crazyrouter
Récupérez votre clé API depuis le tableau de bord
Python 3.8+ ou Node.js 16+

Exemple Python#

python

from openai import OpenAI

client = OpenAI(
    api_key="your-crazyrouter-api-key",
    base_url="https://crazyrouter.com/v1"
)

# Générer un embedding pour un seul texte
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]}")

Exemple Node.js#

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

Exemple cURL#

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"
  }'

Réponse :

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, ...]
    }
  ]
}

Embedding par lots#

Traitez plusieurs textes dans un seul appel d’API pour une meilleure efficacité :

python

from openai import OpenAI

client = OpenAI(
    api_key="your-crazyrouter-api-key",
    base_url="https://crazyrouter.com/v1"
)

# Embedding par lot - plusieurs textes en une seule fois
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
)

# Accéder à chaque 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

Dimensions personnalisées#

Réduisez les coûts de stockage en utilisant des dimensions plus petites. Le modèle prend en charge la réduction de dimension tout en maintenant la qualité :

python

# Utiliser 512 dimensions au lieu de 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

Comparaison des dimensions#

Dimensions	Stockage (par vecteur)	Cas d’usage
256	1 KB	Applications mobiles, stockage limité
512	2 KB	Performance équilibrée
1024	4 KB	Besoins de haute précision
1536	6 KB	Précision maximale

Construire un système de recherche sémantique#

Voici un exemple complet de construction d’un système de recherche sémantique :

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))

# Base de documents
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"
]

# Pré-calculer les embeddings pour tous les documents
doc_embeddings = [get_embedding(doc) for doc in documents]

# Fonction de recherche
def search(query, top_k=3):
    query_embedding = get_embedding(query)

    # Calculer les similarités
    similarities = [
        cosine_similarity(query_embedding, doc_emb)
        for doc_emb in doc_embeddings
    ]

    # Récupérer les meilleurs résultats
    results = sorted(
        zip(documents, similarities),
        key=lambda x: x[1],
        reverse=True
    )[:top_k]

    return results

# Exemple de recherche
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

Intégration avec des bases de données vectorielles#

Intégration Pinecone#

python

import pinecone
from openai import OpenAI

# Initialiser les 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

Intégration ChromaDB#

python

import chromadb
from openai import OpenAI

client = OpenAI(
    api_key="your-crazyrouter-api-key",
    base_url="https://crazyrouter.com/v1"
)

# Initialiser 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]

# Ajouter des documents
documents = ["doc1 content", "doc2 content", "doc3 content"]
embeddings = get_embeddings(documents)

collection.add(
    embeddings=embeddings,
    documents=documents,
    ids=["doc1", "doc2", "doc3"]
)

# Requête
query_embedding = get_embeddings(["search query"])[0]
results = collection.query(
    query_embeddings=[query_embedding],
    n_results=3
)

Modèles d'embedding disponibles#

Crazyrouter donne accès à plusieurs modèles d'embedding OpenAI :

Modèle	Dimensions	Ratio de prix	Idéal pour
`text-embedding-3-small`	1536	0.01	Usage général, meilleur rapport qualité/prix
`text-embedding-3-large`	3072	0.065	Besoins de haute précision
`text-embedding-ada-002`	1536	0.05	Compatibilité avec les systèmes existants

Comparaison des prix#

Fournisseur	Modèle	Prix par 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

Avertissement sur les prix : Les prix indiqués sont à titre d’illustration et peuvent changer. La facturation réelle est basée sur les prix en temps réel au moment de la requête.

Exemple d’économies :

Pour un système RAG traitant 10M tokens/mois :

OpenAI Official : $200/mois
Crazyrouter : $20/mois
Économies : 90 %

Bonnes pratiques#

1. Regroupez vos requêtes (batch)#

python

# Bon - un seul appel d’API pour plusieurs textes
response = client.embeddings.create(
    model="text-embedding-3-small",
    input=["text1", "text2", "text3"]  # Jusqu’à 2048 textes
)

# Mauvais - plusieurs appels d’API
for text in texts:
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )

2. Cachez les embeddings#

python

import hashlib
import json

embedding_cache = {}

def get_embedding_cached(text):
    # Créer une clé de cache
    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. Utilisez des dimensions adaptées#

256 dimensions : Applications mobiles, appareils IoT
512 dimensions : Applications web avec contraintes de stockage
1024 dimensions : Applications standard
1536 dimensions : Exigences de précision maximale

Foire aux questions#

Quelle est la différence entre text-embedding-3-small et text-embedding-3-large ?#

Text-embedding-3-small produit des vecteurs de dimension 1536 et est optimisé pour la rentabilité. Text-embedding-3-large produit des vecteurs de dimension 3072 avec une meilleure précision, mais pour un coût 6,5 fois plus élevé. Pour la plupart des applications, text-embedding-3-small fournit d’excellents résultats.

Puis-je réduire les dimensions après avoir généré les embeddings ?#

Oui, vous pouvez utiliser le paramètre dimensions pour générer directement des vecteurs plus petits. C’est plus efficace que de générer des vecteurs complets puis de les tronquer.

Combien de textes puis-je embedder dans une seule requête ?#

Vous pouvez embedder jusqu’à 2048 textes dans une seule requête d’API. Pour de grands jeux de données, regroupez vos requêtes par lots de 2048.

Les embeddings sont-ils normalisés ?#

Oui, text-embedding-3-small renvoie des vecteurs normalisés (de norme 1), ce qui vous permet d’utiliser le produit scalaire au lieu de la similarité cosinus pour un calcul plus rapide.