← Retour au blog

2026-01-22

Comparatif Embeddings Azure OpenAI : Ada-002 vs 3-Small vs 3-Large

Guide complet pour choisir le bon modèle d'embedding : benchmarks, coûts, performances multilingues et implémentation Python avec Azure OpenAI.

Les embeddings sont au cœur de toute application RAG, recherche sémantique ou système de recommandation. Mais avec trois modèles disponibles sur Azure OpenAI — ada-002, text-embedding-3-small et text-embedding-3-large — comment choisir le bon ? Ce guide comparatif vous donne toutes les clés pour faire le meilleur choix selon votre cas d'usage.

1. Qu'est-ce qu'un Embedding ?

Un embedding (ou plongement vectoriel) est une représentation numérique d'un texte sous forme de vecteur de nombres. Cette transformation capture le sens sémantique du texte, permettant de mesurer la similarité entre différents contenus.

🔢 Exemple simplifié

"Le chat dort sur le canapé"  →  [0.023, -0.156, 0.892, ..., 0.045]  (1536 dimensions)
"Le félin sommeille sur le sofa"  →  [0.021, -0.148, 0.887, ..., 0.042]  ← Très similaire !
"La voiture roule vite"  →  [0.789, 0.234, -0.567, ..., 0.891]  ← Très différent
    
🔍
Recherche Sémantique

Trouver des documents similaires par le sens

🤖
RAG

Retriever les passages pertinents pour le LLM

📊
Clustering

Regrouper des contenus par thématique

2. Les 3 Modèles Azure OpenAI

🏛️

text-embedding-ada-002

Legacy

Le modèle historique d'OpenAI, lancé en décembre 2022. Longtemps la référence, il reste très utilisé mais n'est plus le plus performant.

Dimensions : 1536
Max tokens : 8191
Prix : $0.10/1M tokens
Sortie : Déc 2022

text-embedding-3-small

Recommandé

La nouvelle génération optimisée pour le rapport qualité/prix. 5× moins cher qu'ada-002 avec de meilleures performances sur la plupart des benchmarks.

Dimensions : 512 → 1536
Max tokens : 8191
Prix : $0.02/1M tokens
Sortie : Jan 2024
🚀

text-embedding-3-large

Premium

Le modèle le plus puissant, conçu pour les cas d'usage exigeants en précision. Idéal pour le multilingue et les domaines spécialisés.

Dimensions : 256 → 3072
Max tokens : 8191
Prix : $0.13/1M tokens
Sortie : Jan 2024

💡 Nouveauté embedding-3 : Dimensions variables

Les modèles embedding-3 supportent le raccourcissement de dimensions (Matryoshka Representation Learning). Vous pouvez réduire les dimensions (ex: 3072 → 1024) avec une perte de qualité minimale, économisant ainsi du stockage et accélérant les recherches.

3. Comparatif Détaillé

Critère ada-002 3-small 3-large
Dimensions 1536 (fixe) 512 - 1536 256 - 3072
Prix / 1M tokens $0.10 $0.02 ⭐ $0.13
MTEB Average 61.0% 62.3% 64.6% ⭐
MIRACL (multilingue) 31.4% 44.0% 54.9% ⭐
Stockage / 1M docs ~6 GB ~2-6 GB ⭐ ~1-12 GB
Latence recherche Moyenne Rapide ⭐ Plus lente
Support multilingue Bon Très bon Excellent ⭐
ada-002

Quand l'utiliser : Systèmes existants difficiles à migrer, compatibilité legacy requise.

3-small

Quand l'utiliser : 80% des cas d'usage. Meilleur rapport qualité/prix pour RAG, recherche, classification.

3-large

Quand l'utiliser : Multilingue critique, domaines spécialisés (juridique, médical), précision maximale requise.

4. Benchmarks et Performances

📊 MTEB (Massive Text Embedding Benchmark)

Le benchmark MTEB évalue les embeddings sur 56 tâches différentes : retrieval, classification, clustering, etc.

text-embedding-3-large 64.6%
text-embedding-3-small 62.3%
text-embedding-ada-002 61.0%

🌍 MIRACL (Multilingue)

Le benchmark MIRACL teste la recherche cross-lingue sur 18 langues, crucial pour les applications internationales.

text-embedding-3-large 54.9%
text-embedding-3-small 44.0%
text-embedding-ada-002 31.4%

💡 +75% d'amélioration entre ada-002 et 3-large sur le multilingue !

💰 Analyse Coût / Performance

Scénario ada-002 3-small 3-large
1M documents (~500 tokens/doc) $50 $10 $65
100K requêtes/jour (~20 tokens) $60/mois $12/mois $78/mois
Stockage Azure AI Search (1M vecteurs) ~$15/mois ~$5-15/mois ~$5-30/mois

5. Comment Choisir ?

🎯 Arbre de décision

┌─ Votre cas d'usage est-il multilingue critique ?
│   ├─ OUI → text-embedding-3-large (3072 dims)
│   └─ NON ↓
│
├─ Avez-vous besoin de la précision maximale absolue ?
│   ├─ OUI → text-embedding-3-large (3072 dims)
│   └─ NON ↓
│
├─ Le coût est-il un facteur important ?
│   ├─ OUI → text-embedding-3-small (1536 dims) ⭐ Recommandé
│   └─ NON ↓
│
├─ Avez-vous un système legacy avec ada-002 ?
│   ├─ OUI, migration complexe → Rester sur ada-002 (temporairement)
│   └─ NON → text-embedding-3-small (1536 dims) ⭐
│
└─ Par défaut → text-embedding-3-small (1536 dims) ⭐
    

✅ Choisissez text-embedding-3-small si :

  • • Vous construisez un nouveau projet
  • • Votre contenu est principalement en 1-2 langues
  • • Vous voulez optimiser les coûts
  • • Vous avez besoin de performances rapides
  • • Cas standard : FAQ, documentation, support

✅ Choisissez text-embedding-3-large si :

  • • Contenu multilingue (5+ langues)
  • • Domaines spécialisés (juridique, médical, technique)
  • • Nuances sémantiques critiques
  • • La précision prime sur le coût
  • • Recherche académique ou scientifique

💡 Astuce : Dimensions réduites

Avec text-embedding-3-large, vous pouvez utiliser 1024 dimensions au lieu de 3072. Vous obtenez ~95% de la qualité avec 3× moins de stockage et des recherches plus rapides.

6. Implémentation Azure OpenAI

📦 Installation

pip install openai azure-identity

🔧 Code Python - Générer des embeddings

from openai import AzureOpenAI

client = AzureOpenAI(
    api_key="YOUR_API_KEY",
    api_version="2024-02-01",
    azure_endpoint="https://YOUR_RESOURCE.openai.azure.com"
)

def get_embedding(text: str, model: str = "text-embedding-3-small", dimensions: int = None):
    """
    Génère un embedding pour un texte donné.
    
    Args:
        text: Le texte à vectoriser
        model: "text-embedding-ada-002", "text-embedding-3-small", "text-embedding-3-large"
        dimensions: Nombre de dimensions (uniquement pour embedding-3)
    """
    params = {
        "input": text,
        "model": model  # Nom du déploiement Azure
    }
    
    # Les dimensions ne sont supportées que par embedding-3
    if dimensions and "3-" in model:
        params["dimensions"] = dimensions
    
    response = client.embeddings.create(**params)
    return response.data[0].embedding

# Exemples d'utilisation
# ada-002 (legacy)
emb_ada = get_embedding("Bonjour le monde", model="text-embedding-ada-002")
print(f"ada-002: {len(emb_ada)} dimensions")  # 1536

# 3-small avec dimensions par défaut
emb_small = get_embedding("Bonjour le monde", model="text-embedding-3-small")
print(f"3-small: {len(emb_small)} dimensions")  # 1536

# 3-small avec dimensions réduites
emb_small_512 = get_embedding("Bonjour le monde", model="text-embedding-3-small", dimensions=512)
print(f"3-small (512): {len(emb_small_512)} dimensions")  # 512

# 3-large avec dimensions optimisées
emb_large = get_embedding("Bonjour le monde", model="text-embedding-3-large", dimensions=1024)
print(f"3-large (1024): {len(emb_large)} dimensions")  # 1024

📐 Calcul de similarité

import numpy as np

def cosine_similarity(vec1, vec2):
    """Calcule la similarité cosinus entre deux vecteurs."""
    vec1 = np.array(vec1)
    vec2 = np.array(vec2)
    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))

# Exemple
emb1 = get_embedding("Comment annuler ma commande ?")
emb2 = get_embedding("Je veux annuler mon achat")
emb3 = get_embedding("Quelle est la météo aujourd'hui ?")

print(f"Similarité Q1-Q2: {cosine_similarity(emb1, emb2):.3f}")  # ~0.92 (très similaire)
print(f"Similarité Q1-Q3: {cosine_similarity(emb1, emb3):.3f}")  # ~0.45 (différent)

🔍 Intégration Azure AI Search

from azure.search.documents import SearchClient
from azure.search.documents.models import VectorizedQuery
from azure.core.credentials import AzureKeyCredential

search_client = SearchClient(
    endpoint="https://YOUR_SEARCH.search.windows.net",
    index_name="documents",
    credential=AzureKeyCredential("YOUR_SEARCH_KEY")
)

def semantic_search(query: str, top_k: int = 5):
    # Génère l'embedding de la requête
    query_vector = get_embedding(query, model="text-embedding-3-small", dimensions=1536)
    
    # Recherche vectorielle
    results = search_client.search(
        search_text=None,
        vector_queries=[
            VectorizedQuery(
                vector=query_vector,
                k_nearest_neighbors=top_k,
                fields="contentVector"
            )
        ]
    )
    
    return list(results)

# Utilisation
results = semantic_search("Comment configurer mon compte ?")
for r in results:
    print(f"Score: {r['@search.score']:.3f} - {r['title']}")

7. Migration ada-002 → embedding-3

⚠️ Important : Incompatibilité des embeddings

Les embeddings générés par différents modèles ne sont PAS compatibles entre eux. Vous ne pouvez pas comparer un vecteur ada-002 avec un vecteur embedding-3. Une migration nécessite de ré-indexer tous vos documents.

📋 Checklist de migration

1.
Créer un nouveau déploiement

Déployez text-embedding-3-small ou 3-large dans Azure OpenAI Studio

2.
Créer un nouvel index Azure AI Search

Avec les nouvelles dimensions (1536 ou personnalisées)

3.
Ré-indexer tous les documents

Générer les nouveaux embeddings et les stocker

4.
Tester en parallèle

Comparer les résultats ancien vs nouveau avant bascule

5.
Basculer le trafic

Mettre à jour l'application pour utiliser le nouveau modèle

💡 Astuce : Migration progressive

Pour les gros volumes, utilisez Azure Data Factory ou un script batch pour ré-indexer par lots de 1000-10000 documents, en surveillant les quotas API.

📌 Résumé

Modèle Meilleur pour À éviter si
ada-002 Systèmes legacy, migration impossible Nouveau projet, budget serré
3-small ⭐ 80% des cas, RAG, FAQ, support, coût optimisé Multilingue critique, nuances fines
3-large Multilingue, domaines spécialisés, précision max Budget limité, volumes très élevés

🚀 Besoin d'aide pour votre projet RAG ?

Galaxy AI vous accompagne dans le choix du bon modèle d'embedding, l'architecture de votre index et l'optimisation de vos performances. Profitez de notre expertise Azure OpenAI.

Réserver une consultation gratuite