Avatar IA multilingue : parler à vos clients dans leur langue

import requests
import re

def chat_with_language_detection(user_message: str, system_prompt: str, api_key: str) -> dict:
    """Détecte la langue ET répond en un seul appel API."""

    enhanced_system = (
        f"{system_prompt}\n\n"
        "RÈGLE ABSOLUE : Réponds TOUJOURS dans la langue utilisée par l'utilisateur.\n"
        "Si l'utilisateur écrit en espagnol, réponds en espagnol.\n"
        "Si l'utilisateur écrit en allemand, réponds en allemand.\n"
        "Ne traduis jamais vers une autre langue sauf demande explicite.\n\n"
        "Commence ta réponse par un tag invisible : [LANG:xx] où xx est le code ISO 639-1 "
        "de la langue détectée (fr, en, es, de, etc.). Ce tag sera retiré avant affichage."
    )

    response = requests.post(
        "https://openrouter.ai/api/v1/chat/completions",
        headers={"Authorization": f"Bearer {api_key}"},
        json={
            "model": "anthropic/claude-sonnet-4-20250514",
            "messages": [
                {"role": "system", "content": enhanced_system},
                {"role": "user", "content": user_message}
            ]
        }
    )

    text = response.json()["choices"][0]["message"]["content"]

    # Extraire le tag de langue
    lang_match = re.match(r'\[LANG:(\w{2})\]\s*', text)
    detected_lang = lang_match.group(1) if lang_match else "fr"
    clean_text = re.sub(r'\[LANG:\w{2}\]\s*', '', text)

    return {
        "response": clean_text,
        "detected_language": detected_lang
    }

# Exemple d'utilisation
result = chat_with_language_detection(
    user_message="¿Cuáles son sus horarios de atención?",
    system_prompt="Tu es l'assistant de la boutique La Maison du Thé.",
    api_key="sk-or-..."
)
print(result["detected_language"])  # "es"
print(result["response"])  # Réponse en espagnol

# pip install lingua-language-detector

from lingua import Language, LanguageDetectorBuilder

# Construire un détecteur optimisé pour vos langues cibles
detector = LanguageDetectorBuilder.from_languages(
    Language.FRENCH, Language.ENGLISH, 
    Language.SPANISH, Language.GERMAN,
    Language.PORTUGUESE, Language.ITALIAN
).build()

def detect_language_local(text: str) -> str:
    """Détection locale ultra-rapide (<1ms)."""
    result = detector.detect_language_of(text)
    if result is None:
        return "fr"  # Fallback

    lang_map = {
        Language.FRENCH: "fr", Language.ENGLISH: "en",
        Language.SPANISH: "es", Language.GERMAN: "de",
        Language.PORTUGUESE: "pt", Language.ITALIAN: "it"
    }
    return lang_map.get(result, "fr")

# Tests
print(detect_language_local("How can I help you?"))          # "en"
print(detect_language_local("Wie kann ich Ihnen helfen?"))    # "de"
print(detect_language_local("¿Cómo puedo ayudarle?"))        # "es"

// Côté client - récupérer la langue préférée
const userLang = navigator.language || navigator.userLanguage;
const primaryLang = userLang.split('-')[0]; // "fr" depuis "fr-FR"

// Envoyer avec chaque requête
fetch('/api/chat', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'X-User-Language': primaryLang
    },
    body: JSON.stringify({ message: userInput })
});

MULTILINGUAL_SYSTEM_PROMPT = """
Tu es {nom_avatar}, assistant virtuel de {entreprise}.

## Règles linguistiques (PRIORITÉ MAXIMALE)
1. DÉTECTE la langue du message de l'utilisateur
2. RÉPONDS dans cette MÊME langue — toujours
3. Si l'utilisateur change de langue en cours de conversation, SUIS le changement
4. Garde les termes techniques/noms de marque dans leur forme originale
5. Adapte le niveau de formalité à la culture :
   - Français : vouvoiement par défaut
   - Allemand : Sie (formel) par défaut  
   - Espagnol : usted pour un contexte pro
   - Anglais : registre professionnel neutre
   - Japonais : keigo (langage honorifique)

## Base de connaissances
{knowledge_base}

## Ton
Professionnel mais chaleureux. Utilise les conventions culturelles 
appropriées (salutations, formules de politesse) de la langue détectée.
"""

class MultilingualConversation:
    def __init__(self, system_prompt: str):
        self.messages = [{"role": "system", "content": system_prompt}]
        self.current_language = None
        self.language_history = []

    def add_message(self, role: str, content: str, detected_lang: str = None):
        self.messages.append({"role": role, "content": content})
        if role == "user" and detected_lang:
            self.language_history.append(detected_lang)
            self.current_language = detected_lang

    def get_language_context(self) -> str:
        """Génère un contexte de langue pour le prochain appel."""
        if len(self.language_history) >= 2:
            if self.language_history[-1] != self.language_history[-2]:
                return (
                    f"L'utilisateur vient de passer du "
                    f"{self.language_history[-2]} au "
                    f"{self.language_history[-1]}. "
                    f"Réponds en {self.language_history[-1]}."
                )
        return ""

import numpy as np

class MultilingualRAG:
    """RAG multilingue avec embeddings cross-lingues."""

    def __init__(self, embedding_model: str = "multilingual-e5-large"):
        self.embedding_model = embedding_model
        self.documents = {}  # lang -> [docs]
        self.embeddings = {}  # lang -> [vectors]

    def add_document(self, text: str, lang: str, metadata: dict = None):
        """Ajouter un document dans sa langue originale."""
        if lang not in self.documents:
            self.documents[lang] = []
            self.embeddings[lang] = []

        embedding = self._embed(text)
        self.documents[lang].append({
            "text": text, "lang": lang,
            "metadata": metadata or {}
        })
        self.embeddings[lang].append(embedding)

    def search(self, query: str, query_lang: str, top_k: int = 5) -> list:
        """Recherche cross-lingue dans toutes les langues."""
        query_embedding = self._embed(query)

        all_results = []
        for lang, embeddings in self.embeddings.items():
            for i, doc_emb in enumerate(embeddings):
                score = self._cosine_similarity(query_embedding, doc_emb)
                all_results.append({
                    "document": self.documents[lang][i],
                    "score": score,
                    "source_lang": lang
                })

        all_results.sort(key=lambda x: x["score"], reverse=True)
        return all_results[:top_k]

    def _embed(self, text: str) -> list:
        """Génère l'embedding multilingue via votre API préférée."""
        pass  # Implémentez avec OpenAI, Cohere ou modèle local

    def _cosine_similarity(self, a, b) -> float:
        return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))

CULTURAL_PROFILES = {
    "fr": {
        "greeting": "Bonjour ! ",
        "formality": "vouvoiement",
        "style": "Professionnel mais chaleureux. Vouvoiement. Développe les réponses.",
        "closing": "N'hésitez pas si vous avez d'autres questions.",
        "emoji_level": "modéré"
    },
    "en": {
        "greeting": "Hi! ",
        "formality": "neutral",
        "style": "Professional but approachable. Concise and action-oriented.",
        "closing": "Let me know if you need anything else!",
        "emoji_level": "light"
    },
    "de": {
        "greeting": "Guten Tag! ",
        "formality": "Sie",
        "style": "Formell und präzise. Verwende Sie. Klare Struktur.",
        "closing": "Stehe ich Ihnen gerne für weitere Fragen zur Verfügung.",
        "emoji_level": "minimal"
    },
    "es": {
        "greeting": "¡Hola! ",
        "formality": "usted_professional",
        "style": "Profesional pero cálido. Use usted en contexto profesional.",
        "closing": "¡No dude en consultarme cualquier otra cosa!",
        "emoji_level": "modéré"
    },
    "ja": {
        "greeting": "お問い合わせありがとうございます。",
        "formality": "keigo",
        "style": "丁寧語と敬語を使用。間接的な表現。結論の前に背景を説明。",
        "closing": "他にご不明な点がございましたら、お気軽にお申し付けください。",
        "emoji_level": "none"
    }
}

Pour aller plus loin sur ce sujet, consultez notre guide [Qu'est-ce qu'un avatar IA ? Le guide complet pour comprendre](/article/qu-est-ce-qu-un-avatar-ia-le-guide-complet-pour-comprendre).

def build_cultural_prompt(base_prompt: str, lang: str) -> str:
    """Enrichit le prompt avec le profil culturel adapté."""
    profile = CULTURAL_PROFILES.get(lang, CULTURAL_PROFILES["en"])

    cultural_instructions = (
        f"\n## Instructions culturelles pour la langue '{lang}'\n"
        f"- Niveau de formalité : {profile['formality']}\n"
        f"- Style attendu : {profile['style']}\n"
        f"- Termine par une variante de : \"{profile['closing']}\"\n"
        f"- Niveau d'émojis : {profile['emoji_level']}\n"
    )
    return base_prompt + cultural_instructions

import requests

class MultilingualTTS:
    """Gestion TTS avec sélection automatique de voix par langue."""

    VOICE_MAP = {
        "fr": {"voice_id": "pFZP5JQG7iQjIQuC4Bku", "name": "Léa"},
        "en": {"voice_id": "21m00Tcm4TlvDq8ikWAM", "name": "Rachel"},
        "es": {"voice_id": "GBv7mTt0atIp3Br8iCZE", "name": "María"},
        "de": {"voice_id": "ErXwobaYiN019PkySvjV", "name": "Antoni"},
    }

    def __init__(self, api_key: str):
        self.api_key = api_key

    def synthesize(self, text: str, lang: str) -> bytes:
        """Génère l'audio dans la langue appropriée."""
        voice = self.VOICE_MAP.get(lang, self.VOICE_MAP["en"])

        response = requests.post(
            f"https://api.elevenlabs.io/v1/text-to-speech/{voice['voice_id']}",
            headers={
                "xi-api-key": self.api_key,
                "Content-Type": "application/json"
            },
            json={
                "text": text,
                "model_id": "eleven_multilingual_v2",
                "voice_settings": {
                    "stability": 0.5,
                    "similarity_boost": 0.75
                }
            }
        )
        return response.content

# Utilisation
tts = MultilingualTTS(api_key="your-key")
audio_de = tts.synthesize("Guten Tag! Wie kann ich Ihnen helfen?", "de")
audio_fr = tts.synthesize("Bonjour ! Comment puis-je vous aider ?", "fr")

import json
from datetime import datetime

class UserLanguageMemory:
    """Gère la mémoire linguistique par utilisateur."""

    def __init__(self, memory_file: str = "user_languages.json"):
        self.memory_file = memory_file
        self.data = self._load()

    def _load(self) -> dict:
        try:
            with open(self.memory_file, 'r') as f:
                return json.load(f)
        except FileNotFoundError:
            return {}

    def save(self):
        with open(self.memory_file, 'w') as f:
            json.dump(self.data, f, indent=2, ensure_ascii=False)

    def update_user_language(self, user_id: str, lang: str):
        """Met à jour la langue préférée de l'utilisateur."""
        if user_id not in self.data:
            self.data[user_id] = {
                "preferred_lang": lang,
                "languages_used": [],
                "first_seen": datetime.now().isoformat(),
                "interactions": 0
            }

        profile = self.data[user_id]
        profile["preferred_lang"] = lang
        profile["last_lang"] = lang
        profile["interactions"] += 1
        profile["last_seen"] = datetime.now().isoformat()

        if lang not in profile["languages_used"]:
            profile["languages_used"].append(lang)

        self.save()

    def get_preferred_language(self, user_id: str) -> str:
        return self.data.get(user_id, {}).get("preferred_lang", "fr")

    def is_multilingual_user(self, user_id: str) -> bool:
        return len(self.data.get(user_id, {}).get("languages_used", [])) > 1

{
  "user_abc123": {
    "preferred_lang": "de",
    "languages_used": ["en", "de"],
    "first_seen": "2025-01-15T10:30:00",
    "last_seen": "2025-02-20T14:22:00",
    "interactions": 47,
    "notes": "Client allemand, commence parfois en anglais, préfère l'allemand"
  }
}

import requests
import json
import re

class MultilingualAvatar:
    """Avatar IA multilingue complet."""

    def __init__(self, config: dict):
        self.api_key = config["api_key"]
        self.api_url = config.get("api_url", "https://openrouter.ai/api/v1/chat/completions")
        self.model = config.get("model", "anthropic/claude-sonnet-4-20250514")
        self.company = config["company_name"]
        self.knowledge_base = config.get("knowledge_base", "")
        self.memory = UserLanguageMemory()
        self.conversations = {}

    def _build_system_prompt(self, lang: str = None) -> str:
        cultural = ""
        if lang and lang in CULTURAL_PROFILES:
            p = CULTURAL_PROFILES[lang]
            cultural = f"\nStyle culturel : {p['style']}\nFormalité : {p['formality']}"

        return (
            f"Tu es l'assistant virtuel de {self.company}.\n\n"
            "## Règles linguistiques\n"
            "1. Réponds TOUJOURS dans la langue de l'utilisateur\n"
            "2. Adapte ton ton à la culture du locuteur\n"
            "3. Garde les noms de produits en français (c'est la marque)\n"
            "4. Commence chaque réponse par [LANG:xx]\n"
            f"{cultural}\n\n"
            f"## Base de connaissances\n{self.knowledge_base}"
        )

    def chat(self, user_id: str, message: str) -> dict:
        """Point d'entrée principal."""
        preferred_lang = self.memory.get_preferred_language(user_id)

        if user_id not in self.conversations:
            self.conversations[user_id] = []

        self.conversations[user_id].append({"role": "user", "content": message})

        response = requests.post(
            self.api_url,
            headers={"Authorization": f"Bearer {self.api_key}"},
            json={
                "model": self.model,
                "messages": [
                    {"role": "system", "content": self._build_system_prompt(preferred_lang)},
                    *self.conversations[user_id][-10:]
                ],
                "temperature": 0.7,
                "max_tokens": 1000
            }
        )

        raw_text = response.json()["choices"][0]["message"]["content"]

        lang_match = re.match(r'\[LANG:(\w{2})\]\s*', raw_text)
        detected_lang = lang_match.group(1) if lang_match else preferred_lang
        clean_text = re.sub(r'\[LANG:\w{2}\]\s*', '', raw_text)

        self.memory.update_user_language(user_id, detected_lang)
        self.conversations[user_id].append({"role": "assistant", "content": clean_text})

        return {
            "response": clean_text,
            "language": detected_lang,
            "user_id": user_id
        }

# Utilisation
avatar = MultilingualAvatar({
    "api_key": "sk-or-v1-...",
    "company_name": "La Maison du Thé",
    "knowledge_base": (
        "- Thé vert Sencha : 12€/100g, origine Japon\n"
        "- Earl Grey Premium : 9€/100g, bergamote de Calabre\n"
        "- Livraison : France 48h, Europe 3-5 jours, Monde 7-14 jours\n"
        "- Retours : 30 jours, frais offerts en France"
    )
})

# Client allemand
r = avatar.chat("user_de_001", "Wie lange dauert die Lieferung nach Deutschland?")
print(f"[{r['language']}] {r['response']}")
# [de] Guten Tag! Die Lieferung nach Deutschland dauert 3-5 Werktage...

# Client espagnol
r = avatar.chat("user_es_001", "¿Tienen envío a México?")
print(f"[{r['language']}] {r['response']}")
# [es] ¡Hola! Sí, realizamos envíos internacionales...

def estimate_multilingual_cost(
    conversations_per_month: int,
    avg_tokens_per_conv: int,
    language_distribution: dict,
    cost_per_1k_tokens: float = 0.003
) -> dict:
    """Estime le coût mensuel par langue."""

    LANG_TOKEN_MULTIPLIER = {
        "en": 1.0, "fr": 1.2, "es": 1.2, "de": 1.3,
        "pt": 1.2, "it": 1.2, "nl": 1.3, "ja": 2.0,
        "zh": 1.7, "ko": 2.2, "ar": 1.8, "th": 2.8
    }

    total_cost = 0
    breakdown = {}

    for lang, percentage in language_distribution.items():
        multiplier = LANG_TOKEN_MULTIPLIER.get(lang, 1.5)
        lang_conversations = conversations_per_month * percentage
        lang_tokens = lang_conversations * avg_tokens_per_conv * multiplier
        lang_cost = (lang_tokens / 1000) * cost_per_1k_tokens

        breakdown[lang] = {
            "conversations": int(lang_conversations),
            "estimated_tokens": int(lang_tokens),
            "estimated_cost": round(lang_cost, 2)
        }
        total_cost += lang_cost

    return {"total_monthly_cost": round(total_cost, 2), "breakdown": breakdown}

# Exemple : boutique avec trafic international
cost = estimate_multilingual_cost(
    conversations_per_month=10000,
    avg_tokens_per_conv=500,
    language_distribution={
        "fr": 0.40, "en": 0.30, "de": 0.15, "es": 0.10, "ja": 0.05
    }
)
print(f"Coût mensuel estimé : {cost['total_monthly_cost']}€")

<!-- Sur chaque page localisée -->
<link rel="alternate" hreflang="fr" href="https://votresite.com/fr/assistant" />
<link rel="alternate" hreflang="en" href="https://votresite.com/en/assistant" />
<link rel="alternate" hreflang="de" href="https://votresite.com/de/assistant" />
<link rel="alternate" hreflang="es" href="https://votresite.com/es/assistant" />
<link rel="alternate" hreflang="x-default" href="https://votresite.com/assistant" />