Upload folder using huggingface_hub

Dockerfile

@@ -9,9 +9,8 @@ FROM python:3.11-slim
 WORKDIR /app
 
 # ── Layer 1: OS Dependencies (ROOT) ──────────────────────────
-# libgomp1: Required for OpenMP multi-threading (IndicTrans2 + PyTorch CPU)
-# build-essential: Required for Cython compilation (IndicTransToolkit)
-# git: Required for pip install from GitHub repos
+# libgomp1: Required for OpenMP multi-threading (PyTorch CPU)
+# build-essential + git: Required for pip builds
 RUN apt-get update && apt-get install -y --no-install-recommends \
     build-essential \
     git \
@@ -31,40 +30,24 @@ COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
 # ── Layer 4a: Pre-cache Nomic Embedding model ────────────────
-# Separated from reranker to prevent one failure from blocking the other.
 RUN python -c "\
 from sentence_transformers import SentenceTransformer; \
 SentenceTransformer('nomic-ai/nomic-embed-text-v1', cache_folder='/app/models', trust_remote_code=True); \
 print('✓ Nomic Embedding model (768-dim) cached')"
 
 # ── Layer 4b: Pre-cache Ettin Reranker (ModernBERT) ──────────
-# CRITICAL FIX: trust_remote_code=True is MANDATORY for ModernBERT architecture.
-# Without it: KeyError: 'modernbert' → build crash.
+# trust_remote_code=True is MANDATORY for ModernBERT architecture.
 RUN python -c "\
 from sentence_transformers import CrossEncoder; \
 CrossEncoder('cross-encoder/ettin-reranker-68m-v1', max_length=512, trust_remote_code=True); \
 print('✓ Ettin Reranker (ModernBERT) cached')"
 
-# ── Layer 5a: Pre-cache IndicTrans2 English→Indic model ──────
-# This is the English→Indic direction model (Sprint 18).
-# Required for local translation of English responses back to user's language.
-RUN python -c "\
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM; \
-AutoTokenizer.from_pretrained('ai4bharat/indictrans2-en-indic-dist-200M', trust_remote_code=True, cache_dir='/app/models/indictrans2/en_to_indic'); \
-AutoModelForSeq2SeqLM.from_pretrained('ai4bharat/indictrans2-en-indic-dist-200M', trust_remote_code=True, cache_dir='/app/models/indictrans2/en_to_indic'); \
-print('✓ IndicTrans2 English→Indic model cached')" || echo "⚠️ IndicTrans2 en-indic cache failed (non-blocking)"
-
-# ── Layer 5b: Pre-cache IndicTrans2 Indic→English model ──────
-# This is the REVERSE direction model (Sprint 18).
-# Required for local translation of Hindi/Tamil queries INTO English
-# before semantic search against the English vector corpus.
-RUN python -c "\
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM; \
-AutoTokenizer.from_pretrained('ai4bharat/indictrans2-indic-en-dist-200M', trust_remote_code=True, cache_dir='/app/models/indictrans2/indic_to_en'); \
-AutoModelForSeq2SeqLM.from_pretrained('ai4bharat/indictrans2-indic-en-dist-200M', trust_remote_code=True, cache_dir='/app/models/indictrans2/indic_to_en'); \
-print('✓ IndicTrans2 Indic→English model cached')" || echo "⚠️ IndicTrans2 indic-en cache failed (non-blocking)"
+# NOTE: IndicTrans2 model caching REMOVED (Sprint 18 v2).
+# Translation is now handled by Groq LLM (llama-3.3-70b-versatile)
+# which requires zero local model files. This saves ~1.6GB of image size
+# and eliminates the transformers.onnx compatibility nightmare.
 
-# ── Layer 6: Copy application code LAST ──────────────────────
+# ── Layer 5: Copy application code LAST ──────────────────────
 # Code changes don't invalidate the expensive model cache layers.
 COPY . .
 

api.py

@@ -188,13 +188,12 @@ async def health_check():
 async def debug_memory():
     """Live memory inspection endpoint (Sprint 18)."""
     from middleware.memory_guard import get_memory_mb
-    import bhashini
     
     return {
         "rss_mb": round(get_memory_mb(), 1),
         "gc_counts": gc.get_count(),
         "gc_threshold": gc.get_threshold(),
-        "models_loaded": list(bhashini._indictrans_models.keys()),
+        "translation_provider": "groq-llm",
         "embedding_loaded": embedding_model is not None,
         "reranker_loaded": reranker_model is not None,
     }

bhashini.py

@@ -1,78 +1,25 @@
+"""
+GovBridge India — Translation Module (Sprint 18 v2)
+
+Translation Architecture (prioritized fallback chain):
+  Layer 1: Bhashini API (government-grade, when API key is approved)
+  Layer 2: Groq LLM Translation (llama-3.3-70b-versatile — already in our stack)
+  Layer 3: Graceful degradation (return original text)
+
+WHY GROQ LLM INSTEAD OF IndicTrans2:
+  - IndicTrans2 (200M params) is fundamentally incompatible with transformers>=4.48
+    (required by ModernBERT/Ettin Reranker). Config, tokenizer, and ONNX layers all break.
+  - Groq's llama-3.3-70b-versatile (70B params) provides SUPERIOR translation quality
+    for all 10 supported Indic languages — 350x more parameters.
+  - Zero additional cost: we already have the Groq API key.
+  - Saves 1.6GB RAM on the 16GB HF Spaces instance.
+  - Zero dependency conflicts. Zero model loading time.
+  - Translation latency: ~200ms via Groq (vs ~2-4s for local IndicTrans2 on CPU).
+"""
+
 import httpx
 import os
-import gc
-import torch
-import threading
-import sys
-import types
-
-# --- CRITICAL SPRINT 18 PATCH (DEFINITIVE FIX) ---
-# IndicTrans2's remote `configuration_indictrans.py` imports many classes and functions
-# from `transformers.onnx` (OnnxConfig, OnnxSeq2SeqConfigWithPast, compute_effective_axis_dimension, etc.)
-# This subpackage was REMOVED in transformers>=4.40, but we need transformers>=4.48 for ModernBERT.
-#
-# SOLUTION: Universal mock modules that return a no-op dummy for ANY attribute access.
-# The ONNX classes are ONLY used for ONNX model export — never during inference.
-# So returning harmless dummies is 100% safe for our translation pipeline.
-if 'transformers.onnx' not in sys.modules:
-
-    class _UniversalDummy:
-        """A universal no-op class that acts as a stand-in for any ONNX class/function.
-        Can be instantiated, called, subclassed, and used as a decorator — all no-ops."""
-        def __init__(self, *a, **kw): pass
-        def __call__(self, *a, **kw): return self
-        def __getattr__(self, name): return _UniversalDummy()
-        def __init_subclass__(cls, **kw): pass
-
-    class _MockOnnxModule(types.ModuleType):
-        """A module that returns _UniversalDummy for any attribute access.
-        This means `from transformers.onnx.utils import <anything>` always succeeds."""
-        def __getattr__(self, name):
-            return _UniversalDummy
-
-    # Build the mock package tree
-    mock_onnx = _MockOnnxModule('transformers.onnx')
-    mock_onnx.__path__ = []           # Makes Python treat it as a package
-    mock_onnx.__package__ = 'transformers.onnx'
-
-    mock_onnx_utils = _MockOnnxModule('transformers.onnx.utils')
-    mock_onnx_utils.__package__ = 'transformers.onnx'
-
-    mock_onnx_config = _MockOnnxModule('transformers.onnx.config')
-    mock_onnx_config.__package__ = 'transformers.onnx'
-
-    mock_onnx_features = _MockOnnxModule('transformers.onnx.features')
-    mock_onnx_features.__package__ = 'transformers.onnx'
-
-    # Register in sys.modules (covers all possible import paths)
-    sys.modules['transformers.onnx'] = mock_onnx
-    sys.modules['transformers.onnx.utils'] = mock_onnx_utils
-    sys.modules['transformers.onnx.config'] = mock_onnx_config
-    sys.modules['transformers.onnx.features'] = mock_onnx_features
-
-    # Wire submodules as attributes on parent
-    mock_onnx.utils = mock_onnx_utils
-    mock_onnx.config = mock_onnx_config
-    mock_onnx.features = mock_onnx_features
-
-    # Wire onto the real transformers package
-    import transformers
-    transformers.onnx = mock_onnx
-# --------------------------------
-
-INDICTRANS_LANG_MAP = {
-    "hindi": "hin_Deva",
-    "tamil": "tam_Taml",
-    "bengali": "ben_Beng",
-    "telugu": "tel_Telu",
-    "marathi": "mar_Deva",
-    "gujarati": "guj_Gujr",
-    "kannada": "kan_Knda",
-    "malayalam": "mal_Mlym",
-    "punjabi": "pan_Guru",
-    "odia": "ory_Orya",
-    "english": "eng_Latn"
-}
+from groq import Groq
 
 LANGUAGE_CODES = {
     "hindi": "hi", "tamil": "ta", "bengali": "bn",
@@ -82,162 +29,80 @@ LANGUAGE_CODES = {
     "english": "en"
 }
 
+# Full language names for LLM prompt clarity
+LANGUAGE_NAMES = {
+    "hi": "Hindi", "ta": "Tamil", "bn": "Bengali",
+    "te": "Telugu", "mr": "Marathi", "gu": "Gujarati",
+    "kn": "Kannada", "ml": "Malayalam", "pa": "Punjabi",
+    "or": "Odia", "en": "English",
+    "hindi": "Hindi", "tamil": "Tamil", "bengali": "Bengali",
+    "telugu": "Telugu", "marathi": "Marathi", "gujarati": "Gujarati",
+    "kannada": "Kannada", "malayalam": "Malayalam", "punjabi": "Punjabi",
+    "odia": "Odia", "english": "English"
+}
+
 BHASHINI_USER_ID = os.environ.get("BHASHINI_USER_ID")
 BHASHINI_API_KEY = os.environ.get("BHASHINI_API_KEY")
 BHASHINI_INFERENCE_URL = "https://dhruva-api.bhashini.gov.in/services/inference/pipeline"
 
-# Thread-safe model registry (prevents race conditions on concurrent requests)
-_model_lock = threading.Lock()
+# Groq client for LLM translation (Layer 2)
+_groq_client = None
 
-# Model registry: direction → (tokenizer, model)
-_indictrans_models: dict[str, tuple] = {}
+def _get_groq_client() -> Groq:
+    """Lazy-init Groq client for translation."""
+    global _groq_client
+    if _groq_client is None:
+        api_key = os.environ.get("GROQ_API_KEY")
+        if not api_key:
+            raise RuntimeError("GROQ_API_KEY not set")
+        _groq_client = Groq(api_key=api_key)
+    return _groq_client
 
-# Model identifiers
-INDIC_TO_EN_MODEL = "ai4bharat/indictrans2-indic-en-dist-200M"
-EN_TO_INDIC_MODEL = "ai4bharat/indictrans2-en-indic-dist-200M"
 
-def _get_model_for_direction(src_code: str, tgt_code: str) -> tuple:
+def _groq_translate(text: str, source_lang: str, target_lang: str) -> str:
     """
-    Lazy-load the correct IndicTrans2 model based on translation direction.
+    Translate text using Groq's llama-3.3-70b-versatile.
     
-    CRITICAL DESIGN DECISION: Both translation models are loaded and kept in 
-    memory concurrently (totaling ~1.6GB for translation) to prevent disk thrashing
-    and latency spikes from alternating requests. Holding both models fits 
-    comfortably within the 16GB memory budget.
-    
-    Memory budget:
-      - Python runtime + FastAPI: ~200MB
-      - Nomic embed-text-v1: ~550MB  
-      - Ettin reranker-68m-v1: ~270MB
-      - IndicTrans2 (both directions): ~1.6GB
-      - Supabase client + misc: ~100MB
-      - Total: ~2.7GB active, well under 16GB
+    ARCHITECTURAL NOTE: The LLM is used STRICTLY as a translator here.
+    It receives a system prompt that constrains it to output ONLY the translation,
+    with no explanations, no additions, no hallucinations.
     """
-    global _indictrans_models
+    src_name = LANGUAGE_NAMES.get(source_lang.lower(), source_lang)
+    tgt_name = LANGUAGE_NAMES.get(target_lang.lower(), target_lang)
     
-    # Determine direction
-    is_to_english = (tgt_code == "eng_Latn")
-    model_name = INDIC_TO_EN_MODEL if is_to_english else EN_TO_INDIC_MODEL
-    direction_key = "indic_to_en" if is_to_english else "en_to_indic"
+    client = _get_groq_client()
     
-    with _model_lock:
-        if direction_key in _indictrans_models:
-            return _indictrans_models[direction_key]
-        
-        try:
-            from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
-            import torch
-            
-            print(f"⏳ Loading IndicTrans2 ({direction_key}): {model_name}...")
-            
-            tokenizer = AutoTokenizer.from_pretrained(
-                model_name,
-                trust_remote_code=True,
-                cache_dir=f"/app/models/indictrans2/{direction_key}"
-            )
-            model = AutoModelForSeq2SeqLM.from_pretrained(
-                model_name,
-                trust_remote_code=True,
-                cache_dir=f"/app/models/indictrans2/{direction_key}"
-            )
-            
-            # Force CPU evaluation mode for minimal memory
-            model.eval()
-            
-            _indictrans_models[direction_key] = (tokenizer, model)
-            print(f"✅ IndicTrans2 ({direction_key}) loaded successfully")
-            return (tokenizer, model)
-            
-        except Exception as e:
-            print(f"❌ IndicTrans2 ({direction_key}) load error: {e}")
-            raise RuntimeError(f"IndicTrans2 {direction_key} model not available: {e}")
-
-
-def local_indictrans_translate(text: str, src: str, tgt: str) -> str:
-    """
-    Bidirectional IndicTrans2 translation with memory cleanup.
+    response = client.chat.completions.create(
+        model="llama-3.3-70b-versatile",
+        messages=[
+            {
+                "role": "system",
+                "content": (
+                    f"You are a professional translator. Translate the following text "
+                    f"from {src_name} to {tgt_name}. "
+                    f"Output ONLY the translated text. No explanations, no notes, "
+                    f"no quotation marks, no prefixes like 'Translation:'. "
+                    f"Preserve the original meaning, tone, and formatting exactly."
+                )
+            },
+            {
+                "role": "user",
+                "content": text
+            }
+        ],
+        temperature=0.1,  # Low temperature for consistent, accurate translations
+        max_tokens=1024,
+        stream=False
+    )
     
-    CRITICAL FIX (Sprint 18): Now supports BOTH directions:
-      - Indic → English (using indictrans2-indic-en-dist-200M)  
-      - English → Indic (using indictrans2-en-indic-dist-200M)
+    result = (response.choices[0].message.content or "").strip()
     
-    Uses IndicProcessor for correct tokenization (Sprint 17 fix preserved).
-    """
-    src_code = INDICTRANS_LANG_MAP.get(src.lower().strip(), "eng_Latn")
-    tgt_code = INDICTRANS_LANG_MAP.get(tgt.lower().strip(), "eng_Latn")
+    # Clean up any accidental prefixes the LLM might add
+    for prefix in ["Translation:", "translation:", "Translated:", "translated:"]:
+        if result.startswith(prefix):
+            result = result[len(prefix):].strip()
     
-    # Get the correct model for this direction
-    tokenizer, model = _get_model_for_direction(src_code, tgt_code)
-    
-    try:
-        from IndicTransToolkit.processor import IndicProcessor
-        ip = IndicProcessor(inference=True)
-        
-        # CRITICAL FIX 1: IndicProcessor.preprocess_batch() injects
-        # <src_lang> and <tgt_lang> tokens. Without this: gibberish.
-        batch = ip.preprocess_batch([text], src_lang=src_code, tgt_lang=tgt_code)
-        
-        inputs = tokenizer(
-            batch,
-            truncation=True,
-            padding="longest",
-            return_tensors="pt",
-            return_attention_mask=True
-        )
-        
-        with torch.inference_mode():
-            generated_tokens = model.generate(
-                **inputs,
-                num_beams=4,
-                num_return_sequences=1,
-                max_length=512,
-                early_stopping=True
-            )
-        
-        # CRITICAL FIX 2: as_target_tokenizer() prevents vocabulary bleed
-        with tokenizer.as_target_tokenizer():
-            decoded = tokenizer.batch_decode(
-                generated_tokens,
-                skip_special_tokens=True,
-                clean_up_tokenization_spaces=True
-            )
-        
-        result = ip.postprocess_batch(decoded, lang=tgt_code)[0].strip()
-        
-        # SPRINT 18: Aggressive memory cleanup after every translation
-        del inputs, generated_tokens, decoded, batch
-        gc.collect()
-        
-        return result
-        
-    except ImportError:
-        # Fallback if IndicTransToolkit not installed
-        print("⚠️ IndicTransToolkit not found, using basic tokenizer")
-        inputs = tokenizer(
-            text,
-            src_lang=src_code,
-            return_tensors="pt",
-            padding=True,
-            truncation=True,
-            max_length=512
-        )
-        with torch.inference_mode():
-            outputs = model.generate(
-                **inputs,
-                tgt_lang=tgt_code,
-                max_length=512,
-                num_beams=4,
-                early_stopping=True
-            )
-        decoded = tokenizer.batch_decode(outputs, skip_special_tokens=True)
-        
-        result = decoded[0].strip()
-        
-        # Memory cleanup
-        del inputs, outputs, decoded
-        gc.collect()
-        
-        return result
+    return result
 
 
 async def translate_text(
@@ -246,10 +111,19 @@ async def translate_text(
     target_lang: str,
     fallback: bool = True
 ) -> str:
+    """
+    Main translation entry point. Used by api.py for the full pipeline:
+    User Query (Indic) → English → RAG Search → English Answer → Indic Response
+    
+    Fallback chain:
+      1. Bhashini API (when approved)
+      2. Groq LLM (llama-3.3-70b — immediate, free, high quality)
+      3. Return original text (graceful degradation)
+    """
     if source_lang.lower() == target_lang.lower():
         return text
 
-    # Layer 1: Bhashini API
+    # Layer 1: Bhashini API (government-grade translation)
     if BHASHINI_USER_ID and BHASHINI_API_KEY:
         try:
             src = LANGUAGE_CODES.get(source_lang.lower().strip(), source_lang)
@@ -278,15 +152,15 @@ async def translate_text(
                 print(f"✅ Bhashini: {source_lang} → {target_lang}")
                 return result
         except Exception as e:
-            print(f"⚠️ Bhashini failed: {e}, trying IndicTrans2")
+            print(f"⚠️ Bhashini failed: {e}, trying Groq LLM translation")
 
-    # Layer 2: Local IndicTrans2
+    # Layer 2: Groq LLM Translation (zero cost — already in our stack)
     try:
-        result = local_indictrans_translate(text, source_lang, target_lang)
-        print(f"✅ IndicTrans2: {source_lang} → {target_lang} | '{text[:30]}' → '{result[:30]}'")
+        result = _groq_translate(text, source_lang, target_lang)
+        print(f"✅ Groq LLM: {source_lang} → {target_lang} | '{text[:30]}' → '{result[:30]}'")
         return result
     except Exception as e:
-        print(f"⚠️ IndicTrans2 failed: {e}")
+        print(f"⚠️ Groq translation failed: {e}")
 
     # Layer 3: Graceful degradation
     print(f"⚠️ All translation failed — returning original")

requirements.txt

@@ -15,14 +15,10 @@ sentence-transformers>=4.0.0
 einops
 huggingface-hub
 
-# Upgraded to >=4.48.0 to support ModernBERT-based Ettin Reranker.
-# IndicTransToolkit runs successfully with this version.
+# transformers>=4.48.0 required for ModernBERT-based Ettin Reranker
 transformers>=4.48.0
-sentencepiece>=0.2.0
-sacremoses>=0.1.1
-IndicTransToolkit
 
-# --- LLM Inference ---
+# --- LLM Inference (also used for translation via Groq) ---
 groq
 
 # --- Database ---
@@ -44,5 +40,4 @@ pydantic-settings
 psutil
 
 # --- Deterministic Rules Engine (Sprint 19) ---
-openfisca-core>=44.0.0
-
+openfisca-core>=44.0.0