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:
    """Detects language AND responds in a single API call."""

    enhanced_system = (
        f"{system_prompt}\n\n"
        "ABSOLUTE RULE: Always respond in the language used by the user.\n"
        "If the user writes in Spanish, respond in Spanish.\n"
        "If the user writes in German, respond in German.\n"
        "Never translate to another language unless explicitly requested.\n\n"
        "Start your response with an invisible tag: [LANG:xx] where xx is the ISO 639-1 "
        "code of the detected language (fr, en, es, de, etc.). This tag will be removed before display."
    )

    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"]

    # Extract language tag
    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
    }

# Example usage
result = chat_with_language_detection(
    user_message="¿Cuáles son sus horarios de atención?",
    system_prompt="You are the assistant of La Maison du Thé shop.",
    api_key="sk-or-..."
)
print(result["detected_language"])  # "es"
print(result["response"])  # Response in Spanish

# pip install lingua-language-detector

from lingua import Language, LanguageDetectorBuilder

# Build a detector optimized for your target languages
detector = LanguageDetectorBuilder.from_languages(
    Language.FRENCH, Language.ENGLISH, 
    Language.SPANISH, Language.GERMAN,
    Language.PORTUGUESE, Language.ITALIAN
).build()

def detect_language_local(text: str) -> str:
    """Ultra-fast local detection (<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"

// Client-side - retrieve preferred language
const userLang = navigator.language || navigator.userLanguage;
const primaryLang = userLang.split('-')[0]; // "fr" from "fr-FR"

// Send with each request
fetch('/api/chat', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'X-User-Language': primaryLang
    },
    body: JSON.stringify({ message: userInput })
});

MULTILINGUAL_SYSTEM_PROMPT = """
You are {avatar_name}, virtual assistant of {company}.

## Linguistic Rules (MAXIMUM PRIORITY)
1. DETECT the language of the user's message
2. RESPOND in this SAME language — always
3. If the user changes language during the conversation, FOLLOW the change
4. Keep technical terms/brand names in their original form
5. Adapt the level of formality to the culture:
   - French: formal by default (vouvoiement)
   - German: Sie (formal) by default  
   - Spanish: usted for professional context
   - English: neutral professional register
   - Japanese: keigo (honorific language)

## Knowledge Base
{knowledge_base}

## Tone
Professional but warm. Use culturally appropriate conventions 
(greetings, politeness formulas) of the detected language.
"""

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:
        """Generate language context for the next call."""
        if len(self.language_history) >= 2:
            if self.language_history[-1] != self.language_history[-2]:
                return (
                    f"The user just switched from "
                    f"{self.language_history[-2]} to "
                    f"{self.language_history[-1]}. "
                    f"Respond in {self.language_history[-1]}."
                )
        return ""

import numpy as np

class MultilingualRAG:
    """Multilingual RAG with cross-lingual embeddings."""

    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):
        """Add a document in its original language."""
        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:
        """Cross-lingual search across all languages."""
        query_embedding = self._embed(query)

        all_results = []
        for lang, embeddings in self.embeddings.items():
            for i, doc_emb in enumerate(embeddings):
                score = self._calculate_similarity(query_embedding, doc_emb)
                # ...