Part 3 — Enterprise Application

Multilingual and Cross-Lingual Enterprise Use Cases

Translation is the wrong abstraction for enterprise AI. It is slow, expensive, and lossy — translating technical, legal, or financial text introduces errors that compound through downstream reasoning. More importantly, translation is a workaround for a fundamental limitation of token-level architectures: they cannot reason across languages natively. SONAR's shared concept space eliminates that limitation.

This chapter covers three enterprise patterns that exploit cross-lingual concept space natively: cross-lingual retrieval and comparison, multilingual synthesis, and language-agnostic classification. Each pattern reflects a real category of enterprise need that LLM stacks handle badly and SONAR-based LCM architectures handle correctly.

What You Will Learn

• Design and implement cross-lingual document retrieval and comparison without translation
• Build multilingual synthesis pipelines that aggregate across languages in concept space
• Implement language-agnostic classification using SONAR embeddings and concept clusters
• Select and validate SONAR language coverage for your specific enterprise language set
• Measure cross-lingual system quality using language-invariant evaluation metrics

10.1 Pattern 1: Cross-Lingual Retrieval and Comparison

The enterprise need. A global professional services firm has 200,000 client documents in 15 languages. An analyst working on a cross-border transaction needs to find all documents — regardless of language — that contain obligations equivalent to a specific clause in an English contract. Currently: send the clause to a multilingual team, wait 48 hours for translated search results, review manually.

The SONAR solution. Encode the query clause in English using SONAR. The resulting concept embedding sits in a shared semantic space that includes embeddings of French, German, Japanese, and Spanish documents. Retrieve the K most similar embeddings from the cross-lingual corpus. The retrieved documents contain semantically equivalent content regardless of their original language.

from sonar.inference_pipelines.text import TextToEmbeddingModelPipeline

encoder = TextToEmbeddingModelPipeline(
    encoder="text_sonar_basic_encoder",
    tokenizer="text_sonar_basic_encoder"
)

def cross_lingual_search(
    query: str,
    query_lang: str,
    corpus_index: VectorDatabase,
    top_k: int = 20,
    threshold: float = 0.80
) -> list[SearchResult]:
    """
    Search a multilingual corpus for content semantically equivalent to query.
    No translation required.
    """
    # Encode query in its original language
    query_embedding = encoder.predict([query], source_lang=query_lang)[0]

    # Retrieve from cross-lingual index
    results = corpus_index.search(
        vector=query_embedding.tolist(),
        limit=top_k,
        score_threshold=threshold
    )

    return [
        SearchResult(
            text=r.payload["text"],
            source_lang=r.payload["lang"],
            doc_id=r.payload["doc_id"],
            similarity=r.score
        )
        for r in results
    ]

# Example: Find equivalents to an English non-compete clause in a German corpus
results = cross_lingual_search(
    query="The employee agrees not to engage in competitive activities for 24 months following termination.",
    query_lang="eng_Latn",
    corpus_index=german_document_index,
    threshold=0.82
)
# Returns German clauses with semantically equivalent non-compete obligations
# without any translation step

Architecture considerations. The cross-lingual corpus index must be built with SONAR embeddings for all included languages — not with language-specific embedding models. A corpus built with multilingual BERT embeddings and then a SONAR query will not work: the query embedding and the corpus embeddings must live in the same SONAR concept space.

For language pairs where SONAR alignment is weaker (low-resource languages), add a confidence threshold that is language-pair-specific rather than universal. An 0.80 threshold appropriate for English-French retrieval may over-retrieve false positives for English-Indonesian retrieval, where SONAR alignment is less precise.

Comparison as an extension. Once retrieved, cross-lingual document comparison is a natural extension: for each retrieved result, compute the obligation-projection difference (from Chapter 9) to identify pairs that are semantically equivalent in topic but divergent in obligation direction. This catches cases where a French contract and a Japanese contract address the same topic but take opposite positions — without any translation.

10.2 Pattern 2: Multilingual Synthesis

The enterprise need. A multinational consumer goods company monitors competitor press releases, regulatory filings, and news coverage across 8 countries and 6 languages. The market intelligence team needs a weekly synthesis brief: what are competitors doing, in one language (English), aggregating from all source languages.

Currently: hire local analysts in each country, have them translate and summarize, synthesize the summaries manually. Latency: 5 business days. Cost: significant.

The SONAR solution. Encode all source documents (in all 6 languages) into concept space. The concept model reasons over the unified concept embedding corpus to identify themes, trends, and key events — in language-agnostic concept space. Decode the synthesis into English (or any other SONAR-supported language) using the concept decoder.

from lcm.inference import ConceptModel
from sonar.inference_pipelines.text import (
    TextToEmbeddingModelPipeline,
    EmbeddingToTextModelPipeline,
)

encoder = TextToEmbeddingModelPipeline(
    encoder="text_sonar_basic_encoder",
    tokenizer="text_sonar_basic_encoder"
)
concept_model = ConceptModel.from_pretrained("facebook/lcm-7b")
decoder = EmbeddingToTextModelPipeline(
    decoder="text_sonar_basic_decoder",
    tokenizer="text_sonar_basic_decoder"
)

def multilingual_synthesis(
    source_documents: list[tuple[str, str]],  # (text, language_code) pairs
    output_language: str = "eng_Latn",
    synthesis_prompt: str = "Summarize the key themes and events across all sources."
) -> str:
    """
    Synthesize content from multiple languages into a single output.
    """
    # Encode all source documents into concept space
    all_embeddings = []
    for doc_text, lang in source_documents:
        sentences = split_into_sentences(doc_text)
        embeddings = encoder.predict(sentences, source_lang=lang)
        all_embeddings.extend(embeddings)

    # Encode the synthesis prompt
    prompt_embedding = encoder.predict([synthesis_prompt], source_lang="eng_Latn")

    # Concept model reasons over all source embeddings + prompt
    output_embeddings = concept_model.generate(
        context_embeddings=all_embeddings,
        prompt_embeddings=prompt_embedding,
        max_output_length=50  # Number of output concept embeddings
    )

    # Decode into target language
    output_sentences = decoder.predict(
        output_embeddings,
        target_lang=output_language
    )

    return " ".join(output_sentences)

Quality considerations. Multilingual synthesis quality is limited by the weakest link in the SONAR language coverage chain. If the source document set includes languages with weak SONAR alignment, the synthesis will underrepresent content from those languages — not because it is excluded, but because its concept embeddings are less precisely placed in concept space.

Evaluate synthesis quality by comparing the system's output against a gold-standard synthesis produced by human multilingual analysts. Measure whether key themes from each source language are represented in the synthesis, weighted by the number of source documents in each language. If a language is systematically underrepresented, investigate SONAR alignment quality for that language on your domain vocabulary.

Output language as a business decision. The decoder parameter for output language is genuinely free — the concept model has no preference, and SONAR can decode into any supported language. For global organizations, this means the same synthesis pipeline can produce the weekly brief in English for the US team, French for the European team, and Japanese for the Asia-Pacific team, from the same concept embedding sequence. Localization becomes a rendering parameter, not a separate workflow.

10.3 Pattern 3: Language-Agnostic Classification

The enterprise need. A global financial services company processes 50,000 customer complaint documents per month, arriving in 12 languages. The compliance team needs each complaint classified into one of 15 regulatory categories to trigger the appropriate response workflow. Currently: route to language-specific teams who classify manually, then aggregate. Bottleneck: low-resource languages have insufficient specialist staff.

The SONAR solution. Encode all complaint documents into concept space. Encode the 15 category descriptions into concept space. Classify each complaint by finding the category whose concept embedding is most similar to the complaint's embedding. The classification operates in language-agnostic concept space — a complaint in Japanese about a billing dispute and a complaint in Portuguese about the same type of billing dispute will both be closest to the "billing and payment disputes" category embedding.

import numpy as np

# Category definitions in English (will be encoded into language-agnostic concept space)
REGULATORY_CATEGORIES = {
    "billing_disputes": "Complaints about incorrect charges, billing errors, unauthorized fees, or payment processing issues.",
    "account_access": "Complaints about inability to access accounts, locked accounts, or unauthorized account changes.",
    "product_terms": "Complaints about unexpected changes to product features, terms, conditions, or interest rates.",
    "data_privacy": "Complaints about unauthorized data sharing, privacy violations, or data breach concerns.",
    # ... 11 more categories
}

# Encode categories once, cache embeddings
category_embeddings = {
    name: encoder.predict([description], source_lang="eng_Latn")[0]
    for name, description in REGULATORY_CATEGORIES.items()
}

def classify_complaint(
    complaint_text: str,
    complaint_lang: str,
    top_k: int = 3
) -> list[tuple[str, float]]:
    """
    Classify a complaint into regulatory categories.
    Language-agnostic: works regardless of complaint language.
    """
    # Encode complaint
    complaint_embedding = encoder.predict(
        [complaint_text], source_lang=complaint_lang
    )[0]
    complaint_array = np.array(complaint_embedding)

    # Compute similarity to all categories
    scores = {}
    for category_name, cat_embedding in category_embeddings.items():
        cat_array = np.array(cat_embedding)
        similarity = np.dot(complaint_array, cat_array) / (
            np.linalg.norm(complaint_array) * np.linalg.norm(cat_array)
        )
        scores[category_name] = float(similarity)

    # Return top-k categories
    sorted_categories = sorted(scores.items(), key=lambda x: x[1], reverse=True)
    return sorted_categories[:top_k]

# Classify a Japanese complaint
result = classify_complaint(
    complaint_text="請求書に誤った手数料が記載されており、修正を求めています。",
    complaint_lang="jpn_Jpan"
)
# Returns: [("billing_disputes", 0.91), ("account_access", 0.63), ("product_terms", 0.58)]

Calibration and threshold setting. Zero-shot classification using concept-space similarity works well when the category descriptions are precisely written and the complaint domain is well-represented in SONAR's training data. For domains with specialized vocabulary, the zero-shot approach may underperform. Options:

1. Improve category descriptions. Write category descriptions that use vocabulary common in complaints rather than regulatory jargon. "Customers complain about incorrect charges, unexpected fees appearing on their statements" classifies better than "billing and payment processing disputes."

2. Few-shot calibration. For each category, encode 10-20 example complaints (in multiple languages) and use their centroid in concept space as the category prototype, rather than the category description embedding. The centroid is more representative of actual complaint language.

3. Confidence thresholds. Set a minimum similarity threshold below which the system routes to human review rather than auto-classifying. For regulatory compliance use cases, false classifications have real consequences — a threshold that routes 10% of complaints to human review is preferable to 100% auto-classification with a 5% error rate.

10.4 Language Coverage Validation for Enterprise Use

Before deploying any of these three patterns in production, validate SONAR language coverage for your specific language set and domain.

The validation protocol from Chapter 3 applies directly. For each language in your target set:

1. Collect 50-100 domain-specific sentence pairs (English + target language, semantically equivalent)
2. Encode both languages and compute cosine similarity
3. Measure separation from a set of semantically unrelated pairs
4. Set language-pair-specific thresholds based on the measured alignment quality

For multilingual enterprise deployments, produce a language coverage matrix: a table showing the validated alignment quality for each language pair in your use case. This matrix informs both the confidence thresholds for each pattern and the risk assessment for regulators or auditors who ask about system reliability across languages.

Summary

Three patterns exploit SONAR's cross-lingual concept space: cross-lingual retrieval (find semantically equivalent content across languages), multilingual synthesis (aggregate content from multiple languages into a single output), and language-agnostic classification (classify documents by semantic category regardless of language). Each pattern requires language-specific threshold calibration and domain validation.

• Translation is not required. SONAR's shared concept space makes translation a workaround for an architectural limitation that LCMs do not have.
• Three patterns, three enterprise needs. Retrieval, synthesis, and classification cover the three most common cross-lingual enterprise use cases.
• Language coverage validation is mandatory. SONAR alignment quality varies by language pair and domain. Validate before production deployment and document the results for governance.
• Output language is a rendering parameter. The same synthesis pipeline can produce output in any supported language. Localization becomes a decoder parameter.

Exercises