Multilingual Customer Service with Local AI

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

What this article covers

• Building multilingual customer service with local AI.
• How translation, comprehension, and response generation work across languages.
• Practical examples for support in German, English, French, and more.
• Best practices for quality, consistency, and data privacy.

Introduction: Multilingual customer service explained

Multilingual customer service works like this: customers write in German, English, or French, the AI understands all languages, responds in the correct language, and draws from the same knowledge base. Using Ollama locally keeps all customer data private.

This article is for companies looking to automate multilingual support with AI. For foundational concepts, see Customer Service Automation and FAQ Bot.

Why do you need multilingual customer service?

Imagine you have customers in Germany, France, and Spain. Each writes in their own language. Instead of hiring three support teams, your AI understands all languages, finds the answer in the knowledge base, and responds in the customer’s language. One system for all languages.

How multilingual customer service works

Customer writes in French → AI understands → searches German knowledge base → replies in French. Or: customer writes in English → AI translates internally → searches → translates back.

The core principle: one knowledge base, all languages.

Who should read this article?

• Companies offering international support.
• Support teams covering multiple languages.
• Self-hosters running multilingual AI locally.
• Developers building multilingual support systems.

Key terms

• Ollama - Local model server. Useful for: multilingual models.
• RAG - Knowledge base. Useful for: FAQs.
• Embedding models - For search. Useful for: multilingual-e5 for multiple languages.
• Language detection - Identifying the language. Useful for: automatic response routing.
• Translation - Converting text between languages. Useful for: language switching.

Architecture

Customer inquiry (any language)
    │
    ▼
Language detection (AI identifies language)
    │
    ▼
RAG: Search knowledge base
    │
    ├─ multilingual-e5 for multilingual embeddings
    └─ Or: translate → search → translate back
    │
    ▼
Generate response (in customer language)
    │
    ▼
Optional: verify translation
    │
    ▼
Send response (customer language)

Practical example 1: Language detection and response

import requests

def detect_language(text):
    """Detect language"""
    response = requests.post("http://ollama:11434/api/chat", json={
        "model": "qwen2.5",
        "messages": [
            {"role": "system", "content": "Detect the language of the text. Reply only with the ISO code: de, en, fr, es, it, etc."},
            {"role": "user", "content": f"Text: {text[:500]}"}
        ],
        "stream": False
    })
    return response.json()["message"]["content"].strip().lower()

def answer_multilingual(question, lang):
    """Answer the question in the customer's language"""
    # System prompt in customer language
    system_prompts = {
        "de": "Du bist ein hilfreicher Kundenservice-Assistent. Antworte auf Deutsch.",
        "en": "You are a helpful customer service assistant. Answer in English.",
        "fr": "Tu es un assistant de service client utile. Réponds en français.",
        "es": "Eres un asistente de servicio al cliente útil. Responde en español."
    }

    system = system_prompts.get(lang, system_prompts["de"])

    response = requests.post("http://ollama:11434/api/chat", json={
        "model": "qwen2.5",
        "messages": [
            {"role": "system", "content": system},
            {"role": "user", "content": question}
        ],
        "stream": False
    })
    return response.json()["message"]["content"]

Practical example 2: RAG with multilingual-e5

import chromadb

class MultilingualKB:
    """Multilingual knowledge base"""

    def __init__(self):
        self.chroma = chromadb.HttpClient(host="chromadb", port=8000)
        self.collection = self.chroma.get_or_create_collection("faq")

    def get_embedding(self, text):
        """multilingual-e5 for multilingual embeddings"""
        response = requests.post("http://ollama:11434/api/embeddings", json={
            "model": "multilingual-e5",
            "prompt": text
        })
        return response.json()["embedding"]

    def ask(self, question, lang):
        """Answer a question in any language"""
        # multilingual-e5 understands all languages
        query_embedding = self.get_embedding(question)

        results = self.collection.query(
            query_embeddings=[query_embedding],
            n_results=5
        )

        context = "\n\n".join(results["documents"][0])

        # Generate response in customer language
        return answer_multilingual(
            f"Context:\n{context}\n\nQuestion: {question}",
            lang
        )

Practical example 3: Translation as an intermediate step

def translate_and_answer(question, source_lang, target_lang="de"):
    """Translate → search → translate back"""
    # 1. Translate to target language
    translated_q = translate(question, source_lang, target_lang)

    # 2. Search knowledge base
    context = search_knowledge_base(translated_q)

    # 3. Generate response (in target language)
    answer_de = generate_answer(translated_q, context)

    # 4. Translate back
    answer = translate(answer_de, target_lang, source_lang)

    return answer

def translate(text, source, target):
    """Translate text"""
    response = requests.post("http://ollama:11434/api/chat", json={
        "model": "qwen2.5",
        "messages": [
            {"role": "system", "content": f"Translate from {source} to {target}. Only provide the translation."},
            {"role": "user", "content": text}
        ],
        "stream": False
    })
    return response.json()["message"]["content"]

Practical example 4: Support ticket routing

def route_ticket(ticket_text):
    """Route ticket to the right team"""
    lang = detect_language(ticket_text)

    # AI analyzes issue and language
    analysis = requests.post("http://ollama:11434/api/chat", json={
        "model": "qwen2.5",
        "messages": [
            {"role": "system", "content": "Analyze the support ticket. Reply as JSON: {\"category\": \"...\", \"priority\": \"...\", \"language\": \"...\", \"team\": \"...\"}"},
            {"role": "user", "content": f"Ticket: {ticket_text[:2000]}"}
        ],
        "stream": False,
        "format": "json"
    })

    result = json.loads(analysis.json()["message"]["content"])

    # Route based on language and category
    teams = {
        "de": "support-de",
        "en": "support-en",
        "fr": "support-fr"
    }

    result["assigned_team"] = teams.get(result["language"], "support-de")
    return result

Security Considerations

• Customer Data: All data remains local. See Data Privacy.
• Translation Quality: AI translations can contain errors. Verify critical communications manually.
• Cultural Differences: Not all responses fit every culture. Consider context.
• Prompt Injection: Customers may attempt injections. See Prompt Injection.

Common Pitfalls

• Wrong Embedding Model: nomic-embed-text supports English only. For multilingual support, use multilingual-e5 or bge-m3.
• Translation Errors: AI translations can be inaccurate. For critical communications, apply human review.
• Context Loss: Translation can degrade context. Responding directly in the customer’s language is preferable.
• Language Detection Fails: Language identification is unreliable for short text. Use a fallback default language.
• Too Many Languages: Not all models perform equally across all languages. Test your target languages.

Further Reading

• Customer Service Automation - Automate support.
• FAQ Bot - FAQ systems.
• Embedding Models - For multilingual support.
• Local RAG - Knowledge base.
• Ollama - Model server.
• Text Models - Multilingual models.

Key Takeaways:

• Multilingual support: one knowledge base, all languages.
• multilingual-e5 for multilingual embeddings.
• qwen2.5 for strong multilingual performance.
• Language detection → RAG → response in customer language.
• Ideal for international companies running local AI.

FAQ

Sources and Further Reading

• Ollama - Local model server.
• multilingual-e5 - Embedding model.
• Qwen - Multilingual model.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert