Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,57 @@
+FROM python:3.11-slim
+
+# System dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ffmpeg \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Pre-download all models at build time using snapshot_download
+# HF_TOKEN must be set as a build secret or Space secret
+ARG HF_TOKEN
+ENV HF_TOKEN=${HF_TOKEN}
+
+RUN python - <<'EOF'
+import os
+from huggingface_hub import snapshot_download, login
+
+token = os.environ.get("HF_TOKEN", "")
+if token:
+    login(token=token)
+
+models = [
+    "drrobot9/wav2vec2-nigerian-language-identifier-v8",
+    "NCAIR1/Yoruba-ASR",
+    "NCAIR1/Igbo-ASR",
+    "NCAIR1/Hausa-ASR",
+    "NCAIR1/NigerianAccentedEnglish",
+    "NCAIR1/N-ATLaS",
+]
+
+for model_id in models:
+    print(f"Downloading {model_id}...")
+    snapshot_download(
+        repo_id=model_id,
+        token=token,
+        ignore_patterns=["*.msgpack", "*.h5", "flax_model*", "tf_model*",
+                         "rust_model*", "optimizer.pt", "rng_state*",
+                         "training_args.bin", "trainer_state.json",
+                         "scheduler.pt"],
+    )
+    print(f"  Done: {model_id}")
+
+print("All models downloaded.")
+EOF
+
+EXPOSE 7860
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

app/config.py

@@ -0,0 +1,37 @@
+import os
+from dataclasses import dataclass, field
+from typing import Dict
+
+
+@dataclass
+class ModelConfig:
+    
+    HF_TOKEN: str = field(default_factory=lambda: os.environ.get("HF_TOKEN", "HF_TOKEN"))
+
+    
+    LID_MODEL: str = "drrobot9/wav2vec2-nigerian-language-identifier-v8"
+
+   
+    ASR_MODELS: Dict[str, str] = field(default_factory=lambda: {
+        "yoruba":  "NCAIR1/Yoruba-ASR",
+        "igbo":    "NCAIR1/Igbo-ASR",
+        "hausa":   "NCAIR1/Hausa-ASR",
+        "english": "NCAIR1/NigerianAccentedEnglish",
+    })
+
+    # LLM
+    LLM_MODEL: str = "NCAIR1/N-ATLaS"
+
+    # Audio
+    SAMPLING_RATE: int = 16_000
+
+    # LLM generation
+    LLM_MAX_NEW_TOKENS:     int   = 1000
+    LLM_TEMPERATURE:        float = 0.1
+    LLM_REPETITION_PENALTY: float = 1.12
+
+    # Memory
+    MAX_HISTORY_TURNS: int = 10
+
+
+config = ModelConfig()

app/main.py

@@ -0,0 +1,133 @@
+import os
+from transformers import safetensors_conversion
+safetensors_conversion.auto_conversion = lambda *args, **kwargs: None
+
+os.environ["TRANSFORMERS_NO_ADVISORY_WARNINGS"] = "1"
+
+import uuid
+import base64
+from huggingface_hub import login, get_token
+from fastapi import FastAPI, UploadFile, File, Header, HTTPException
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+from typing import Optional
+
+# Authenticate
+hf_token = os.environ.get("HF_TOKEN") or get_token()
+if hf_token:
+    login(token=hf_token)
+else:
+    raise RuntimeError(
+        "No HuggingFace token found. "
+        "Set HF_TOKEN environment variable or run `huggingface-cli login`."
+    )
+
+from memory import get_history, append_turn, clear_session
+from stt_module.pipeline import stt_pipeline
+from text_module.router import prepare_user_message
+from llm.engine import llm_engine
+
+app = FastAPI(title="FarmLingua AI", version="1.0.0")
+
+
+# Helpers
+
+def resolve_uid(x_uid: Optional[str]) -> str:
+    return x_uid if x_uid else str(uuid.uuid4())
+
+
+def encode_header(value: str) -> str:
+    """Base64-encode header values that may contain non-latin-1 characters."""
+    return base64.b64encode(value.encode("utf-8")).decode("ascii")
+
+
+def stream_llm(uid: str, channel: str, user_message: str):
+    history = get_history(uid, channel)
+    append_turn(uid, channel, "user", user_message)
+
+    streamer      = llm_engine.stream(history, user_message)
+    full_response = []
+
+    for token in streamer:
+        full_response.append(token)
+        yield token
+
+    assistant_reply = "".join(full_response).strip()
+    append_turn(uid, channel, "assistant", assistant_reply)
+
+
+# Routes 
+
+@app.post("/stt/transcribe-and-chat")
+async def stt_transcribe_and_chat(
+    audio: UploadFile = File(...),
+    x_uid: Optional[str] = Header(default=None),
+):
+    uid         = resolve_uid(x_uid)
+    audio_bytes = await audio.read()
+
+    try:
+        stt_result = stt_pipeline.transcribe(audio_bytes)
+    except ValueError as e:
+        raise HTTPException(status_code=422, detail=str(e))
+
+    transcription = stt_result["transcription"]
+
+    headers = {
+        "X-UID":           uid,
+        "X-Transcription": encode_header(transcription),   # base64 — safe for latin-1
+        "X-Language":      stt_result["language"],
+        "X-Confidence":    str(stt_result["confidence"]),
+        "Access-Control-Expose-Headers": "X-UID, X-Transcription, X-Language, X-Confidence",
+    }
+
+    try:
+        return StreamingResponse(
+            stream_llm(uid, "stt", transcription),
+            media_type="text/plain",
+            headers=headers,
+        )
+    except RuntimeError as e:
+        raise HTTPException(status_code=503, detail=str(e))
+
+
+class TextRequest(BaseModel):
+    message: str
+
+
+@app.post("/text/chat")
+async def text_chat(
+    body: TextRequest,
+    x_uid: Optional[str] = Header(default=None),
+):
+    uid = resolve_uid(x_uid)
+
+    try:
+        user_message = prepare_user_message(body.message)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+    headers = {
+        "X-UID": uid,
+        "Access-Control-Expose-Headers": "X-UID",
+    }
+
+    try:
+        return StreamingResponse(
+            stream_llm(uid, "text", user_message),
+            media_type="text/plain",
+            headers=headers,
+        )
+    except RuntimeError as e:
+        raise HTTPException(status_code=503, detail=str(e))
+
+
+@app.delete("/session")
+async def clear_user_session(x_uid: str = Header(...)):
+    clear_session(x_uid)
+    return {"status": "cleared", "uid": x_uid}
+
+
+@app.get("/health")
+async def health():
+    return {"status": "ok"}

llm/engine.py

@@ -0,0 +1,83 @@
+import torch
+from datetime import datetime
+from threading import Thread
+from transformers import AutoTokenizer, AutoModelForCausalLM, TextIteratorStreamer
+from typing import List
+
+from app.config import config
+
+SYSTEM_PROMPT = (
+    "You are a helpful multilingual assistant supporting Yoruba, Igbo, Hausa, and English. "
+    "Respond clearly and directly. Do not repeat the user's question. "
+    "Do not include any prompt, preamble, or meta-commentary in your response. "
+    "You are called FarmLingua AI that is you name. "
+    "You are an agricultural expert on all kinds of farming. "
+    "You are here to help Nigerian farmers."
+    "so always tell the users after answering their questions that kawafarm LTD built you for farmers."
+    "make sure you answer the users questions very well ."
+)
+
+
+class LLMEngine:
+    def __init__(self):
+        token = config.HF_TOKEN or None
+
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            config.LLM_MODEL,
+            token=token,
+        )
+        self.model = AutoModelForCausalLM.from_pretrained(
+            config.LLM_MODEL,
+            dtype=torch.float16,
+            device_map="auto",
+            token=token,
+            # N-ATLaS ships sharded safetensors — do not set use_safetensors=False
+        )
+        self.model.eval()
+
+    def _build_messages(self, history: List[dict], user_message: str) -> List[dict]:
+        messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+        messages.extend(history)
+        messages.append({"role": "user", "content": user_message})
+        return messages
+
+    def _format_prompt(self, messages: List[dict]) -> str:
+        return self.tokenizer.apply_chat_template(
+            messages,
+            add_generation_prompt=True,
+            tokenize=False,
+            date_string=datetime.now().strftime("%d %b %Y"),
+        )
+
+    def stream(self, history: List[dict], user_message: str):
+        messages = self._build_messages(history, user_message)
+        prompt   = self._format_prompt(messages)
+
+        inputs = self.tokenizer(
+            prompt,
+            return_tensors="pt",
+            add_special_tokens=False,
+        ).to(self.model.device)
+
+        streamer = TextIteratorStreamer(
+            self.tokenizer,
+            skip_prompt=True,
+            skip_special_tokens=True,
+        )
+
+        generation_kwargs = dict(
+            **inputs,
+            streamer=streamer,
+            max_new_tokens=config.LLM_MAX_NEW_TOKENS,
+            temperature=config.LLM_TEMPERATURE,
+            repetition_penalty=config.LLM_REPETITION_PENALTY,
+            use_cache=True,
+            do_sample=True,
+        )
+
+        thread = Thread(target=self.model.generate, kwargs=generation_kwargs)
+        thread.start()
+        return streamer
+
+
+llm_engine = LLMEngine()

memory.py

@@ -0,0 +1,30 @@
+from collections import defaultdict
+from typing import Dict, List
+from app.config import config
+
+
+# In-memory store: { uid: { "stt": [...], "text": [...] } }
+_store: Dict[str, Dict[str, List[dict]]] = defaultdict(
+    lambda: {"stt": [], "text": []}
+)
+
+
+def get_history(uid: str, channel: str) -> List[dict]:
+    """Return conversation history for a user on a given channel (stt | text)."""
+    return _store[uid][channel]
+
+
+def append_turn(uid: str, channel: str, role: str, content: str) -> None:
+    """Append a single turn and enforce the history cap."""
+    history = _store[uid][channel]
+    history.append({"role": role, "content": content})
+
+    # Keep only the last N turns (each turn = 1 message, cap covers both roles)
+    max_messages = config.MAX_HISTORY_TURNS * 2
+    if len(history) > max_messages:
+        _store[uid][channel] = history[-max_messages:]
+
+
+def clear_session(uid: str) -> None:
+    """Clear all history for a user across both channels."""
+    _store.pop(uid, None)

requirements.txt

@@ -0,0 +1,12 @@
+fastapi
+uvicorn[standard]
+transformers
+torch
+torchaudio
+pydub
+accelerate
+soundfile
+python-multipart 
+huggingface-hub
+datasets
+numpy

stt_module/pipeline.py

@@ -0,0 +1,104 @@
+import io
+import numpy as np
+import torch
+from pydub import AudioSegment
+from transformers import (
+    pipeline,
+    WhisperProcessor,
+    WhisperForConditionalGeneration,
+)
+from typing import Tuple
+
+from app.config import config
+
+
+class WhisperASR:
+    """Explicit Whisper loader — avoids pipeline preprocessor num_frames bug."""
+
+    def __init__(self, model_id: str, token: str, device: torch.device):
+        self.processor = WhisperProcessor.from_pretrained(
+            model_id,
+            token=token,
+        )
+        self.model = WhisperForConditionalGeneration.from_pretrained(
+            model_id,
+            token=token,
+            use_safetensors=False,
+        ).to(device)
+        self.model.eval()
+        self.device = device
+
+    def transcribe(self, samples: np.ndarray, sampling_rate: int) -> str:
+        inputs = self.processor(
+            samples,
+            sampling_rate=sampling_rate,
+            return_tensors="pt",
+        ).to(self.device)
+
+        with torch.no_grad():
+            predicted_ids = self.model.generate(**inputs)
+
+        transcription = self.processor.batch_decode(
+            predicted_ids,
+            skip_special_tokens=True,
+        )
+        return transcription[0].strip()
+
+
+class STTPipeline:
+    def __init__(self):
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        token = config.HF_TOKEN or None
+
+        # Language identifier — wav2vec2, pipeline is fine here
+        self.lid = pipeline(
+            "audio-classification",
+            model=config.LID_MODEL,
+            device=0 if self.device.type == "cuda" else -1,
+            token=token,
+        )
+
+        # ASR models — explicit Whisper loader per language
+        self.asr: dict = {
+            lang: WhisperASR(model_id, token, self.device)
+            for lang, model_id in config.ASR_MODELS.items()
+        }
+
+    def decode_audio(self, audio_bytes: bytes) -> Tuple[np.ndarray, float]:
+        seg = AudioSegment.from_file(io.BytesIO(audio_bytes))
+        seg = seg.set_channels(1).set_frame_rate(config.SAMPLING_RATE)
+        samples = np.array(seg.get_array_of_samples()).astype(np.float32)
+        samples /= np.iinfo(seg.array_type).max
+        duration = len(seg) / 1000.0
+        return samples, duration
+
+    def classify_language(self, samples: np.ndarray) -> Tuple[str, float]:
+        result = self.lid(
+            {"array": samples, "sampling_rate": config.SAMPLING_RATE},
+            top_k=1,
+        )
+        label      = result[0]["label"].lower()
+        confidence = result[0]["score"]
+        return label, confidence
+
+    def transcribe(self, audio_bytes: bytes) -> dict:
+        samples, duration = self.decode_audio(audio_bytes)
+        language, confidence = self.classify_language(samples)
+
+        asr_model = self.asr.get(language)
+        if asr_model is None:
+            raise ValueError(
+                f"No ASR model available for detected language: '{language}'. "
+                f"Supported languages: {list(self.asr.keys())}"
+            )
+
+        transcription = asr_model.transcribe(samples, config.SAMPLING_RATE)
+        return {
+            "transcription": transcription,
+            "language":      language,
+            "confidence":    round(confidence, 4),
+            "duration_sec":  round(duration, 2),
+        }
+
+
+stt_pipeline = STTPipeline()

text_module/router.py

@@ -0,0 +1,6 @@
+
+def prepare_user_message(text: str) -> str:
+    text = text.strip()
+    if not text:
+        raise ValueError("User message cannot be empty.")
+    return text

wav2vec2-nigerian-lid-v2/config.json

@@ -0,0 +1,129 @@
+{
+  "activation_dropout": 0.0,
+  "adapter_attn_dim": null,
+  "adapter_kernel_size": 3,
+  "adapter_stride": 2,
+  "add_adapter": false,
+  "apply_spec_augment": true,
+  "architectures": [
+    "Wav2Vec2ForSequenceClassification"
+  ],
+  "attention_dropout": 0.1,
+  "bos_token_id": 1,
+  "classifier_proj_size": 256,
+  "codevector_dim": 768,
+  "contrastive_logits_temperature": 0.1,
+  "conv_bias": true,
+  "conv_dim": [
+    512,
+    512,
+    512,
+    512,
+    512,
+    512,
+    512
+  ],
+  "conv_kernel": [
+    10,
+    3,
+    3,
+    3,
+    3,
+    2,
+    2
+  ],
+  "conv_stride": [
+    5,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2
+  ],
+  "ctc_loss_reduction": "sum",
+  "ctc_zero_infinity": false,
+  "diversity_loss_weight": 0.1,
+  "do_stable_layer_norm": true,
+  "dtype": "float32",
+  "eos_token_id": 2,
+  "feat_extract_activation": "gelu",
+  "feat_extract_dropout": 0.0,
+  "feat_extract_norm": "layer",
+  "feat_proj_dropout": 0.1,
+  "feat_quantizer_dropout": 0.0,
+  "final_dropout": 0.0,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout": 0.1,
+  "hidden_size": 1024,
+  "id2label": {
+    "0": "hausa",
+    "1": "igbo",
+    "2": "yoruba",
+    "3": "english"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 4096,
+  "label2id": {
+    "english": 3,
+    "hausa": 0,
+    "igbo": 1,
+    "yoruba": 2
+  },
+  "layer_norm_eps": 1e-05,
+  "layerdrop": 0.1,
+  "mask_channel_length": 10,
+  "mask_channel_min_space": 1,
+  "mask_channel_other": 0.0,
+  "mask_channel_prob": 0.0,
+  "mask_channel_selection": "static",
+  "mask_feature_length": 10,
+  "mask_feature_min_masks": 0,
+  "mask_feature_prob": 0.0,
+  "mask_time_length": 10,
+  "mask_time_min_masks": 2,
+  "mask_time_min_space": 1,
+  "mask_time_other": 0.0,
+  "mask_time_prob": 0.075,
+  "mask_time_selection": "static",
+  "model_type": "wav2vec2",
+  "num_adapter_layers": 3,
+  "num_attention_heads": 16,
+  "num_codevector_groups": 2,
+  "num_codevectors_per_group": 320,
+  "num_conv_pos_embedding_groups": 16,
+  "num_conv_pos_embeddings": 128,
+  "num_feat_extract_layers": 7,
+  "num_hidden_layers": 24,
+  "num_negatives": 100,
+  "output_hidden_size": 1024,
+  "pad_token_id": 0,
+  "proj_codevector_dim": 768,
+  "tdnn_dilation": [
+    1,
+    2,
+    3,
+    1,
+    1
+  ],
+  "tdnn_dim": [
+    512,
+    512,
+    512,
+    512,
+    1500
+  ],
+  "tdnn_kernel": [
+    5,
+    3,
+    3,
+    1,
+    1
+  ],
+  "transformers_version": "5.0.0",
+  "use_cache": false,
+  "use_weighted_layer_sum": false,
+  "vocab_size": 32,
+  "xvector_output_dim": 512
+}