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 — technical, legal, and financial text accumulates errors through translation that compound in downstream reasoning. More fundamentally, translation is a workaround for a structural 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 directly: cross-lingual retrieval and comparison, multilingual synthesis, and language-agnostic classification.

10.1 Pattern 1: Cross-Lingual Retrieval and Comparison

The enterprise need. A global professional services firm has 200,000 client documents across 15 languages. An analyst working a cross-border transaction needs every document — regardless of language — that contains obligations equivalent to a specific clause in an English contract. Current workflow: send the clause to a multilingual team, wait 48 hours, review manually.

The SONAR solution. Encode the query clause in English. The resulting concept embedding sits in a shared semantic space that already contains 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 source 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 queried with a SONAR embedding will not work: the query and the corpus must live in the same SONAR concept space.

For language pairs where SONAR alignment is weaker — low-resource languages especially — use language-pair-specific confidence thresholds rather than a single universal one. An 0.80 threshold appropriate for English-French retrieval may produce false positives for English-Indonesian retrieval, where alignment is less precise.

Comparison as an extension. Once retrieved, cross-lingual document comparison follows naturally: for each retrieved result, compute the obligation-projection difference from Chapter 9 to identify pairs that are 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 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 in English, aggregating all source languages.

Current workflow: hire local analysts per country, translate and summarize, synthesize manually. Latency: 5 business days.

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 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. Synthesis quality is limited by the weakest link in SONAR's language coverage chain. If source documents include languages with poor SONAR alignment, those languages will be underrepresented in the synthesis — not excluded, but imprecisely placed in concept space.

Evaluate against a gold-standard synthesis produced by human multilingual analysts. Measure whether key themes from each source language appear in the output, weighted by document count per language. Systematic underrepresentation from a given language means investigating SONAR alignment quality for that language on your domain vocabulary.

Output language as a business decision. The decoder's target language is genuinely free — the concept model has no preference. The same concept embedding sequence can be decoded into English for the US team, French for the European team, and Japanese for the Asia-Pacific team. 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 across 12 languages. The compliance team needs each complaint classified into one of 15 regulatory categories to trigger the appropriate response workflow. Current bottleneck: low-resource languages have insufficient specialist staff, so complaints in those languages wait.

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 embedding is most similar to the complaint's embedding. A Japanese complaint about a billing dispute and a Portuguese complaint about the same issue will both land closest to the "billing and payment disputes" category — the classification operates in concept space, not in any particular language.

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 category descriptions are precisely written and the complaint domain is well-represented in SONAR's training data. Three options when it underperforms:

1. Improve category descriptions. Write descriptions using vocabulary common in actual 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 (across multiple languages) and use their centroid in concept space as the category prototype instead of the 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, false classifications carry real consequences. A system that auto-classifies 90% of complaints and routes 10% 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 measured alignment quality

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

SONAR alignment is not uniform. English-French and English-Spanish alignment is strong and well-documented on general domain text. English-Japanese and English-Mandarin alignment is good on general text and degrades on specialized terminology. Low-resource language pairs require empirical validation before production — do not assume alignment quality from language family membership alone.

Exercises