Build a Multi-Language Translator App with Claude API

import anthropic
import json
from enum import Enum

client = anthropic.Anthropic()


class Domain(str, Enum):
    general = "general"
    legal = "legal"
    medical = "medical"
    technical = "technical"
    marketing = "marketing"
    customer_service = "customer_service"


class Formality(str, Enum):
    formal = "formal"
    neutral = "neutral"
    informal = "informal"


# ─── Tool Definitions ─────────────────────────────────────────────────────────

DETECT_LANGUAGE_TOOL = {
    "name": "detect_language",
    "description": "Detect the language of input text",
    "input_schema": {
        "type": "object",
        "properties": {
            "language_name": {"type": "string", "description": "Full language name, e.g. 'English', 'French'"},
            "language_code": {"type": "string", "description": "ISO 639-1 code, e.g. 'en', 'fr', 'de'"},
            "confidence": {"type": "number", "description": "Confidence score 0.0 to 1.0"},
            "script": {"type": "string", "description": "Writing script, e.g. 'Latin', 'Cyrillic', 'Arabic'"}
        },
        "required": ["language_name", "language_code", "confidence"]
    }
}

TRANSLATE_TOOL = {
    "name": "translate_text",
    "description": "Translate text from one language to another",
    "input_schema": {
        "type": "object",
        "properties": {
            "translated_text": {
                "type": "string",
                "description": "The translated text"
            },
            "source_language": {"type": "string", "description": "Detected or specified source language"},
            "target_language": {"type": "string", "description": "Target language"},
            "formality_applied": {
                "type": "string",
                "enum": ["formal", "neutral", "informal"],
                "description": "The formality register used in the translation"
            },
            "translation_notes": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Notes on translation decisions, cultural adaptations, or terms without direct equivalents"
            }
        },
        "required": ["translated_text", "source_language", "target_language", "formality_applied"]
    }
}

QUALITY_CHECK_TOOL = {
    "name": "quality_assessment",
    "description": "Assess the quality of a translation",
    "input_schema": {
        "type": "object",
        "properties": {
            "accuracy_score": {
                "type": "integer",
                "description": "Score 1-10: how accurately the meaning is preserved"
            },
            "fluency_score": {
                "type": "integer",
                "description": "Score 1-10: how natural the translation reads"
            },
            "formality_score": {
                "type": "integer",
                "description": "Score 1-10: how well formality level is maintained"
            },
            "issues": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Specific translation issues found, if any"
            },
            "overall_quality": {
                "type": "string",
                "enum": ["excellent", "good", "acceptable", "poor"],
                "description": "Overall translation quality assessment"
            }
        },
        "required": ["accuracy_score", "fluency_score", "formality_score", "overall_quality"]
    }
}


# ─── Core Functions ───────────────────────────────────────────────────────────

def detect_language(text: str) -> dict:
    """Detect the language of the input text."""
    response = client.messages.create(
        model="claude-haiku-4-5",  # Fast, cheap for detection
        max_tokens=256,
        tools=[DETECT_LANGUAGE_TOOL],
        tool_choice={"type": "tool", "name": "detect_language"},
        messages=[{"role": "user", "content": f"Detect the language of this text:\n\n{text[:500]}"}]
    )
    
    for block in response.content:
        if block.type == "tool_use":
            return block.input
    raise RuntimeError("Language detection failed")


def translate(
    text: str,
    target_language: str,
    source_language: str = "auto",
    domain: Domain = Domain.general,
    formality: Formality = Formality.neutral
) -> dict:
    """Translate text to the target language with domain and formality awareness."""
    
    domain_guidance = {
        Domain.legal: "Use precise legal terminology appropriate for the target jurisdiction. Maintain formal register. Do not paraphrase legal concepts.",
        Domain.medical: "Use accurate medical/clinical terminology. Maintain precision over readability for clinical content.",
        Domain.technical: "Use technical terminology accurately. Preserve product names, API names, and technical identifiers untranslated.",
        Domain.marketing: "Adapt cultural references and idiomatic expressions for the target culture. Prioritise emotional impact over literal accuracy.",
        Domain.customer_service: "Keep language clear, empathetic, and appropriate for customer communication.",
        Domain.general: "Balance accuracy and natural expression."
    }
    
    formality_guidance = {
        Formality.formal: "Use formal vocabulary and grammar throughout. In languages with formal pronouns (vous, Sie, usted), use the formal form.",
        Formality.neutral: "Use standard, professional language.",
        Formality.informal: "Use conversational language. In languages with informal pronouns (tu, du, tú), use the informal form."
    }
    
    source_note = f"Source language: {source_language}" if source_language != "auto" else "Auto-detect the source language."
    
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=4096,
        tools=[TRANSLATE_TOOL],
        tool_choice={"type": "tool", "name": "translate_text"},
        system=f"""You are a professional translator with expertise across multiple languages and domains.

Translation parameters:
- Target language: {target_language}
- Domain: {domain.value} — {domain_guidance[domain]}
- Formality: {formality.value} — {formality_guidance[formality]}
- {source_note}

Provide accurate, culturally appropriate translations. Note any translation decisions that deviate from literal meaning or terms without direct equivalents.""",
        messages=[{"role": "user", "content": f"Translate the following text:\n\n{text}"}]
    )
    
    for block in response.content:
        if block.type == "tool_use":
            return block.input
    raise RuntimeError("Translation failed")


def check_quality(
    original_text: str,
    translation: str,
    source_language: str,
    target_language: str
) -> dict:
    """
    Check translation quality via back-translation comparison.
    Translates the result back and compares with the original.
    """
    # Back-translate
    back_translation = translate(
        text=translation,
        target_language=source_language,
        source_language=target_language
    )
    
    back_translated_text = back_translation.get("translated_text", "")
    
    response = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=1024,
        tools=[QUALITY_CHECK_TOOL],
        tool_choice={"type": "tool", "name": "quality_assessment"},
        messages=[
            {
                "role": "user",
                "content": f"""Assess translation quality.

Original ({source_language}):
{original_text}

Translation ({target_language}):
{translation}

Back-translation to {source_language}:
{back_translated_text}

Compare the original with the back-translation to assess meaning preservation.
Also evaluate the direct translation for fluency."""
            }
        ]
    )
    
    for block in response.content:
        if block.type == "tool_use":
            result = block.input
            result["back_translation"] = back_translated_text
            return result
    raise RuntimeError("Quality check failed")

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional

app = FastAPI(title="AI Translator API", version="1.0")


class TranslationRequest(BaseModel):
    text: str
    target_language: str
    source_language: Optional[str] = "auto"
    domain: Optional[Domain] = Domain.general
    formality: Optional[Formality] = Formality.neutral
    quality_check: Optional[bool] = False


class TranslationResponse(BaseModel):
    original_text: str
    translated_text: str
    source_language: str
    target_language: str
    domain: str
    formality_applied: str
    translation_notes: list
    quality: Optional[dict] = None


@app.post("/translate", response_model=TranslationResponse)
async def translate_endpoint(request: TranslationRequest):
    """Translate text with optional quality checking."""
    
    if len(request.text) > 10000:
        raise HTTPException(status_code=400, detail="Text exceeds 10,000 character limit")
    
    # Detect source language if auto
    source_lang = request.source_language
    if source_lang == "auto":
        detection = detect_language(request.text)
        source_lang = detection["language_name"]
    
    # Translate
    translation_result = translate(
        text=request.text,
        target_language=request.target_language,
        source_language=source_lang,
        domain=request.domain,
        formality=request.formality
    )
    
    # Optional quality check
    quality_result = None
    if request.quality_check:
        quality_result = check_quality(
            original_text=request.text,
            translation=translation_result["translated_text"],
            source_language=source_lang,
            target_language=request.target_language
        )
    
    return TranslationResponse(
        original_text=request.text,
        translated_text=translation_result["translated_text"],
        source_language=source_lang,
        target_language=request.target_language,
        domain=request.domain.value,
        formality_applied=translation_result["formality_applied"],
        translation_notes=translation_result.get("translation_notes", []),
        quality=quality_result
    )


@app.post("/detect")
async def detect_endpoint(body: dict):
    """Detect the language of input text."""
    text = body.get("text", "")
    if not text:
        raise HTTPException(status_code=400, detail="text is required")
    return detect_language(text)


# Run with: uvicorn translator:app --reload