Multilingual Content

# Create environment
python3 -m venv venv && source venv/bin/activate

# Install packages
pip install praisonaiagents praisonai

# Set API key
export OPENAI_API_KEY="your-key"

# Create source content
cat > content.json << 'EOF'
[
  {"id": "MKT001", "type": "marketing", "text": "Unlock your potential with our revolutionary AI platform!", "tone": "enthusiastic"},
  {"id": "DOC001", "type": "documentation", "text": "To configure the API, set the environment variable.", "tone": "technical"},
  {"id": "SOC001", "type": "social", "text": "Check out our latest feature drop! 🚀", "tone": "casual"}
]
EOF

# Create cultural guidelines
cat > cultural_rules.json << 'EOF'
{
  "es": {"formality": "formal", "avoid": ["slang"], "adapt": ["idioms"]},
  "ja": {"formality": "very_formal", "avoid": ["emojis", "casual_tone"], "adapt": ["honorifics"]},
  "de": {"formality": "formal", "avoid": ["hyperbole"], "adapt": ["compound_words"]},
  "fr": {"formality": "formal", "avoid": ["anglicisms"], "adapt": ["idioms"]}
}
EOF

from praisonaiagents import Agent, Agents, Task, tool
from pydantic import BaseModel
from typing import List, Dict
import json

# Structured output
class LocalizedContent(BaseModel):
    content_id: str
    source_language: str
    target_language: str
    original_text: str
    translated_text: str
    cultural_adaptations: List[str]
    quality_score: int

# Database persistence is configured via memory={} parameter

# Tools
@tool
def get_content(content_id: str) -> str:
    """Get source content by ID."""
    with open("content.json") as f:
        contents = json.load(f)
    for c in contents:
        if c["id"] == content_id:
            return json.dumps(c)
    return json.dumps({"error": "Content not found"})

@tool
def get_cultural_rules(language_code: str) -> str:
    """Get cultural adaptation rules for a language."""
    with open("cultural_rules.json") as f:
        rules = json.load(f)
    return json.dumps(rules.get(language_code, {}))

@tool
def check_translation_quality(original: str, translated: str) -> str:
    """Check translation quality."""
    # Simple quality heuristics
    score = 100
    if len(translated) < len(original) * 0.5:
        score -= 30  # Too short
    if len(translated) > len(original) * 2:
        score -= 20  # Too long
    
    quality = "high" if score >= 80 else "medium" if score >= 60 else "low"
    return json.dumps({"score": score, "quality": quality})

# Agents
content_manager = Agent(
    name="ContentManager",
    instructions="Get source content. Use get_content tool.",
    tools=[get_content],
    memory={
        "db": "sqlite:///translations.db",
        "session_id": "multilingual"
    }
)

translator = Agent(
    name="Translator",
    instructions="""Translate content to target language.
    Maintain meaning and tone. Adapt idioms appropriately."""
)

cultural_adapter = Agent(
    name="CulturalAdapter",
    instructions="Apply cultural rules. Use get_cultural_rules tool.",
    tools=[get_cultural_rules]
)

quality_checker = Agent(
    name="QualityChecker",
    instructions="Check translation quality. Use check_translation_quality tool.",
    tools=[check_translation_quality]
)

# Tasks
get_task = Task(
    description="Get content: {content_id}",
    agent=content_manager,
    expected_output="Source content with metadata"
)

translate_task = Task(
    description="Translate to {target_language}",
    agent=translator,
    expected_output="Translated text"
)

adapt_task = Task(
    description="Apply cultural adaptations for target language",
    agent=cultural_adapter,
    expected_output="Culturally adapted content"
)

quality_task = Task(
    description="Check translation quality",
    agent=quality_checker,
    expected_output="Quality assessment",
    output_pydantic=LocalizedContent
)

# Run
agents = Agents(
    agents=[content_manager, translator, cultural_adapter, quality_checker],
    tasks=[get_task, translate_task, adapt_task, quality_task]
)
result = agents.start(content_id="MKT001", target_language="Japanese")
print(result)

# Translate single content
praisonai "Translate 'Hello World' to Spanish with cultural adaptation" --verbose

# With persistence
praisonai "Localize marketing content for Japanese market" --memory --user-id localization_team

# Batch translation
praisonai "Translate content.json to French, German, Spanish" --file content.json

framework: praisonai
topic: "multilingual content localization"
roles:
  translator:
    role: Professional Translator
    goal: Accurate translation preserving meaning
    backstory: Expert linguist with 10+ years experience
    tasks:
      translate:
        description: |
          Translate content:
          - Preserve original meaning
          - Maintain tone and style
          - Adapt idioms appropriately
        expected_output: Translated text
        
  cultural:
    role: Cultural Consultant
    goal: Ensure cultural appropriateness
    backstory: Expert in cross-cultural communication
    tasks:
      adapt:
        description: |
          Cultural adaptation:
          - Check formality level
          - Adapt cultural references
          - Remove inappropriate content
          - Localize examples
        expected_output: Culturally adapted content
        
  quality:
    role: Quality Reviewer
    goal: Ensure translation quality
    backstory: Expert at translation quality assurance
    tasks:
      review:
        description: |
          Quality check:
          - Accuracy score (0-100)
          - Fluency assessment
          - Cultural fit rating
          - Recommendations
        expected_output: Quality report with score

praisonai agents.yaml --verbose

# View translation history
praisonai --history 10 --user-id localization_team

# Check metrics
praisonai --metrics

# Export translations
praisonai --save translations_export

from praisonaiagents import Agent, tool
import json

@tool
def quick_translate(text: str, target_lang: str) -> str:
    """Quick translation with cultural notes."""
    # In production, this would call a translation API
    translations = {
        "es": {"hello": "hola", "goodbye": "adiós"},
        "fr": {"hello": "bonjour", "goodbye": "au revoir"},
        "de": {"hello": "hallo", "goodbye": "auf wiedersehen"},
        "ja": {"hello": "こんにちは", "goodbye": "さようなら"}
    }
    
    lang_dict = translations.get(target_lang, {})
    translated = text.lower()
    for en, local in lang_dict.items():
        translated = translated.replace(en, local)
    
    return json.dumps({"original": text, "translated": translated, "language": target_lang})

agent = Agent(
    name="TranslationAPI",
    instructions="Translate text to target language.",
    tools=[quick_translate]
)

agent.launch(path="/translate", port=8000)

curl -X POST http://localhost:8000/translate \
  -H "Content-Type: application/json" \
  -d '{"message": "Translate hello to Japanese"}'

rm -f translations.db content.json cultural_rules.json
deactivate