""" Multilingual Swiss Assistant Specialized implementation for Swiss multilingual use cases """ from typing import Dict, List, Optional, Any import logging from .apertus_core import ApertusCore logger = logging.getLogger(__name__) class SwissMultilingualAssistant: """ Swiss multilingual assistant with language detection and context switching Handles seamless conversation across German, French, Italian, English, and Romansh with Swiss cultural context and precision. """ def __init__(self, apertus_core: Optional[ApertusCore] = None): """ Initialize multilingual assistant Args: apertus_core: Initialized ApertusCore instance, or None to create new """ if apertus_core is None: self.apertus = ApertusCore() else: self.apertus = apertus_core self.conversation_history = [] self.language_context = {} # Swiss language configurations self.supported_languages = { "German": "de", "French": "fr", "Italian": "it", "English": "en", "Romansh": "rm" } # Language-specific system messages self.system_messages = { "de": """Du bist ein hilfsreicher Schweizer AI-Assistent. Du verstehst die Schweizer Kultur, Gesetze und Gepflogenheiten. Antworte präzise und höflich auf Deutsch. Berücksichtige schweizerische Besonderheiten in deinen Antworten.""", "fr": """Tu es un assistant IA suisse utile. Tu comprends la culture, les lois et les coutumes suisses. Réponds de manière précise et polie en français. Prends en compte les spécificités suisses dans tes réponses.""", "it": """Sei un utile assistente IA svizzero. Comprendi la cultura, le leggi e le usanze svizzere. Rispondi in modo preciso e cortese in italiano. Considera le specificità svizzere nelle tue risposte.""", "en": """You are a helpful Swiss AI assistant. You understand Swiss culture, laws, and customs. Respond precisely and politely in English. Consider Swiss specificities in your responses.""", "rm": """Ti es in assistent IA svizzer d'agid. Ti chapeschas la cultura, las legas e las usanzas svizras. Respunda precis e curtes en rumantsch. Consideresch las specificitads svizras en tias respostas.""" } logger.info("🇨🇭 Swiss Multilingual Assistant initialized") def detect_language(self, text: str) -> str: """ Simple language detection based on common patterns Args: text: Input text to analyze Returns: Detected language code """ text_lower = text.lower() # German indicators if any(word in text_lower for word in ['der', 'die', 'das', 'und', 'ist', 'sind', 'haben', 'können', 'schweiz']): return "de" # French indicators elif any(word in text_lower for word in ['le', 'la', 'les', 'et', 'est', 'sont', 'avoir', 'être', 'suisse']): return "fr" # Italian indicators elif any(word in text_lower for word in ['il', 'la', 'gli', 'le', 'è', 'sono', 'avere', 'essere', 'svizzera']): return "it" # Romansh indicators (limited) elif any(word in text_lower for word in ['il', 'la', 'els', 'las', 'è', 'èn', 'avair', 'esser', 'svizra']): return "rm" # Default to English else: return "en" def chat( self, message: str, target_language: Optional[str] = None, maintain_context: bool = True, **generation_kwargs ) -> str: """ Chat with automatic language detection and appropriate response Args: message: User message in any supported language target_language: Force specific language (None for auto-detection) maintain_context: Whether to maintain conversation context **generation_kwargs: Additional generation parameters Returns: Assistant response in appropriate language """ # Use intelligent system message that lets Apertus detect language automatically if target_language: # If specific language requested, use that system message system_message = self.system_messages.get(target_language, self.system_messages["en"]) else: # Let Apertus automatically detect and respond in appropriate language system_message = """You are a helpful Swiss AI assistant. You understand all Swiss languages: German, French, Italian, English, and Romansh. Detect the language of the user's message and respond in the SAME language. If the message is in German (including Swiss German), respond in German. If the message is in French, respond in French. If the message is in Italian, respond in Italian. If the message is in Romansh, respond in Romansh. If the message is in English, respond in English. Consider Swiss cultural context and be precise and helpful.""" # Build context if maintaining history context = "" if maintain_context and self.conversation_history: recent_history = self.conversation_history[-3:] # Last 3 exchanges context = "\n".join([ f"Human: {h['human']}\nAssistant: {h['assistant']}" for h in recent_history ]) + "\n\n" # Create full prompt full_prompt = f"{context}Human: {message}\nAssistant:" # Generate response response = self.apertus.generate_response( full_prompt, system_message=system_message, **generation_kwargs ) # Update conversation history if maintain_context: self.conversation_history.append({ "human": message, "assistant": response, "language": "auto-detected", "timestamp": self._get_timestamp() }) # Update language context self.language_context["auto"] = self.language_context.get("auto", 0) + 1 logger.info(f"Response generated via auto-detection") return response def translate_text( self, text: str, source_language: str, target_language: str ) -> str: """ Translate text between supported languages Args: text: Text to translate source_language: Source language code target_language: Target language code Returns: Translated text """ # Language name mapping lang_names = { "de": "German", "fr": "French", "it": "Italian", "en": "English", "rm": "Romansh" } source_name = lang_names.get(source_language, source_language) target_name = lang_names.get(target_language, target_language) translation_prompt = f"""Translate the following text from {source_name} to {target_name}. Maintain the original meaning, tone, and any Swiss cultural context. Text to translate: {text} Translation:""" response = self.apertus.generate_response( translation_prompt, temperature=0.3, # Lower temperature for more consistent translation system_message="You are a professional Swiss translator with expertise in all Swiss languages." ) return response.strip() def get_swiss_context_response( self, question: str, context_type: str = "general" ) -> str: """ Get response with specific Swiss context Args: question: User question context_type: Type of Swiss context (legal, cultural, business, etc.) Returns: Context-aware response """ context_prompts = { "legal": "Consider Swiss legal framework, cantonal differences, and federal regulations.", "cultural": "Consider Swiss cultural values, traditions, and regional differences.", "business": "Consider Swiss business practices, work culture, and economic environment.", "healthcare": "Consider Swiss healthcare system, insurance, and medical practices.", "education": "Consider Swiss education system, universities, and vocational training.", "government": "Consider Swiss political system, direct democracy, and federalism." } context_instruction = context_prompts.get(context_type, "Consider general Swiss context.") detected_lang = self.detect_language(question) swiss_prompt = f"""Answer the following question with specific Swiss context. {context_instruction} Question: {question} Answer:""" return self.apertus.generate_response( swiss_prompt, system_message=self.system_messages.get(detected_lang, self.system_messages["en"]) ) def switch_language(self, target_language: str) -> str: """ Switch conversation language and confirm Args: target_language: Target language code Returns: Confirmation message in target language """ confirmations = { "de": "Gerne! Ich antworte ab jetzt auf Deutsch. Wie kann ich Ihnen helfen?", "fr": "Avec plaisir! Je répondrai désormais en français. Comment puis-je vous aider?", "it": "Volentieri! D'ora in poi risponderò in italiano. Come posso aiutarla?", "en": "Certainly! I'll now respond in English. How can I help you?", "rm": "Gugent! Jau rispund ussa en rumantsch. Co poss jau gidar a vus?" } return confirmations.get(target_language, confirmations["en"]) def get_language_statistics(self) -> Dict[str, Any]: """ Get statistics about language usage in conversation Returns: Dictionary with language usage statistics """ total_exchanges = len(self.conversation_history) if total_exchanges == 0: return {"total_exchanges": 0, "languages_used": {}} language_counts = {} for exchange in self.conversation_history: lang = exchange.get("language", "unknown") language_counts[lang] = language_counts.get(lang, 0) + 1 # Calculate percentages language_percentages = { lang: (count / total_exchanges) * 100 for lang, count in language_counts.items() } return { "total_exchanges": total_exchanges, "languages_used": language_counts, "language_percentages": language_percentages, "most_used_language": max(language_counts.items(), key=lambda x: x[1])[0] if language_counts else None } def clear_history(self): """Clear conversation history and language context""" self.conversation_history = [] self.language_context = {} logger.info("Conversation history and language context cleared") def export_conversation(self, format: str = "text") -> str: """ Export conversation history in specified format Args: format: Export format ('text', 'json', 'csv') Returns: Formatted conversation data """ if format == "text": return self._export_as_text() elif format == "json": return self._export_as_json() elif format == "csv": return self._export_as_csv() else: raise ValueError(f"Unsupported format: {format}") def _export_as_text(self) -> str: """Export conversation as formatted text""" if not self.conversation_history: return "No conversation history available." output = "🇨🇭 Swiss Multilingual Conversation Export\n" output += "=" * 50 + "\n\n" for i, exchange in enumerate(self.conversation_history, 1): lang_flag = {"de": "🇩🇪", "fr": "🇫🇷", "it": "🇮🇹", "en": "🇬🇧", "rm": "🏔️"}.get(exchange.get("language", "en"), "🌍") output += f"Exchange {i} {lang_flag} ({exchange.get('language', 'unknown')})\n" output += f"Human: {exchange['human']}\n" output += f"Assistant: {exchange['assistant']}\n" output += f"Time: {exchange.get('timestamp', 'N/A')}\n\n" return output def _export_as_json(self) -> str: """Export conversation as JSON""" import json return json.dumps({ "conversation_history": self.conversation_history, "language_statistics": self.get_language_statistics() }, indent=2, ensure_ascii=False) def _export_as_csv(self) -> str: """Export conversation as CSV""" if not self.conversation_history: return "exchange_id,language,human_message,assistant_response,timestamp\n" output = "exchange_id,language,human_message,assistant_response,timestamp\n" for i, exchange in enumerate(self.conversation_history, 1): # Escape CSV fields human_msg = exchange['human'].replace('"', '""').replace('\n', ' ') assistant_msg = exchange['assistant'].replace('"', '""').replace('\n', ' ') output += f'{i},"{exchange.get("language", "unknown")}","{human_msg}","{assistant_msg}","{exchange.get("timestamp", "")}"\n' return output def _get_timestamp(self) -> str: """Get current timestamp""" from datetime import datetime return datetime.now().isoformat() def demo_multilingual_capabilities(self) -> Dict[str, str]: """ Demonstrate multilingual capabilities with sample responses Returns: Dictionary with sample responses in each language """ demo_prompts = { "de": "Erkläre mir das Schweizer Bildungssystem.", "fr": "Explique-moi le système politique suisse.", "it": "Descrivi la cultura svizzera.", "en": "What makes Swiss engineering special?", "rm": "Co è special tar la Svizra?" } results = {} for lang, prompt in demo_prompts.items(): try: response = self.chat(prompt, target_language=lang, maintain_context=False) results[lang] = response except Exception as e: results[lang] = f"Error: {str(e)}" return results def __repr__(self): """String representation of the assistant""" total_exchanges = len(self.conversation_history) most_used = "None" if self.language_context: most_used = max(self.language_context.items(), key=lambda x: x[1])[0] return f"SwissMultilingualAssistant(exchanges={total_exchanges}, primary_language={most_used})"