Forem: Nabil

RAG : Comment créer un chatbot IA qui ne ment jamais avec Azure AI

Nabil — Sat, 24 Jan 2026 08:42:49 +0000

RAG : Comment créer un chatbot IA qui ne ment jamais avec Azure AI

Par Nabil Ghanem, fondateur de Galaxy AI — Expert Azure AI & Microsoft Partner

Les chatbots IA classiques ont un problème majeur : ils inventent des réponses. C'est ce qu'on appelle les "hallucinations". Pour les entreprises, c'est inacceptable. Un chatbot RH qui invente des règles de congés ou un assistant juridique qui cite de fausses lois peut avoir des conséquences désastreuses.

La solution ? Le RAG (Retrieval Augmented Generation). Cette architecture force l'IA à répondre uniquement à partir de vos documents validés.

TL;DR — Résumé rapide

Aspect	Chatbot classique	Chatbot RAG
Source des réponses	Connaissance générale du modèle	Vos documents uniquement
Hallucinations	Fréquentes	Quasi-inexistantes
Mise à jour	Nécessite ré-entraînement	Immédiate (ajout de documents)
Coût	Élevé (fine-tuning)	Modéré (indexation)
Traçabilité	Aucune	Citations avec sources

Qu'est-ce que le RAG ?

RAG signifie Retrieval Augmented Generation. Le principe est simple :

L'utilisateur pose une question
Le système recherche les documents pertinents dans votre base
L'IA génère une réponse basée uniquement sur ces documents
La réponse inclut les sources citées

Architecture RAG sur Azure

Question utilisateur
       │
       ▼
Azure AI Search (recherche sémantique)
       │
       ├──► Documents pertinents trouvés
       │
       ▼
Azure OpenAI (GPT-4o)
       │
       ├──► Prompt : "Réponds uniquement avec ces documents"
       │
       ▼
Réponse + Citations

Pourquoi le RAG élimine les hallucinations

Un LLM comme GPT-4 possède une connaissance générale massive, mais cette connaissance :

Date de son entraînement (pas les infos récentes)
Ne contient pas vos données internes
Peut mélanger des informations incorrectes

Avec le RAG, on "injecte" vos documents dans le contexte de la requête. Le modèle n'a plus le choix : il doit se baser sur ce qu'on lui fournit.

Exemple de prompt système RAG

Tu es un assistant RH pour l'entreprise XYZ.
Réponds UNIQUEMENT en utilisant les documents fournis ci-dessous.
Si l'information n'est pas dans les documents, dis
"Je n'ai pas cette information dans la documentation disponible."
Ne jamais inventer de réponse.

Documents :
{documents_retrouvés}

💡 Astuce : Une température basse (0.1–0.3) réduit encore plus les hallucinations car le modèle devient moins "créatif".

Les composants Azure pour un RAG performant

1. Azure AI Search

C'est le moteur de recherche qui retrouve les documents pertinents :

✅ Recherche sémantique — Comprend le sens, pas juste les mots-clés
✅ Recherche vectorielle — Compare les embeddings pour trouver des similarités
✅ Recherche hybride — Combine les deux pour de meilleurs résultats
✅ Filtrage — Par date, catégorie, département, etc.

2. Azure OpenAI

Le cerveau qui génère les réponses :

GPT-4o pour les réponses complexes
GPT-4o-mini pour les cas simples (moins cher)
Embeddings text-embedding-3-large pour la vectorisation

3. Azure Blob Storage

Stockage des documents sources :

PDF, Word, Excel, PowerPoint
Pages web crawlées
Bases de données exportées

Implémentation pas à pas

Étape 1 : Indexation des documents

from azure.search.documents.indexes import SearchIndexClient
from azure.search.documents.indexes.models import (
    SearchIndex,
    SearchField,
    SearchFieldDataType,
    VectorSearch,
    HnswAlgorithmConfiguration,
    VectorSearchProfile,
    SemanticConfiguration,
    SemanticField,
    SemanticPrioritizedFields,
    SemanticSearch
)

index = SearchIndex(
    name="documents-rh",
    fields=[
        SearchField(name="id", type=SearchFieldDataType.String, key=True),
        SearchField(name="content", type=SearchFieldDataType.String, searchable=True),
        SearchField(name="title", type=SearchFieldDataType.String, searchable=True),
        SearchField(name="category", type=SearchFieldDataType.String, filterable=True),
        SearchField(
            name="content_vector",
            type=SearchFieldDataType.Collection(SearchFieldDataType.Single),
            searchable=True,
            vector_search_dimensions=3072,
            vector_search_profile_name="vector-profile"
        )
    ],
    vector_search=VectorSearch(
        algorithms=[HnswAlgorithmConfiguration(name="hnsw-config")],
        profiles=[VectorSearchProfile(
            name="vector-profile",
            algorithm_configuration_name="hnsw-config"
        )]
    ),
    semantic_search=SemanticSearch(
        configurations=[SemanticConfiguration(
            name="semantic-config",
            prioritized_fields=SemanticPrioritizedFields(
                content_fields=[SemanticField(field_name="content")],
                title_field=SemanticField(field_name="title")
            )
        )]
    )
)

index_client.create_or_update_index(index)

Étape 2 : Vectorisation des documents

from azure.openai import AzureOpenAI

openai_client = AzureOpenAI(
    azure_endpoint="https://votre-instance.openai.azure.com",
    api_key="votre-api-key",
    api_version="2024-02-01"
)

def get_embedding(text):
    response = openai_client.embeddings.create(
        input=text,
        model="text-embedding-3-large"
    )
    return response.data[0].embedding

for doc in documents:
    doc["content_vector"] = get_embedding(doc["content"])
    search_client.upload_documents([doc])

Étape 3 : Recherche et génération

from azure.search.documents import SearchClient
from azure.search.documents.models import VectorizedQuery

def ask_rag(question: str) -> str:
    question_vector = get_embedding(question)

    results = search_client.search(
        search_text=question,
        vector_queries=[VectorizedQuery(
            vector=question_vector,
            k_nearest_neighbors=5,
            fields="content_vector"
        )],
        query_type="semantic",
        semantic_configuration_name="semantic-config",
        top=5
    )

    context = ""
    sources = []
    for result in results:
        context += f"\n\n---\nDocument: {result['title']}\n{result['content']}"
        sources.append(result['title'])

    response = openai_client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": f"""Tu es un assistant RH.
Réponds UNIQUEMENT en utilisant les documents ci-dessous.
Si l'information n'est pas disponible, dis-le clairement.
Cite toujours la source de ta réponse.

Documents disponibles:
{context}"""
            },
            {"role": "user", "content": question}
        ],
        temperature=0.1
    )

    answer = response.choices[0].message.content
    return f"{answer}\n\nSources: {', '.join(sources)}"

Optimisations avancées

1. Chunking intelligent

Ne pas indexer des documents entiers, mais des morceaux (chunks) :

def chunk_document(text, chunk_size=500, overlap=50):
    chunks = []
    start = 0
    while start < len(text):
        end = start + chunk_size
        chunk = text[start:end]
        chunks.append(chunk)
        start = end - overlap
    return chunks

📏 Taille optimale : 300–800 tokens selon le type de document

2. Reranking

Après la recherche, re-classer les résultats :

results = search_client.search(
    search_text=question,
    query_type="semantic",
    semantic_configuration_name="semantic-config",
    query_caption="extractive",
    query_answer="extractive"
)

3. Filtrage contextuel

Limiter la recherche selon le profil utilisateur :

results = search_client.search(
    search_text=question,
    filter="category eq 'Finance' or category eq 'General'",
    ...
)

Cas d'usage entreprise

🏢 Assistant RH interne

Questions sur les congés, mutuelle, avantages
Procédures internes
Onboarding nouveaux employés

📞 Support client niveau 1

FAQ produits
Procédures de dépannage
Politique de retour/remboursement

💻 Base de connaissances technique

Documentation produit
Guides d'intégration API
Troubleshooting

⚖️ Juridique et conformité

Contrats types
Réglementations applicables
Procédures de conformité

Coûts estimatifs (Azure, janvier 2025)

Composant	Tarif
Azure AI Search (Basic)	~70 €/mois
Azure OpenAI GPT-4o	2.50 €/1M tokens input
Azure OpenAI Embeddings	0.13 €/1M tokens
Azure Blob Storage	~2 €/100 Go/mois

Pour une PME avec 1000 documents et 500 requêtes/jour :

💰 Coût mensuel estimé : 100–150 €

Erreurs à éviter

❌ Chunks trop grands ou trop petits

Trop grands : Perte de précision, contexte dilué
Trop petits : Perte de sens, réponses incomplètes
✅ Optimal : 300–800 tokens

❌ Ignorer les métadonnées

Date du document (éviter les infos obsolètes)
Source (crédibilité)
Catégorie (filtrage)

❌ Température trop élevée

Utilisez temperature=0.1 à 0.3 pour le RAG
Plus la température est basse, moins l'IA "improvise"

❌ Pas de fallback

Toujours prévoir : "Je n'ai pas trouvé cette information"
Éviter les réponses inventées

Conclusion

Le RAG est aujourd'hui la meilleure architecture pour déployer des chatbots IA en entreprise. En combinant Azure AI Search et Azure OpenAI, vous obtenez :

✅ Des réponses fiables basées sur vos documents

✅ Une traçabilité complète avec citations

✅ Une mise à jour instantanée (ajout de documents = nouvelles connaissances)

✅ Un coût maîtrisé sans fine-tuning

Pour les entreprises qui ne peuvent pas se permettre d'hallucinations, le RAG n'est plus une option, c'est une nécessité.

À propos de l'auteur

Nabil Ghanem est le fondateur de Galaxy AI, une entreprise spécialisée dans les solutions Azure AI pour entreprises. Microsoft Partner certifié, Galaxy AI accompagne les entreprises dans le déploiement de chatbots RAG et d'agents vocaux IA.

🌐 galaxyai.life

💼 LinkedIn

📅 Prendre rendez-vous

Cet article a été rédigé en janvier 2025. Les tarifs et fonctionnalités peuvent évoluer.

Tags : #Azure #ArtificialIntelligence #RAG #Chatbot #AzureOpenAI #MachineLearning #EnterpriseAI #LLM

Voice Live vs Real-Time API : Quelle solution choisir sur Azure AI Foundry ?

Nabil — Sat, 24 Jan 2026 08:06:20 +0000

Voice Live vs Real-Time API : Quelle solution choisir sur Azure AI Foundry ?

Par Nabil Ghanem, fondateur de Galaxy AI - Expert Azure AI & Microsoft Partner

Avec l'essor des agents vocaux IA, Azure AI Foundry propose deux approches distinctes pour le traitement vocal en temps réel : Voice Live (via Azure Communication Services) et Real-Time API (via Azure OpenAI). Ces deux technologies répondent à des besoins différents. Voici un guide complet pour choisir la bonne solution.

TL;DR - Résumé rapide

Critère	Voice Live (ACS)	Real-Time API (OpenAI)
Cas d'usage principal	Téléphonie d'entreprise	Applications conversationnelles
Latence	300-500ms	200-400ms
Intégration téléphonique	Native (PSTN, SIP)	Nécessite passerelle
Coût	Par minute d'appel	Par token + audio
Complexité	Moyenne	Élevée

Qu'est-ce que Voice Live (Azure Communication Services) ?

Voice Live est la solution de téléphonie IA intégrée à Azure Communication Services (ACS). Elle permet de créer des agents vocaux capables de :

Répondre aux appels téléphoniques entrants
Passer des appels sortants automatisés
S'intégrer nativement aux réseaux PSTN et SIP
Gérer le transfert vers des agents humains

Architecture Voice Live

Appelant (PSTN/SIP)
       │
       ▼
Azure Communication Services
       │
       ├──► Speech-to-Text (Azure AI Speech)
       │
       ├──► Azure OpenAI (GPT-4o)
       │
       └──► Text-to-Speech (Azure AI Speech)
       │
       ▼
Réponse vocale à l'appelant

Avantages de Voice Live

Intégration téléphonique native : Achetez un numéro de téléphone directement dans Azure et recevez des appels sans infrastructure supplémentaire.
Gestion des appels complète : Transfert, mise en attente, conférence, enregistrement - tout est géré nativement.
Facturation simple : Tarification à la minute, prévisible pour les centres d'appels.
Conformité entreprise : Certifications SOC 2, HIPAA, GDPR incluses.

Exemple de code Voice Live

from azure.communication.callautomation import CallAutomationClient
from azure.communication.callautomation import PhoneNumberIdentifier

client = CallAutomationClient.from_connection_string(connection_string)

# Répondre à un appel entrant
call_connection = client.answer_call(
    incoming_call_context=incoming_call_context,
    callback_url="https://votre-webhook.com/events"
)

# Lancer la reconnaissance vocale avec Azure OpenAI
call_connection.start_recognizing_media(
    input_type="speech",
    target_participant=PhoneNumberIdentifier(caller_number),
    speech_recognition_model_endpoint_id="votre-deployment-openai"
)

Qu'est-ce que Real-Time API (Azure OpenAI) ?

Real-Time API est une fonctionnalité d'Azure OpenAI qui permet des conversations vocales bidirectionnelles en streaming. Contrairement à Voice Live, elle n'est pas liée à la téléphonie mais offre une latence ultra-faible.

Architecture Real-Time API

Application client (Web/Mobile)
       │
       ▼ (WebSocket)
Azure OpenAI Real-Time API
       │
       ├──► Audio Input Stream
       │
       ├──► GPT-4o-realtime
       │
       └──► Audio Output Stream
       │
       ▼
Réponse vocale instantanée

Avantages de Real-Time API

Latence minimale : Streaming audio bidirectionnel, réponses quasi-instantanées.
Interruptions naturelles : L'utilisateur peut interrompre l'IA mid-sentence, comme une vraie conversation.
Multimodalité native : Audio + texte dans le même flux, sans étapes intermédiaires.
Contrôle granulaire : Gestion fine des tours de parole, détection de silence, etc.

Exemple de code Real-Time API

import asyncio
from azure.openai import AsyncAzureOpenAI

client = AsyncAzureOpenAI(
    azure_endpoint="https://votre-instance.openai.azure.com",
    api_key="votre-api-key",
    api_version="2024-10-01-preview"
)

async def conversation():
    async with client.realtime.connect(
        deployment="gpt-4o-realtime-preview"
    ) as connection:

        # Configurer la session
        await connection.session.update(
            modalities=["text", "audio"],
            voice="alloy",
            input_audio_format="pcm16",
            output_audio_format="pcm16"
        )

        # Envoyer l'audio de l'utilisateur
        await connection.input_audio_buffer.append(audio_data)

        # Recevoir la réponse en streaming
        async for event in connection:
            if event.type == "response.audio.delta":
                play_audio(event.delta)

Comparaison détaillée

1. Latence et performance

Métrique	Voice Live	Real-Time API
Temps de première réponse	400-600ms	200-350ms
Latence bout-en-bout	500-800ms	300-500ms
Gestion des interruptions	Limitée	Native

Verdict : Real-Time API gagne sur la latence pure, mais Voice Live reste acceptable pour la téléphonie traditionnelle.

2. Intégration téléphonique

Fonctionnalité	Voice Live	Real-Time API
Numéros PSTN	Natif	Via passerelle SIP
Transfert d'appel	Natif	Manuel
Enregistrement	Natif	À implémenter
IVR/Menu vocal	Natif	À implémenter

Verdict : Voice Live est clairement supérieur pour les cas d'usage téléphoniques.

3. Coûts (estimations janvier 2025)

Composant	Voice Live	Real-Time API
Audio entrant	$0.004/min	$0.06/min (100 tokens/sec)
Audio sortant	$0.004/min	$0.24/min (400 tokens/sec)
LLM (GPT-4o)	$0.005/1K tokens	Inclus dans audio
Numéro téléphone	$2/mois	N/A

Exemple pour 1000 minutes d'appels/mois :

Voice Live : ~$50-80
Real-Time API : ~$300-400

Verdict : Voice Live est significativement moins cher pour les gros volumes téléphoniques.

4. Qualité conversationnelle

Aspect	Voice Live	Real-Time API
Naturalité	Bonne	Excellente
Gestion du contexte	Via prompt	Native
Émotions/Ton	Limité	Avancé
Multilingue	Oui	Oui

Verdict : Real-Time API offre une expérience plus naturelle et fluide.

Cas d'usage recommandés

Utilisez Voice Live si :

Vous créez un centre d'appels automatisé
Vous avez besoin d'intégration PSTN/SIP
Le volume d'appels est élevé (>1000 min/mois)
Vous voulez une facturation prévisible
Vous avez besoin de transfert vers agents humains

Exemples :

Standard téléphonique IA 24/7
Qualification de leads par téléphone
Support client niveau 1
Prise de rendez-vous automatisée

Utilisez Real-Time API si :

Vous créez une application web/mobile avec voix
La latence ultra-faible est critique
Vous voulez des conversations très naturelles
L'utilisateur doit pouvoir interrompre l'IA
Vous intégrez dans une expérience immersive

Exemples :

Assistant vocal dans une app mobile
Tuteur IA conversationnel
Jeu vidéo avec PNJ vocaux
Interface vocale pour IoT

Architecture hybride : Le meilleur des deux mondes

Pour certains projets, combiner les deux approches peut être optimal :

                    Appel téléphonique
                           │
                           ▼
                Azure Communication Services
                           │
           ┌───────────────┴───────────────┐
           │                               │
           ▼                               ▼
    Requêtes simples              Conversations complexes
    (IVR, routage)                (négociation, support)
           │                               │
           ▼                               ▼
    Voice Live standard            Real-Time API
    (Speech + GPT-4o)              (streaming natif)

Cette architecture permet de :

Utiliser Voice Live pour le routage initial et les requêtes simples
Basculer vers Real-Time API pour les conversations complexes nécessitant plus de fluidité

Conclusion

Voice Live et Real-Time API ne sont pas en compétition directe - ils répondent à des besoins différents.

Voice Live excelle dans la téléphonie d'entreprise avec son intégration native PSTN, sa tarification prévisible et ses fonctionnalités de centre d'appels.
Real-Time API brille pour les expériences conversationnelles immersives où la latence et la naturalité sont primordiales.

Le choix dépend de votre cas d'usage principal. Et pour les projets ambitieux, une architecture hybride peut offrir le meilleur des deux mondes.

À propos de l'auteur

Site web : galaxyai.life
LinkedIn : Galaxy AI
Contact : Prendre rendez-vous

Cet article a été rédigé en janvier 2026. Les tarifs et fonctionnalités peuvent évoluer. Consultez la documentation officielle Azure pour les informations les plus récentes.

Tags : #Azure #AzureAI #VoiceAI #AzureOpenAI #RealTimeAPI #AzureCommunicationServices #VoiceLive #Chatbot #IA #MicrosoftPartner