Added LLM Classifiers as an option and added session history

src/api/app.py

@@ -6,11 +6,10 @@ from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
 from src.intent_classifier.intent_classifier import IntentClassifier
-from src.language_detector.language_detector import LanguageDetector
-from src.emotion_classifier import EmotionClassifier
 from src.language_translator import Translator
 from src.ner_extractor import NERExtractor
 from src.utils import QueryOptimizer, Embedder
+from src import config
 
 from src.api.routes import chat, health
 
@@ -19,8 +18,10 @@ load_dotenv()
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     print("Loading NLP models into memory...")
-    app.state.lang_detector      = LanguageDetector()
-    app.state.emotion_classifier = EmotionClassifier()
+    print(f"  Emotion classifier backend  : {config.emotion_classifier_backend()}")
+    print(f"  Language classifier backend : {config.language_classifier_backend()}")
+    app.state.lang_detector      = config.build_language_detector()
+    app.state.emotion_classifier = config.build_emotion_classifier()
     app.state.intent_classifier  = IntentClassifier()
     app.state.translator         = Translator(groq_api_key=os.environ["GROQ_API_KEY"])
     app.state.ner_extractor      = NERExtractor()

src/api/routes/chat.py

@@ -16,8 +16,9 @@ from src.api.dependencies import (
 from src.pipeline.safety_checks import SafetyChecker
 from src.utils.conversation_manager import ConversationManager
 from src.utils.vector_db import VectorDBManager
+from src import config
 from functools import lru_cache
-
+from src.ner_extractor import NERResult
 router = APIRouter()
 
 # ── Tone map (mirrors orchestrator) ───────────────────────────────────────────
@@ -99,7 +100,11 @@ def get_safety_checker() -> SafetyChecker:
 
 @lru_cache(maxsize=1)
 def get_conversation_manager() -> ConversationManager:
-    return ConversationManager(max_turns=10)
+    return ConversationManager(
+        max_turns=10,
+        summarizer=config.build_memory_summarizer(),
+        memory_window=3,
+    )
 
 
 @lru_cache(maxsize=1)
@@ -445,7 +450,7 @@ async def process_chat_message(
     if detected_lang != "en":
         response = translator.to_lang(response, detected_lang)
 
-    ner = ner_result or {}
+    ner = ner_result.__dict__ if ner_result else {}
 
     import random
 

src/config.py

@@ -0,0 +1,79 @@
+"""
+src/config.py
+==============
+Central place to resolve runtime backend choices from environment variables.
+
+Both the FastAPI startup (src/api/app.py) and the legacy Orchestrator
+(src/pipeline/orchestrator.py) build their classifiers through the factory
+functions here, so a single env var flips the behaviour everywhere instead
+of being checked in two different places.
+
+Env vars
+--------
+EMOTION_CLASSIFIER_BACKEND    : "model" (default) | "llm"
+LANGUAGE_CLASSIFIER_BACKEND   : "model" (default) | "llm"
+MEMORY_SUMMARIZATION_ENABLED  : "true" (default) | "false"
+
+GROQ_API_KEY_EMOTION_CLASSIFIER  : key used when EMOTION_CLASSIFIER_BACKEND=llm
+GROQ_API_KEY_LANGUAGE_CLASSIFIER : key used when LANGUAGE_CLASSIFIER_BACKEND=llm
+GROQ_API_KEY_SUMMARIZER          : key used for conversation memory summarization
+"""
+
+from __future__ import annotations
+
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Every other module in this codebase hardcodes this model name for Groq
+# calls (translator, NER, intent classifier) — reuse it here for consistency.
+DEFAULT_GROQ_MODEL = "llama-3.3-70b-versatile"
+
+
+def _flag(name: str, default: bool) -> bool:
+    val = os.getenv(name)
+    if val is None:
+        return default
+    return val.strip().lower() not in ("0", "false", "no", "")
+
+
+def emotion_classifier_backend() -> str:
+    return os.getenv("EMOTION_CLASSIFIER_BACKEND", "model").strip().lower()
+
+
+def language_classifier_backend() -> str:
+    return os.getenv("LANGUAGE_CLASSIFIER_BACKEND", "model").strip().lower()
+
+
+def memory_summarization_enabled() -> bool:
+    return _flag("MEMORY_SUMMARIZATION_ENABLED", True)
+
+
+def build_emotion_classifier():
+    """Return an EmotionClassifier-compatible instance per EMOTION_CLASSIFIER_BACKEND."""
+    if emotion_classifier_backend() == "llm":
+        from src.emotion_classifier.llm_emotion_classifier import LLMEmotionClassifier
+        return LLMEmotionClassifier(api_key=os.getenv("GROQ_API_KEY_EMOTION_CLASSIFIER", ""))
+
+    from src.emotion_classifier.emotion_classifier import EmotionClassifier
+    return EmotionClassifier()
+
+
+def build_language_detector():
+    """Return a LanguageDetector-compatible instance per LANGUAGE_CLASSIFIER_BACKEND."""
+    if language_classifier_backend() == "llm":
+        from src.language_detector.llm_language_detector import LLMLanguageDetector
+        return LLMLanguageDetector(api_key=os.getenv("GROQ_API_KEY_LANGUAGE_CLASSIFIER", ""))
+
+    from src.language_detector.language_detector import LanguageDetector
+    return LanguageDetector()
+
+
+def build_memory_summarizer():
+    """Return a MemorySummarizer instance, or None if summarization is disabled."""
+    if not memory_summarization_enabled():
+        return None
+
+    from src.utils.memory_summarizer import MemorySummarizer
+    return MemorySummarizer(api_key=os.getenv("GROQ_API_KEY_SUMMARIZER", ""))

src/emotion_classifier/__init__.py

@@ -2,6 +2,7 @@
 
 from .data_processor import load_tokenizer, save_tokenizer, get_dataloaders, load_data
 from .emotion_classifier import EmotionClassifier
+from .llm_emotion_classifier import LLMEmotionClassifier
 from .train import train, train_one_epoch, evaluate_one_epoch
 from .evaluate import evaluate  
 from .model import EmotionClassifierModel

src/emotion_classifier/llm_emotion_classifier.py

@@ -0,0 +1,132 @@
+"""
+src/emotion_classifier/llm_emotion_classifier.py
+===================================================
+LLM-backed drop-in replacement for EmotionClassifier (the trained BiLSTM
+model). Same public contract — classify(text) / predict(text) — so it can
+be swapped in via EMOTION_CLASSIFIER_BACKEND=llm without touching callers.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+# Mirrors EMOTION_LABELS in emotion_classifier.py — duplicated (not imported)
+# so picking the "llm" backend doesn't force-load torch/transformers.
+EMOTION_LABELS = ["sadness", "joy", "love", "anger", "fear", "surprise"]
+
+_EMOTION_PROMPT = """You are an emotion classifier for a mental health support chatbot.
+Classify the dominant emotion expressed in the user's message.
+
+Return ONLY valid JSON, no explanation, no markdown, exactly this schema:
+{{"emotion": "one of: sadness, joy, love, anger, fear, surprise", "confidence": 0.0 to 1.0}}
+
+User message: "{text}"
+JSON:"""
+
+
+class LLMEmotionClassifier:
+    """
+    Zero-shot emotion classification via Groq LLM.
+
+    Parameters
+    ----------
+    api_key : Groq API key (defaults to GROQ_API_KEY_EMOTION_CLASSIFIER env var,
+              falling back to GROQ_API_KEY if unset).
+    model   : Groq model name.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        model: str = "llama-3.3-70b-versatile",
+        timeout: float = 8.0,
+    ) -> None:
+        self._api_key = (
+            api_key
+            or os.getenv("GROQ_API_KEY_EMOTION_CLASSIFIER", "")
+            or os.getenv("GROQ_API_KEY", "")
+        )
+        self._model = model
+        self._timeout = timeout
+        self._client = None
+
+    def _get_client(self):
+        if self._client is None:
+            from groq import Groq
+            self._client = Groq(api_key=self._api_key, timeout=self._timeout)
+        return self._client
+
+    def _classify_via_llm(self, text: str) -> dict:
+        prompt = _EMOTION_PROMPT.format(text=text)
+        resp = self._get_client().chat.completions.create(
+            model=self._model,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=50,
+            temperature=0.0,
+        )
+        raw = resp.choices[0].message.content or "{}"
+        raw = re.sub(r"^```(?:json)?\s*|\s*```$", "", raw.strip())
+        data = json.loads(raw)
+
+        emotion = str(data.get("emotion", "")).strip().lower()
+        if emotion not in EMOTION_LABELS:
+            emotion = "unknown"
+
+        try:
+            confidence = max(0.0, min(1.0, float(data.get("confidence", 0.0))))
+        except (TypeError, ValueError):
+            confidence = 0.0
+
+        all_scores = {lbl: 0.0 for lbl in EMOTION_LABELS}
+        if emotion in all_scores:
+            all_scores[emotion] = confidence
+
+        return {
+            "emotion": emotion,
+            "confidence": confidence,
+            "all_scores": dict(sorted(all_scores.items(), key=lambda x: -x[1])),
+        }
+
+    # ── Public API ────────────────────────────────────────────────────────────
+
+    def classify(self, text: str) -> dict:
+        """
+        Classify a single text.
+
+        Returns
+        -------
+        {"emotion": "sadness", "confidence": 0.87, "all_scores": {...}}
+        """
+        if not isinstance(text, str) or not text.strip():
+            return {"emotion": "unknown", "confidence": 0.0, "all_scores": {}}
+
+        if not self._api_key:
+            logger.warning("LLMEmotionClassifier: no API key set — returning unknown")
+            return {"emotion": "unknown", "confidence": 0.0, "all_scores": {}}
+
+        try:
+            return self._classify_via_llm(text)
+        except Exception as exc:
+            logger.warning(f"LLMEmotionClassifier failed: {exc}")
+            return {"emotion": "unknown", "confidence": 0.0, "all_scores": {}}
+
+    def predict(self, text: str) -> dict:
+        """Alias to keep consistent with the FastAPI endpoint expectations."""
+        return self.classify(text)
+
+    def classify_batch(self, texts: list[str]) -> list[dict]:
+        return [self.classify(t) for t in texts]
+
+    @property
+    def labels(self) -> list[str]:
+        return EMOTION_LABELS
+
+    def __repr__(self) -> str:
+        mode = "ready" if self._api_key else "no-api-key"
+        return f"LLMEmotionClassifier(model='{self._model}', status={mode})"

src/language_detector/__init__.py

@@ -1 +1,2 @@
-from .language_detector import LanguageDetector
+from .language_detector import LanguageDetector
+from .llm_language_detector import LLMLanguageDetector

src/language_detector/llm_language_detector.py

@@ -0,0 +1,121 @@
+"""
+src/language_detector/llm_language_detector.py
+=================================================
+LLM-backed drop-in replacement for LanguageDetector (the TF-IDF + LR model).
+Same public contract — detect(text) — so it can be swapped in via
+LANGUAGE_CLASSIFIER_BACKEND=llm without touching callers.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+_ISO_CODE_RE = re.compile(r"^[a-z]{2}$")
+
+_LANGUAGE_PROMPT = """You are a language identification engine.
+Identify the ISO 639-1 language code (e.g. "en", "es", "ar", "fr", "zh") of the
+user's message.
+
+Return ONLY valid JSON, no explanation, no markdown, exactly this schema:
+{{"language": "two-letter ISO 639-1 code, lowercase", "confidence": 0.0 to 1.0}}
+
+Message: "{text}"
+JSON:"""
+
+
+class LLMLanguageDetector:
+    """
+    Zero-shot language detection via Groq LLM.
+
+    Parameters
+    ----------
+    api_key : Groq API key (defaults to GROQ_API_KEY_LANGUAGE_CLASSIFIER env var,
+              falling back to GROQ_API_KEY if unset).
+    model   : Groq model name.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        model: str = "llama-3.3-70b-versatile",
+        timeout: float = 8.0,
+    ) -> None:
+        self._api_key = (
+            api_key
+            or os.getenv("GROQ_API_KEY_LANGUAGE_CLASSIFIER", "")
+            or os.getenv("GROQ_API_KEY", "")
+        )
+        self._model = model
+        self._timeout = timeout
+        self._client = None
+
+    def _get_client(self):
+        if self._client is None:
+            from groq import Groq
+            self._client = Groq(api_key=self._api_key, timeout=self._timeout)
+        return self._client
+
+    def _detect_via_llm(self, text: str) -> dict[str, Any]:
+        prompt = _LANGUAGE_PROMPT.format(text=text)
+        resp = self._get_client().chat.completions.create(
+            model=self._model,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=30,
+            temperature=0.0,
+        )
+        raw = resp.choices[0].message.content or "{}"
+        raw = re.sub(r"^```(?:json)?\s*|\s*```$", "", raw.strip())
+        data = json.loads(raw)
+
+        lang = str(data.get("language", "")).strip().lower()
+        if not _ISO_CODE_RE.match(lang):
+            lang = "en"
+
+        try:
+            confidence = max(0.0, min(1.0, float(data.get("confidence", 0.0))))
+        except (TypeError, ValueError):
+            confidence = 0.0
+
+        return {
+            "language": lang,
+            "confidence": confidence,
+            "method": "llm",
+            "all_scores": None,
+        }
+
+    # ── Public API ────────────────────────────────────────────────────────────
+
+    def detect(self, text: str) -> dict[str, Any]:
+        """
+        Detect the language of *text*.
+
+        Returns
+        -------
+        {"language": "en", "confidence": 0.95, "method": "llm", "all_scores": None}
+        """
+        text = (text or "").strip()
+        if not text:
+            return {"language": "en", "confidence": 0.0, "method": "llm_empty", "all_scores": None}
+
+        if not self._api_key:
+            logger.warning("LLMLanguageDetector: no API key set — defaulting to 'en'")
+            return {"language": "en", "confidence": 0.0, "method": "llm_no_key", "all_scores": None}
+
+        try:
+            return self._detect_via_llm(text)
+        except Exception as exc:
+            logger.warning(f"LLMLanguageDetector failed: {exc}")
+            return {"language": "en", "confidence": 0.0, "method": "llm_error_fallback", "all_scores": None}
+
+    def detect_batch(self, texts: "list[str]") -> "list[dict[str, Any]]":
+        return [self.detect(t) for t in texts]
+
+    def __repr__(self) -> str:
+        mode = "ready" if self._api_key else "no-api-key"
+        return f"LLMLanguageDetector(model='{self._model}', status={mode})"

src/ner_extractor/__init__.py

@@ -1 +1 @@
-from .ner_extractor import NERExtractor
+from .ner_extractor import NERExtractor, NERResult

src/ner_extractor/ner_extractor.py

@@ -22,11 +22,21 @@ Usage
 
 from __future__ import annotations
 import json, logging, os, re
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Optional
 
 logger = logging.getLogger(__name__)
 
+
+@dataclass
+class NERResult:
+    """Structured view of an extract() dict, for callers that prefer attribute access."""
+    symptoms: list[str] = field(default_factory=list)
+    triggers: list[str] = field(default_factory=list)
+    duration: Optional[str] = None
+    severity: str = "medium"
+
 # ── Mental health vocabulary for regex fallback ───────────────────────────────
 _SYMPTOMS = [
     "anxiety","anxious","depression","depressed","stress","stressed","panic",

src/pipeline/orchestrator.py

@@ -133,8 +133,13 @@ class Orchestrator:
         self._hybrid_search = None
         self._hybrid_chunks = None
 
+        from src import config
         from src.utils.conversation_manager import ConversationManager
-        self.conversation = ConversationManager(max_turns=10)
+        self.conversation = ConversationManager(
+            max_turns=10,
+            summarizer=config.build_memory_summarizer(),
+            memory_window=3,
+        )
 
         self._greeting_idx = 0
 
@@ -142,14 +147,14 @@ class Orchestrator:
 
     def _get_lang_detector(self):
         if self._lang_detector is None:
-            from src.language_detector import LanguageDetector
-            self._lang_detector = LanguageDetector()
+            from src import config
+            self._lang_detector = config.build_language_detector()
         return self._lang_detector
 
     def _get_emotion_clf(self):
         if self._emotion_clf is None:
-            from src.emotion_classifier import EmotionClassifier
-            self._emotion_clf = EmotionClassifier()
+            from src import config
+            self._emotion_clf = config.build_emotion_classifier()
         return self._emotion_clf
 
     def _get_ner(self):

src/utils/__init__.py

@@ -1,3 +1,4 @@
 from .query_optimizer import QueryOptimizer
 from .embedder import Embedder
+from .memory_summarizer import MemorySummarizer
 #from .hybrid_search import HybridSearch

src/utils/conversation_manager.py

@@ -38,9 +38,19 @@ class ConversationManager:
     ----------
     max_turns : maximum turns to keep (older ones are dropped).
                 Keeps the system prompt lean for LLM calls.
+    summarizer : optional MemorySummarizer. When provided, the last
+                 `memory_window` turns are summarized via LLM after every
+                 assistant turn, and the result is folded into
+                 get_context_for_prompt().
+    memory_window : number of most recent turns to summarize (default 3).
     """
 
-    def __init__(self, max_turns: int = 10) -> None:
+    def __init__(
+        self,
+        max_turns: int = 10,
+        summarizer=None,
+        memory_window: int = 3,
+    ) -> None:
         self.max_turns   = max_turns
         self._turns:     list[Turn] = []
         # Accumulated clinical context — grows throughout the session
@@ -51,6 +61,10 @@ class ConversationManager:
         self._emotions:  list[str] = []
         self._turn_count = 0          # total including dropped turns
 
+        self._summarizer = summarizer
+        self._memory_window = memory_window
+        self._memory_summary = ""
+
     # ── Adding turns ─────────────────────────────────────────────────────────
 
     def add_turn(
@@ -113,6 +127,15 @@ class ConversationManager:
                 if s not in self._suggestions:
                     self._suggestions.append(s)
 
+        # Refresh the rolling LLM memory summary after each assistant turn
+        # (i.e. once a full user/assistant exchange has landed).
+        if role == "assistant" and self._summarizer is not None:
+            try:
+                recent = self.get_recent_history(self._memory_window)
+                self._memory_summary = self._summarizer.summarize(recent)
+            except Exception:
+                pass
+
     # ── Context retrieval ─────────────────────────────────────────────────────
 
     def get_context_for_prompt(self, max_chars: int = 600) -> str:
@@ -125,6 +148,8 @@ class ConversationManager:
             Topics discussed: sleep, panic attacks.
         """
         parts = []
+        if self._memory_summary:
+            parts.append(f"Recent conversation summary: {self._memory_summary}")
         if self._symptoms:
             parts.append(f"Symptoms mentioned: {', '.join(self._symptoms[:6])}")
         if self._triggers:
@@ -183,6 +208,10 @@ class ConversationManager:
             "narrative":           narrative,
         }
 
+    def get_memory_summary(self) -> str:
+        """Return the current rolling LLM summary of the last `memory_window` turns."""
+        return self._memory_summary
+
     def get_accumulated_context(self) -> dict:
         """Return raw accumulated context dict (used by orchestrator metadata)."""
         return {
@@ -199,7 +228,11 @@ class ConversationManager:
 
     def reset(self) -> None:
         """Clear the session (start fresh)."""
-        self.__init__(max_turns=self.max_turns)
+        self.__init__(
+            max_turns=self.max_turns,
+            summarizer=self._summarizer,
+            memory_window=self._memory_window,
+        )
 
     @property
     def turn_count(self) -> int:

src/utils/memory_summarizer.py

@@ -0,0 +1,104 @@
+"""
+src/utils/memory_summarizer.py
+=================================
+Summarizes the last few conversation turns into a short rolling memory
+note via Groq LLM, so ConversationManager can augment its session context
+with an abstractive summary instead of just accumulated keyword lists.
+
+Usage
+-----
+    from src.utils.memory_summarizer import MemorySummarizer
+    summarizer = MemorySummarizer()
+    summary = summarizer.summarize([
+        {"role": "user", "content": "I've been anxious about work"},
+        {"role": "assistant", "content": "That sounds difficult..."},
+        {"role": "user", "content": "It's mostly the deadlines"},
+    ])
+    # "User is anxious about work, mainly due to looming deadlines."
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+_SUMMARY_PROMPT = """Summarize the following snippet of a mental health support \
+conversation in ONE short sentence (max 30 words). Focus on what the user is \
+feeling and dealing with — no preamble, no quotes, just the sentence.
+
+{transcript}
+
+Summary:"""
+
+
+class MemorySummarizer:
+    """
+    Parameters
+    ----------
+    api_key : Groq API key (defaults to GROQ_API_KEY_SUMMARIZER env var,
+              falling back to GROQ_API_KEY if unset).
+    model   : Groq model name.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        model: str = "llama-3.3-70b-versatile",
+        timeout: float = 8.0,
+    ) -> None:
+        self._api_key = (
+            api_key
+            or os.getenv("GROQ_API_KEY_SUMMARIZER", "")
+            or os.getenv("GROQ_API_KEY", "")
+        )
+        self._model = model
+        self._timeout = timeout
+        self._client = None
+
+    def _get_client(self):
+        if self._client is None:
+            from groq import Groq
+            self._client = Groq(api_key=self._api_key, timeout=self._timeout)
+        return self._client
+
+    def _fallback(self, turns: list[dict]) -> str:
+        """Naive concatenation, used when no API key is set or the call fails."""
+        parts = [f"{t.get('role', '?')}: {t.get('content', '')}" for t in turns]
+        joined = " | ".join(parts)
+        return joined[:200]
+
+    def summarize(self, turns: list[dict]) -> str:
+        """
+        Summarize a small window of turns (each {"role": ..., "content": ...}).
+        Returns an empty string if turns is empty.
+        """
+        if not turns:
+            return ""
+
+        if not self._api_key:
+            return self._fallback(turns)
+
+        transcript = "\n".join(
+            f"{t.get('role', '?')}: {t.get('content', '')}" for t in turns
+        )
+        prompt = _SUMMARY_PROMPT.format(transcript=transcript)
+
+        try:
+            resp = self._get_client().chat.completions.create(
+                model=self._model,
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=60,
+                temperature=0.2,
+            )
+            summary = (resp.choices[0].message.content or "").strip()
+            return summary or self._fallback(turns)
+        except Exception as exc:
+            logger.warning(f"MemorySummarizer failed: {exc}")
+            return self._fallback(turns)
+
+    def __repr__(self) -> str:
+        mode = "llm" if self._api_key else "fallback"
+        return f"MemorySummarizer(model='{self._model}', mode={mode})"