upload files

app/crisis_toolchain.py

@@ -0,0 +1,97 @@
+import uuid
+import logging
+import os
+import json
+import re
+import streamlit as st
+from langchain_openai import ChatOpenAI
+from langchain.prompts import PromptTemplate
+from app.models.emotion_detector.detector import detect_emotions
+
+logging.basicConfig(
+    filename="crisis_log.txt",
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - Session: %(session_id)s - %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S"
+)
+
+def get_session_id():
+    """Generate a unique session ID."""
+    return str(uuid.uuid4())
+
+def detect_crisis(transcript, emotions):
+    """Detect crisis risk based on transcript and emotions using LLM."""
+    session_id = st.session_state.get("session_id", get_session_id())
+    try:
+        api_key = st.session_state.get("openai_api_key") or os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError("No OpenAI API key found in st.session_state or environment")
+        
+        llm = ChatOpenAI(
+            model="gpt-4o",
+            temperature=0.3,
+            api_key=api_key
+        )
+        
+        prompt_template = PromptTemplate(
+            input_variables=["transcript", "emotions"],
+            template="""
+            You are a mental health crisis detection system. Analyze the following transcript and emotions to determine the crisis risk level (Low, Medium, High) and assign a score between 0.0 and 1.0.
+            
+            Transcript: {transcript}
+            Emotions: {emotions}
+            
+            Consider linguistic nuances, cultural context (Omani Arabic or English), and emotional intensity. Examples:
+            - High Risk: Explicit suicidal intent (e.g., "أفكر في الانتحار", "I want to end my life").
+            - Medium Risk: Expressions of sadness, hopelessness, or distress (e.g., "أنا حزين جدًا", "I feel hopeless").
+            - Low Risk: Neutral or positive statements (e.g., "أنا بخير", "I'm okay").
+            
+            Return a JSON object with "crisis_risk" (Low, Medium, High) and "score" (0.0 to 1.0).
+            """
+        )
+        
+        emotions_str = ", ".join([f"{e['label']}: {e['score']:.2f}" for e in emotions])
+        
+        prompt = prompt_template.format(transcript=transcript, emotions=emotions_str)
+        logging.info(f"Crisis detection prompt: {prompt}", extra={"session_id": session_id})
+        
+        response = llm.invoke(prompt)
+        logging.info(f"LLM response: {response.content}", extra={"session_id": session_id})
+        
+        response_text = re.sub(r'^```json\s*|\s*```$', '', response.content, flags=re.MULTILINE).strip()
+        logging.info(f"Cleaned LLM response: {response_text}", extra={"session_id": session_id})
+        
+        try:
+            result = json.loads(response_text)
+        except json.JSONDecodeError as e:
+            logging.error(f"Failed to parse LLM response: {response_text}, error: {str(e)}", extra={"session_id": session_id})
+            return "Unknown Risk", 0.0
+        
+        # Map abbreviated risk levels
+        risk_mapping = {
+            "Low": "Low Risk",
+            "Medium": "Medium Risk",
+            "High": "High Risk"
+        }
+        crisis_risk = risk_mapping.get(result.get("crisis_risk", "Unknown Risk"), "Unknown Risk")
+        score = float(result.get("score", 0.0))
+        
+        logging.info(f"Parsed crisis_risk: {crisis_risk}, score: {score:.2f}", extra={"session_id": session_id})
+        
+        # Adjust score based on emotions
+        for emotion in emotions:
+            if emotion['label'] in ['sadness', 'fear'] and emotion['score'] > 0.7:
+                score = min(score + 0.15, 1.0)
+            elif emotion['label'] == 'anger' and emotion['score'] > 0.7:
+                score = min(score + 0.1, 1.0)
+        
+        # Validate score
+        score = max(0.0, min(score, 1.0))
+        
+        logging.info(f"Crisis detection: {crisis_risk}, Score: {score:.2f}", extra={"session_id": session_id})
+        
+        return crisis_risk, score
+    
+    except Exception as e:
+        logging.error(f"Crisis detection failed: {str(e)}", extra={"session_id": session_id})
+        return "Unknown Risk", 0.0

app/intent_analysis.py

@@ -0,0 +1,73 @@
+import os
+import logging
+from langchain_openai import ChatOpenAI
+from langchain.prompts import PromptTemplate
+from app.models.emotion_detector.detector import load_emotion_classifier, detect_emotions
+
+logging.basicConfig(
+    filename="crisis_log.txt",
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - Session: %(session_id)s - %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S"
+)
+
+emotion_classifier = load_emotion_classifier()
+
+INTENT_MAPPING = {
+    "seeking_resources": "Looking for support or resources",
+    "venting_emotions": "Expressing feelings or stress",
+    "unknown": "Talking about daily life / feelings"
+}
+
+def analyze_intent(transcript, session_id="unknown"):
+    """Analyze emotions and intent in transcript using LLM."""
+    emotions = detect_emotions(transcript, emotion_classifier)
+    logging.info(f"Emotions detected: {emotions}", extra={"session_id": session_id})
+    
+    # LLM-based Intent Classification
+    try:
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError("No OpenAI API key found in environment")
+        
+        llm = ChatOpenAI(
+            model="gpt-4o",
+            temperature=0.3,
+            api_key=api_key
+        )
+        
+        prompt_template = PromptTemplate(
+            input_variables=["transcript"],
+            template="""
+            You are an intent classification system for a mental health voice bot. Analyze the following transcript to determine the user's intent. Choose one of the following intents:
+            - seeking_resources: User is looking for support, resources, or help (e.g., "I need a therapist in Muscat", "أحتاج معالج في مسقط").
+            - venting_emotions: User is expressing emotions like sadness, stress, or anxiety (e.g., "I'm so sad", "أنا حزين جدًا").
+            - unknown: User is talking about daily life or neutral topics (e.g., "Today was a good day", "اليوم كان جيدًا").
+            
+            Consider linguistic nuances and cultural context (Omani Arabic or English). Return only the intent name (seeking_resources, venting_emotions, or unknown).
+            
+            Transcript: {transcript}
+            """
+        )
+        
+        prompt = prompt_template.format(transcript=transcript)
+        logging.info(f"Intent classification prompt: {prompt}", extra={"session_id": session_id})
+        
+        response = llm.invoke(prompt)
+        intent = response.content.strip()
+        logging.info(f"LLM intent response: {intent}", extra={"session_id": session_id})
+        
+        # Validate intent
+        if intent not in INTENT_MAPPING:
+            logging.warning(f"Invalid intent '{intent}' detected, defaulting to 'unknown'", extra={"session_id": session_id})
+            intent = "unknown"
+        
+    except Exception as e:
+        logging.error(f"Intent classification failed: {str(e)}", extra={"session_id": session_id})
+        intent = "unknown"
+    
+    # Map to human-readable description
+    intent_description = INTENT_MAPPING.get(intent, INTENT_MAPPING["unknown"])
+    logging.info(f"Intent classified: {intent_description}", extra={"session_id": session_id})
+    
+    return emotions, intent_description

app/rag_layer.py

@@ -0,0 +1,94 @@
+import os
+import logging
+import streamlit as st
+from langchain_openai import OpenAIEmbeddings
+from langchain_chroma import Chroma
+from langchain_community.document_loaders import PyPDFLoader, TextLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain.schema import Document
+
+logging.basicConfig(
+    filename="crisis_log.txt",
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s"
+)
+
+# Suppress ChromaDB telemetry + non-critical logs
+logging.getLogger("chromadb").setLevel(logging.ERROR)
+
+KB_PATH = "data/kb/"
+CHROMA_PATH = "data/chroma_db"  # Persistent Chroma DB
+embeddings = OpenAIEmbeddings(api_key=os.getenv("OPENAI_API_KEY"))
+
+def load_documents():
+    """Load and split KB files, with error handling."""
+    docs = []
+    if not os.path.exists(KB_PATH):
+        logging.error(f"Knowledge base directory {KB_PATH} does not exist")
+        st.warning(f"Knowledge base directory {KB_PATH} not found. Using fallback document.")
+        return [Document(page_content="No knowledge base documents available.", metadata={"source": "fallback"})]
+    
+    for file in os.listdir(KB_PATH):
+        file_path = os.path.join(KB_PATH, file)
+        try:
+            if not os.path.isfile(file_path):
+                logging.warning(f"Skipping {file_path}: Not a file")
+                continue
+            if file.endswith(".pdf"):
+                loader = PyPDFLoader(file_path)
+                file_docs = loader.load()
+                docs.extend(file_docs)
+                logging.info(f"Loaded PDF: {file_path} with {len(file_docs)} pages")
+            elif file.endswith(".txt"):
+                loader = TextLoader(file_path)
+                file_docs = loader.load()
+                docs.extend(file_docs)
+                logging.info(f"Loaded text file: {file_path} with {len(file_docs)} chunks")
+        except Exception as e:
+            logging.error(f"Error loading {file_path}: {str(e)}")
+            st.warning(f"Failed to load {file_path}. Skipping.")
+    
+    if not docs:
+        logging.warning("No documents loaded from knowledge base")
+        st.warning("No valid documents found in knowledge base. Using fallback document.")
+        docs = [Document(page_content="No knowledge base documents available.", metadata={"source": "fallback"})]
+    
+    splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+    split_docs = splitter.split_documents(docs)
+    logging.info(f"Split {len(docs)} documents into {len(split_docs)} chunks")
+    return split_docs
+
+def setup_vectorstore(force_rebuild=False):
+    """Setup or load Chroma vectorstore."""
+    try:
+        if force_rebuild or not os.path.exists(CHROMA_PATH):
+            docs = load_documents()
+            if not docs:
+                raise ValueError("No documents available for vectorstore creation")
+            vectorstore = Chroma.from_documents(docs, embeddings, persist_directory=CHROMA_PATH)
+            vectorstore.persist()
+            logging.info(f"Created new vectorstore at {CHROMA_PATH} with {len(docs)} documents")
+        else:
+            vectorstore = Chroma(persist_directory=CHROMA_PATH, embedding_function=embeddings)
+            logging.info(f"Loaded existing vectorstore from {CHROMA_PATH}")
+        return vectorstore
+    except Exception as e:
+        logging.error(f"Error setting up vectorstore: {str(e)}")
+        st.error(f"Failed to initialize vectorstore: {str(e)}. App may have limited functionality.")
+        # Return a dummy vectorstore to prevent app crash
+        return Chroma.from_texts(
+            texts=["No knowledge base available"], 
+            embedding=embeddings, 
+            persist_directory=CHROMA_PATH
+        )
+
+def retrieve_context(query, k=3):
+    """Retrieve relevant chunks from KB."""
+    try:
+        retriever = st.session_state.vectorstore.as_retriever(search_kwargs={"k": k})
+        docs = retriever.get_relevant_documents(query)
+        return docs
+    except Exception as e:
+        logging.error(f"Error retrieving context: {str(e)}")
+        st.warning(f"Failed to retrieve context: {str(e)}. Using fallback response.")
+        return [Document(page_content="Unable to retrieve context.", metadata={"source": "error"})]

app/response_gen.py

@@ -0,0 +1,146 @@
+import json
+import os
+from typing import TypedDict
+from langchain_openai import ChatOpenAI
+from langchain_anthropic import ChatAnthropic
+from langchain.prompts import ChatPromptTemplate, FewShotChatMessagePromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from langgraph.graph import StateGraph, END
+from langchain.schema import AIMessage, HumanMessage
+from app.rag_layer import retrieve_context
+from app.validation import validate_response
+from app import config
+import streamlit as st
+from langsmith import Client
+
+langsmith_client = Client() if config.LANGSMITH_API_KEY else None
+
+with open("data/kb/few_shot_prompts.json", "r") as f:
+    few_shot_data = json.load(f)
+
+few_shot_examples = [
+    {"user": ex["user"], "context": ex["context"], "response": ex["response"]}
+    for ex in few_shot_data["examples"]
+]
+
+example_prompt = ChatPromptTemplate.from_messages([
+    ("human", "{user}\nContext: {context}"),
+    ("ai", "{response}")
+])
+
+few_shot_prompt = FewShotChatMessagePromptTemplate(
+    example_prompt=example_prompt,
+    examples=few_shot_examples,
+)
+
+system_prompt = """
+You are an empathetic mental health chatbot specializing in Omani Arabic. Respond in Omani dialect Arabic.
+Use retrieved context and best practices: {best_practices}.
+Be supportive, suggest resources, but never diagnose or give medical advice.
+If crisis_risk is 'High Risk', respond with: "ياخي، أشوفك محتاج دعم فوري. تواصل مع مستشفى المسارة على 2487 3268 أو اتصل 9999 للطوارئ."
+If crisis_risk is 'Medium Risk', include a CBT de-escalation technique from context and suggest professional help.
+User query: {query}
+Retrieved context: {context}
+Emotions: {emotions}
+Intent: {intent}
+Crisis Risk: {crisis_risk}
+"""
+
+final_prompt = ChatPromptTemplate.from_messages([
+    ("system", system_prompt),
+    few_shot_prompt,
+    ("human", "{query}")
+])
+
+# LLMs
+gpt4 = ChatOpenAI(model="gpt-4o", api_key=config.OPENAI_API_KEY)
+claude = ChatAnthropic(model="claude-3-opus-20240229", api_key=config.ANTHROPIC_API_KEY)
+
+def generate_with_failover(query, context, emotions, intent, crisis_risk):
+    chain = final_prompt | gpt4 | StrOutputParser()
+    try:
+        response = chain.invoke({
+            "query": query,
+            "context": context,
+            "emotions": emotions,
+            "intent": intent,
+            "crisis_risk": crisis_risk,
+            "best_practices": json.dumps(few_shot_data["best_practices"])
+        })
+        # Log to LangSmith
+        if langsmith_client:
+            langsmith_client.create_run(
+                name="response_generation",
+                inputs={"query": query, "crisis_risk": crisis_risk},
+                outputs={"response": response},
+                run_type="chain"
+            )
+        return response
+    except Exception:
+        # Failover to Claude
+        chain = final_prompt | claude | StrOutputParser()
+        response = chain.invoke({
+            "query": query,
+            "context": context,
+            "emotions": emotions,
+            "intent": intent,
+            "crisis_risk": crisis_risk,
+            "best_practices": json.dumps(few_shot_data["best_practices"])
+        })
+        if langsmith_client:
+            langsmith_client.create_run(
+                name="response_generation_failover",
+                inputs={"query": query, "crisis_risk": crisis_risk},
+                outputs={"response": response},
+                run_type="chain"
+            )
+        return response
+
+# LangGraph workflow: retrieve -> generate -> validate
+class AgentState(TypedDict):
+    query: str
+    emotions: str
+    intent: str
+    crisis_risk: str
+    context: str
+    response: str
+    validation_score: float
+
+def retrieve(state: AgentState) -> AgentState:
+    context_docs = retrieve_context(state["query"])
+    state["context"] = "\n".join([doc.page_content for doc in context_docs])
+    return state
+
+def generate(state: AgentState) -> AgentState:
+    state["response"] = generate_with_failover(
+        state["query"], state["context"], state["emotions"], state["intent"], state["crisis_risk"]
+    )
+    return state
+
+def validate(state: AgentState) -> AgentState:
+    score, feedback = validate_response(state["response"], state["query"])
+    state["validation_score"] = score
+    if score < 0.7:  # Threshold for re-generation
+        state["response"] = "Response invalidated. Regenerating..."  # Or re-run generate
+    return state
+
+workflow = StateGraph(AgentState)
+workflow.add_node("retrieve", retrieve)
+workflow.add_node("generate", generate)
+workflow.add_node("validate", validate)
+workflow.add_edge("retrieve", "generate")
+workflow.add_edge("generate", "validate")
+workflow.add_edge("validate", END)
+workflow.set_entry_point("retrieve")
+
+app = workflow.compile()
+
+def generate_response(query, emotions, intent, crisis_risk):
+    inputs = {
+        "query": query,
+        "emotions": emotions,
+        "intent": intent,
+        "crisis_risk": crisis_risk
+    }
+    result = app.invoke(inputs)
+    return result["response"]

app/stt_pipeline.py

@@ -0,0 +1,73 @@
+import streamlit as st
+import openai
+from io import BytesIO
+from streamlit_mic_recorder import mic_recorder
+from app import config
+import logging
+
+logging.getLogger("openai").setLevel(logging.ERROR)
+
+if config.OPENAI_API_KEY:
+    client = openai.OpenAI(api_key=config.OPENAI_API_KEY)
+else:
+    client = None
+    st.error("OpenAI API key not found in .env file. Please set OPENAI_API_KEY.")
+
+# session state
+if "chat_history" not in st.session_state:
+    st.session_state.chat_history = []
+if "audio_history" not in st.session_state:
+    st.session_state.audio_history = []
+if "transcript" not in st.session_state:
+    st.session_state.transcript = None
+
+def transcribe_callback():
+    """Callback to auto-transcribe and display on recording stop."""
+    if 'recorder_output' in st.session_state and st.session_state.recorder_output:
+        audio_data = st.session_state.recorder_output
+        if client:
+            try:
+                audio_file = BytesIO(audio_data['bytes'])
+                audio_file.name = "audio.webm"
+                
+                st.session_state.is_processing = True
+                
+                transcript = client.audio.transcriptions.create(
+                    model="whisper-1",
+                    file=audio_file,
+                    response_format="text"
+                )
+                
+                st.session_state.transcript = transcript
+                st.session_state.chat_history.append(f"User: {transcript}")
+                st.session_state.audio_history.append(("user", audio_data['bytes'], transcript))
+                st.success(f"Transcription: {transcript}")
+                logging.info(f"Session: {st.session_state.get('session_id', 'unknown')} - Transcription completed: {transcript}")
+                
+                st.session_state.is_processing = False
+                st.rerun()
+                
+            except Exception as e:
+                st.session_state.is_processing = False
+                logging.error(f"Session: {st.session_state.get('session_id', 'unknown')} - Transcription error: {str(e)}")
+                st.error(f"Transcription error: {str(e)}")
+        else:
+            st.session_state.is_processing = False
+            st.error("No OpenAI API key provided.")
+
+def render_mic_recorder():
+    """Render the mic recorder component."""
+    if st.session_state.get("is_processing", False):
+        with st.spinner("Processing audio..."):
+            pass
+    else:
+        audio = mic_recorder(
+            key="recorder",
+            start_prompt="🎤 Start Recording",
+            stop_prompt="⏹️ Stop & Transcribe",
+            just_once=False,
+            use_container_width=True,
+            format="webm",
+            callback=transcribe_callback
+        )
+        return audio

app/tts_pipeline.py

@@ -0,0 +1,33 @@
+import streamlit as st
+import openai
+from io import BytesIO
+from app import config
+import logging
+
+logging.getLogger("openai").setLevel(logging.ERROR)
+
+client = openai.OpenAI(api_key=config.OPENAI_API_KEY)
+
+def text_to_speech(text):
+    """Convert text to speech using OpenAI TTS."""
+    try:
+        st.session_state.is_processing = True
+        
+        response = client.audio.speech.create(
+            model="tts-1",
+            voice="nova",
+            input=text
+        )
+        audio_bytes = BytesIO(response.content)
+        st.audio(audio_bytes, format="audio/mp3")
+        if "chat_history" in st.session_state:
+            st.session_state.chat_history.append(f"Bot: {text}")
+        if "audio_history" in st.session_state:
+            st.session_state.audio_history.append(("bot", response.content, text))
+        logging.info(f"Session: {st.session_state.get('session_id', 'unknown')} - TTS completed for response: {text[:50]}...")
+        
+        st.session_state.is_processing = False
+    except Exception as e:
+        st.session_state.is_processing = False
+        logging.error(f"Session: {st.session_state.get('session_id', 'unknown')} - TTS error: {str(e)}")
+        st.error(f"TTS error: {str(e)}")

app/ui.py

@@ -0,0 +1,93 @@
+import streamlit as st
+from app.stt_pipeline import render_mic_recorder
+from app.crisis_toolchain import get_session_id
+
+def consent_banner():
+    """Render consent banner and manage consent state."""
+    st.markdown("## 🛡️ Consent & Disclosure")
+    st.info(
+        "This AI chatbot is **not a substitute for professional therapy**.\n\n"
+        "Your voice may be processed for analysis. "
+        "Data will only be stored if you consent."
+    )
+    
+    if "consent" not in st.session_state:
+        st.session_state.consent = False
+    
+    st.session_state.consent = st.checkbox(
+        "I consent to continue and agree that this is not a substitute for professional therapy.",
+        value=st.session_state.consent
+    )
+    
+    if st.session_state.consent:
+        if "recorder_output" in st.session_state:
+            st.session_state.recorder_output = None
+    
+    return st.session_state.consent
+
+def emergency_resources():
+    """Display emergency resources."""
+    st.markdown("### Ministry of Health (MOH)")
+    st.markdown("- **General Adult Psychiatry:** +968 2487 3127")
+    st.markdown("- **Child & Adolescence Psychiatry:** +968 2487 3127")
+    st.markdown("- **Psychology Services:** +968 2487 3983")
+    st.markdown("### National Hospitals")
+    st.markdown("- **Al Masarra Hospital (Psychiatry & Addiction):** +968 2487 3268")
+    st.markdown("- **Royal Hospital – Mental Health Support (Mon–Fri, 8 AM–8 PM):** +968 24 607 555")
+    st.markdown("### Private Clinics")
+    st.markdown("- **KIMSHEALTH Oman Hospital (Darsait):** +968 2476 0100")
+    st.markdown("- **Oman International Hospital (Al Ghubrah):** +968 2490 3500 | WhatsApp: +968 9938 9376")
+    st.markdown("- **Muscat Private Hospital:** +968 2458 3600")
+    st.markdown("- **Aster Al Raffah Hospital:** +968 2249 6000")
+    st.markdown("- **Badr Al Samaa Hospital:** +968 2459 1000")
+    st.markdown("- **Burjeel Medical Center:** +968 24 399 777")
+    st.markdown("- **Hatat House Polyclinic:** +968 2456 3641 / 9943 1173")
+    st.markdown("### 🌐 Global Resource")
+    st.markdown("- **WHO – Mental Health:** https://www.who.int/health-topics/mental-health")
+    st.info("🚨 Immediate emergency? Call Royal Oman Police / Ambulance: 9999.")
+
+def audio_input():
+    """Render audio input UI and return chat history."""
+    if "chat_history" not in st.session_state:
+        st.session_state.chat_history = []
+    if "audio_history" not in st.session_state:
+        st.session_state.audio_history = []  # Store (type, audio_bytes, transcript) tuples
+    if "is_processing" not in st.session_state:
+        st.session_state.is_processing = False
+    
+    # session ID
+    if "session_id" not in st.session_state:
+        st.session_state.session_id = get_session_id()
+    session_id = st.session_state.session_id
+    st.markdown(f"**Session ID**: {session_id}")
+    
+    if st.session_state.consent:
+        st.success("✅ Consent given. Ready to start.")
+        st.markdown("Click on **START** to begin speaking.")
+        
+        with st.container():
+            render_mic_recorder()
+        
+        # Display chat history + audio playback
+        st.markdown("### Conversation History")
+        for i, entry in enumerate(st.session_state.chat_history):
+            if entry.startswith("User:"):
+                transcript = entry.replace("User: ", "")
+                st.markdown(f"**You**: {transcript}")
+
+                for audio_type, audio_bytes, audio_transcript in st.session_state.audio_history:
+                    if audio_type == "user" and audio_transcript == transcript:
+                        st.audio(audio_bytes, format="audio/webm")
+            elif entry.startswith("Bot:"):
+                transcript = entry.replace("Bot: ", "")
+                st.markdown(f"**Bot**: {transcript}")
+
+                for audio_type, audio_bytes, audio_transcript in st.session_state.audio_history:
+                    if audio_type == "bot" and audio_transcript == transcript:
+                        st.audio(audio_bytes, format="audio/mp3")
+    
+    return st.session_state.chat_history
+
+def display_latest_audio():
+    """Placeholder function, no longer needed as audio is shown in chat history."""
+    pass

app/validation.py

@@ -0,0 +1,25 @@
+from langchain_openai import ChatOpenAI
+from langchain.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import JsonOutputParser
+from app import config
+
+validator = ChatOpenAI(model="gpt-4o", api_key=config.OPENAI_API_KEY)
+
+validation_prompt = ChatPromptTemplate.from_template("""
+Validate this mental health response for safety and quality.
+Criteria:
+- Empathy: 0-1 (shows understanding?)
+- Accuracy: 0-1 (facts correct, no diagnosis?)
+- Non-harmful: 0-1 (no encouragement of harm?)
+- Cultural fit: 0-1 (Omani/Arabic sensitive?)
+Overall score: average of above.
+Query: {query}
+Response: {response}
+Output JSON: {{"score": float, "feedback": str}}
+""")
+
+chain = validation_prompt | validator | JsonOutputParser()
+
+def validate_response(response, query):
+    result = chain.invoke({"query": query, "response": response})
+    return result["score"], result["feedback"]