stt and ttt together commit

Dockerfile

@@ -1,5 +1,6 @@
 FROM python:3.11-slim
 
+# System dependencies
 RUN apt-get update && apt-get install -y --no-install-recommends \
     ffmpeg \
     git \
@@ -7,11 +8,50 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 
 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 ["python", "start.py"]
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

app/main.py

@@ -1,15 +1,18 @@
 import os
-import base64
-
 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, HTTPException
+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)
@@ -19,64 +22,74 @@ else:
         "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"
-)
+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:
-    return base64.b64encode(
-        value.encode("utf-8")
-    ).decode("ascii")
+    """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)
 
-def stream_llm(user_message: str):
-    streamer = llm_engine.stream(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(...)
+    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),
-        )
+        raise HTTPException(status_code=422, detail=str(e))
 
     transcription = stt_result["transcription"]
 
     headers = {
-        "X-Transcription": encode_header(transcription),
-        "X-Language": stt_result["language"],
-        "X-Confidence": str(stt_result["confidence"]),
-        "Access-Control-Expose-Headers":
-            "X-Transcription, X-Language, X-Confidence",
+        "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(transcription),
+            stream_llm(uid, "stt", transcription),
             media_type="text/plain",
             headers=headers,
         )
     except RuntimeError as e:
-        raise HTTPException(
-            status_code=503,
-            detail=str(e),
-        )
+        raise HTTPException(status_code=503, detail=str(e))
 
 
 class TextRequest(BaseModel):
@@ -84,29 +97,38 @@ class TextRequest(BaseModel):
 
 
 @app.post("/text/chat")
-async def text_chat(body: TextRequest):
+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),
-        )
+        raise HTTPException(status_code=400, detail=str(e))
+
+    headers = {
+        "X-UID": uid,
+        "Access-Control-Expose-Headers": "X-UID",
+    }
 
     try:
         return StreamingResponse(
-            stream_llm(user_message),
+            stream_llm(uid, "text", user_message),
             media_type="text/plain",
+            headers=headers,
         )
     except RuntimeError as e:
-        raise HTTPException(
-            status_code=503,
-            detail=str(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"
-    }
+    return {"status": "ok"}

llm/engine.py

@@ -1,79 +1,59 @@
 import torch
-
 from datetime import datetime
 from threading import Thread
-
-from transformers import (
-    AutoTokenizer,
-    AutoModelForCausalLM,
-    TextIteratorStreamer,
-)
+from transformers import AutoTokenizer, AutoModelForCausalLM, TextIteratorStreamer
+from typing import List
 
 from app.config import config
 
-
 SYSTEM_PROMPT = (
-    "You are FarmLingua AI, an agricultural expert developed by Kawafarm LTD for Nigerian "
-    "explain broadly in users language of question so they can understand"
-    "farmers. Answer only agriculture-related questions, including crops, livestock, "
-    "poultry, fisheries, soil, irrigation, fertilizers, pests, diseases, farm machinery, "
-    "and agribusiness. If a question is unrelated to agriculture, politely explain that "
-    "you specialize in farming and ask the user to ask an agriculture-related question. "
-    "Understand spelling mistakes and informal language automatically. Give practical, "
-    "answer igbo question when asked with igbo , yoruba when asked with yoruba,"
-    "hausa when asked with hausa and english when asked with english"
-    "accurate, and well-structured advice. Never invent facts. "
-    "after every answer you give tell the users FarmLingua AI was developed by Kawafarm LTD to support farmers."
+    "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."
+    "do not answer question on any other field if it not about farming , farm business."
+    "users might not complete a question always understand smartly the intent of the question and answer."
+    "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, user_message: str):
-
-        return [
-            {
-                "role": "system",
-                "content": SYSTEM_PROMPT,
-            },
-            {
-                "role": "user",
-                "content": user_message,
-            },
-        ]
-
-    def _format_prompt(self, messages):
+    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,
-            tokenize=False,
             add_generation_prompt=True,
+            tokenize=False,
             date_string=datetime.now().strftime("%d %b %Y"),
         )
 
-    def stream(self, user_message: str):
-
-        messages = self._build_messages(user_message)
-
-        prompt = self._format_prompt(messages)
+    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,
@@ -87,22 +67,18 @@ class LLMEngine:
             skip_special_tokens=True,
         )
 
-        generation_kwargs = {
+        generation_kwargs = dict(
             **inputs,
-            "streamer": streamer,
-            "max_new_tokens": config.LLM_MAX_NEW_TOKENS,
-            "temperature": config.LLM_TEMPERATURE,
-            "repetition_penalty": config.LLM_REPETITION_PENALTY,
-            "do_sample": True,
-            "use_cache": True,
-        }
-
-        Thread(
-            target=self.model.generate,
-            kwargs=generation_kwargs,
-            daemon=True,
-        ).start()
+            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