Initial commit from PainReport

.env.example

@@ -0,0 +1,12 @@
+# Example environment variables
+# Copy this file to .env and fill in your values
+
+# Required: OpenAI API key for GPT-5.2 report generation
+OPENAI_API_KEY=sk-your-api-key-here
+
+# Optional: Choose embedding model
+# Options: "biolord" (recommended, free, local) or "openai" (paid, API)
+EMBEDDING_MODEL=biolord
+
+# Optional: API configuration (for Hugging Face Spaces)
+# API_URL=http://localhost:8000

.gitattributes

@@ -1,35 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Auto detect text files and perform LF normalization
+* text=auto

.gitignore

@@ -0,0 +1,14 @@
+# env
+.env
+Backend/.env
+
+# Python
+__pycache__/
+*.py[cod]
+*.pyc
+
+# IDE
+.vscode/
+
+report.txt
+MULTILINGUAL_USAGE_GUIDE.md

Backend/inference/__init__.py

@@ -0,0 +1,6 @@
+"""
+Rule-based clinical inference engine for deterministic medical reasoning.
+"""
+from .rule_engine import ClinicalRule, RuleEngine
+
+__all__ = ['ClinicalRule', 'RuleEngine']

Backend/inference/rule_engine.py

@@ -0,0 +1,355 @@
+"""
+Deterministic rule-based clinical inference engine.
+
+Applies expert-validated If-Then rules to structured pain ontology data.
+NO probabilistic reasoning or LLM-based inference - all clinical logic is 
+deterministic and traceable.
+
+This module implements the symbolic reasoning component of the neuro-symbolic
+hybrid architecture, ensuring medical decisions are explainable and evidence-based.
+"""
+
+from typing import List, Dict, Callable
+from dataclasses import dataclass
+import sys
+import os
+
+# Add Backend to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from models.pain_schema import PainOntology, ClinicalRecommendation
+
+
+@dataclass
+class ClinicalRule:
+    """
+    Represents a single clinical decision rule.
+    
+    Each rule consists of:
+    - Condition: A function that evaluates PainOntology and returns True/False
+    - Action: The recommendation to make if condition is met
+    - Evidence fields: Which PainOntology fields to include as evidence
+    - Guideline reference: Citation to clinical guideline supporting the rule
+    """
+    rule_id: str
+    name: str
+    condition: Callable[[PainOntology], bool]
+    recommendation: str
+    evidence_fields: List[str]
+    guideline_reference: str = None
+    confidence: str = "high"
+
+
+class RuleEngine:
+    """
+    Expert system rule engine for pain assessment.
+    
+    Applies deterministic clinical rules to structured pain data and generates
+    explainable recommendations with complete evidence chains.
+    
+    All rules are:
+    1. Based on established clinical guidelines
+    2. Deterministic (no probabilistic inference)
+    3. Fully explainable (evidence is explicitly tracked)
+    4. Independently verifiable by medical experts
+    """
+    
+    def __init__(self):
+        """Initialize rule engine and load clinical decision rules."""
+        self.rules: List[ClinicalRule] = []
+        self._initialize_rules()
+    
+    def _initialize_rules(self):
+        """
+        Initialize clinical decision rules.
+        
+        Each rule is based on established clinical guidelines and pain management
+        best practices. Rules are evaluated in order of priority.
+        """
+        
+        # ========== RULE A: Chronic Pain + Depressive Symptoms → Behavioral Therapy ==========
+        def rule_a_condition(pain_data: PainOntology) -> bool:
+            """
+            Chronic pain with significant affective distress requires multimodal approach.
+            
+            Based on: Wisconsin Medical Examining Board Guidelines for Chronic Pain Management
+            Rationale: Chronic pain with depression benefits from CBT and non-pharmacologic
+                      interventions before considering pharmacological escalation.
+            """
+            temporal_chronic = (
+                pain_data.temporal_pattern and 
+                ("chronic" in pain_data.temporal_pattern.lower() or "months" in pain_data.temporal_pattern.lower())
+            )
+            
+            emotion_depressed = pain_data.emotion and any(
+                term in pain_data.emotion.lower() 
+                for term in ["depressed", "depression", "despair", "hopeless"]
+            )
+            
+            return temporal_chronic and emotion_depressed
+        
+        self.rules.append(ClinicalRule(
+            rule_id="RULE_A",
+            name="Chronic Pain + Depression → Behavioral Therapy",
+            condition=rule_a_condition,
+            recommendation=(
+                "Recommend behavioral therapy (CBT) per Wisconsin chronic pain guidelines. "
+                "Chronic pain with significant depressive symptoms benefits from "
+                "culturally concordant behavioral interventions. Prioritize non-pharmacologic "
+                "multidisciplinary care before considering pharmacological escalation."
+            ),
+            evidence_fields=["temporal_pattern", "emotion"],
+            guideline_reference="Wisconsin Medical Examining Board Guidelines for Chronic Pain Management",
+            confidence="high"
+        ))
+        
+        # ========== RULE B: Neuropathic Pain in Distal Extremities → Peripheral Neuropathy Screening ==========
+        def rule_b_condition(pain_data: PainOntology) -> bool:
+            """
+            Neuropathic pain in hands/feet suggests peripheral neuropathy.
+            
+            Rationale: Classic presentation of peripheral neuropathy includes neuropathic
+                      pain descriptors (electric-shock, tingling, burning) in distal extremities.
+                      Requires screening for underlying causes (diabetes, vitamin B12 deficiency, etc.)
+            """
+            neuropathic = pain_data.pain_type and "neuropathic" in pain_data.pain_type.lower()
+            
+            distal_location = pain_data.location and any(
+                loc in pain_data.location.lower() 
+                for loc in ["lower extremities", "feet", "hands", "legs", "arms", "extremities"]
+            )
+            
+            return neuropathic and distal_location
+        
+        self.rules.append(ClinicalRule(
+            rule_id="RULE_B",
+            name="Neuropathic Pain in Distal Extremities → Peripheral Neuropathy Screening",
+            condition=rule_b_condition,
+            recommendation=(
+                "Recommend peripheral neuropathy screening. "
+                "Neuropathic pain in distal extremities suggests possible peripheral nerve pathology. "
+                "Consider neurological examination and investigation of potential underlying causes "
+                "(diabetes mellitus, vitamin B12 deficiency, autoimmune conditions, medication toxicity)."
+            ),
+            evidence_fields=["pain_type", "location"],
+            confidence="high"
+        ))
+        
+        # ========== RULE C: Severe Functional Impact → Multidisciplinary Pain Clinic Referral ==========
+        def rule_c_condition(pain_data: PainOntology) -> bool:
+            """
+            Severe functional impairment requires comprehensive pain management.
+            
+            Rationale: Pain causing significant functional disability (sleep, work, mobility)
+                      often requires multidisciplinary approach beyond primary care.
+            """
+            has_functional_impact = pain_data.functional_impact is not None
+            
+            severe_impact = has_functional_impact and any(
+                term in pain_data.functional_impact.lower()
+                for term in ["severe", "unable", "cannot", "impossible", "interfere", "disability"]
+            )
+            
+            return severe_impact
+        
+        self.rules.append(ClinicalRule(
+            rule_id="RULE_C",
+            name="Severe Functional Impact → Multidisciplinary Pain Clinic",
+            condition=rule_c_condition,
+            recommendation=(
+                "Consider referral to multidisciplinary pain clinic. "
+                "Severe functional impairment indicates need for comprehensive pain management "
+                "involving physical therapy, occupational therapy, psychological support, and "
+                "coordinated medical management."
+            ),
+            evidence_fields=["functional_impact", "temporal_pattern"],
+            confidence="high"
+        ))
+        
+        # ========== RULE D: Burning Pain → Consider Inflammatory or Neuropathic Etiology ==========
+        def rule_d_condition(pain_data: PainOntology) -> bool:
+            """
+            Burning pain quality suggests specific etiologies.
+            
+            Rationale: Burning pain can indicate inflammatory processes or small fiber neuropathy.
+            """
+            burning_pain = pain_data.pain_type and "burning" in pain_data.pain_type.lower()
+            return burning_pain
+        
+        self.rules.append(ClinicalRule(
+            rule_id="RULE_D",
+            name="Burning Pain → Inflammatory/Neuropathic Workup",
+            condition=rule_d_condition,
+            recommendation=(
+                "Burning pain quality suggests possible inflammatory or small fiber neuropathic etiology. "
+                "Consider evaluation for inflammatory conditions, nerve injury, or small fiber neuropathy. "
+                "May benefit from topical treatments or neuropathic pain medications."
+            ),
+            evidence_fields=["pain_type", "location"],
+            confidence="medium"
+        ))
+    
+    def evaluate(self, pain_data: PainOntology) -> List[ClinicalRecommendation]:
+        """
+        Apply all rules to the pain data and return triggered recommendations.
+        
+        Each recommendation includes:
+        - The clinical recommendation text
+        - Which rule triggered it
+        - The specific evidence (field values) that triggered the rule
+        - Confidence level
+        - Guideline reference
+        
+        Args:
+            pain_data: Structured pain ontology data
+            
+        Returns:
+            List of clinical recommendations with complete evidence chains
+            
+        Example:
+            >>> pain = PainOntology(
+            ...     pain_type="Neuropathic (Electric-shock-like)",
+            ...     location="Lower extremities",
+            ...     temporal_pattern="Chronic (4 months)",
+            ...     emotion="Depressed"
+            ... )
+            >>> engine = RuleEngine()
+            >>> recommendations = engine.evaluate(pain)
+            >>> # Returns recommendations for RULE_A and RULE_B
+        """
+        recommendations = []
+        
+        for rule in self.rules:
+            try:
+                if rule.condition(pain_data):
+                    # Extract evidence from specified fields
+                    evidence = {}
+                    for field in rule.evidence_fields:
+                        if hasattr(pain_data, field):
+                            value = getattr(pain_data, field)
+                            if value is not None:  # Only include non-None values
+                                evidence[field] = value
+                    
+                    recommendations.append(ClinicalRecommendation(
+                        recommendation=rule.recommendation,
+                        triggered_by_rule=f"{rule.rule_id}: {rule.name}",
+                        evidence=evidence,
+                        confidence=rule.confidence,
+                        guideline_reference=rule.guideline_reference
+                    ))
+            except Exception as e:
+                # Log error but continue evaluating other rules
+                print(f"Warning: Error evaluating {rule.rule_id}: {str(e)}")
+                continue
+        
+        return recommendations
+    
+    def generate_reasoning_chain(
+        self, 
+        pain_data: PainOntology, 
+        recommendations: List[ClinicalRecommendation],
+        ontology_mappings: List[Dict]
+    ) -> List[str]:
+        """
+        Generate human-readable reasoning chain showing complete decision pathway.
+        
+        This provides full transparency from patient input to clinical recommendations,
+        enabling clinical validation and building trust in the system.
+        
+        The reasoning chain includes:
+        1. Ontology mapping (Chinese → English medical terms)
+        2. Structured pain data extraction
+        3. Rule evaluation and triggers
+        4. Final recommendations with evidence
+        
+        Args:
+            pain_data: Structured pain ontology data
+            recommendations: List of triggered recommendations
+            ontology_mappings: List of multilingual→English mappings
+            
+        Returns:
+            List of reasoning step strings
+            
+        Example output:
+            [
+                "=== Ontology Mapping ===",
+                "Input '电击一样' → Mapped to 'Electric-shock-like (Neuropathic)'",
+                "=== Structured Pain Data ===",
+                "Pain Type: Neuropathic (Electric-shock-like)",
+                "=== Rule Engine Evaluation ===",
+                "✓ Triggered: RULE_B",
+                "  Evidence: {'pain_type': 'Neuropathic', 'location': 'Lower extremities'}"
+            ]
+        """
+        chain = []
+        
+        # ===== Step 1: Show ontology mappings =====
+        chain.append("=== Ontology Mapping ===")
+        if ontology_mappings:
+            for mapping in ontology_mappings:
+                # Show: matched text in user input → dictionary term → English translation
+                matched = mapping.get('matched_text', mapping.get('original_term', 'N/A'))
+                original = mapping.get('original_term', 'N/A')
+                english = mapping.get('mapped_english', 'N/A')
+                
+                # Display: what user said → what it matches → English term
+                if matched != original:
+                    display_input = f"{matched} (matches '{original}')"
+                else:
+                    display_input = matched
+                
+                chain.append(
+                    f"Input '{display_input}' → "
+                    f"Mapped to '{english}' "
+                    f"({mapping.get('dimension', 'N/A')}, confidence: {mapping.get('confidence', 'N/A')})"
+                )
+        else:
+            chain.append("No specific pain descriptors were mapped from ontology dictionary.")
+        
+        # ===== Step 2: Show structured data extraction =====
+        chain.append("\n=== Structured Pain Data ===")
+        chain.append(f"Pain Type: {pain_data.pain_type}")
+        chain.append(f"Location: {pain_data.location}")
+        chain.append(f"Temporal Pattern: {pain_data.temporal_pattern}")
+        if pain_data.intensity and pain_data.intensity != "Not explicitly stated":
+            chain.append(f"Intensity: {pain_data.intensity}")
+        if pain_data.emotion:
+            chain.append(f"Emotional Dimension: {pain_data.emotion}")
+        if pain_data.functional_impact:
+            chain.append(f"Functional Impact: {pain_data.functional_impact}")
+        
+        # ===== Step 3: Show rule triggers and recommendations =====
+        chain.append("\n=== Rule Engine Evaluation ===")
+        if recommendations:
+            for rec in recommendations:
+                chain.append(f"✓ Triggered: {rec.triggered_by_rule}")
+                chain.append(f"  Evidence: {rec.evidence}")
+                chain.append(f"  → Recommendation: {rec.recommendation}")
+                if rec.guideline_reference:
+                    chain.append(f"  → Guideline: {rec.guideline_reference}")
+                chain.append("")  # Blank line for readability
+        else:
+            chain.append("No specific clinical rules triggered.")
+            chain.append("Standard pain assessment and management pathway recommended.")
+        
+        return chain
+    
+    def add_rule(self, rule: ClinicalRule):
+        """
+        Add a custom clinical rule to the engine.
+        
+        This allows for dynamic rule expansion and customization based on
+        specific clinical contexts or institutional guidelines.
+        
+        Args:
+            rule: ClinicalRule instance to add
+        """
+        self.rules.append(rule)
+    
+    def get_rule_count(self) -> int:
+        """Return the number of active rules in the engine."""
+        return len(self.rules)
+    
+    def get_rule_ids(self) -> List[str]:
+        """Return list of all rule IDs for reference."""
+        return [rule.rule_id for rule in self.rules]

Backend/main.py

@@ -0,0 +1,214 @@
+from fastapi import FastAPI, File, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles 
+import os
+
+from services.whisper_service import transcribeAudio
+from services.llm_service import analyzePainDescription
+from services.conversation_service import generateFollowUpQuestions
+from services.neuro_symbolic_service import analyze_pain_neuro_symbolic, get_system_info
+
+# Smart embedding service selection
+EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL", "biolord")  # Options: "biolord", "openai"
+
+if EMBEDDING_MODEL == "biolord":
+    print(f"[Main] Using BioLORD-2023-M embeddings (medical specialist)")
+    from services.semantic_distance_service_biolord import precompute_dictionary_embeddings
+else:
+    print(f"[Main] Using OpenAI embeddings (general purpose)")
+    from services.semantic_distance_service_v2 import precompute_dictionary_embeddings
+
+from pydantic import BaseModel
+from typing import List, Dict
+
+
+class ConversationRequest(BaseModel):
+    history: List[Dict]
+    
+    
+app = FastAPI(
+    title = "Pain Report Platform",
+    version = "0.2.0"  # Updated to v0.2.0 with BioLORD support
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.mount("/images", StaticFiles(directory="images"), name="images")
+
+@app.get("/")
+async def root():
+    return {
+        "message": "This is pain report platform backend API.",
+        "status": "running"
+    }
+    
+@app.get("/health")
+async def healthCheck():
+    return {
+        "status": "healthy",
+        "message": "The API is healthy and running",
+        "version": "0.1.3"
+    }
+    
+    
+@app.post("/api/analyze-audio")
+async def analyze_audio(file: UploadFile = File(...)):
+    #check file
+    if not file.content_type.startswith("audio/"):
+        return {"error": "Invalid file type.", 
+                "message": "Please upload an audio file."}
+    
+    #read file
+    audioBytes = await file.read()
+    
+    try:
+        transcription = transcribeAudio(audioBytes, language=None)
+        
+        analysis = analyzePainDescription(transcription["text"])
+        
+        return {
+            "status": "success",
+            "message": "Audio file received",
+            "size": len(audioBytes),
+            "filename": file.filename,
+            "trancription": transcription["text"],
+            "language": transcription["language"],
+            "analysis": analysis
+        }
+        
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": str(e)
+        }
+    
+    
+@app.post("/api/follow-up")
+async def getFollowUpQuestion(request: ConversationRequest):
+    try:
+        followUp = generateFollowUpQuestions(request.history)
+        
+        return {
+            "status": "success",
+            "followup": followUp
+        }
+    
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": str(e)
+        }
+
+
+@app.post("/api/analyze-text-neuro-symbolic")
+async def analyzeTextNeuroSymbolic(request: dict):
+    """
+    Analyze text pain description using neuro-symbolic architecture.
+    
+    This is the new upgraded analysis endpoint that uses:
+    - LLM for narrow-scope entity extraction only
+    - Ontology mapping for multilingual medical terminology
+    - Rule-based engine for deterministic clinical recommendations
+    
+    Returns structured pain data with complete explainability and reasoning chain.
+    """
+    try:
+        patient_text = request.get("text", "")
+        if not patient_text:
+            return {
+                "status": "error",
+                "message": "No text provided"
+            }
+        
+        # Execute neuro-symbolic pipeline
+        analysis = analyze_pain_neuro_symbolic(patient_text)
+        return analysis
+        
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": str(e)
+        }
+
+
+@app.post("/api/analyze-audio-neuro-symbolic")
+async def analyzeAudioNeuroSymbolic(file: UploadFile = File(...)):
+    """
+    Analyze audio pain description using neuro-symbolic architecture.
+    
+    Combines:
+    1. Whisper transcription (audio → text)
+    2. Neuro-symbolic analysis (text → structured clinical data)
+    
+    Returns complete explainable report with reasoning chain.
+    """
+    if not file.content_type.startswith("audio/"):
+        return {
+            "error": "Invalid file type.", 
+            "message": "Please upload an audio file."
+        }
+    
+    audioBytes = await file.read()
+    
+    try:
+        # Step 1: Transcribe audio
+        transcription_result = transcribeAudio(audioBytes, language=None)
+        original_transcription = transcription_result["text"]
+        
+        # Step 2: Neuro-symbolic analysis (includes normalization + ontology mapping)
+        analysis = analyze_pain_neuro_symbolic(original_transcription)
+        
+        # Merge transcription info with analysis results
+        # The analysis already contains transcription normalization in analysis["transcription"]
+        return {
+            "status": "success",
+            "message": "Audio analyzed successfully using neuro-symbolic architecture",
+            "size": len(audioBytes),
+            "filename": file.filename,
+            "whisper_language": transcription_result["language"],
+            **analysis  # Spread analysis results (includes transcription, structured_data, etc.)
+        }
+        
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": str(e)
+        }
+
+
+@app.get("/api/system-info")
+async def getSystemInfo():
+    """
+    Get information about the neuro-symbolic pain assessment system.
+    
+    Returns system configuration, capabilities, and limitations.
+    Useful for documentation and debugging.
+    """
+    try:
+        info = get_system_info()
+        return {
+            "status": "success",
+            "system_info": info
+        }
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": str(e)
+        }
+    
+@app.on_event("startup")
+async def startup_event():
+    print("[Startup] Precomputing dictionary embeddings...")
+    precompute_dictionary_embeddings()
+    print("[Startup] System ready!")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+

Backend/models/__init__.py

@@ -0,0 +1,6 @@
+"""
+Pydantic data models for neuro-symbolic pain assessment.
+"""
+from .pain_schema import PainOntology, ClinicalRecommendation, ExplainableReport
+
+__all__ = ['PainOntology', 'ClinicalRecommendation', 'ExplainableReport']

Backend/models/pain_schema.py

@@ -0,0 +1,192 @@
+"""
+Pydantic data models for structured pain assessment.
+
+This module defines the core data structures for the neuro-symbolic pain assessment system:
+- PainOntology: Structured representation of pain characteristics
+- ClinicalRecommendation: Rule-based clinical recommendations with evidence
+- ExplainableReport: Complete assessment output with reasoning chain
+"""
+
+from pydantic import BaseModel, Field
+from typing import Optional, List, Dict, Any
+
+
+class PainOntology(BaseModel):
+    """
+    Core pain ontology representing structured clinical pain data.
+    
+    Maps unstructured patient descriptions to standardized medical terminology
+    aligned with McGill Pain Questionnaire (SF-MPQ) and SNOMED CT.
+    
+    This is the minimal semantic structure that all pain descriptions must converge to.
+    """
+    
+    pain_type: str = Field(
+        description="Physical sensation description and neuropathic/nociceptive classification. "
+                   "E.g., 'Neuropathic (Electric-shock-like, Tingling)' or 'Nociceptive (Aching, Burning)'"
+    )
+    
+    intensity: Optional[str] = Field(
+        default="Not explicitly stated",
+        description="Pain intensity: numeric (0-10) or qualitative (Mild/Moderate/Severe). "
+                   "Only capture if explicitly stated by patient."
+    )
+    
+    location: str = Field(
+        description="Anatomical location of pain. E.g., 'Lower back', 'Both knees', 'Upper extremities'"
+    )
+    
+    emotion: Optional[str] = Field(
+        default=None,
+        description="Affective dimension: emotional distress associated with pain. "
+                   "E.g., 'Depressed', 'Anxious', 'Exhausting', 'Frustrated'. "
+                   "Maps to McGill Pain Questionnaire Affective dimension."
+    )
+    
+    temporal_pattern: str = Field(
+        description="Onset, frequency, and duration of pain. "
+                   "E.g., 'Chronic (>3 months)', 'Acute (<3 months)', 'Intermittent', 'Constant'"
+    )
+    
+    functional_impact: Optional[str] = Field(
+        default=None,
+        description="Impact on daily activities and quality of life. "
+                   "E.g., 'Severe sleep interference', 'Unable to work', 'Limited mobility'"
+    )
+    
+    class Config:
+        """Pydantic configuration."""
+        json_schema_extra = {
+            "example": {
+                "pain_type": "Neuropathic (Electric-shock-like, Tingling)",
+                "intensity": "Not explicitly stated",
+                "location": "Lower back to lower extremities",
+                "emotion": "Depressed",
+                "temporal_pattern": "Chronic (4 months)",
+                "functional_impact": "Severe sleep interference"
+            }
+        }
+
+
+class ClinicalRecommendation(BaseModel):
+    """
+    Represents a single clinical recommendation triggered by the rule engine.
+    
+    Each recommendation is linked to a specific clinical decision rule and includes
+    the evidence (structured data fields) that triggered the rule.
+    """
+    
+    recommendation: str = Field(
+        description="Clinical action or pathway recommendation"
+    )
+    
+    triggered_by_rule: str = Field(
+        description="Name/ID of the rule that triggered this recommendation"
+    )
+    
+    evidence: Dict[str, Any] = Field(
+        description="Specific field values from PainOntology that triggered the rule"
+    )
+    
+    confidence: str = Field(
+        default="high",
+        description="Confidence level of the recommendation: high/medium/low"
+    )
+    
+    guideline_reference: Optional[str] = Field(
+        default=None,
+        description="Reference to clinical guideline or evidence base. "
+                   "E.g., 'Wisconsin Medical Examining Board Guidelines for Chronic Pain Management'"
+    )
+    
+    class Config:
+        """Pydantic configuration."""
+        json_schema_extra = {
+            "example": {
+                "recommendation": "Recommend behavioral therapy (CBT) per Wisconsin chronic pain guidelines",
+                "triggered_by_rule": "RULE_A: Chronic Pain + Depression",
+                "evidence": {
+                    "temporal_pattern": "Chronic (4 months)",
+                    "emotion": "Depressed"
+                },
+                "confidence": "high",
+                "guideline_reference": "Wisconsin Medical Examining Board Guidelines"
+            }
+        }
+
+
+class ExplainableReport(BaseModel):
+    """
+    Final output containing structured data, reasoning chain, and readable report.
+    
+    This is the complete output of the neuro-symbolic pain assessment pipeline,
+    providing full transparency from input to clinical recommendations.
+    
+    Key components:
+    - structured_data: Normalized pain ontology
+    - ontology_mapping_trace: How Chinese terms were mapped to English medical terms
+    - clinical_recommendations: Rule-triggered recommendations with evidence
+    - reasoning_chain: Step-by-step reasoning from input to output
+    - physician_summary: Human-readable clinical summary
+    """
+    
+    structured_data: PainOntology = Field(
+        description="Structured pain data following the PainOntology schema"
+    )
+    
+    ontology_mapping_trace: List[Dict[str, Any]] = Field(
+        description="Trace of Chinese input → English medical term mapping. "
+                   "Each entry shows: chinese_input, mapped_english, dimension, pain_type, SNOMED CT code, confidence"
+    )
+    
+    clinical_recommendations: List[ClinicalRecommendation] = Field(
+        description="List of clinical recommendations triggered by rule engine"
+    )
+    
+    reasoning_chain: List[str] = Field(
+        description="Human-readable step-by-step reasoning process showing complete decision pathway"
+    )
+    
+    physician_summary: str = Field(
+        description="Natural language summary for clinical review"
+    )
+    
+    class Config:
+        """Pydantic configuration."""
+        json_schema_extra = {
+            "example": {
+                "structured_data": {
+                    "pain_type": "Neuropathic (Electric-shock-like, Tingling)",
+                    "intensity": "Not explicitly stated",
+                    "location": "Lower back to lower extremities",
+                    "emotion": "Depressed",
+                    "temporal_pattern": "Chronic (4 months)",
+                    "functional_impact": "Severe sleep interference"
+                },
+                "ontology_mapping_trace": [
+                    {
+                        "multilingual_input": "electric-shock-like",
+                        "mapped_english": "Electric-shock-like",
+                        "dimension": "sensory",
+                        "pain_type": "neuropathic",
+                        "snomed_ct": "60924000",
+                        "confidence": "high"
+                    }
+                ],
+                "clinical_recommendations": [
+                    {
+                        "recommendation": "Recommend behavioral therapy (CBT)",
+                        "triggered_by_rule": "RULE_A: Chronic Pain + Depression",
+                        "evidence": {"temporal_pattern": "Chronic", "emotion": "Depressed"},
+                        "confidence": "high"
+                    }
+                ],
+                "reasoning_chain": [
+                    "=== Ontology Mapping ===",
+                    "Input 'electric-shock-like' → Mapped to 'Electric-shock-like (Neuropathic)'",
+                    "=== Rule Engine Evaluation ===",
+                    "✓ Triggered: RULE_A"
+                ],
+                "physician_summary": "Patient presents with chronic pain (4 months duration)..."
+            }
+        }

Backend/ontology/__init__.py

@@ -0,0 +1,20 @@
+"""
+Cross-lingual pain ontology mapping and terminology alignment.
+"""
+from .pain_mapping import (
+    CHINESE_PAIN_DESCRIPTORS,
+    TEMPORAL_PATTERNS,
+    ANATOMICAL_LOCATIONS,
+    map_chinese_to_english,
+    extract_temporal_pattern,
+    extract_anatomical_location
+)
+
+__all__ = [
+    'CHINESE_PAIN_DESCRIPTORS',
+    'TEMPORAL_PATTERNS',
+    'ANATOMICAL_LOCATIONS',
+    'map_chinese_to_english',
+    'extract_temporal_pattern',
+    'extract_anatomical_location'
+]

Backend/ontology/mcgill_translations.py

@@ -0,0 +1,268 @@
+"""
+McGill Pain Questionnaire - Multilingual Translations
+
+Standard McGill pain descriptors translated into Chinese, Korean, Spanish, and Hmong.
+These translations are INDEPENDENT from the system's multilingual_pain_data.json dictionary.
+
+**Purpose:** 
+Auxiliary semantic matching when system dictionary doesn't have a match.
+Uses BioLORD for same-language medical semantic understanding.
+
+**Architecture:**
+Chinese patient "蚂蚁爬" → BioLORD → Chinese McGill "蚁爬感" → English "formication"
+Korean patient "개미 감각" → BioLORD → Korean McGill "개미가 기어가는 느낌" → English "formication"
+
+**McGill Standard Reference:** 
+Melzack, R. (1975). The McGill Pain Questionnaire: Major properties and scoring methods.
+"""
+
+# Chinese McGill Pain Descriptors (中文麦吉尔疼痛问卷)
+CHINESE_MCGILL = {
+    # Sensory - Neuropathic (神经性疼痛)
+    "灼烧感": {"english": "burning", "type": "neuropathic", "dimension": "sensory",
+               "aliases": ["火烧火燎", "灼热感", "烧灼感", "火辣辣的疼", "辣的疼"]},
+    "刺痛": {"english": "tingling", "type": "neuropathic", "dimension": "sensory"},
+    "麻木": {"english": "numbness", "type": "neuropathic", "dimension": "sensory"},
+    "蚁爬感": {"english": "formication", "type": "neuropathic", "dimension": "sensory", 
+               "aliases": ["蚂蚁爬", "像蚂蚁在爬", "虫爬感"]},
+    "针刺感": {"english": "pins and needles", "type": "neuropathic", "dimension": "sensory",
+               "aliases": ["针扎感", "针刺样"]},
+    "电击感": {"english": "electric shock", "type": "neuropathic", "dimension": "sensory",
+               "aliases": ["电击样", "像电击一样", "触电感"]},
+    "放射痛": {"english": "shooting", "type": "neuropathic", "dimension": "sensory"},
+    "刀刺样痛": {"english": "stabbing", "type": "neuropathic", "dimension": "sensory"},
+    "锐痛": {"english": "sharp", "type": "neuropathic", "dimension": "sensory"},
+    "穿刺样痛": {"english": "piercing", "type": "neuropathic", "dimension": "sensory"},
+    "蛰刺感": {"english": "stinging", "type": "neuropathic", "dimension": "sensory",
+               "aliases": ["蚊虫叮咬样", "刺痒感"]},
+    
+    # Sensory - Nociceptive (伤害性疼痛)
+    "酸痛": {"english": "aching", "type": "nociceptive", "dimension": "sensory"},
+    "跳痛": {"english": "throbbing", "type": "nociceptive", "dimension": "sensory",
+             "aliases": ["搏动性疼痛", "一跳一跳疼"]},
+    "捶击样痛": {"english": "pounding", "type": "nociceptive", "dimension": "sensory"},
+    "敲打样痛": {"english": "beating", "type": "nociceptive", "dimension": "sensory"},
+    "脉冲样痛": {"english": "pulsing", "type": "nociceptive", "dimension": "sensory"},
+    "绞痛": {"english": "cramping", "type": "nociceptive", "dimension": "sensory",
+             "aliases": ["痉挛性疼痛"]},
+    "啃咬样痛": {"english": "gnawing", "type": "nociceptive", "dimension": "sensory"},
+    "压榨样痛": {"english": "crushing", "type": "nociceptive", "dimension": "sensory",
+                 "aliases": ["像被大象踩一样", "像被压碎", "像被车碾过", "压着的感觉"]},
+    "压迫感": {"english": "pressing", "type": "nociceptive", "dimension": "sensory",
+               "aliases": ["像被石头压着", "压着痛", "压痛"]},
+    "挤压感": {"english": "squeezing", "type": "nociceptive", "dimension": "sensory",
+               "aliases": ["被挤压", "紧缩感"]},
+    "牵拉痛": {"english": "pulling", "type": "nociceptive", "dimension": "sensory"},
+    "撕裂痛": {"english": "tearing", "type": "nociceptive", "dimension": "sensory"},
+    "裂开样痛": {"english": "splitting", "type": "nociceptive", "dimension": "sensory"},
+    "痛楚": {"english": "sore", "type": "nociceptive", "dimension": "sensory"},
+    "触痛": {"english": "tender", "type": "nociceptive", "dimension": "sensory"},
+    "钝痛": {"english": "dull", "type": "nociceptive", "dimension": "sensory"},
+    "沉重感": {"english": "heavy", "type": "nociceptive", "dimension": "sensory",
+               "aliases": ["重的感觉", "像被重物压着", "沉甸甸"]},
+    
+    # Thermal (温度性)
+    "发热感": {"english": "hot", "type": "nociceptive", "dimension": "sensory",
+               "aliases": ["热痛", "火辣辣", "烫痛"]},
+    "冷痛": {"english": "cold", "type": "nociceptive", "dimension": "sensory"},
+    "冰冷刺痛": {"english": "freezing", "type": "nociceptive", "dimension": "sensory"},
+    "灼热痛": {"english": "scalding", "type": "nociceptive", "dimension": "sensory"},
+    
+    # Affective (情感性)
+    "令人疲惫": {"english": "exhausting", "type": "affective", "dimension": "affective"},
+    "令人劳累": {"english": "tiring", "type": "affective", "dimension": "affective"},
+    "麻烦的": {"english": "troublesome", "type": "affective", "dimension": "affective"},
+    "悲惨的": {"english": "miserable", "type": "affective", "dimension": "affective"},
+    "无法忍受": {"english": "unbearable", "type": "affective", "dimension": "affective"},
+    "可怕的": {"english": "frightful", "type": "affective", "dimension": "affective"},
+    "恐怖的": {"english": "terrifying", "type": "affective", "dimension": "affective"},
+    "残酷的": {"english": "cruel", "type": "affective", "dimension": "affective"},
+    "凶恶的": {"english": "vicious", "type": "affective", "dimension": "affective"},
+    "折磨人": {"english": "punishing", "type": "affective", "dimension": "affective"},
+    
+    # Evaluative (评价性)
+    "恼人的": {"english": "annoying", "type": "evaluative", "dimension": "evaluative"},
+    "纠缠不休": {"english": "nagging", "type": "evaluative", "dimension": "evaluative"},
+    "强烈的": {"english": "intense", "type": "evaluative", "dimension": "evaluative"},
+}
+
+# Korean McGill Pain Descriptors (한국어 맥길 통증 설문지)
+KOREAN_MCGILL = {
+    # Sensory - Neuropathic
+    "타는 느낌": {"english": "burning", "type": "neuropathic", "dimension": "sensory"},
+    "따끔거림": {"english": "tingling", "type": "neuropathic", "dimension": "sensory"},
+    "무감각": {"english": "numbness", "type": "neuropathic", "dimension": "sensory"},
+    "개미가 기어가는 느낌": {"english": "formication", "type": "neuropathic", "dimension": "sensory",
+                      "aliases": ["개미 감각", "벌레 기어가는"]},
+    "바늘로 찌르는": {"english": "pins and needles", "type": "neuropathic", "dimension": "sensory"},
+    "전기 충격": {"english": "electric shock", "type": "neuropathic", "dimension": "sensory"},
+    "쏘는": {"english": "shooting", "type": "neuropathic", "dimension": "sensory"},
+    "칼로 찌르는": {"english": "stabbing", "type": "neuropathic", "dimension": "sensory"},
+    "날카로운": {"english": "sharp", "type": "neuropathic", "dimension": "sensory"},
+    "꿰뚫는": {"english": "piercing", "type": "neuropathic", "dimension": "sensory"},
+    "쏘는 통증": {"english": "stinging", "type": "neuropathic", "dimension": "sensory"},
+    
+    # Sensory - Nociceptive
+    "쑤시는": {"english": "aching", "type": "nociceptive", "dimension": "sensory"},
+    "욱신거리는": {"english": "throbbing", "type": "nociceptive", "dimension": "sensory"},
+    "두드리는": {"english": "pounding", "type": "nociceptive", "dimension": "sensory"},
+    "때리는": {"english": "beating", "type": "nociceptive", "dimension": "sensory"},
+    "맥박": {"english": "pulsing", "type": "nociceptive", "dimension": "sensory"},
+    "경련": {"english": "cramping", "type": "nociceptive", "dimension": "sensory"},
+    "갉아먹는": {"english": "gnawing", "type": "nociceptive", "dimension": "sensory"},
+    "으스러지는": {"english": "crushing", "type": "nociceptive", "dimension": "sensory"},
+    "누르는": {"english": "pressing", "type": "nociceptive", "dimension": "sensory"},
+    "조이는": {"english": "squeezing", "type": "nociceptive", "dimension": "sensory"},
+    "당기는": {"english": "pulling", "type": "nociceptive", "dimension": "sensory"},
+    "찢어지는": {"english": "tearing", "type": "nociceptive", "dimension": "sensory"},
+    "갈라지는": {"english": "splitting", "type": "nociceptive", "dimension": "sensory"},
+    "아픈": {"english": "sore", "type": "nociceptive", "dimension": "sensory"},
+    "압통": {"english": "tender", "type": "nociceptive", "dimension": "sensory"},
+    "둔한": {"english": "dull", "type": "nociceptive", "dimension": "sensory"},
+    "무거운": {"english": "heavy", "type": "nociceptive", "dimension": "sensory"},
+    
+    # Thermal
+    "뜨거운": {"english": "hot", "type": "nociceptive", "dimension": "sensory"},
+    "차가운": {"english": "cold", "type": "nociceptive", "dimension": "sensory"},
+    "얼어붙는": {"english": "freezing", "type": "nociceptive", "dimension": "sensory"},
+    "데는": {"english": "scalding", "type": "nociceptive", "dimension": "sensory"},
+    
+    # Affective
+    "지치게 하는": {"english": "exhausting", "type": "affective", "dimension": "affective"},
+    "피곤하게 하는": {"english": "tiring", "type": "affective", "dimension": "affective"},
+    "귀찮은": {"english": "troublesome", "type": "affective", "dimension": "affective"},
+    "비참한": {"english": "miserable", "type": "affective", "dimension": "affective"},
+    "참을 수 없는": {"english": "unbearable", "type": "affective", "dimension": "affective"},
+    "무서운": {"english": "frightful", "type": "affective", "dimension": "affective"},
+    "공포스러운": {"english": "terrifying", "type": "affective", "dimension": "affective"},
+    "잔인한": {"english": "cruel", "type": "affective", "dimension": "affective"},
+    "악의적인": {"english": "vicious", "type": "affective", "dimension": "affective"},
+    "처벌하는": {"english": "punishing", "type": "affective", "dimension": "affective"},
+    
+    # Evaluative
+    "짜증나는": {"english": "annoying", "type": "evaluative", "dimension": "evaluative"},
+    "괴롭히는": {"english": "nagging", "type": "evaluative", "dimension": "evaluative"},
+    "강렬한": {"english": "intense", "type": "evaluative", "dimension": "evaluative"},
+}
+
+# Spanish McGill Pain Descriptors (Cuestionario de Dolor McGill en Español)
+SPANISH_MCGILL = {
+    # Sensory - Neuropathic
+    "ardiente": {"english": "burning", "type": "neuropathic", "dimension": "sensory",
+                 "aliases": ["quemante", "que arde"]},
+    "hormigueo": {"english": "tingling", "type": "neuropathic", "dimension": "sensory"},
+    "entumecimiento": {"english": "numbness", "type": "neuropathic", "dimension": "sensory",
+                       "aliases": ["adormecimiento"]},
+    "sensación de hormigas": {"english": "formication", "type": "neuropathic", "dimension": "sensory",
+                              "aliases": ["como hormigas caminando", "hormigueo intenso"]},
+    "alfileres y agujas": {"english": "pins and needles", "type": "neuropathic", "dimension": "sensory"},
+    "choque eléctrico": {"english": "electric shock", "type": "neuropathic", "dimension": "sensory",
+                         "aliases": ["descarga eléctrica"]},
+    "punzante": {"english": "shooting", "type": "neuropathic", "dimension": "sensory"},
+    "apuñalante": {"english": "stabbing", "type": "neuropathic", "dimension": "sensory"},
+    "agudo": {"english": "sharp", "type": "neuropathic", "dimension": "sensory"},
+    "perforante": {"english": "piercing", "type": "neuropathic", "dimension": "sensory"},
+    "punzada": {"english": "stinging", "type": "neuropathic", "dimension": "sensory"},
+    
+    # Sensory - Nociceptive
+    "dolor sordo": {"english": "aching", "type": "nociceptive", "dimension": "sensory"},
+    "pulsátil": {"english": "throbbing", "type": "nociceptive", "dimension": "sensory",
+                 "aliases": ["latiendo", "palpitante"]},
+    "martilleante": {"english": "pounding", "type": "nociceptive", "dimension": "sensory"},
+    "golpeante": {"english": "beating", "type": "nociceptive", "dimension": "sensory"},
+    "pulsante": {"english": "pulsing", "type": "nociceptive", "dimension": "sensory"},
+    "calambre": {"english": "cramping", "type": "nociceptive", "dimension": "sensory"},
+    "roedor": {"english": "gnawing", "type": "nociceptive", "dimension": "sensory"},
+    "aplastante": {"english": "crushing", "type": "nociceptive", "dimension": "sensory"},
+    "presión": {"english": "pressing", "type": "nociceptive", "dimension": "sensory"},
+    "apretante": {"english": "squeezing", "type": "nociceptive", "dimension": "sensory"},
+    "tirante": {"english": "pulling", "type": "nociceptive", "dimension": "sensory"},
+    "desgarrante": {"english": "tearing", "type": "nociceptive", "dimension": "sensory"},
+    "dividiendo": {"english": "splitting", "type": "nociceptive", "dimension": "sensory"},
+    "adolorido": {"english": "sore", "type": "nociceptive", "dimension": "sensory"},
+    "sensible": {"english": "tender", "type": "nociceptive", "dimension": "sensory"},
+    "sordo": {"english": "dull", "type": "nociceptive", "dimension": "sensory"},
+    "pesado": {"english": "heavy", "type": "nociceptive", "dimension": "sensory"},
+    
+    # Thermal
+    "caliente": {"english": "hot", "type": "nociceptive", "dimension": "sensory"},
+    "frío": {"english": "cold", "type": "nociceptive", "dimension": "sensory"},
+    "congelante": {"english": "freezing", "type": "nociceptive", "dimension": "sensory"},
+    "escaldante": {"english": "scalding", "type": "nociceptive", "dimension": "sensory"},
+    
+    # Affective
+    "agotador": {"english": "exhausting", "type": "affective", "dimension": "affective"},
+    "cansador": {"english": "tiring", "type": "affective", "dimension": "affective"},
+    "problemático": {"english": "troublesome", "type": "affective", "dimension": "affective"},
+    "miserable": {"english": "miserable", "type": "affective", "dimension": "affective"},
+    "insoportable": {"english": "unbearable", "type": "affective", "dimension": "affective"},
+    "espantoso": {"english": "frightful", "type": "affective", "dimension": "affective"},
+    "aterrador": {"english": "terrifying", "type": "affective", "dimension": "affective"},
+    "cruel": {"english": "cruel", "type": "affective", "dimension": "affective"},
+    "vicioso": {"english": "vicious", "type": "affective", "dimension": "affective"},
+    "castigador": {"english": "punishing", "type": "affective", "dimension": "affective"},
+    
+    # Evaluative
+    "molesto": {"english": "annoying", "type": "evaluative", "dimension": "evaluative"},
+    "persistente": {"english": "nagging", "type": "evaluative", "dimension": "evaluative"},
+    "intenso": {"english": "intense", "type": "evaluative", "dimension": "evaluative"},
+}
+
+# Hmong McGill Pain Descriptors (Hmong McGill Mob Nug)
+HMONG_MCGILL = {
+    # Sensory - Neuropathic
+    "kub hnyiab": {"english": "burning", "type": "neuropathic", "dimension": "sensory"},
+    "tub nkeeg": {"english": "tingling", "type": "neuropathic", "dimension": "sensory"},
+    "loog": {"english": "numbness", "type": "neuropathic", "dimension": "sensory"},
+    "zoo li ntsaum nkag": {"english": "formication", "type": "neuropathic", "dimension": "sensory",
+                           "aliases": ["zoo li kab nkag", "ntsaum taug kev"]},
+    "koob thiab tus pin": {"english": "pins and needles", "type": "neuropathic", "dimension": "sensory"},
+    "mob hluav taw xob": {"english": "electric shock", "type": "neuropathic", "dimension": "sensory"},
+    "tua": {"english": "shooting", "type": "neuropathic", "dimension": "sensory"},
+    "ntaus ntaj": {"english": "stabbing", "type": "neuropathic", "dimension": "sensory"},
+    "ntse": {"english": "sharp", "type": "neuropathic", "dimension": "sensory"},
+    "piercing": {"english": "piercing", "type": "neuropathic", "dimension": "sensory"},
+    "tom": {"english": "stinging", "type": "neuropathic", "dimension": "sensory"},
+    
+    # Sensory - Nociceptive
+    "mob": {"english": "aching", "type": "nociceptive", "dimension": "sensory"},
+    "dhia": {"english": "throbbing", "type": "nociceptive", "dimension": "sensory"},
+    "ntaus": {"english": "pounding", "type": "nociceptive", "dimension": "sensory"},
+    "ntaus": {"english": "beating", "type": "nociceptive", "dimension": "sensory"},
+    "pulsing": {"english": "pulsing", "type": "nociceptive", "dimension": "sensory"},
+    "cramping": {"english": "cramping", "type": "nociceptive", "dimension": "sensory"},
+    "zom": {"english": "gnawing", "type": "nociceptive", "dimension": "sensory"},
+    "tsoo": {"english": "crushing", "type": "nociceptive", "dimension": "sensory"},
+    "nias": {"english": "pressing", "type": "nociceptive", "dimension": "sensory"},
+    "nyem": {"english": "squeezing", "type": "nociceptive", "dimension": "sensory"},
+    "rub": {"english": "pulling", "type": "nociceptive", "dimension": "sensory"},
+    "tsuas": {"english": "tearing", "type": "nociceptive", "dimension": "sensory"},
+    "sib cais": {"english": "splitting", "type": "nociceptive", "dimension": "sensory"},
+    "mob": {"english": "sore", "type": "nociceptive", "dimension": "sensory"},
+    "rhiab": {"english": "tender", "type": "nociceptive", "dimension": "sensory"},
+    "dull": {"english": "dull", "type": "nociceptive", "dimension": "sensory"},
+    "hnyav": {"english": "heavy", "type": "nociceptive", "dimension": "sensory"},
+    
+    # Thermal
+    "kub": {"english": "hot", "type": "nociceptive", "dimension": "sensory"},
+    "txias": {"english": "cold", "type": "nociceptive", "dimension": "sensory"},
+    "khov": {"english": "freezing", "type": "nociceptive", "dimension": "sensory"},
+    "scalding": {"english": "scalding", "type": "nociceptive", "dimension": "sensory"},
+    
+    # Affective
+    "nkees": {"english": "exhausting", "type": "affective", "dimension": "affective"},
+    "nkees": {"english": "tiring", "type": "affective", "dimension": "affective"},
+    "teeb meem": {"english": "troublesome", "type": "affective", "dimension": "affective"},
+    "tu siab": {"english": "miserable", "type": "affective", "dimension": "affective"},
+    "tsis tau": {"english": "unbearable", "type": "affective", "dimension": "affective"},
+    "ntshai": {"english": "frightful", "type": "affective", "dimension": "affective"},
+    "txaus ntshai": {"english": "terrifying", "type": "affective", "dimension": "affective"},
+    "siab phem": {"english": "cruel", "type": "affective", "dimension": "affective"},
+    "phem": {"english": "vicious", "type": "affective", "dimension": "affective"},
+    "rau txim": {"english": "punishing", "type": "affective", "dimension": "affective"},
+    
+    # Evaluative
+    "ntxhov siab": {"english": "annoying", "type": "evaluative", "dimension": "evaluative"},
+    "nagging": {"english": "nagging", "type": "evaluative", "dimension": "evaluative"},
+    "muaj zog": {"english": "intense", "type": "evaluative", "dimension": "evaluative"},
+}

Backend/ontology/pain_mapping.py

@@ -0,0 +1,449 @@
+"""
+Chinese-English pain ontology mapping dictionary.
+
+Maps culturally-specific Chinese pain descriptors to standardized English medical terminology
+aligned with McGill Pain Questionnaire (SF-MPQ) and SNOMED CT.
+
+This module provides deterministic, dictionary-based mapping to ensure medical accuracy
+and cross-cultural semantic alignment.
+"""
+
+from typing import List, Dict, Optional, Any
+
+
+# Chinese pain descriptor mappings
+# Each entry maps a Chinese term to its English medical equivalent with metadata
+CHINESE_PAIN_DESCRIPTORS = {
+    # ========== Neuropathic Pain Descriptors ==========
+    "针扎": {
+        "english": "Pricking",
+        "aliases": ["像针扎一样", "针刺", "如针扎", "针扎样"],
+        "dimension": "sensory",
+        "pain_type": "neuropathic",
+        "mcgill_category": "Sensory",
+        "description": "Sharp, needle-like pain sensation typical of nerve irritation"
+    },
+    
+    "触电": {
+        "english": "Electric-shock-like",
+        "aliases": ["像触电一样", "电击", "过电", "触电样", "电击样"],
+        "dimension": "sensory",
+        "pain_type": "neuropathic",
+        "mcgill_category": "Sensory",
+        "description": "Sharp, sudden, shocking nerve pain resembling electric shock"
+    },
+    
+    "麻": {
+        "english": "Tingling",
+        "aliases": ["发麻", "麻木", "麻刺", "又麻又痛", "麻痹"],
+        "dimension": "sensory",
+        "pain_type": "neuropathic",
+        "mcgill_category": "Sensory",
+        "description": "Tingling, numbness, or pins-and-needles sensation"
+    },
+    
+    "刺": {
+        "english": "Stabbing",
+        "aliases": ["刺痛", "刀刺", "刺骨", "像刀刺一样"],
+        "dimension": "sensory",
+        "pain_type": "neuropathic",
+        "mcgill_category": "Sensory",
+        "description": "Sharp, stabbing pain sensation"
+    },
+    
+    "蚂蚁": {
+        "english": "Formication (crawling sensation)",
+        "aliases": ["蚂蚁在咬", "蚂蚁爬", "虫子爬", "有东西在爬"],
+        "dimension": "sensory",
+        "pain_type": "neuropathic",
+        "mcgill_category": "Sensory",
+        "description": "Crawling, tingling sensation like insects on skin"
+    },
+    
+    # ========== Nociceptive Pain Descriptors ==========
+    "火辣辣": {
+        "english": "Burning",
+        "aliases": ["烧灼", "灼烧", "火烧", "灼热", "火辣"],
+        "dimension": "sensory",
+        "pain_type": "nociceptive",
+        "mcgill_category": "Sensory",
+        "description": "Hot, burning sensation"
+    },
+    
+    "隐痛": {
+        "english": "Aching",
+        "aliases": ["隐隐作痛", "隐隐的痛", "隐约的痛"],
+        "dimension": "sensory",
+        "pain_type": "nociceptive",
+        "mcgill_category": "Sensory",
+        "description": "Dull, continuous aching pain"
+    },
+    
+    "酸痛": {
+        "english": "Sore",
+        "aliases": ["酸", "发酸", "又酸又痛"],
+        "dimension": "sensory",
+        "pain_type": "nociceptive",
+        "mcgill_category": "Sensory",
+        "description": "Sore, achy muscle pain"
+    },
+    
+    "胀": {
+        "english": "Distended",
+        "aliases": ["胀痛", "又酸又胀", "发胀", "膨胀"],
+        "dimension": "sensory",
+        "pain_type": "nociceptive",
+        "mcgill_category": "Sensory",
+        "description": "Distending, swelling pain sensation"
+    },
+    
+    "跳": {
+        "english": "Throbbing",
+        "aliases": ["跳痛", "一跳一跳的", "像心跳一样"],
+        "dimension": "sensory",
+        "pain_type": "nociceptive",
+        "mcgill_category": "Sensory",
+        "description": "Pulsating, throbbing pain"
+    },
+    
+    "钝痛": {
+        "english": "Dull",
+        "aliases": ["钝钝的", "不尖锐"],
+        "dimension": "sensory",
+        "pain_type": "nociceptive",
+        "mcgill_category": "Sensory",
+        "description": "Dull, non-sharp pain"
+    },
+
+    
+    # ========== Affective (Emotional) Descriptors ==========
+    "郁闷": {
+        "english": "Depressed",
+        "aliases": ["抑郁", "心情不好", "情绪低落", "沮丧", "低落"],
+        "dimension": "affective",
+        "mcgill_category": "Affective",
+        "description": "Emotional distress and depressive symptoms associated with pain"
+    },
+    
+    "烦躁": {
+        "english": "Anxious",
+        "aliases": ["焦虑", "心烦", "烦", "不安", "烦恼"],
+        "dimension": "affective",
+        "mcgill_category": "Affective",
+        "description": "Anxiety, irritability, and restlessness"
+    },
+    
+    "累": {
+        "english": "Exhausting",
+        "aliases": ["疲惫", "累得慌", "精疲力竭", "疲劳", "乏力"],
+        "dimension": "affective",
+        "mcgill_category": "Affective",
+        "description": "Physical and emotional exhaustion from persistent pain"
+    },
+    
+    "难受": {
+        "english": "Distressing",
+        "aliases": ["痛苦", "受罪", "���磨"],
+        "dimension": "affective",
+        "mcgill_category": "Affective",
+        "description": "Overall distress and suffering"
+    },
+    
+    "绝望": {
+        "english": "Hopeless",
+        "aliases": ["没希望", "无望"],
+        "dimension": "affective",
+        "mcgill_category": "Affective",
+        "description": "Sense of hopelessness and despair"
+    }
+    
+
+}
+
+
+# Temporal pattern mappings
+TEMPORAL_PATTERNS = {
+    "几个月": "Chronic (>3 months)",
+    "好几个月": "Chronic (>3 months)",
+    "很久": "Chronic (>3 months)",
+    "长期": "Chronic (>3 months)",
+    "一直": "Constant",
+    "总是": "Constant",
+    "经常": "Frequent",
+    "偶尔": "Intermittent",
+    "时不时": "Intermittent",
+    "有时候": "Intermittent",
+    "突然": "Acute onset",
+    "最近": "Recent onset",
+    "反复": "Recurring",
+    "每天": "Daily",
+    "晚上": "Nocturnal"
+}
+
+
+# Anatomical location mappings
+ANATOMICAL_LOCATIONS = {
+    "腰": "Lower back",
+    "后腰": "Lower back",
+    "腰部": "Lower back",
+    "腿": "Lower extremities",
+    "下肢": "Lower extremities",
+    "大腿": "Thighs",
+    "小腿": "Legs",
+    "膝盖": "Knees",
+    "膝": "Knees",
+    "手": "Hands",
+    "上肢": "Upper extremities",
+    "脚": "Feet",
+    "足": "Feet",
+    "头": "Head",
+    "颈": "Neck",
+    "脖子": "Neck",
+    "肩": "Shoulders",
+    "背": "Back",
+    "胸": "Chest",
+    "腹": "Abdomen",
+    "肚子": "Abdomen",
+    "浑身": "Whole body"
+    
+}
+
+
+def map_chinese_to_english(chinese_text: str) -> List[Dict[str, Any]]:
+    """
+    Map Chinese pain descriptors to standardized English medical terminology.
+    
+    Uses dictionary-based exact and fuzzy matching to identify pain descriptors
+    in patient text and map them to McGill Pain Questionnaire dimensions and
+    SNOMED CT codes.
+    
+    Args:
+        chinese_text: Raw Chinese patient description
+        
+    Returns:
+        List of mappings, each containing:
+        - chinese_input: The Chinese term found in text
+        - mapped_english: Standardized English medical term
+        - dimension: sensory/affective
+        - pain_type: neuropathic/nociceptive (if applicable)
+        - snomed_ct: SNOMED CT code (if applicable)
+        - confidence: Mapping confidence (high/medium/low)
+    
+    Example:
+        >>> mappings = map_chinese_to_english("腰部像触电一样的麻痛，很郁闷")
+        >>> # Returns mappings for "触电" → "Electric-shock-like" and "郁闷" → "Depressed"
+    """
+    mappings = []
+    
+    # Iterate through all defined pain descriptors
+    for chinese_term, term_data in CHINESE_PAIN_DESCRIPTORS.items():
+        # Check if main term appears in text
+        if chinese_term in chinese_text:
+            mappings.append({
+                "chinese_input": chinese_term,
+                "mapped_english": term_data["english"],
+                "dimension": term_data["dimension"],
+                "pain_type": term_data.get("pain_type"),
+                "confidence": "high",
+                "mcgill_category": term_data.get("mcgill_category")
+            })
+        else:
+            # Check aliases for fuzzy matching
+            for alias in term_data.get("aliases", []):
+                if alias in chinese_text:
+                    mappings.append({
+                        "chinese_input": alias,
+                        "mapped_english": term_data["english"],
+                        "dimension": term_data["dimension"],
+                        "pain_type": term_data.get("pain_type"),
+                        "confidence": "high",
+                        "mcgill_category": term_data.get("mcgill_category")
+                    })
+                    break  # Only match once per term to avoid duplicates
+    
+    return mappings
+
+
+def extract_temporal_pattern(chinese_text: str) -> Optional[str]:
+    """
+    Extract and standardize temporal pattern from Chinese text.
+    
+    Identifies duration, frequency, and onset patterns and maps them to
+    standardized clinical terminology.
+    
+    Args:
+        chinese_text: Raw Chinese patient description
+        
+    Returns:
+        Standardized temporal pattern string or None if not found
+        
+    Example:
+        >>> extract_temporal_pattern("已经好几个月了")
+        'Chronic (>3 months)'
+    """
+    # Check for duration indicators (prioritize more specific patterns)
+    # Look for "X个月" pattern first
+    import re
+    
+    # Extract numeric duration
+    month_match = re.search(r'(\d+)\s*个月', chinese_text)
+    if month_match:
+        months = int(month_match.group(1))
+        if months >= 3:
+            return f"Chronic ({months} months)"
+        else:
+            return f"Acute (<3 months, {months} months)"
+    
+    # Check predefined temporal patterns
+    for chinese_pattern, english_pattern in TEMPORAL_PATTERNS.items():
+        if chinese_pattern in chinese_text:
+            return english_pattern
+    
+    return None
+
+
+def extract_anatomical_location(chinese_text: str) -> List[str]:
+    """
+    Extract anatomical locations from Chinese text.
+    
+    Identifies body parts mentioned in patient description and maps them
+    to standardized anatomical terminology.
+    
+    Args:
+        chinese_text: Raw Chinese patient description
+        
+    Returns:
+        List of standardized anatomical location strings
+        
+    Example:
+        >>> extract_anatomical_location("腰部到腿部都痛")
+        ['Lower back', 'Lower extremities']
+    """
+    locations = []
+    
+    for chinese_loc, english_loc in ANATOMICAL_LOCATIONS.items():
+        if chinese_loc in chinese_text:
+            if english_loc not in locations:  # Avoid duplicates
+                locations.append(english_loc)
+    
+    return locations
+
+
+def get_unmapped_descriptors(chinese_text: str, mappings: List[Dict]) -> List[str]:
+    """
+    Identify pain-related words in text that were not mapped to standard terminology.
+    
+    This helps track coverage gaps in the mapping dictionary and identify
+    culturally-specific terms that may need to be added.
+    
+    Args:
+        chinese_text: Raw Chinese patient description
+        mappings: List of mappings returned by map_chinese_to_english()
+        
+    Returns:
+        List of Chinese pain-related terms that were not mapped
+        
+    Note:
+        This is a simple heuristic-based approach. For production use,
+        consider using NER or more sophisticated linguistic analysis.
+    """
+    # Common pain-related indicator words in Chinese
+    pain_indicators = ["痛", "疼", "酸", "麻", "胀", "难受", "不舒服"]
+    
+    unmapped = []
+    # Support both old format (chinese_input) and new format (original_term)
+    mapped_terms = {m.get("chinese_input") or m.get("original_term") for m in mappings}
+    
+    # Simple heuristic: look for pain indicator characters
+    for indicator in pain_indicators:
+        if indicator in chinese_text and indicator not in mapped_terms:
+            # Extract context around the indicator (basic approach)
+            import re
+            pattern = f".{{0,3}}{indicator}.{{0,3}}"
+            matches = re.findall(pattern, chinese_text)
+            for match in matches:
+                if match not in mapped_terms and match not in unmapped:
+                    unmapped.append(match)
+    
+    return unmapped
+
+
+def suggest_similar_terms(unmapped_term: str, language: str = "zh") -> List[Dict[str, Any]]:
+    """
+    Suggest similar pain descriptors from the dictionary for unmapped terms.
+    
+    This function provides NON-DEFINITIVE suggestions for terms not found in the dictionary.
+    It helps clinicians understand what the patient MIGHT be trying to express,
+    but DOES NOT make automatic mappings.
+    
+    Args:
+        unmapped_term: Pain descriptor not found in dictionary
+        language: Language code (currently supports 'zh' for Chinese)
+        
+    Returns:
+        List of dictionaries containing similar terms and their properties:
+        [
+            {
+                "dictionary_term": "刺痛",
+                "english": "Stabbing",
+                "similarity_reason": "shares character '痛'",
+                "confidence": "low",  # Always low for suggestions
+                "note": "⚠️ Suggestion only - clinical review required"
+            }
+        ]
+        
+    Example:
+        >>> suggest_similar_terms("猛痛", "zh")
+        [
+            {
+                "dictionary_term": "刺痛",
+                "english": "Stabbing",
+                "similarity_reason": "shares '痛' character, both indicate sharp pain",
+                "confidence": "low",
+                "note": "⚠️ This is a suggestion based on character similarity. The patient's exact term '猛痛' should be noted for clinical context."
+            }
+        ]
+    """
+    if language != "zh":
+        return []  # Only support Chinese for now
+    
+    suggestions = []
+    
+    # Extract key characters from unmapped term
+    pain_chars = set()
+    for char in ["痛", "疼", "酸", "麻", "胀", "刺", "钝", "跳", "抽", "紧", "沉", "胀"]:
+        if char in unmapped_term:
+            pain_chars.add(char)
+    
+    if not pain_chars:
+        return []
+    
+    # Search dictionary for terms sharing similar characters
+    for dict_term, metadata in CHINESE_PAIN_DESCRIPTORS.items():
+        shared_chars = pain_chars & set(dict_term)
+        
+        if shared_chars:
+            similarity_reason = f"shares character(s): {', '.join(shared_chars)}"
+            
+            # Check if both terms share semantic elements
+            if len(unmapped_term) > 1 and len(dict_term) > 1:
+                # Check for substring match
+                if unmapped_term in dict_term or dict_term in unmapped_term:
+                    similarity_reason += " (possible variant or related form)"
+            
+            suggestions.append({
+                "dictionary_term": dict_term,
+                "english": metadata["english"],
+                "pain_type": metadata.get("pain_type", "unknown"),
+                "dimension": metadata.get("dimension", "unknown"),
+                "similarity_reason": similarity_reason,
+                "confidence": "low",  # Always low - this is just a suggestion
+                "note": f"⚠️ Suggestion only. Patient used '{unmapped_term}' which is not in our dictionary. "
+                        f"'{dict_term}' is similar but may not match patient's intent. Clinical review recommended."
+            })
+    
+    # Sort by number of shared characters (most similar first)
+    suggestions.sort(key=lambda x: len([c for c in pain_chars if c in x["dictionary_term"]]), reverse=True)
+    
+    # Return top 3 suggestions at most
+    return suggestions[:3]

Backend/ontology/pain_mapping_multilingual.py

@@ -0,0 +1,320 @@
+"""
+Multilingual pain ontology mapping dictionary.
+
+Extends the Chinese-English mapping to support Korean, Spanish, and Hmong languages.
+Maps culturally-specific pain descriptors to standardized English medical terminology
+aligned with McGill Pain Questionnaire (SF-MPQ) and SNOMED CT.
+
+Supported Languages:
+- Chinese (Simplified)
+- Korean (Hangul)
+- Spanish (Castilian)
+- Hmong
+
+This module provides deterministic, dictionary-based mapping to ensure medical accuracy
+and cross-cultural semantic alignment.
+"""
+
+import json
+import os
+import sys
+from typing import List, Dict, Optional, Any
+
+# Add parent directory to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from utils.language_detector import detect_language, LanguageCode
+
+# Load multilingual pain descriptors from JSON
+def _load_pain_descriptors():
+    """Load pain descriptors from JSON file"""
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    json_path = os.path.join(current_dir, '..', 'scripts', 'multilingual_pain_data.json')
+    
+    with open(json_path, 'r', encoding='utf-8') as f:
+        return json.load(f)
+
+
+def _extract_core_terms(term: str, language: str) -> List[str]:
+    """
+    Extract core pain descriptor terms to enable fuzzy matching across all languages.
+    
+    Handles linguistic variations:
+    - Chinese: Removes suffixes like 'de-tong', 'de-teng', 'de-ganjue'
+    - Korean: Removes verb endings like 'hada', 'apeuda'
+    - Spanish: Extracts root words, handles verb forms
+    - Hmong: Splits compound words
+    
+    Args:
+        term: Original term from ontology dictionary
+        language: Language code ('zh', 'ko', 'es', 'hmong', 'en')
+        
+    Returns:
+        List of core term variants (including original)
+        
+    Example:
+        >>> _extract_core_terms("yi-chou-yi-chou-de-tong", "zh")
+        ['yi-chou-yi-chou', 'yi-chou-yi-chou-de-tong']
+        >>> _extract_core_terms("punzante", "es")
+        ['punzante', 'punz']  # root form
+    """
+    cores = []
+    
+    if language == 'zh':  # Chinese
+        # Remove common pain-related suffixes to extract core descriptor
+        suffixes = ['的痛', '的疼', '的感觉', '痛', '疼', '的']
+        core = term
+        
+        for suffix in suffixes:
+            if core.endswith(suffix) and len(core) > len(suffix):
+                core = core[:-len(suffix)]
+                cores.append(core)
+                break
+        
+        cores.append(term)  # Also keep original term for exact matching
+        
+    elif language == 'ko':  # Korean
+        # Handle Korean verb conjugations and descriptive forms
+        if term.endswith('하다') and len(term) > 2:
+            cores.append(term[:-2])
+        elif term.endswith('아프다') and len(term) > 3:
+            cores.append(term[:-3])
+        elif term.endswith('듯') and len(term) > 2:
+            cores.append(term[:-2])
+        cores.append(term)
+        
+    elif language == 'es':  # Spanish
+        # Handle common Spanish suffixes and verb forms
+        # Examples: "punzante" → "punz", "ardiente" → "ardi"
+        spanish_suffixes = ['ante', 'ente', 'ción', 'miento', 'oso', 'osa']
+        core = term.lower()
+        
+        for suffix in spanish_suffixes:
+            if core.endswith(suffix) and len(core) > len(suffix) + 3:
+                cores.append(core[:-len(suffix)])
+                break
+        
+        # Also try matching first 4+ characters for root
+        if len(term) >= 4:
+            cores.append(term[:4])
+        
+        cores.append(term)
+        
+    elif language == 'hmong':  # Hmong
+        # Hmong often uses compound words separated by spaces
+        # Split and try individual words too
+        if ' ' in term:
+            words = term.split()
+            cores.extend(words)  # Add individual words
+        cores.append(term)  # Keep full phrase
+        
+    else:  # English - keep as is
+        cores.append(term)
+    
+    return list(set(cores))  # Remove duplicates
+
+# Load data at module level
+_MULTILINGUAL_DATA = _load_pain_descriptors()
+
+# Flatten the multilingual data for easier access
+# Structure: {language: {term: {english, dimension, pain_type, ...}}}
+KOREAN_PAIN_DESCRIPTORS = {}
+for category in ['neuropathic', 'nociceptive', 'affective']:
+    for term, data in _MULTILINGUAL_DATA['korean'].get(category, {}).items():
+        KOREAN_PAIN_DESCRIPTORS[term] = {
+            **data,
+            'pain_type': category if category != 'affective' else None,
+            'dimension': 'affective' if category == 'affective' else 'sensory'
+        }
+
+SPANISH_PAIN_DESCRIPTORS = {}
+for category in ['neuropathic', 'nociceptive', 'affective']:
+    for term, data in _MULTILINGUAL_DATA['spanish'].get(category, {}).items():
+        SPANISH_PAIN_DESCRIPTORS[term] = {
+            **data,
+            'pain_type': category if category != 'affective' else None,
+            'dimension': 'affective' if category == 'affective' else 'sensory'
+        }
+
+HMONG_PAIN_DESCRIPTORS = {}
+for category in ['neuropathic', 'nociceptive', 'affective']:
+    for term, data in _MULTILINGUAL_DATA['hmong'].get(category, {}).items():
+        HMONG_PAIN_DESCRIPTORS[term] = {
+            **data,
+            'pain_type': category if category != 'affective' else None,
+            'dimension': 'affective' if category == 'affective' else 'sensory'
+        }
+
+CHINESE_PAIN_DESCRIPTORS = {}
+for category in ['neuropathic', 'nociceptive', 'affective']:
+    for term, data in _MULTILINGUAL_DATA['chinese'].get(category, {}).items():
+        CHINESE_PAIN_DESCRIPTORS[term] = {
+            **data,
+            'pain_type': category if category != 'affective' else None,
+            'dimension': 'affective' if category == 'affective' else 'sensory'
+        }
+
+# Map language codes to descriptor dictionaries
+LANGUAGE_DESCRIPTORS = {
+    'zh': CHINESE_PAIN_DESCRIPTORS,
+    'ko': KOREAN_PAIN_DESCRIPTORS,
+    'es': SPANISH_PAIN_DESCRIPTORS,
+    'hmong': HMONG_PAIN_DESCRIPTORS,
+    'en': {}  # English input doesn't need translation
+}
+
+
+def map_multilingual_to_english(
+    text: str, 
+    language: Optional[LanguageCode] = None
+) -> List[Dict[str, Any]]:
+    """
+    Map multilingual pain descriptors to standardized English medical terminology.
+    
+    Supports Chinese, Korean, Spanish, Hmong, and English input.
+    Uses dictionary-based exact matching to identify pain descriptors
+    and map them to McGill Pain Questionnaire dimensions.
+    
+    Args:
+        text: Raw patient description in any supported language
+        language: Language code ('zh', 'ko', 'es', 'hmong', 'en'). 
+                 If None, will auto-detect from text.
+        
+    Returns:
+        List of mappings, each containing:
+        - original_term: The term found in text
+        - mapped_english: Standardized English medical term
+        - dimension: sensory/affective
+        - pain_type: neuropathic/nociceptive (if applicable)
+        - confidence: Mapping confidence (high/medium/low)
+        - detected_language: The detected or specified language
+    
+    Example:
+        >>> # Chinese input
+        >>> mappings = map_multilingual_to_english("I have burning pain")
+        >>> # Returns mapping for "burning pain" → "burning"
+        
+        >>> # Korean input
+        >>> mappings = map_multilingual_to_english("허리가 따끔거리듯이 아프다")
+        >>> # Returns mapping for "따끔거리다" → "sting"
+    """
+    # Auto-detect language if not specified
+    if language is None:
+        language = detect_language(text)
+    
+    # Get appropriate descriptor dictionary
+    descriptors = LANGUAGE_DESCRIPTORS.get(language, {})
+    
+    if not descriptors:
+        # If language not supported or English input
+        return [{
+            "original_term": text,
+            "mapped_english": text,  # Pass through for English
+            "dimension": "unknown",
+            "pain_type": None,
+            "confidence": "low",
+            "detected_language": language
+        }]
+    
+    mappings = []
+    
+    # Iterate through all defined pain descriptors for this language
+    for term, term_data in descriptors.items():
+        # Extract core terms for fuzzy matching
+        core_terms = _extract_core_terms(term, language)
+        
+        # Try to match any core term variant
+        matched_core = None
+        for core in core_terms:
+            # For Chinese, allow single character matches (麻, 疼, 痛, 酸, etc.)
+            # For other languages, require at least 2 characters to avoid false positives
+            min_length = 1 if language == 'zh' else 2
+            if core in text and len(core) >= min_length:
+                matched_core = core
+                break
+        
+        if matched_core:
+            # Determine confidence based on match type
+            confidence = "high" if matched_core == term else "medium"
+            
+            mappings.append({
+                "original_term": term,  # Original ontology term
+                "matched_text": matched_core,  # What actually matched in user input
+                "mapped_english": term_data["english"],
+                "dimension": term_data["dimension"],
+                "pain_type": term_data.get("pain_type"),
+                "confidence": confidence,
+                "mcgill_dimension": term_data.get("mcgill_dimension", "sensory"),
+                "detected_language": language
+            })
+    
+    return mappings
+
+
+def get_supported_languages() -> List[str]:
+    """
+    Get list of all supported languages.
+    
+    Returns:
+        List of language codes
+    """
+    return ['zh', 'ko', 'es', 'hmong', 'en']
+
+
+def get_descriptor_count(language: LanguageCode) -> int:
+    """
+    Get the number of pain descriptors available for a language.
+    
+    Args:
+        language: Language code
+        
+    Returns:
+        Number of descriptors
+    """
+    return len(LANGUAGE_DESCRIPTORS.get(language, {}))
+
+
+# Re-export temporal and anatomical mappings from original module
+# These are language-agnostic or can be expanded in the future
+try:
+    from ontology.pain_mapping import (
+        TEMPORAL_PATTERNS,
+        ANATOMICAL_LOCATIONS,
+        extract_temporal_pattern,
+        extract_anatomical_location
+    )
+except ImportError:
+    # Fallback if running as standalone
+    from pain_mapping import (
+        TEMPORAL_PATTERNS,
+        ANATOMICAL_LOCATIONS,
+        extract_temporal_pattern,
+        extract_anatomical_location
+    )
+
+
+if __name__ == '__main__':
+    # Test multilingual mapping
+    test_cases = [
+        ("我有火辣辣的疼痛", "zh"),
+        ("허리가 따끔거리듯이 아프다", "ko"),
+        ("Tengo un dolor agudo", "es"),
+        ("Kuv mob mob heev", "hmong"),
+    ]
+    
+    print("Multilingual Pain Mapping Tests:")
+    print("=" * 70)
+    
+    for text, expected_lang in test_cases:
+        print(f"\nText: {text}")
+        print(f"Expected language: {expected_lang}")
+        
+        mappings = map_multilingual_to_english(text)
+        
+        if mappings:
+            print(f"Mappings found: {len(mappings)}")
+            for m in mappings:
+                print(f"  - {m['original_term']} → {m['mapped_english']} ({m['pain_type']})")
+                print(f"    Language: {m['detected_language']}, Confidence: {m['confidence']}")
+        else:
+            print("  No mappings found")

Backend/pipeline/__init__.py

@@ -0,0 +1,6 @@
+"""
+End-to-end neuro-symbolic pain assessment pipeline orchestration.
+"""
+from .pain_assessment_pipeline import PainAssessmentPipeline
+
+__all__ = ['PainAssessmentPipeline']

Backend/pipeline/pain_assessment_pipeline.py

@@ -0,0 +1,644 @@
+"""
+End-to-end neuro-symbolic pain assessment pipeline with multilingual support.
+
+Orchestrates: LLM extraction -> Ontology mapping -> JSON structuring -> Rule engine -> Report generation
+
+Supported Languages: Chinese (中文), Korean (한국어), Spanish (Español), Hmong
+
+This module implements the complete data flow from unstructured patient input to
+structured, explainable clinical recommendations. LLM is used ONLY for narrow-scope
+entity extraction and optional report formatting. All clinical logic is deterministic
+and rule-based.
+"""
+
+from typing import Dict, Any, List
+import sys
+import os
+
+# Add Backend to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from models.pain_schema import PainOntology, ExplainableReport
+from ontology.pain_mapping_multilingual import (
+    map_multilingual_to_english,
+    extract_temporal_pattern,
+    extract_anatomical_location,
+    get_supported_languages
+)
+from ontology.pain_mapping import get_unmapped_descriptors, suggest_similar_terms
+from utils.language_detector import detect_language, get_language_name, LanguageCode
+from inference.rule_engine import RuleEngine
+from utils.report_generator import generate_comprehensive_report, translate_to_english_simple
+
+# Smart semantic distance service selection
+EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL", "biolord")
+
+if EMBEDDING_MODEL == "biolord":
+    from services.semantic_distance_service_biolord import calculate_semantic_distances
+else:
+    from services.semantic_distance_service_v2 import calculate_semantic_distances
+
+
+class PainAssessmentPipeline:
+    """
+    Orchestrates the complete neuro-symbolic pain assessment workflow.
+    
+    Pipeline stages:
+    1. Input Reception - Receive raw patient text
+    2. LLM Entity Extraction - Extract entities using constrained LLM (NER only)
+    3. Ontology Mapping - Map Chinese terms to English medical terminology
+    4. JSON Structuring - Populate PainOntology Pydantic model
+    5. Rule Engine - Apply deterministic clinical decision rules
+    6. Report Generation - Create final explainable report
+    
+    LLM is used ONLY for narrow-scope NER and final report formatting.
+    All clinical logic is deterministic and rule-based.
+    """
+    
+    def __init__(self, verbose: bool = True):
+        """
+        Initialize the pain assessment pipeline.
+        
+        Args:
+            verbose: If True, print progress messages for each pipeline stage
+        """
+        self.rule_engine = RuleEngine()
+        self.verbose = verbose
+    
+    def _log(self, message: str):
+        """Print log message if verbose mode is enabled."""
+        if self.verbose:
+            print(message)
+    
+    def execute(
+        self, 
+        patient_text: str, 
+        llm_entities: Dict[str, Any] = None,
+        language: LanguageCode = None
+    ) -> ExplainableReport:
+        """
+        Execute the complete pain assessment pipeline with multilingual support.
+        
+        Args:
+            patient_text: Raw patient pain description in any supported language
+                         (Chinese, Korean, Spanish, Hmong, English)
+            llm_entities: Optional pre-extracted LLM entities (for testing or caching)
+                         If None, will need to call LLM service externally
+            language: Optional language code ('zh', 'ko', 'es', 'hmong', 'en')
+                     If None, will auto-detect from text
+            
+        Returns:
+            ExplainableReport with structured data, reasoning chain, and recommendations
+            
+        Example:
+            >>> pipeline = PainAssessmentPipeline()
+            >>> # Chinese input
+            >>> text = "最近四个月腰部到腿部总是像触电一样的麻痛，晚上痛得睡不着，心情很郁闷"
+            >>> llm_entities = {
+            ...     "pain_descriptors": ["触电一样", "麻痛"],
+            ...     "location": "腰部到腿部",
+            ...     "duration_phrase": "四个月",
+            ...     "emotion_keywords": ["郁闷"],
+            ...     "functional_impact": "睡不着"
+            ... }
+            >>> report = pipeline.execute(text, llm_entities)
+            >>> 
+            >>> # Korean input
+            >>> text_ko = "허리가 따끔거리듯이 아프다"
+            >>> report = pipeline.execute(text_ko, language='ko')
+        """
+        
+        # ===== Save context for GPT report generation =====
+        self.original_patient_text = patient_text
+        self.detected_language = None
+        self.current_ontology_mappings = []
+        
+        # ===== Node 1: Input Reception with Language Detection =====
+        self._log(f"[Node 1] Received input: {patient_text[:100]}...")
+        
+        # Auto-detect language if not specified
+        if language is None:
+            language = detect_language(patient_text)
+        
+        language_name = get_language_name(language)
+        self.detected_language = language_name  # Save language name
+        self._log(f"[Node 1] Detected language: {language_name} ({language})")
+        
+        # ===== Node 2: LLM Entity Extraction (Narrow-Scope NER) =====
+        # Note: LLM extraction is handled externally by llm_service.py
+        # This pipeline receives the extracted entities as input
+        self._log("[Node 2] Using provided LLM entity extraction...")
+        if llm_entities is None:
+            llm_entities = {}  # Fallback to empty dict if not provided
+        
+        # ===== Node 3: Ontology Mapping (Deterministic) =====
+        self._log(f"[Node 3] Performing {language_name} → English ontology mapping...")
+        ontology_mappings = map_multilingual_to_english(patient_text, language)
+        self.current_ontology_mappings = ontology_mappings  # Save for GPT use
+        temporal_pattern = extract_temporal_pattern(patient_text)
+        locations = extract_anatomical_location(patient_text)
+        
+        # Check for unmapped descriptors
+        unmapped = get_unmapped_descriptors(patient_text, ontology_mappings)
+        unmapped_suggestions = []  # Store suggestions for unmapped terms
+        
+        if unmapped:
+            self._log(f"[Node 3] ⚠️  Unmapped pain descriptors found: {unmapped}")
+            self._log(f"[Node 3] Generating similarity suggestions (non-definitive)...")
+            
+            # Generate suggestions for each unmapped term
+            for term in unmapped:
+                suggestions = suggest_similar_terms(term, language)
+                if suggestions:
+                    unmapped_suggestions.append({
+                        "unmapped_term": term,
+                        "suggestions": suggestions
+                    })
+                    self._log(f"[Node 3]   '{term}' → Found {len(suggestions)} similar dictionary term(s)")
+            
+            # Add suggestions to ontology mappings for display
+            for item in unmapped_suggestions:
+                for suggestion in item["suggestions"]:
+                    ontology_mappings.append({
+                        "original_term": item["unmapped_term"],
+                        "mapped_english": f"⚠️ {suggestion['english']} (suggested)",
+                        "pain_type": suggestion.get("pain_type", "unknown"),
+                        "dimension": suggestion.get("dimension", "unknown"),
+                        "confidence": "suggestion_only",  # Mark as suggestion
+                        "is_suggestion": True,
+                        "suggestion_note": suggestion["note"],
+                        "similarity_reason": suggestion["similarity_reason"]
+                    })
+        
+        self._log(f"[Node 3] Found {len(ontology_mappings)} term mapping(s) from {language_name}")
+        
+        # ===== Node 3.5: Semantic Analysis V2 (Multilingual Dictionary Matching) =====
+        if unmapped:
+            self._log(f"[Node 3.5] Analyzing {len(unmapped)} unmapped terms (V2: Multilingual dictionary)...")
+            semantic_analysis = calculate_semantic_distances(
+                unmapped_terms=unmapped,  # Original native language expressions
+                patient_text=patient_text,
+                language=language_name
+            )
+        else:
+            semantic_analysis = None
+
+        self.semantic_analysis = semantic_analysis
+        
+        # ===== Node 4: Forced JSON Structuring =====
+        self._log("[Node 4] Constructing PainOntology JSON...")
+        pain_data = self._construct_pain_ontology(
+            llm_entities, 
+            ontology_mappings, 
+            temporal_pattern,
+            locations,
+            unmapped
+        )
+        
+        # ===== Node 5: Rule Engine (Symbolic Reasoning) =====
+        self._log("[Node 5] Applying clinical decision rules...")
+        recommendations = self.rule_engine.evaluate(pain_data)
+        self._log(f"[Node 5] Triggered {len(recommendations)} recommendation(s)")
+        
+        reasoning_chain = self.rule_engine.generate_reasoning_chain(
+            pain_data, 
+            recommendations, 
+            ontology_mappings
+        )
+        
+        # ===== Node 6: Report Generation =====
+        self._log("[Node 6] Generating final clinical report...")
+        physician_summary = self._generate_summary(
+            pain_data, 
+            recommendations,
+            unmapped
+        )
+        
+        # Assemble final explainable report
+        report = ExplainableReport(
+            structured_data=pain_data,
+            ontology_mapping_trace=ontology_mappings,
+            clinical_recommendations=recommendations,
+            reasoning_chain=reasoning_chain,
+            physician_summary=physician_summary
+        )
+        
+        self._log("[Pipeline] Execution complete!")
+        return report
+    
+    def execute_with_mappings(
+        self, 
+        patient_text: str, 
+        llm_entities: Dict[str, Any],
+        ontology_mappings: List[Dict],
+        language: LanguageCode = None
+    ) -> ExplainableReport:
+        """
+        Execute pipeline with pre-computed ontology mappings.
+        
+        Used when LLM has already matched terms from provided vocabulary.
+        Skips the ontology mapping step and uses pre-translated mappings.
+        
+        Args:
+            patient_text: Patient description
+            llm_entities: LLM extracted structured fields (pain_descriptors = unique/unmapped terms)
+            ontology_mappings: Pre-computed term translations from vocabulary
+            language: Language code
+            
+        Returns:
+            ExplainableReport with full analysis
+        """
+        if language is None:
+            language = detect_language(patient_text)
+        
+        # ===== Save context for GPT report generation =====
+        self.original_patient_text = patient_text
+        language_name = get_language_name(language)
+        self.detected_language = language_name
+        self.current_ontology_mappings = ontology_mappings
+        
+        self._log(f"[Pipeline-Fast] Using {len(ontology_mappings)} pre-computed mappings")
+        
+        # Extract patterns
+        temporal_pattern = extract_temporal_pattern(patient_text)
+        locations = extract_anatomical_location(patient_text)
+        
+        # Unmapped descriptors = unique expressions in llm_entities.pain_descriptors
+        # These are creative/metaphorical terms not in dictionary (e.g., "蚂蚁在爬", "따끔거리다")
+        unmapped = llm_entities.get("pain_descriptors", [])
+        
+        # ===== Semantic Analysis V2: Multilingual Dictionary Matching =====
+        if unmapped:
+            self._log(f"[Pipeline-Fast] Analyzing {len(unmapped)} unmapped terms (V2: Multilingual dictionary)...")
+            self.semantic_analysis = calculate_semantic_distances(
+                unmapped_terms=unmapped,  # Original native language expressions
+                patient_text=patient_text,
+                language=language_name
+            )
+            # Debug: Print semantic analysis results
+            if self.semantic_analysis:
+                self._log(f"[Pipeline-Fast] Semantic analysis completed: {self.semantic_analysis}")
+        else:
+            self.semantic_analysis = None
+
+        # Construct pain data
+        pain_data = self._construct_pain_ontology(
+            llm_entities, 
+            ontology_mappings, 
+            temporal_pattern,
+            locations,
+            unmapped
+        )
+        
+        # Apply rules
+        recommendations = self.rule_engine.evaluate(pain_data)
+        reasoning_chain = self.rule_engine.generate_reasoning_chain(
+            pain_data, recommendations, ontology_mappings
+        )
+        
+        # Generate report
+        physician_summary = self._generate_summary(pain_data, recommendations, unmapped)
+        
+        report = ExplainableReport(
+            structured_data=pain_data,
+            ontology_mapping_trace=ontology_mappings,
+            clinical_recommendations=recommendations,
+            reasoning_chain=reasoning_chain,
+            physician_summary=physician_summary
+        )
+        
+        self._log("[Pipeline-Fast] Execution complete!")
+        return report
+    
+    def _construct_pain_ontology(
+        self,
+        llm_entities: Dict[str, Any],
+        ontology_mappings: List[Dict],
+        temporal_pattern: str,
+        locations: List[str],
+        unmapped_descriptors: List[str]
+    ) -> PainOntology:
+        """
+        Construct PainOntology from mapped data.
+        
+        Combines LLM extraction with deterministic ontology mapping to populate
+        the structured pain model. Prioritizes ontology mapping over LLM extraction
+        for medical terms to ensure accuracy.
+        
+        Args:
+            llm_entities: Dictionary of entities extracted by LLM
+            ontology_mappings: List of Chinese→English mappings from ontology
+            temporal_pattern: Standardized temporal pattern
+            locations: List of anatomical locations
+            unmapped_descriptors: Pain descriptors that couldn't be mapped
+            
+        Returns:
+            PainOntology instance with all fields populated
+        """
+        
+        # ===== Extract pain type from ontology mappings =====
+        pain_types = []
+        pain_classification = None
+        
+        for mapping in ontology_mappings:
+            if mapping['dimension'] == 'sensory':
+                pain_types.append(mapping['mapped_english'])
+                if not pain_classification and mapping.get('pain_type'):
+                    pain_classification = mapping['pain_type'].capitalize()
+        
+        # Construct pain type string
+        if pain_types:
+            pain_type_str = f"{pain_classification or 'Mixed'} ({', '.join(pain_types)})"
+        else:
+            # Fallback to LLM extraction if no ontology mapping
+            llm_descriptors = llm_entities.get('pain_descriptors', [])
+            if llm_descriptors:
+                pain_type_str = f"Unclassified ({', '.join(llm_descriptors)})"
+            else:
+                pain_type_str = "Not clearly specified"
+        
+        # Add note if unmapped descriptors exist
+        if unmapped_descriptors:
+            pain_type_str += f" [Unmapped terms: {', '.join(unmapped_descriptors[:3])}]"
+        
+        # ===== Extract emotion from affective mappings =====
+        emotions = [
+            mapping['mapped_english'] 
+            for mapping in ontology_mappings 
+            if mapping['dimension'] == 'affective'
+        ]
+        
+        # Fallback to LLM if no ontology mapping
+        if not emotions and llm_entities.get('emotion_keywords'):
+            emotions = llm_entities['emotion_keywords']
+        
+        emotion_str = ', '.join(emotions) if emotions else None
+        
+        # ===== Construct location string =====
+        if locations:
+            location_str = ', '.join(locations)
+        else:
+            location_str = llm_entities.get('location') or 'Not specified'
+        
+        # ===== Temporal pattern =====
+        if not temporal_pattern:
+            temporal_pattern = llm_entities.get('temporal_pattern') or "Not specified"
+        
+        # ===== Intensity (from LLM only, as it's factual extraction) =====
+        # Format: "Original text [English translation]" for bilingual display
+        intensity_raw = llm_entities.get('intensity', 'Not explicitly stated')
+        if intensity_raw and intensity_raw != 'Not explicitly stated' and intensity_raw != 'Not stated':
+            # Try to translate if non-English
+            intensity_en = translate_to_english_simple(intensity_raw)
+            # If translation differs from original, use bilingual format
+            if intensity_en != intensity_raw:
+                intensity = f"{intensity_raw} [{intensity_en}]"
+            else:
+                intensity = intensity_raw
+        else:
+            intensity = intensity_raw
+        
+        # ===== Functional impact =====
+        # Format: "Original text [English translation]" for bilingual display
+        functional_impact_raw = llm_entities.get('functional_impact')
+        if functional_impact_raw:
+            # Try to translate if non-English
+            functional_impact_en = translate_to_english_simple(functional_impact_raw)
+            # If translation differs from original, use bilingual format
+            if functional_impact_en != functional_impact_raw:
+                functional_impact = f"{functional_impact_raw} [{functional_impact_en}]"
+            else:
+                functional_impact = functional_impact_raw
+        else:
+            functional_impact = None
+        
+        return PainOntology(
+            pain_type=pain_type_str,
+            intensity=intensity,
+            location=location_str,
+            emotion=emotion_str,
+            temporal_pattern=temporal_pattern,
+            functional_impact=functional_impact
+        )
+    
+    def _generate_summary(
+        self,
+        pain_data: PainOntology,
+        recommendations: List,
+        unmapped_descriptors: List[str]
+    ) -> str:
+        """
+        Generate clinical summary using GPT comprehensive report.
+        
+        Calls GPT to generate bilingual/multilingual clinical report after
+        rule-based analysis completes.
+        """
+        try:
+            # Call GPT to generate comprehensive report
+            report = generate_comprehensive_report(
+                original_text=self.original_patient_text,
+                structured_data=pain_data.model_dump(),
+                ontology_mappings=self.current_ontology_mappings,
+                clinical_recommendations=[rec.model_dump() for rec in recommendations],
+                detected_language=self.detected_language or "Chinese",  # Default to Chinese
+                semantic_analysis=self.semantic_analysis  # Pass semantic distance results
+            )
+            
+            # Add MAPPED terms section (direct dictionary matches)
+            mapped_count = 0
+            if self.current_ontology_mappings:
+                # Filter out suggestions, only show exact mappings
+                exact_mappings = [m for m in self.current_ontology_mappings 
+                                 if not m.get('is_suggestion') and m.get('confidence') != 'suggestion_only']
+                
+                if exact_mappings:
+                    mapped_count = len(exact_mappings)
+                    report += "\n\n---\n\n## ✅ Successfully Mapped Pain Descriptors\n\n"
+                    report += "*These terms were found directly in the standard medical pain dictionary:*\n\n"
+                    
+                    for mapping in exact_mappings[:10]:  # Limit display
+                        original = mapping.get('original_term', '')
+                        english = mapping.get('mapped_english', '')
+                        pain_type = mapping.get('pain_type', 'unknown')
+                        if original and english:
+                            report += f"- **{original}** → {english} (Category: {pain_type})\n"
+                    
+                    if len(exact_mappings) > 10:
+                        report += f"\n*...and {len(exact_mappings) - 10} more mapped terms*\n"
+            
+            # Add UNMAPPED terms semantic analysis section
+            if self.semantic_analysis and self.semantic_analysis.get('unmapped_analysis'):
+                report += "\n\n---\n\n## 🔬 Unmapped Terms - Semantic Distance Analysis (AI-Assisted Interpretation)\n\n"
+                report += "*The following expressions were NOT found in the standard dictionary. Our AI system performed semantic analysis to suggest possible medical term matches:*\n\n"
+                report += f"**Total unmapped terms analyzed:** {len(self.semantic_analysis['unmapped_analysis'])}\n\n"
+                
+                for item in self.semantic_analysis['unmapped_analysis']:
+                    original = item['original_term']  # Patient's native language expression
+                    matched_native = item.get('matched_mcgill_native')  # Best matching dictionary term (native lang)
+                    standard_english = item.get('matched_standard_english')  # Dictionary's medical English translation
+                    matches = item['closest_matches']
+                    confidence = item['confidence']
+                    lang_code = item.get('language', 'unknown')
+                    
+                    report += f"### Original Expression: \"{original}\"\n\n"
+                    
+                    # Show dictionary match (works for all languages: Chinese, Korean, Spanish, Hmong)
+                    if matched_native and standard_english:
+                        report += f"**Best Dictionary Match:** {matched_native} → **{standard_english}**\n\n"
+                    
+                    report += f"**Confidence Level:** {confidence.upper()}\n\n"
+                    report += "**Top 3 Similar Medical Terms (from dictionary):**\n\n"
+                    
+                    for i, match in enumerate(matches[:3], 1):
+                        similarity_pct = match['score'] * 100
+                        native_term = match.get('native_term', match.get('chinese_term', match.get('term', '')))
+                        english_term = match.get('english', '')
+                        report += f"{i}. **{native_term}** ({english_term}) - Similarity: {match['score']:.3f} ({similarity_pct:.1f}%)\n"
+                    
+                    # Improved interpretation
+                    top_score = matches[0]['score']
+                    if top_score > 0.75:
+                        strength = "strong"
+                    elif top_score > 0.60:
+                        strength = "moderate"
+                    else:
+                        strength = "weak"
+                    
+                    report += f"\n**Clinical Interpretation:** The semantic analysis shows {strength} similarity "
+                    if matched_native and standard_english:
+                        report += f"(score: {top_score:.3f}) to the dictionary term '{matched_native}' ({standard_english}). "
+                        report += f"This suggests the patient may be experiencing {standard_english.lower()}-type pain sensations.\n\n"
+                    else:
+                        report += f"(score: {top_score:.3f}) to medical terms in the dictionary.\n\n"
+                    report += "---\n\n"
+                
+                report += "---\n\n**Summary:**\n"
+                report += f"- ✅ Mapped (direct dictionary match): {mapped_count} terms\n"
+                report += f"- 🔬 Unmapped (AI-assisted analysis): {len(self.semantic_analysis['unmapped_analysis'])} terms\n\n"
+                report += "*Note: These are AI-generated suggestions based on semantic embedding similarity. Scores closer to 1.0 indicate stronger semantic relationships. Always verify with clinical assessment.*\n\n"
+            
+            # Add unmapped term warning
+            if unmapped_descriptors:
+                report += f"\n\n**⚠️ Note | 注意**: Some pain descriptors could not be automatically mapped: {', '.join(unmapped_descriptors[:3])}. Manual clinical review recommended."
+            
+            # Ensure Clinical Action Plan is included (add if missing)
+            if "⚕️ Clinical Action Plan" not in report and "Clinical Action Plan" not in report:
+                report += "\n\n---\n\n## ⚕️ Clinical Action Plan\n\n"
+                if recommendations:
+                    for i, rec in enumerate(recommendations, 1):
+                        report += f"**{i}. {rec.triggered_by_rule}**\n\n"
+                        report += f"{rec.recommendation}\n\n"
+                        if rec.guideline_reference:
+                            report += f"*Reference: {rec.guideline_reference}*\n\n"
+                else:
+                    report += "Based on the pain assessment:\n\n"
+                    report += "1. **Comprehensive Clinical Evaluation**: Conduct detailed pain assessment with standardized scales and physical examination.\n\n"
+                    report += "2. **Documentation**: Document all pain characteristics, triggers, and functional impacts for ongoing monitoring.\n\n"
+                    report += "3. **Individualized Management**: Develop treatment plan based on complete clinical picture and patient preferences.\n\n"
+            
+            return report
+            
+        except Exception as e:
+            # If GPT fails, fallback to template generation
+            import traceback
+            error_details = traceback.format_exc()
+            self._log(f"[Warning] GPT report generation failed: {e}")
+            self._log(f"[Error Details] {error_details}")
+            print(f"\n{'='*80}")
+            print(f"[ERROR] Report generation failed!")
+            print(f"Exception: {e}")
+            print(f"Traceback:\n{error_details}")
+            print(f"{'='*80}\n")
+            return self._generate_summary_template(pain_data, recommendations, unmapped_descriptors)
+
+    def _generate_summary_template(
+        self,
+        pain_data: PainOntology,
+        recommendations: List,
+        unmapped_descriptors: List[str]
+    ) -> str:
+        """Template-based summary as fallback if GPT fails."""
+        
+        summary_parts = []
+        
+        # ===== Patient Presentation =====
+        summary_parts.append("**Patient Presentation:**\n")
+        
+        # Temporal pattern and location
+        if pain_data.temporal_pattern != "Not specified":
+            summary_parts.append(
+                f"Patient presents with {pain_data.temporal_pattern.lower()} "
+                f"pain localized to {pain_data.location.lower()}. "
+            )
+        else:
+            summary_parts.append(f"Patient presents with pain in {pain_data.location.lower()}. ")
+        
+        # Pain characteristics
+        if pain_data.pain_type != "Not clearly specified":
+            summary_parts.append(
+                f"Pain is characterized as {pain_data.pain_type.lower()}. "
+            )
+        
+        # Intensity
+        if pain_data.intensity and pain_data.intensity != "Not explicitly stated":
+            summary_parts.append(f"Pain intensity: {pain_data.intensity}. ")
+        
+        # Emotional/functional impact
+        if pain_data.emotion:
+            summary_parts.append(
+                f"Patient reports significant affective distress ({pain_data.emotion.lower()}). "
+            )
+        
+        if pain_data.functional_impact:
+            summary_parts.append(
+                f"Functional impact noted: {pain_data.functional_impact.lower()}. "
+            )
+        
+        # Unmapped terms warning
+        if unmapped_descriptors:
+            summary_parts.append(
+                f"\n**Note:** Some pain descriptors could not be automatically mapped to "
+                f"standard medical terminology ({', '.join(unmapped_descriptors[:3])}). "
+                f"Manual clinical review recommended.\n"
+            )
+        
+        # ===== Clinical Recommendations =====
+        if recommendations:
+            summary_parts.append("\n**Clinical Recommendations:**\n")
+            for i, rec in enumerate(recommendations, 1):
+                summary_parts.append(f"\n{i}. {rec.recommendation}\n")
+                if rec.guideline_reference:
+                    summary_parts.append(f"   *Reference: {rec.guideline_reference}*\n")
+                summary_parts.append(f"   *Evidence: {rec.evidence}*\n")
+        else:
+            summary_parts.append(
+                "\n**Clinical Recommendations:**\n"
+                "Standard pain assessment and management pathway recommended. "
+                "Consider detailed clinical interview for further characterization.\n"
+            )
+        
+        return ''.join(summary_parts)
+    
+    def get_pipeline_info(self) -> Dict[str, Any]:
+        """
+        Get information about the current pipeline configuration.
+        
+        Returns:
+            Dictionary with pipeline metadata
+        """
+        return {
+            "pipeline_version": "2.0.0",
+            "architecture": "Neuro-Symbolic Hybrid (Multilingual)",
+            "supported_languages": get_supported_languages(),
+            "rule_count": self.rule_engine.get_rule_count(),
+            "active_rules": self.rule_engine.get_rule_ids(),
+            "ontology_coverage": {
+                "total_descriptors": 373,
+                "chinese_terms": 88,
+                "korean_terms": 116,
+                "spanish_terms": 105,
+                "hmong_terms": 64,
+                "temporal_patterns": 14,
+                "anatomical_locations": 21
+            }
+        }

Backend/read_xlsx.py

@@ -0,0 +1,33 @@
+"""
+Temporary script to read and display the xlsx content.
+This will help us understand the structure and extend to multilingual support.
+"""
+import pandas as pd
+import sys
+import os
+
+# Add Backend to path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+try:
+    # Read the xlsx file
+    xlsx_path = os.path.join(os.path.dirname(__file__), 'data', 'questionnaire_form.xlsx')
+    
+    # Try to read all sheets
+    xl_file = pd.ExcelFile(xlsx_path)
+    print(f"📊 Found {len(xl_file.sheet_names)} sheet(s): {xl_file.sheet_names}\n")
+    
+    for sheet_name in xl_file.sheet_names:
+        print(f"\n{'='*60}")
+        print(f"📋 Sheet: {sheet_name}")
+        print('='*60)
+        
+        df = pd.read_excel(xlsx_path, sheet_name=sheet_name)
+        print(f"\nColumns: {df.columns.tolist()}")
+        print(f"Rows: {len(df)}\n")
+        print(df.head(20).to_string())
+        
+except Exception as e:
+    print(f"❌ Error reading xlsx: {e}")
+    print("\nℹ️ Make sure pandas and openpyxl are installed:")
+    print("   pip install pandas openpyxl")

Backend/scripts/format_pain_descriptors.py

@@ -0,0 +1,85 @@
+"""
+Convert multilingual_pain_data.json to Python dictionary format
+for pain_mapping.py
+"""
+import json
+import os
+
+def format_dict_for_python(data, indent=1):
+    """Format dictionary data as Python code"""
+    lines = []
+    tab = "    " * indent
+    
+    for key, value in data.items():
+        if isinstance(value, dict):
+            # Check if it's a descriptor dict or category dict
+            if 'english' in value:
+                # It's a descriptor
+                lines.append(f'{tab}"{key}": {{')
+                lines.append(f'{tab}    "english": "{value["english"]}",')
+                lines.append(f'{tab}    "mcgill_dimension": "sensory",')
+                
+                # Add SNOMED CT if available
+                if value.get('snomed_ct'):
+                    lines.append(f'{tab}    "snomed_ct": "{value["snomed_ct"]}"')
+                else:
+                    lines.append(f'{tab}    "snomed_ct": None')
+                
+                lines.append(f'{tab}}},')
+            else:
+                # It's a category
+                lines.append(f'{tab}"{key}": {{')
+                lines.extend(format_dict_for_python(value, indent + 1))
+                lines.append(f'{tab}}},')
+    
+    return lines
+
+def main():
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    json_path = os.path.join(script_dir, 'multilingual_pain_data.json')
+    
+    with open(json_path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    
+    output_lines = []
+    
+    # Generate dictionaries for each language
+    lang_names = {
+        'chinese': 'CHINESE',
+        'korean': 'KOREAN',
+        'spanish': 'SPANISH',
+        'hmong': 'HMONG'
+    }
+    
+    for lang_key, lang_upper in lang_names.items():
+        output_lines.append(f"\n# {lang_upper} Pain Descriptors")
+        output_lines.append(f"{lang_upper}_PAIN_DESCRIPTORS = {{")
+        
+        lang_data = data[lang_key]
+        for category in ['neuropathic', 'nociceptive', 'affective']:
+            if category in lang_data and lang_data[category]:
+                output_lines.append(f'    "{category}": {{')
+                
+                for term, info in lang_data[category].items():
+                    output_lines.append(f'        "{term}": {{')
+                    output_lines.append(f'            "english": "{info["english"]}",')
+                    output_lines.append(f'            "mcgill_dimension": "sensory"')
+                    output_lines.append(f'        }},')
+                
+                output_lines.append(f'    }},')
+        
+        output_lines.append(f"}}\n")
+    
+    # Save to file
+    output_path = os.path.join(script_dir, 'pain_descriptors_formatted.py')
+    with open(output_path, 'w', encoding='utf-8') as f:
+        f.write('\n'.join(output_lines))
+    
+    print(f"✅ Formatted pain descriptors saved to: {output_path}")
+    print(f"\nStatistics:")
+    for lang_key, lang_upper in lang_names.items():
+        total = sum(len(data[lang_key].get(cat, {})) for cat in ['neuropathic', 'nociceptive', 'affective'])
+        print(f"  {lang_upper}: {total} terms")
+
+if __name__ == '__main__':
+    main()

Backend/scripts/multilingual_pain_data.json

@@ -0,0 +1,1525 @@
+{
+  "chinese": {
+    "neuropathic": {
+      "火辣辣的疼": {
+        "english": "burning",
+        "mcgill_dimension": "sensory"
+      },
+      "麻的": {
+        "english": "numb",
+        "mcgill_dimension": "sensory"
+      },
+      "刺骨痛": {
+        "english": "piercing",
+        "mcgill_dimension": "sensory"
+      },
+      "刺痛": {
+        "english": "tingling",
+        "mcgill_dimension": "sensory"
+      },
+      "剧烈的疼": {
+        "english": "sharp",
+        "mcgill_dimension": "sensory"
+      },
+      "蚊虫叮咬的刺疼": {
+        "english": "stinging",
+        "mcgill_dimension": "sensory"
+      }
+    },
+    "nociceptive": {
+      "疼": {
+        "english": "aching",
+        "mcgill_dimension": "sensory"
+      },
+      "急性的": {
+        "english": "acute",
+        "mcgill_dimension": "sensory"
+      },
+      "极度的疼痛": {
+        "english": "agonizing",
+        "mcgill_dimension": "sensory"
+      },
+      "跳动的痛": {
+        "english": "beating",
+        "mcgill_dimension": "sensory"
+      },
+      "强烈的疼痛": {
+        "english": "blinding",
+        "mcgill_dimension": "sensory"
+      },
+      "被刺穿的疼": {
+        "english": "boring",
+        "mcgill_dimension": "sensory"
+      },
+      "短暂的": {
+        "english": "brief",
+        "mcgill_dimension": "sensory"
+      },
+      "慢性的": {
+        "english": "chronic",
+        "mcgill_dimension": "sensory"
+      },
+      "冷痛": {
+        "english": "cold",
+        "mcgill_dimension": "sensory"
+      },
+      "不间断的": {
+        "english": "constant",
+        "mcgill_dimension": "sensory"
+      },
+      "冷的": {
+        "english": "cool",
+        "mcgill_dimension": "sensory"
+      },
+      "绞痛": {
+        "english": "cramp",
+        "mcgill_dimension": "sensory"
+      },
+      "压迫痛": {
+        "english": "crushing",
+        "mcgill_dimension": "sensory"
+      },
+      "切割痛": {
+        "english": "cutting",
+        "mcgill_dimension": "sensory"
+      },
+      "拉扯痛": {
+        "english": "pulling",
+        "mcgill_dimension": "sensory"
+      },
+      "可怕的痛苦": {
+        "english": "dreadful",
+        "mcgill_dimension": "sensory"
+      },
+      "钻痛": {
+        "english": "drilling",
+        "mcgill_dimension": "sensory"
+      },
+      "隐约的疼痛": {
+        "english": "dull",
+        "mcgill_dimension": "sensory"
+      },
+      "疼到没力气": {
+        "english": "exhaust",
+        "mcgill_dimension": "sensory"
+      },
+      "可怕的痛": {
+        "english": "fearful",
+        "mcgill_dimension": "sensory"
+      },
+      "一阵阵的": {
+        "english": "fitful",
+        "mcgill_dimension": "sensory"
+      },
+      "一闪而过的痛": {
+        "english": "flashing",
+        "mcgill_dimension": "sensory"
+      },
+      "闪烁的痛": {
+        "english": "Flickering",
+        "mcgill_dimension": "sensory"
+      },
+      "冷疼": {
+        "english": "freezing",
+        "mcgill_dimension": "sensory"
+      },
+      "疼的可怕": {
+        "english": "frightful",
+        "mcgill_dimension": "sensory"
+      },
+      "折磨的痛": {
+        "english": "gnawing",
+        "mcgill_dimension": "sensory"
+      },
+      "折磨人的": {
+        "english": "gruelling",
+        "mcgill_dimension": "sensory"
+      },
+      "非常痛": {
+        "english": "heavy",
+        "mcgill_dimension": "sensory"
+      },
+      "热的": {
+        "english": "hot",
+        "mcgill_dimension": "sensory"
+      },
+      "使...难受": {
+        "english": "hurt",
+        "mcgill_dimension": "sensory"
+      },
+      "强烈的": {
+        "english": "intense",
+        "mcgill_dimension": "sensory"
+      },
+      "痒的": {
+        "english": "itchy",
+        "mcgill_dimension": "sensory"
+      },
+      "跳动的疼": {
+        "english": "jumping",
+        "mcgill_dimension": "sensory"
+      },
+      "及其": {
+        "english": "to kill",
+        "mcgill_dimension": "sensory"
+      },
+      "撕裂痛": {
+        "english": "lacerating",
+        "mcgill_dimension": "sensory"
+      },
+      "撕裂的痛": {
+        "english": "lancinating",
+        "mcgill_dimension": "sensory"
+      },
+      "使人不得安宁": {
+        "english": "nagging",
+        "mcgill_dimension": "sensory"
+      },
+      "钻心的": {
+        "english": "nauseating",
+        "mcgill_dimension": "sensory"
+      },
+      "渗透的": {
+        "english": "penetrating",
+        "mcgill_dimension": "sensory"
+      },
+      "一阵一阵的痛": {
+        "english": "periodic",
+        "mcgill_dimension": "sensory"
+      },
+      "掐疼": {
+        "english": "pinching",
+        "mcgill_dimension": "sensory"
+      },
+      "重击痛": {
+        "english": "pounding",
+        "mcgill_dimension": "sensory"
+      },
+      "压着痛": {
+        "english": "pressing",
+        "mcgill_dimension": "sensory"
+      },
+      "搏动性痛": {
+        "english": "pulsing",
+        "mcgill_dimension": "sensory"
+      },
+      "颤抖": {
+        "english": "quivering",
+        "mcgill_dimension": "sensory"
+      },
+      "发散性疼痛": {
+        "english": "radiating",
+        "mcgill_dimension": "sensory"
+      },
+      "粗糙的": {
+        "english": "raspy",
+        "mcgill_dimension": "sensory"
+      },
+      "有节奏的": {
+        "english": "rhythmic",
+        "mcgill_dimension": "sensory"
+      },
+      "烫伤": {
+        "english": "scalding",
+        "mcgill_dimension": "sensory"
+      },
+      "灼痛": {
+        "english": "searing",
+        "mcgill_dimension": "sensory"
+      },
+      "剧烈疼痛": {
+        "english": "smarting",
+        "mcgill_dimension": "sensory"
+      },
+      "酸痛": {
+        "english": "sore",
+        "mcgill_dimension": "sensory"
+      },
+      "分裂痛": {
+        "english": "splitting",
+        "mcgill_dimension": "sensory"
+      },
+      "扩散性疼痛": {
+        "english": "spreading",
+        "mcgill_dimension": "sensory"
+      },
+      "挤压的疼痛": {
+        "english": "squeezing",
+        "mcgill_dimension": "sensory"
+      },
+      "令人窒息的": {
+        "english": "suffocating",
+        "mcgill_dimension": "sensory"
+      },
+      "紧张的": {
+        "english": "taut",
+        "mcgill_dimension": "sensory"
+      },
+      "撕裂的": {
+        "english": "tearing",
+        "mcgill_dimension": "sensory"
+      },
+      "一碰就痛": {
+        "english": "tender",
+        "mcgill_dimension": "sensory"
+      },
+      "程度很高的痛苦": {
+        "english": "terrifying",
+        "mcgill_dimension": "sensory"
+      },
+      "一抽一抽的痛": {
+        "english": "throbbing",
+        "mcgill_dimension": "sensory"
+      },
+      "顽固的": {
+        "english": "unyielding.",
+        "mcgill_dimension": "sensory"
+      },
+      "疲倦": {
+        "english": "to tire",
+        "mcgill_dimension": "sensory"
+      },
+      "折磨": {
+        "english": "torturing",
+        "mcgill_dimension": "sensory"
+      },
+      "剧烈的痛苦": {
+        "english": "vicious",
+        "mcgill_dimension": "sensory"
+      },
+      "极为痛苦的": {
+        "english": "wrenching",
+        "mcgill_dimension": "sensory"
+      },
+      "头": {
+        "english": "Head",
+        "mcgill_dimension": "sensory"
+      },
+      "脖子": {
+        "english": "Neck",
+        "mcgill_dimension": "sensory"
+      },
+      "脸": {
+        "english": "Face",
+        "mcgill_dimension": "sensory"
+      },
+      "手": {
+        "english": "Hands",
+        "mcgill_dimension": "sensory"
+      },
+      "手臂": {
+        "english": "Arms",
+        "mcgill_dimension": "sensory"
+      },
+      "背": {
+        "english": "Back",
+        "mcgill_dimension": "sensory"
+      },
+      "腿": {
+        "english": "Legs",
+        "mcgill_dimension": "sensory"
+      },
+      "脚": {
+        "english": "Feet",
+        "mcgill_dimension": "sensory"
+      },
+      "胸腔": {
+        "english": "Chest",
+        "mcgill_dimension": "sensory"
+      },
+      "腹部": {
+        "english": "Abdomen",
+        "mcgill_dimension": "sensory"
+      },
+      "肺": {
+        "english": "lungs",
+        "mcgill_dimension": "sensory"
+      },
+      "心脏": {
+        "english": "heart",
+        "mcgill_dimension": "sensory"
+      }
+    },
+    "affective": {
+      "烦人的": {
+        "english": "annoying",
+        "mcgill_dimension": "sensory"
+      },
+      "痛苦": {
+        "english": "miserable",
+        "mcgill_dimension": "sensory"
+      },
+      "麻烦的": {
+        "english": "troublesome",
+        "mcgill_dimension": "sensory"
+      },
+      "难以忍受的": {
+        "english": "unbearable",
+        "mcgill_dimension": "sensory"
+      }
+    }
+  },
+  "korean": {
+    "neuropathic": {
+      "따끔거리다": {
+        "english": "sting",
+        "mcgill_dimension": "sensory"
+      },
+      "찌르다": {
+        "english": "stabbing",
+        "mcgill_dimension": "sensory"
+      },
+      "타는것 같다": {
+        "english": "burning",
+        "mcgill_dimension": "sensory"
+      },
+      "아리다": {
+        "english": "stinging",
+        "mcgill_dimension": "sensory"
+      },
+      "얼얼하다": {
+        "english": "numb",
+        "mcgill_dimension": "sensory"
+      },
+      "쏘듯이 아프다": {
+        "english": "shooting",
+        "mcgill_dimension": "sensory"
+      },
+      "바늘로 찌르듯": {
+        "english": "pricking",
+        "mcgill_dimension": "sensory"
+      },
+      "칼로 찌르듯": {
+        "english": "stabbing",
+        "mcgill_dimension": "sensory"
+      },
+      "쓰라리다": {
+        "english": "sharp",
+        "mcgill_dimension": "sensory"
+      },
+      "화끈거리다": {
+        "english": "burning",
+        "mcgill_dimension": "sensory"
+      },
+      "서물서물하다": {
+        "english": "tingling",
+        "mcgill_dimension": "sensory"
+      },
+      "톡 쏘듯이 아프다": {
+        "english": "stinging",
+        "mcgill_dimension": "sensory"
+      },
+      "지치게 아프다": {
+        "english": "exhausting",
+        "mcgill_dimension": "sensory"
+      },
+      "뼈를 쳐미듯이 아프다": {
+        "english": "piercing",
+        "mcgill_dimension": "sensory"
+      },
+      "저리다": {
+        "english": "numb",
+        "mcgill_dimension": "sensory"
+      }
+    },
+    "nociceptive": {
+      "꼬집히다": {
+        "english": "pinched",
+        "mcgill_dimension": "sensory"
+      },
+      "뻐근하다": {
+        "english": "stiff",
+        "mcgill_dimension": "sensory"
+      },
+      "조이다": {
+        "english": "constricting",
+        "mcgill_dimension": "sensory"
+      },
+      "찢어지다": {
+        "english": "torn",
+        "mcgill_dimension": "sensory"
+      },
+      "터지다": {
+        "english": "broken",
+        "mcgill_dimension": "sensory"
+      },
+      "팽팽하다": {
+        "english": "tight",
+        "mcgill_dimension": "sensory"
+      },
+      "긁히다": {
+        "english": "scrape",
+        "mcgill_dimension": "sensory"
+      },
+      "꿈틀거리다": {
+        "english": "wriggle",
+        "mcgill_dimension": "sensory"
+      },
+      "둔하다": {
+        "english": "obtuse",
+        "mcgill_dimension": "sensory"
+      },
+      "무디다": {
+        "english": "dull",
+        "mcgill_dimension": "sensory"
+      },
+      "뻗치다": {
+        "english": "sticking out",
+        "mcgill_dimension": "sensory"
+      },
+      "쐬다": {
+        "english": "get stung",
+        "mcgill_dimension": "sensory"
+      },
+      "오싹하다": {
+        "english": "feel a chill",
+        "mcgill_dimension": "sensory"
+      },
+      "지지다": {
+        "english": "frying",
+        "mcgill_dimension": "sensory"
+      },
+      "화끈거리다": {
+        "english": "hot",
+        "mcgill_dimension": "sensory"
+      },
+      "부딪히다": {
+        "english": "hitting",
+        "mcgill_dimension": "sensory"
+      },
+      "쓰라리다": {
+        "english": "sore",
+        "mcgill_dimension": "sensory"
+      },
+      "으스러지다": {
+        "english": "be shattered",
+        "mcgill_dimension": "sensory"
+      },
+      "끊어지다": {
+        "english": "cut",
+        "mcgill_dimension": "sensory"
+      },
+      "살을 에이는 듯한 아픔.": {
+        "english": "penetrating",
+        "mcgill_dimension": "sensory"
+      },
+      "울리다": {
+        "english": "ringing",
+        "mcgill_dimension": "sensory"
+      },
+      "쪼개지다": {
+        "english": "splitting",
+        "mcgill_dimension": "sensory"
+      },
+      "시리다": {
+        "english": "cool",
+        "mcgill_dimension": "sensory"
+      },
+      "부서지다": {
+        "english": "smashing",
+        "mcgill_dimension": "sensory"
+      },
+      "싸하다": {
+        "english": "pungent",
+        "mcgill_dimension": "sensory"
+      },
+      "잘리다": {
+        "english": "be chopped",
+        "mcgill_dimension": "sensory"
+      },
+      "찌릿하다": {
+        "english": "throbbing",
+        "mcgill_dimension": "sensory"
+      },
+      "깎이다": {
+        "english": "peeling",
+        "mcgill_dimension": "sensory"
+      },
+      "깨지다": {
+        "english": "cracking",
+        "mcgill_dimension": "sensory"
+      },
+      "갈리다": {
+        "english": "be ground",
+        "mcgill_dimension": "sensory"
+      },
+      "비틀리다": {
+        "english": "be twisted",
+        "mcgill_dimension": "sensory"
+      },
+      "빠지다": {
+        "english": "falling out,",
+        "mcgill_dimension": "sensory"
+      },
+      "뻣뻣하다": {
+        "english": "stiff",
+        "mcgill_dimension": "sensory"
+      },
+      "삐드득": {
+        "english": "creaking",
+        "mcgill_dimension": "sensory"
+      },
+      "쑤시다": {
+        "english": "poking",
+        "mcgill_dimension": "sensory"
+      },
+      "가물가물 아프다": {
+        "english": "flickering",
+        "mcgill_dimension": "sensory"
+      },
+      "지근거리다": {
+        "english": "nagging",
+        "mcgill_dimension": "sensory"
+      },
+      "욱신욱신하다": {
+        "english": "pulsing",
+        "mcgill_dimension": "sensory"
+      },
+      "들먹거리다": {
+        "english": "beating",
+        "mcgill_dimension": "sensory"
+      },
+      "쾅쾅치듯이 아프다": {
+        "english": "pounding",
+        "mcgill_dimension": "sensory"
+      },
+      "움찔하게 아프다": {
+        "english": "jumping",
+        "mcgill_dimension": "sensory"
+      },
+      "따끔하다": {
+        "english": "flashing",
+        "mcgill_dimension": "sensory"
+      },
+      "송곳으로 찌르���": {
+        "english": "boring",
+        "mcgill_dimension": "sensory"
+      },
+      "구멍을 뚫듯이": {
+        "english": "drilling",
+        "mcgill_dimension": "sensory"
+      },
+      "칼로 찔러 쑤시듯": {
+        "english": "lancinating",
+        "mcgill_dimension": "sensory"
+      },
+      "베듯이 아프다": {
+        "english": "cutting",
+        "mcgill_dimension": "sensory"
+      },
+      "도려내듯 아프다": {
+        "english": "lacerating",
+        "mcgill_dimension": "sensory"
+      },
+      "꼬집듯 따끔하다": {
+        "english": "pinching",
+        "mcgill_dimension": "sensory"
+      },
+      "누르듯 아프다": {
+        "english": "pressing",
+        "mcgill_dimension": "sensory"
+      },
+      "꽉 무는듯 아프다": {
+        "english": "gnawing",
+        "mcgill_dimension": "sensory"
+      },
+      "꽉 지는듯 아프다": {
+        "english": "cramping",
+        "mcgill_dimension": "sensory"
+      },
+      "짓이기는 듯 아프다": {
+        "english": "crushing",
+        "mcgill_dimension": "sensory"
+      },
+      "결린다": {
+        "english": "tugging",
+        "mcgill_dimension": "sensory"
+      },
+      "땅긴다": {
+        "english": "pulling",
+        "mcgill_dimension": "sensory"
+      },
+      "뒤틀리듯 아프다": {
+        "english": "wrenching",
+        "mcgill_dimension": "sensory"
+      },
+      "따끈하다": {
+        "english": "hot",
+        "mcgill_dimension": "sensory"
+      },
+      "물이나 불에 애듯이 아프다": {
+        "english": "scalding",
+        "mcgill_dimension": "sensory"
+      },
+      "불로 지지듯이 아프다": {
+        "english": "searing",
+        "mcgill_dimension": "sensory"
+      },
+      "근질근질하게 아프다": {
+        "english": "itchy",
+        "mcgill_dimension": "sensory"
+      },
+      "아리다": {
+        "english": "bitter",
+        "mcgill_dimension": "sensory"
+      },
+      "욱신거리다": {
+        "english": "smarting",
+        "mcgill_dimension": "sensory"
+      },
+      "멍하다": {
+        "english": "dull",
+        "mcgill_dimension": "sensory"
+      },
+      "우리하다": {
+        "english": "dull",
+        "mcgill_dimension": "sensory"
+      },
+      "둔하게 아프다": {
+        "english": "hurting",
+        "mcgill_dimension": "sensory"
+      },
+      "쑤신다": {
+        "english": "aching",
+        "mcgill_dimension": "sensory"
+      },
+      "빠개지듯 아프다": {
+        "english": "heavy",
+        "mcgill_dimension": "sensory"
+      },
+      "만지면 아프다": {
+        "english": "tender",
+        "mcgill_dimension": "sensory"
+      },
+      "누르면 아프다": {
+        "english": "tender",
+        "mcgill_dimension": "sensory"
+      },
+      "꽉 찬 것 같다": {
+        "english": "taut",
+        "mcgill_dimension": "sensory"
+      },
+      "갈아내듯이 아프다": {
+        "english": "rasping",
+        "mcgill_dimension": "sensory"
+      },
+      "터질듯이 아프다": {
+        "english": "splitting",
+        "mcgill_dimension": "sensory"
+      },
+      "살살 아프다": {
+        "english": "sickening",
+        "mcgill_dimension": "sensory"
+      },
+      "숨이 막힐듯 아프다": {
+        "english": "suffocating",
+        "mcgill_dimension": "sensory"
+      },
+      "겁나게 아프다": {
+        "english": "fearful",
+        "mcgill_dimension": "sensory"
+      },
+      "소름 끼치게 아프다": {
+        "english": "frightful",
+        "mcgill_dimension": "sensory"
+      },
+      "까무러치게 아프다": {
+        "english": "terrifying",
+        "mcgill_dimension": "sensory"
+      },
+      "쩔쩔매게 아프다": {
+        "english": "punishing",
+        "mcgill_dimension": "sensory"
+      },
+      "기진맥진하게 아프다": {
+        "english": "grueling",
+        "mcgill_dimension": "sensory"
+      },
+      "지독하게 아프다": {
+        "english": "dreadful",
+        "mcgill_dimension": "sensory"
+      },
+      "무지막하게 아프다": {
+        "english": "vicious",
+        "mcgill_dimension": "sensory"
+      },
+      "죽을 정도로 아프다": {
+        "english": "killing",
+        "mcgill_dimension": "sensory"
+      },
+      "고약하게 아프다": {
+        "english": "wretched",
+        "mcgill_dimension": "sensory"
+      },
+      "정신 못차리게 아프다": {
+        "english": "blinding",
+        "mcgill_dimension": "sensory"
+      },
+      "지속적으로 대단히 아프다": {
+        "english": "intense",
+        "mcgill_dimension": "sensory"
+      },
+      "참을수 없게 아프다": {
+        "english": "unberable",
+        "mcgill_dimension": "sensory"
+      },
+      "번져가면서 아프다": {
+        "english": "spreading",
+        "mcgill_dimension": "sensory"
+      },
+      "통증이 삐친다": {
+        "english": "radiating",
+        "mcgill_dimension": "sensory"
+      },
+      "관통하듯이 아프다": {
+        "english": "penetrating",
+        "mcgill_dimension": "sensory"
+      },
+      "조인다": {
+        "english": "tight",
+        "mcgill_dimension": "sensory"
+      },
+      "끌어당기듯이 아프다": {
+        "english": "drawing",
+        "mcgill_dimension": "sensory"
+      },
+      "쥐어짜듯이 아프다": {
+        "english": "squeezing",
+        "mcgill_dimension": "sensory"
+      },
+      "찢어지는듯 아프다": {
+        "english": "tearing",
+        "mcgill_dimension": "sensory"
+      },
+      "싸늘하게 아프다": {
+        "english": "cold",
+        "mcgill_dimension": "sensory"
+      },
+      "오싹하게 아프다": {
+        "english": "freezing",
+        "mcgill_dimension": "sensory"
+      },
+      "토할 정도로 아프다": {
+        "english": "nauseating",
+        "mcgill_dimension": "sensory"
+      },
+      "괴롭게 아프다": {
+        "english": "agonizing",
+        "mcgill_dimension": "sensory"
+      },
+      "고문 받는것 처럼 아프다": {
+        "english": "torturing",
+        "mcgill_dimension": "sensory"
+      }
+    },
+    "affective": {
+      "노곤하게 아프다": {
+        "english": "tiring",
+        "mcgill_dimension": "sensory"
+      },
+      "신경이 자꾸 쓰이게 아프다": {
+        "english": "annoying",
+        "mcgill_dimension": "sensory"
+      },
+      "난처하게 아프다": {
+        "english": "troublesome",
+        "mcgill_dimension": "sensory"
+      },
+      "괴롭게 아프다": {
+        "english": "miserable",
+        "mcgill_dimension": "sensory"
+      }
+    }
+  },
+  "spanish": {
+    "neuropathic": {
+      "de ardor": {
+        "english": "burning",
+        "mcgill_dimension": "sensory"
+      },
+      "quemadura": {
+        "english": "burning",
+        "mcgill_dimension": "sensory"
+      },
+      "quemazón": {
+        "english": "burning",
+        "mcgill_dimension": "sensory"
+      },
+      "adormecido": {
+        "english": "numb",
+        "mcgill_dimension": "sensory"
+      },
+      "perforante": {
+        "english": "piercing",
+        "mcgill_dimension": "sensory"
+      },
+      "pinchazo": {
+        "english": "pricking",
+        "mcgill_dimension": "sensory"
+      },
+      "agudo": {
+        "english": "sharp",
+        "mcgill_dimension": "sensory"
+      },
+      "expandirse": {
+        "english": "shooting",
+        "mcgill_dimension": "sensory"
+      },
+      "punzante": {
+        "english": "stabbing",
+        "mcgill_dimension": "sensory"
+      },
+      "picazón": {
+        "english": "stinging",
+        "mcgill_dimension": "sensory"
+      },
+      "hormigueo": {
+        "english": "tingling",
+        "mcgill_dimension": "sensory"
+      }
+    },
+    "nociceptive": {
+      "dolorido": {
+        "english": "aching",
+        "mcgill_dimension": "sensory"
+      },
+      "agudo": {
+        "english": "acute",
+        "mcgill_dimension": "sensory"
+      },
+      "anónico": {
+        "english": "agonizing",
+        "mcgill_dimension": "sensory"
+      },
+      "batiente": {
+        "english": "beating",
+        "mcgill_dimension": "sensory"
+      },
+      "agobiante": {
+        "english": "heavy",
+        "mcgill_dimension": "sensory"
+      },
+      "sofocante": {
+        "english": "suffocating",
+        "mcgill_dimension": "sensory"
+      },
+      "ceguera": {
+        "english": "blinding",
+        "mcgill_dimension": "sensory"
+      },
+      "terebrante": {
+        "english": "boring",
+        "mcgill_dimension": "sensory"
+      },
+      "breve": {
+        "english": "brief",
+        "mcgill_dimension": "sensory"
+      },
+      "quemadura": {
+        "english": "burn",
+        "mcgill_dimension": "sensory"
+      },
+      "crónico": {
+        "english": "chronic",
+        "mcgill_dimension": "sensory"
+      },
+      "helante": {
+        "english": "cold",
+        "mcgill_dimension": "sensory"
+      },
+      "constante": {
+        "english": "constant",
+        "mcgill_dimension": "sensory"
+      },
+      "frío": {
+        "english": "cool",
+        "mcgill_dimension": "sensory"
+      },
+      "calambre": {
+        "english": "cramp",
+        "mcgill_dimension": "sensory"
+      },
+      "retortijón": {
+        "english": "cramp",
+        "mcgill_dimension": "sensory"
+      },
+      "triturante": {
+        "english": "crushing",
+        "mcgill_dimension": "sensory"
+      },
+      "incisión": {
+        "english": "cut",
+        "mcgill_dimension": "sensory"
+      },
+      "cortante": {
+        "english": "cutting",
+        "mcgill_dimension": "sensory"
+      },
+      "de estiramiento": {
+        "english": "drawing",
+        "mcgill_dimension": "sensory"
+      },
+      "atemorizante": {
+        "english": "dreadful",
+        "mcgill_dimension": "sensory"
+      },
+      "taladrante": {
+        "english": "drilling",
+        "mcgill_dimension": "sensory"
+      },
+      "leve": {
+        "english": "dull",
+        "mcgill_dimension": "sensory"
+      },
+      "agotar": {
+        "english": "exhaust",
+        "mcgill_dimension": "sensory"
+      },
+      "dar miedo": {
+        "english": "fearful",
+        "mcgill_dimension": "sensory"
+      },
+      "intermitente": {
+        "english": "fitful",
+        "mcgill_dimension": "sensory"
+      },
+      "destello de": {
+        "english": "flickering",
+        "mcgill_dimension": "sensory"
+      },
+      "centelleante": {
+        "english": "flashing",
+        "mcgill_dimension": "sensory"
+      },
+      "congelante": {
+        "english": "freezing",
+        "mcgill_dimension": "sensory"
+      },
+      "alarmante": {
+        "english": "frightful",
+        "mcgill_dimension": "sensory"
+      },
+      "lacerante": {
+        "english": "lancinating",
+        "mcgill_dimension": "sensory"
+      },
+      "mordicante": {
+        "english": "gnawing",
+        "mcgill_dimension": "sensory"
+      },
+      "agotador": {
+        "english": "gruelling",
+        "mcgill_dimension": "sensory"
+      },
+      "caliente": {
+        "english": "hot",
+        "mcgill_dimension": "sensory"
+      },
+      "doler": {
+        "english": "to hurt",
+        "mcgill_dimension": "sensory"
+      },
+      "intenso": {
+        "english": "intense",
+        "mcgill_dimension": "sensory"
+      },
+      "comezón": {
+        "english": "itch",
+        "mcgill_dimension": "sensory"
+      },
+      "picante": {
+        "english": "itchy",
+        "mcgill_dimension": "sensory"
+      },
+      "saltón": {
+        "english": "jumping",
+        "mcgill_dimension": "sensory"
+      },
+      "matar": {
+        "english": "kill",
+        "mcgill_dimension": "sensory"
+      },
+      "molesto": {
+        "english": "nagging",
+        "mcgill_dimension": "sensory"
+      },
+      "dar náuseas": {
+        "english": "nauseating",
+        "mcgill_dimension": "sensory"
+      },
+      "penetrante": {
+        "english": "penetrating",
+        "mcgill_dimension": "sensory"
+      },
+      "regular": {
+        "english": "periodic",
+        "mcgill_dimension": "sensory"
+      },
+      "periódico": {
+        "english": "periodic",
+        "mcgill_dimension": "sensory"
+      },
+      "pellizcante": {
+        "english": "pinching",
+        "mcgill_dimension": "sensory"
+      },
+      "latiendo": {
+        "english": "pounding",
+        "mcgill_dimension": "sensory"
+      },
+      "hacer presión sobre": {
+        "english": "pressing",
+        "mcgill_dimension": "sensory"
+      },
+      "tensar": {
+        "english": "pulling",
+        "mcgill_dimension": "sensory"
+      },
+      "palpitar": {
+        "english": "pulsing",
+        "mcgill_dimension": "sensory"
+      },
+      "temblando": {
+        "english": "quivering",
+        "mcgill_dimension": "sensory"
+      },
+      "irradiar": {
+        "english": "radiating",
+        "mcgill_dimension": "sensory"
+      },
+      "ronca": {
+        "english": "raspy",
+        "mcgill_dimension": "sensory"
+      },
+      "rítmico": {
+        "english": "rhythmic",
+        "mcgill_dimension": "sensory"
+      },
+      "hirviente": {
+        "english": "scalding",
+        "mcgill_dimension": "sensory"
+      },
+      "ardiente": {
+        "english": "searing",
+        "mcgill_dimension": "sensory"
+      },
+      "seco": {
+        "english": "smarting",
+        "mcgill_dimension": "sensory"
+      },
+      "adolorido": {
+        "english": "sore",
+        "mcgill_dimension": "sensory"
+      },
+      "severo": {
+        "english": "splitting",
+        "mcgill_dimension": "sensory"
+      },
+      "que se extiende": {
+        "english": "spreading",
+        "mcgill_dimension": "sensory"
+      },
+      "apretar": {
+        "english": "squeezing",
+        "mcgill_dimension": "sensory"
+      },
+      "tirante": {
+        "english": "taut",
+        "mcgill_dimension": "sensory"
+      },
+      "desgarrador": {
+        "english": "wrenching",
+        "mcgill_dimension": "sensory"
+      },
+      "sensible": {
+        "english": "tender",
+        "mcgill_dimension": "sensory"
+      },
+      "aterrador": {
+        "english": "terrifying",
+        "mcgill_dimension": "sensory"
+      },
+      "punzante": {
+        "english": "throbbing",
+        "mcgill_dimension": "sensory"
+      },
+      "firme": {
+        "english": "unyielding",
+        "mcgill_dimension": "sensory"
+      },
+      "cansarse": {
+        "english": "to tire",
+        "mcgill_dimension": "sensory"
+      },
+      "torturante": {
+        "english": "torturing",
+        "mcgill_dimension": "sensory"
+      },
+      "maligno": {
+        "english": "vicious",
+        "mcgill_dimension": "sensory"
+      },
+      "la cabeza": {
+        "english": "Head",
+        "mcgill_dimension": "sensory"
+      },
+      "el cuello": {
+        "english": "Neck",
+        "mcgill_dimension": "sensory"
+      },
+      "la cara": {
+        "english": "Face",
+        "mcgill_dimension": "sensory"
+      },
+      "las manos": {
+        "english": "Hands",
+        "mcgill_dimension": "sensory"
+      },
+      "los brazos": {
+        "english": "Arms",
+        "mcgill_dimension": "sensory"
+      },
+      "la espalda": {
+        "english": "Back",
+        "mcgill_dimension": "sensory"
+      },
+      "las piernas": {
+        "english": "Legs",
+        "mcgill_dimension": "sensory"
+      },
+      "los pies": {
+        "english": "Feet",
+        "mcgill_dimension": "sensory"
+      },
+      "el pecho": {
+        "english": "Chest",
+        "mcgill_dimension": "sensory"
+      },
+      "el abdomen": {
+        "english": "Abdomen",
+        "mcgill_dimension": "sensory"
+      },
+      "los pulmones": {
+        "english": "lungs",
+        "mcgill_dimension": "sensory"
+      },
+      "el corazón": {
+        "english": "heart",
+        "mcgill_dimension": "sensory"
+      },
+      "angustioso": {
+        "english": "distressing",
+        "mcgill_dimension": "sensory"
+      },
+      "escalofrio": {
+        "english": "chill",
+        "mcgill_dimension": "sensory"
+      },
+      "migraña": {
+        "english": "Throbbing headache",
+        "mcgill_dimension": "sensory"
+      },
+      "Nervios": {
+        "english": "anxious",
+        "mcgill_dimension": "sensory"
+      },
+      "susto": {
+        "english": "anxiety",
+        "mcgill_dimension": "sensory"
+      },
+      "tenso": {
+        "english": "muscle tension",
+        "mcgill_dimension": "sensory"
+      },
+      "irritarse": {
+        "english": "irritated",
+        "mcgill_dimension": "sensory"
+      },
+      "entumir": {
+        "english": "Fall asleep",
+        "mcgill_dimension": "sensory"
+      }
+    },
+    "affective": {
+      "fastidioso": {
+        "english": "annoying",
+        "mcgill_dimension": "sensory"
+      },
+      "atroz": {
+        "english": "miserable",
+        "mcgill_dimension": "sensory"
+      },
+      "pesado": {
+        "english": "troublesome",
+        "mcgill_dimension": "sensory"
+      },
+      "insoportable": {
+        "english": "unbearable",
+        "mcgill_dimension": "sensory"
+      }
+    }
+  },
+  "hmong": {
+    "neuropathic": {
+      "Plev": {
+        "english": "stinging",
+        "mcgill_dimension": "sensory"
+      },
+      "Muab Nkaug": {
+        "english": "stabbing",
+        "mcgill_dimension": "sensory"
+      },
+      "Kub Heev": {
+        "english": "burning",
+        "mcgill_dimension": "sensory"
+      },
+      "Loog": {
+        "english": "numb",
+        "mcgill_dimension": "sensory"
+      },
+      "Mob ntse": {
+        "english": "picking and pricking",
+        "mcgill_dimension": "sensory"
+      },
+      "Txais hluas taws xob": {
+        "english": "receive an electric shock",
+        "mcgill_dimension": "sensory"
+      },
+      "Nkaug": {
+        "english": "stabbing",
+        "mcgill_dimension": "sensory"
+      },
+      "Khaus": {
+        "english": "tingling",
+        "mcgill_dimension": "sensory"
+      },
+      "Mob": {
+        "english": "stinging",
+        "mcgill_dimension": "sensory"
+      }
+    },
+    "nociceptive": {
+      "Rub Leeg": {
+        "english": "tugging",
+        "mcgill_dimension": "sensory"
+      },
+      "leg": {
+        "english": "twisted",
+        "mcgill_dimension": "sensory"
+      },
+      "De": {
+        "english": "pinching",
+        "mcgill_dimension": "sensory"
+      },
+      "Ntuag": {
+        "english": "tearing",
+        "mcgill_dimension": "sensory"
+      },
+      "Raug Ntuag": {
+        "english": "be torn",
+        "mcgill_dimension": "sensory"
+      },
+      "Piam": {
+        "english": "broken",
+        "mcgill_dimension": "sensory"
+      },
+      "Khaus Khaus": {
+        "english": "be scratched",
+        "mcgill_dimension": "sensory"
+      },
+      "Tig": {
+        "english": "wriggle,",
+        "mcgill_dimension": "sensory"
+      },
+      "Obtuse": {
+        "english": "obtuse",
+        "mcgill_dimension": "sensory"
+      },
+      "Tawm": {
+        "english": "sticking out",
+        "mcgill_dimension": "sensory"
+      },
+      "Plev": {
+        "english": "get stung",
+        "mcgill_dimension": "sensory"
+      },
+      "Txias": {
+        "english": "feel a chill",
+        "mcgill_dimension": "sensory"
+      },
+      "Tawg": {
+        "english": "cracking",
+        "mcgill_dimension": "sensory"
+      },
+      "Nkau": {
+        "english": "penetrating",
+        "mcgill_dimension": "sensory"
+      },
+      "Cheeb yob tsis tau": {
+        "english": "having a convulsive fit",
+        "mcgill_dimension": "sensory"
+      },
+      "Hnyav": {
+        "english": "feel heavy",
+        "mcgill_dimension": "sensory"
+      },
+      "Nyob qis tab sis kho": {
+        "english": "be low but steady",
+        "mcgill_dimension": "sensory"
+      },
+      "Nqaij Khov": {
+        "english": "feels like frostbite",
+        "mcgill_dimension": "sensory"
+      },
+      "Hnov nqaij khaus ntawm ib cheem tsam": {
+        "english": "tingle, feel a twinge in the area",
+        "mcgill_dimension": "sensory"
+      },
+      "Mob, Loog": {
+        "english": "aching, throbbing",
+        "mcgill_dimension": "sensory"
+      },
+      "Muab tswj": {
+        "english": "be twisted",
+        "mcgill_dimension": "sensory"
+      },
+      "Tsw muaj zog": {
+        "english": "pungent",
+        "mcgill_dimension": "sensory"
+      },
+      "Mob": {
+        "english": "throbbing",
+        "mcgill_dimension": "sensory"
+      },
+      "Tev": {
+        "english": "peeling",
+        "mcgill_dimension": "sensory"
+      },
+      "Pleb": {
+        "english": "cracking",
+        "mcgill_dimension": "sensory"
+      },
+      "Nyob ruaj khov": {
+        "english": "be ground",
+        "mcgill_dimension": "sensory"
+      },
+      "Muab Tswj": {
+        "english": "be twisted",
+        "mcgill_dimension": "sensory"
+      },
+      "Txawv": {
+        "english": "out of place",
+        "mcgill_dimension": "sensory"
+      },
+      "Ntog": {
+        "english": "falling out,",
+        "mcgill_dimension": "sensory"
+      },
+      "Suab Tawg": {
+        "english": "creaking",
+        "mcgill_dimension": "sensory"
+      },
+      "Chob": {
+        "english": "poking",
+        "mcgill_dimension": "sensory"
+      },
+      "ci ntsa iab": {
+        "english": "flickering",
+        "mcgill_dimension": "sensory"
+      },
+      "Tshee": {
+        "english": "quivering",
+        "mcgill_dimension": "sensory"
+      },
+      "Co heev": {
+        "english": "pulsing",
+        "mcgill_dimension": "sensory"
+      },
+      "Ntaus": {
+        "english": "pounding",
+        "mcgill_dimension": "sensory"
+      },
+      "Teeb ntsai": {
+        "english": "flashing",
+        "mcgill_dimension": "sensory"
+      },
+      "La la Li": {
+        "english": "boring",
+        "mcgill_dimension": "sensory"
+      },
+      "Tho": {
+        "english": "drilling",
+        "mcgill_dimension": "sensory"
+      },
+      "Nkaug": {
+        "english": "lancinating",
+        "mcgill_dimension": "sensory"
+      },
+      "Hlai": {
+        "english": "lacerating",
+        "mcgill_dimension": "sensory"
+      },
+      "Tom": {
+        "english": "gnawing",
+        "mcgill_dimension": "sensory"
+      },
+      "Mob qaib": {
+        "english": "cramping",
+        "mcgill_dimension": "sensory"
+      },
+      "Tswj": {
+        "english": "wrenching",
+        "mcgill_dimension": "sensory"
+      },
+      "Kub Heev": {
+        "english": "scalding",
+        "mcgill_dimension": "sensory"
+      },
+      "Hlawv": {
+        "english": "searing",
+        "mcgill_dimension": "sensory"
+      },
+      "Mos Mos": {
+        "english": "tender",
+        "mcgill_dimension": "sensory"
+      },
+      "Rub nruj": {
+        "english": "taut",
+        "mcgill_dimension": "sensory"
+      },
+      "Ua pa hnyav": {
+        "english": "rasping",
+        "mcgill_dimension": "sensory"
+      },
+      "Mob heev": {
+        "english": "sickening",
+        "mcgill_dimension": "sensory"
+      },
+      "Tsim Txos": {
+        "english": "grueling",
+        "mcgill_dimension": "sensory"
+      },
+      "Hnyav heev": {
+        "english": "intense",
+        "mcgill_dimension": "sensory"
+      },
+      "Kis log Tuag": {
+        "english": "radiating",
+        "mcgill_dimension": "sensory"
+      },
+      "Rub": {
+        "english": "drawing",
+        "mcgill_dimension": "sensory"
+      },
+      "Thab": {
+        "english": "nagging",
+        "mcgill_dimension": "sensory"
+      },
+      "Tsis zoo siab": {
+        "english": "dreadful",
+        "mcgill_dimension": "sensory"
+      }
+    },
+    "affective": {}
+  }
+}

Backend/scripts/pain_descriptors_formatted.py

@@ -0,0 +1,1533 @@
+
+# CHINESE Pain Descriptors
+CHINESE_PAIN_DESCRIPTORS = {
+    "neuropathic": {
+        "火辣辣的疼": {
+            "english": "burning",
+            "mcgill_dimension": "sensory"
+        },
+        "麻的": {
+            "english": "numb",
+            "mcgill_dimension": "sensory"
+        },
+        "刺骨痛": {
+            "english": "piercing",
+            "mcgill_dimension": "sensory"
+        },
+        "刺痛": {
+            "english": "tingling",
+            "mcgill_dimension": "sensory"
+        },
+        "剧烈的疼": {
+            "english": "sharp",
+            "mcgill_dimension": "sensory"
+        },
+        "蚊虫叮咬的刺疼": {
+            "english": "stinging",
+            "mcgill_dimension": "sensory"
+        },
+    },
+    "nociceptive": {
+        "疼": {
+            "english": "aching",
+            "mcgill_dimension": "sensory"
+        },
+        "急性的": {
+            "english": "acute",
+            "mcgill_dimension": "sensory"
+        },
+        "极度的疼痛": {
+            "english": "agonizing",
+            "mcgill_dimension": "sensory"
+        },
+        "跳动的痛": {
+            "english": "beating",
+            "mcgill_dimension": "sensory"
+        },
+        "强烈的疼痛": {
+            "english": "blinding",
+            "mcgill_dimension": "sensory"
+        },
+        "被刺穿的疼": {
+            "english": "boring",
+            "mcgill_dimension": "sensory"
+        },
+        "短暂的": {
+            "english": "brief",
+            "mcgill_dimension": "sensory"
+        },
+        "慢性的": {
+            "english": "chronic",
+            "mcgill_dimension": "sensory"
+        },
+        "冷痛": {
+            "english": "cold",
+            "mcgill_dimension": "sensory"
+        },
+        "不间断的": {
+            "english": "constant",
+            "mcgill_dimension": "sensory"
+        },
+        "冷的": {
+            "english": "cool",
+            "mcgill_dimension": "sensory"
+        },
+        "绞痛": {
+            "english": "cramp",
+            "mcgill_dimension": "sensory"
+        },
+        "压迫痛": {
+            "english": "crushing",
+            "mcgill_dimension": "sensory"
+        },
+        "切割痛": {
+            "english": "cutting",
+            "mcgill_dimension": "sensory"
+        },
+        "拉扯痛": {
+            "english": "pulling",
+            "mcgill_dimension": "sensory"
+        },
+        "可怕的痛苦": {
+            "english": "dreadful",
+            "mcgill_dimension": "sensory"
+        },
+        "钻痛": {
+            "english": "drilling",
+            "mcgill_dimension": "sensory"
+        },
+        "隐约的疼痛": {
+            "english": "dull",
+            "mcgill_dimension": "sensory"
+        },
+        "疼到没力气": {
+            "english": "exhaust",
+            "mcgill_dimension": "sensory"
+        },
+        "可怕的痛": {
+            "english": "fearful",
+            "mcgill_dimension": "sensory"
+        },
+        "一阵阵的": {
+            "english": "fitful",
+            "mcgill_dimension": "sensory"
+        },
+        "一闪而过的痛": {
+            "english": "flashing",
+            "mcgill_dimension": "sensory"
+        },
+        "闪烁的痛": {
+            "english": "Flickering",
+            "mcgill_dimension": "sensory"
+        },
+        "冷疼": {
+            "english": "freezing",
+            "mcgill_dimension": "sensory"
+        },
+        "疼的可怕": {
+            "english": "frightful",
+            "mcgill_dimension": "sensory"
+        },
+        "折磨的痛": {
+            "english": "gnawing",
+            "mcgill_dimension": "sensory"
+        },
+        "折磨人的": {
+            "english": "gruelling",
+            "mcgill_dimension": "sensory"
+        },
+        "非常痛": {
+            "english": "heavy",
+            "mcgill_dimension": "sensory"
+        },
+        "热的": {
+            "english": "hot",
+            "mcgill_dimension": "sensory"
+        },
+        "使...难受": {
+            "english": "hurt",
+            "mcgill_dimension": "sensory"
+        },
+        "强烈的": {
+            "english": "intense",
+            "mcgill_dimension": "sensory"
+        },
+        "痒的": {
+            "english": "itchy",
+            "mcgill_dimension": "sensory"
+        },
+        "跳动的疼": {
+            "english": "jumping",
+            "mcgill_dimension": "sensory"
+        },
+        "及其": {
+            "english": "to kill",
+            "mcgill_dimension": "sensory"
+        },
+        "撕裂痛": {
+            "english": "lacerating",
+            "mcgill_dimension": "sensory"
+        },
+        "撕裂的痛": {
+            "english": "lancinating",
+            "mcgill_dimension": "sensory"
+        },
+        "使人不得安宁": {
+            "english": "nagging",
+            "mcgill_dimension": "sensory"
+        },
+        "钻心的": {
+            "english": "nauseating",
+            "mcgill_dimension": "sensory"
+        },
+        "渗透的": {
+            "english": "penetrating",
+            "mcgill_dimension": "sensory"
+        },
+        "一阵一阵的痛": {
+            "english": "periodic",
+            "mcgill_dimension": "sensory"
+        },
+        "掐疼": {
+            "english": "pinching",
+            "mcgill_dimension": "sensory"
+        },
+        "重击痛": {
+            "english": "pounding",
+            "mcgill_dimension": "sensory"
+        },
+        "压着痛": {
+            "english": "pressing",
+            "mcgill_dimension": "sensory"
+        },
+        "搏动性痛": {
+            "english": "pulsing",
+            "mcgill_dimension": "sensory"
+        },
+        "颤抖": {
+            "english": "quivering",
+            "mcgill_dimension": "sensory"
+        },
+        "发散性疼痛": {
+            "english": "radiating",
+            "mcgill_dimension": "sensory"
+        },
+        "粗糙的": {
+            "english": "raspy",
+            "mcgill_dimension": "sensory"
+        },
+        "有节奏的": {
+            "english": "rhythmic",
+            "mcgill_dimension": "sensory"
+        },
+        "烫伤": {
+            "english": "scalding",
+            "mcgill_dimension": "sensory"
+        },
+        "灼痛": {
+            "english": "searing",
+            "mcgill_dimension": "sensory"
+        },
+        "剧烈疼痛": {
+            "english": "smarting",
+            "mcgill_dimension": "sensory"
+        },
+        "酸痛": {
+            "english": "sore",
+            "mcgill_dimension": "sensory"
+        },
+        "分裂痛": {
+            "english": "splitting",
+            "mcgill_dimension": "sensory"
+        },
+        "扩散性疼痛": {
+            "english": "spreading",
+            "mcgill_dimension": "sensory"
+        },
+        "挤压的疼痛": {
+            "english": "squeezing",
+            "mcgill_dimension": "sensory"
+        },
+        "令人窒息的": {
+            "english": "suffocating",
+            "mcgill_dimension": "sensory"
+        },
+        "紧张的": {
+            "english": "taut",
+            "mcgill_dimension": "sensory"
+        },
+        "撕裂的": {
+            "english": "tearing",
+            "mcgill_dimension": "sensory"
+        },
+        "一碰就痛": {
+            "english": "tender",
+            "mcgill_dimension": "sensory"
+        },
+        "程度很高的痛苦": {
+            "english": "terrifying",
+            "mcgill_dimension": "sensory"
+        },
+        "一抽一抽的痛": {
+            "english": "throbbing",
+            "mcgill_dimension": "sensory"
+        },
+        "顽固的": {
+            "english": "unyielding.",
+            "mcgill_dimension": "sensory"
+        },
+        "疲倦": {
+            "english": "to tire",
+            "mcgill_dimension": "sensory"
+        },
+        "折磨": {
+            "english": "torturing",
+            "mcgill_dimension": "sensory"
+        },
+        "剧烈的痛苦": {
+            "english": "vicious",
+            "mcgill_dimension": "sensory"
+        },
+        "极为痛苦的": {
+            "english": "wrenching",
+            "mcgill_dimension": "sensory"
+        },
+        "头": {
+            "english": "Head",
+            "mcgill_dimension": "sensory"
+        },
+        "脖子": {
+            "english": "Neck",
+            "mcgill_dimension": "sensory"
+        },
+        "脸": {
+            "english": "Face",
+            "mcgill_dimension": "sensory"
+        },
+        "手": {
+            "english": "Hands",
+            "mcgill_dimension": "sensory"
+        },
+        "手臂": {
+            "english": "Arms",
+            "mcgill_dimension": "sensory"
+        },
+        "背": {
+            "english": "Back",
+            "mcgill_dimension": "sensory"
+        },
+        "腿": {
+            "english": "Legs",
+            "mcgill_dimension": "sensory"
+        },
+        "脚": {
+            "english": "Feet",
+            "mcgill_dimension": "sensory"
+        },
+        "胸腔": {
+            "english": "Chest",
+            "mcgill_dimension": "sensory"
+        },
+        "腹部": {
+            "english": "Abdomen",
+            "mcgill_dimension": "sensory"
+        },
+        "肺": {
+            "english": "lungs",
+            "mcgill_dimension": "sensory"
+        },
+        "心脏": {
+            "english": "heart",
+            "mcgill_dimension": "sensory"
+        },
+    },
+    "affective": {
+        "烦人的": {
+            "english": "annoying",
+            "mcgill_dimension": "sensory"
+        },
+        "痛苦": {
+            "english": "miserable",
+            "mcgill_dimension": "sensory"
+        },
+        "麻烦的": {
+            "english": "troublesome",
+            "mcgill_dimension": "sensory"
+        },
+        "难以忍受的": {
+            "english": "unbearable",
+            "mcgill_dimension": "sensory"
+        },
+    },
+}
+
+
+# KOREAN Pain Descriptors
+KOREAN_PAIN_DESCRIPTORS = {
+    "neuropathic": {
+        "따끔거리다": {
+            "english": "sting",
+            "mcgill_dimension": "sensory"
+        },
+        "찌르다": {
+            "english": "stabbing",
+            "mcgill_dimension": "sensory"
+        },
+        "타는것 같다": {
+            "english": "burning",
+            "mcgill_dimension": "sensory"
+        },
+        "아리다": {
+            "english": "stinging",
+            "mcgill_dimension": "sensory"
+        },
+        "얼얼하다": {
+            "english": "numb",
+            "mcgill_dimension": "sensory"
+        },
+        "쏘듯이 아프다": {
+            "english": "shooting",
+            "mcgill_dimension": "sensory"
+        },
+        "바늘로 찌르듯": {
+            "english": "pricking",
+            "mcgill_dimension": "sensory"
+        },
+        "칼로 찌르듯": {
+            "english": "stabbing",
+            "mcgill_dimension": "sensory"
+        },
+        "쓰라리다": {
+            "english": "sharp",
+            "mcgill_dimension": "sensory"
+        },
+        "화끈거리다": {
+            "english": "burning",
+            "mcgill_dimension": "sensory"
+        },
+        "서물서물하다": {
+            "english": "tingling",
+            "mcgill_dimension": "sensory"
+        },
+        "톡 쏘듯이 아프다": {
+            "english": "stinging",
+            "mcgill_dimension": "sensory"
+        },
+        "지치게 아프다": {
+            "english": "exhausting",
+            "mcgill_dimension": "sensory"
+        },
+        "뼈를 쳐미듯이 아프다": {
+            "english": "piercing",
+            "mcgill_dimension": "sensory"
+        },
+        "저리다": {
+            "english": "numb",
+            "mcgill_dimension": "sensory"
+        },
+    },
+    "nociceptive": {
+        "꼬집히다": {
+            "english": "pinched",
+            "mcgill_dimension": "sensory"
+        },
+        "뻐근하다": {
+            "english": "stiff",
+            "mcgill_dimension": "sensory"
+        },
+        "조이다": {
+            "english": "constricting",
+            "mcgill_dimension": "sensory"
+        },
+        "찢어지다": {
+            "english": "torn",
+            "mcgill_dimension": "sensory"
+        },
+        "터지다": {
+            "english": "broken",
+            "mcgill_dimension": "sensory"
+        },
+        "팽팽하다": {
+            "english": "tight",
+            "mcgill_dimension": "sensory"
+        },
+        "긁히다": {
+            "english": "scrape",
+            "mcgill_dimension": "sensory"
+        },
+        "꿈틀거리다": {
+            "english": "wriggle",
+            "mcgill_dimension": "sensory"
+        },
+        "둔하다": {
+            "english": "obtuse",
+            "mcgill_dimension": "sensory"
+        },
+        "무디다": {
+            "english": "dull",
+            "mcgill_dimension": "sensory"
+        },
+        "뻗치다": {
+            "english": "sticking out",
+            "mcgill_dimension": "sensory"
+        },
+        "쐬다": {
+            "english": "get stung",
+            "mcgill_dimension": "sensory"
+        },
+        "오싹하다": {
+            "english": "feel a chill",
+            "mcgill_dimension": "sensory"
+        },
+        "지지다": {
+            "english": "frying",
+            "mcgill_dimension": "sensory"
+        },
+        "화끈거리다": {
+            "english": "hot",
+            "mcgill_dimension": "sensory"
+        },
+        "부딪히다": {
+            "english": "hitting",
+            "mcgill_dimension": "sensory"
+        },
+        "쓰라리다": {
+            "english": "sore",
+            "mcgill_dimension": "sensory"
+        },
+        "으스러지다": {
+            "english": "be shattered",
+            "mcgill_dimension": "sensory"
+        },
+        "끊어지다": {
+            "english": "cut",
+            "mcgill_dimension": "sensory"
+        },
+        "살을 에이는 듯한 아픔.": {
+            "english": "penetrating",
+            "mcgill_dimension": "sensory"
+        },
+        "울리다": {
+            "english": "ringing",
+            "mcgill_dimension": "sensory"
+        },
+        "쪼개지다": {
+            "english": "splitting",
+            "mcgill_dimension": "sensory"
+        },
+        "시리다": {
+            "english": "cool",
+            "mcgill_dimension": "sensory"
+        },
+        "부서지다": {
+            "english": "smashing",
+            "mcgill_dimension": "sensory"
+        },
+        "싸하다": {
+            "english": "pungent",
+            "mcgill_dimension": "sensory"
+        },
+        "잘리다": {
+            "english": "be chopped",
+            "mcgill_dimension": "sensory"
+        },
+        "찌릿하다": {
+            "english": "throbbing",
+            "mcgill_dimension": "sensory"
+        },
+        "깎이다": {
+            "english": "peeling",
+            "mcgill_dimension": "sensory"
+        },
+        "깨지다": {
+            "english": "cracking",
+            "mcgill_dimension": "sensory"
+        },
+        "갈리다": {
+            "english": "be ground",
+            "mcgill_dimension": "sensory"
+        },
+        "비틀리다": {
+            "english": "be twisted",
+            "mcgill_dimension": "sensory"
+        },
+        "빠지다": {
+            "english": "falling out,",
+            "mcgill_dimension": "sensory"
+        },
+        "뻣뻣하다": {
+            "english": "stiff",
+            "mcgill_dimension": "sensory"
+        },
+        "삐드득": {
+            "english": "creaking",
+            "mcgill_dimension": "sensory"
+        },
+        "쑤시다": {
+            "english": "poking",
+            "mcgill_dimension": "sensory"
+        },
+        "가물가물 아프다": {
+            "english": "flickering",
+            "mcgill_dimension": "sensory"
+        },
+        "지근거리다": {
+            "english": "nagging",
+            "mcgill_dimension": "sensory"
+        },
+        "욱신욱신하다": {
+            "english": "pulsing",
+            "mcgill_dimension": "sensory"
+        },
+        "들먹거리다": {
+            "english": "beating",
+            "mcgill_dimension": "sensory"
+        },
+        "쾅쾅치듯이 아프다": {
+            "english": "pounding",
+            "mcgill_dimension": "sensory"
+        },
+        "움찔하게 아프다": {
+            "english": "jumping",
+            "mcgill_dimension": "sensory"
+        },
+        "따끔하다": {
+            "english": "flashing",
+            "mcgill_dimension": "sensory"
+        },
+        "송곳으로 찌르듯": {
+            "english": "boring",
+            "mcgill_dimension": "sensory"
+        },
+        "구멍을 뚫듯이": {
+            "english": "drilling",
+            "mcgill_dimension": "sensory"
+        },
+        "칼로 찔러 쑤시듯": {
+            "english": "lancinating",
+            "mcgill_dimension": "sensory"
+        },
+        "베듯이 아프다": {
+            "english": "cutting",
+            "mcgill_dimension": "sensory"
+        },
+        "도려내듯 아프다": {
+            "english": "lacerating",
+            "mcgill_dimension": "sensory"
+        },
+        "꼬집듯 따끔하다": {
+            "english": "pinching",
+            "mcgill_dimension": "sensory"
+        },
+        "누르듯 아프다": {
+            "english": "pressing",
+            "mcgill_dimension": "sensory"
+        },
+        "꽉 무는듯 아프다": {
+            "english": "gnawing",
+            "mcgill_dimension": "sensory"
+        },
+        "꽉 지는듯 아프다": {
+            "english": "cramping",
+            "mcgill_dimension": "sensory"
+        },
+        "짓이기는 듯 아프다": {
+            "english": "crushing",
+            "mcgill_dimension": "sensory"
+        },
+        "결린다": {
+            "english": "tugging",
+            "mcgill_dimension": "sensory"
+        },
+        "땅긴다": {
+            "english": "pulling",
+            "mcgill_dimension": "sensory"
+        },
+        "뒤틀리듯 아프다": {
+            "english": "wrenching",
+            "mcgill_dimension": "sensory"
+        },
+        "따끈하다": {
+            "english": "hot",
+            "mcgill_dimension": "sensory"
+        },
+        "물이나 불에 애듯이 아프다": {
+            "english": "scalding",
+            "mcgill_dimension": "sensory"
+        },
+        "불로 지지듯이 아프다": {
+            "english": "searing",
+            "mcgill_dimension": "sensory"
+        },
+        "근질근질하게 아프다": {
+            "english": "itchy",
+            "mcgill_dimension": "sensory"
+        },
+        "아리다": {
+            "english": "bitter",
+            "mcgill_dimension": "sensory"
+        },
+        "욱신거리다": {
+            "english": "smarting",
+            "mcgill_dimension": "sensory"
+        },
+        "멍하다": {
+            "english": "dull",
+            "mcgill_dimension": "sensory"
+        },
+        "우리하다": {
+            "english": "dull",
+            "mcgill_dimension": "sensory"
+        },
+        "둔하게 아프다": {
+            "english": "hurting",
+            "mcgill_dimension": "sensory"
+        },
+        "쑤신다": {
+            "english": "aching",
+            "mcgill_dimension": "sensory"
+        },
+        "빠개지듯 아프다": {
+            "english": "heavy",
+            "mcgill_dimension": "sensory"
+        },
+        "만지면 아프다": {
+            "english": "tender",
+            "mcgill_dimension": "sensory"
+        },
+        "누르면 아프다": {
+            "english": "tender",
+            "mcgill_dimension": "sensory"
+        },
+        "꽉 찬 것 같다": {
+            "english": "taut",
+            "mcgill_dimension": "sensory"
+        },
+        "갈아내듯이 아프다": {
+            "english": "rasping",
+            "mcgill_dimension": "sensory"
+        },
+        "터질듯이 아프다": {
+            "english": "splitting",
+            "mcgill_dimension": "sensory"
+        },
+        "살살 아프다": {
+            "english": "sickening",
+            "mcgill_dimension": "sensory"
+        },
+        "숨이 막힐듯 아프다": {
+            "english": "suffocating",
+            "mcgill_dimension": "sensory"
+        },
+        "겁나게 아프다": {
+            "english": "fearful",
+            "mcgill_dimension": "sensory"
+        },
+        "소름 끼치게 아프다": {
+            "english": "frightful",
+            "mcgill_dimension": "sensory"
+        },
+        "까무러치게 아프다": {
+            "english": "terrifying",
+            "mcgill_dimension": "sensory"
+        },
+        "쩔쩔매게 아프다": {
+            "english": "punishing",
+            "mcgill_dimension": "sensory"
+        },
+        "기진맥진하게 아프다": {
+            "english": "grueling",
+            "mcgill_dimension": "sensory"
+        },
+        "지독하게 아프다": {
+            "english": "dreadful",
+            "mcgill_dimension": "sensory"
+        },
+        "무지막하게 아프다": {
+            "english": "vicious",
+            "mcgill_dimension": "sensory"
+        },
+        "죽을 정도로 아프다": {
+            "english": "killing",
+            "mcgill_dimension": "sensory"
+        },
+        "고약하게 아프다": {
+            "english": "wretched",
+            "mcgill_dimension": "sensory"
+        },
+        "정신 못차리게 아프다": {
+            "english": "blinding",
+            "mcgill_dimension": "sensory"
+        },
+        "지속적으로 대단히 아프다": {
+            "english": "intense",
+            "mcgill_dimension": "sensory"
+        },
+        "참을수 없게 아프다": {
+            "english": "unberable",
+            "mcgill_dimension": "sensory"
+        },
+        "번져가면서 아프다": {
+            "english": "spreading",
+            "mcgill_dimension": "sensory"
+        },
+        "통증이 삐친다": {
+            "english": "radiating",
+            "mcgill_dimension": "sensory"
+        },
+        "관통하듯이 아프다": {
+            "english": "penetrating",
+            "mcgill_dimension": "sensory"
+        },
+        "조인다": {
+            "english": "tight",
+            "mcgill_dimension": "sensory"
+        },
+        "끌어당기듯이 아프다": {
+            "english": "drawing",
+            "mcgill_dimension": "sensory"
+        },
+        "쥐어짜듯이 아프다": {
+            "english": "squeezing",
+            "mcgill_dimension": "sensory"
+        },
+        "찢어지는듯 아프다": {
+            "english": "tearing",
+            "mcgill_dimension": "sensory"
+        },
+        "싸늘하게 아프다": {
+            "english": "cold",
+            "mcgill_dimension": "sensory"
+        },
+        "오싹하게 아프다": {
+            "english": "freezing",
+            "mcgill_dimension": "sensory"
+        },
+        "토할 정도로 아프다": {
+            "english": "nauseating",
+            "mcgill_dimension": "sensory"
+        },
+        "괴롭게 아프다": {
+            "english": "agonizing",
+            "mcgill_dimension": "sensory"
+        },
+        "고문 받는것 처럼 아프다": {
+            "english": "torturing",
+            "mcgill_dimension": "sensory"
+        },
+    },
+    "affective": {
+        "노곤하게 아프다": {
+            "english": "tiring",
+            "mcgill_dimension": "sensory"
+        },
+        "신경이 자꾸 쓰이게 아프다": {
+            "english": "annoying",
+            "mcgill_dimension": "sensory"
+        },
+        "난처하게 아프다": {
+            "english": "troublesome",
+            "mcgill_dimension": "sensory"
+        },
+        "괴롭게 아프다": {
+            "english": "miserable",
+            "mcgill_dimension": "sensory"
+        },
+    },
+}
+
+
+# SPANISH Pain Descriptors
+SPANISH_PAIN_DESCRIPTORS = {
+    "neuropathic": {
+        "de ardor": {
+            "english": "burning",
+            "mcgill_dimension": "sensory"
+        },
+        "quemadura": {
+            "english": "burning",
+            "mcgill_dimension": "sensory"
+        },
+        "quemazón": {
+            "english": "burning",
+            "mcgill_dimension": "sensory"
+        },
+        "adormecido": {
+            "english": "numb",
+            "mcgill_dimension": "sensory"
+        },
+        "perforante": {
+            "english": "piercing",
+            "mcgill_dimension": "sensory"
+        },
+        "pinchazo": {
+            "english": "pricking",
+            "mcgill_dimension": "sensory"
+        },
+        "agudo": {
+            "english": "sharp",
+            "mcgill_dimension": "sensory"
+        },
+        "expandirse": {
+            "english": "shooting",
+            "mcgill_dimension": "sensory"
+        },
+        "punzante": {
+            "english": "stabbing",
+            "mcgill_dimension": "sensory"
+        },
+        "picazón": {
+            "english": "stinging",
+            "mcgill_dimension": "sensory"
+        },
+        "hormigueo": {
+            "english": "tingling",
+            "mcgill_dimension": "sensory"
+        },
+    },
+    "nociceptive": {
+        "dolorido": {
+            "english": "aching",
+            "mcgill_dimension": "sensory"
+        },
+        "agudo": {
+            "english": "acute",
+            "mcgill_dimension": "sensory"
+        },
+        "anónico": {
+            "english": "agonizing",
+            "mcgill_dimension": "sensory"
+        },
+        "batiente": {
+            "english": "beating",
+            "mcgill_dimension": "sensory"
+        },
+        "agobiante": {
+            "english": "heavy",
+            "mcgill_dimension": "sensory"
+        },
+        "sofocante": {
+            "english": "suffocating",
+            "mcgill_dimension": "sensory"
+        },
+        "ceguera": {
+            "english": "blinding",
+            "mcgill_dimension": "sensory"
+        },
+        "terebrante": {
+            "english": "boring",
+            "mcgill_dimension": "sensory"
+        },
+        "breve": {
+            "english": "brief",
+            "mcgill_dimension": "sensory"
+        },
+        "quemadura": {
+            "english": "burn",
+            "mcgill_dimension": "sensory"
+        },
+        "crónico": {
+            "english": "chronic",
+            "mcgill_dimension": "sensory"
+        },
+        "helante": {
+            "english": "cold",
+            "mcgill_dimension": "sensory"
+        },
+        "constante": {
+            "english": "constant",
+            "mcgill_dimension": "sensory"
+        },
+        "frío": {
+            "english": "cool",
+            "mcgill_dimension": "sensory"
+        },
+        "calambre": {
+            "english": "cramp",
+            "mcgill_dimension": "sensory"
+        },
+        "retortijón": {
+            "english": "cramp",
+            "mcgill_dimension": "sensory"
+        },
+        "triturante": {
+            "english": "crushing",
+            "mcgill_dimension": "sensory"
+        },
+        "incisión": {
+            "english": "cut",
+            "mcgill_dimension": "sensory"
+        },
+        "cortante": {
+            "english": "cutting",
+            "mcgill_dimension": "sensory"
+        },
+        "de estiramiento": {
+            "english": "drawing",
+            "mcgill_dimension": "sensory"
+        },
+        "atemorizante": {
+            "english": "dreadful",
+            "mcgill_dimension": "sensory"
+        },
+        "taladrante": {
+            "english": "drilling",
+            "mcgill_dimension": "sensory"
+        },
+        "leve": {
+            "english": "dull",
+            "mcgill_dimension": "sensory"
+        },
+        "agotar": {
+            "english": "exhaust",
+            "mcgill_dimension": "sensory"
+        },
+        "dar miedo": {
+            "english": "fearful",
+            "mcgill_dimension": "sensory"
+        },
+        "intermitente": {
+            "english": "fitful",
+            "mcgill_dimension": "sensory"
+        },
+        "destello de": {
+            "english": "flickering",
+            "mcgill_dimension": "sensory"
+        },
+        "centelleante": {
+            "english": "flashing",
+            "mcgill_dimension": "sensory"
+        },
+        "congelante": {
+            "english": "freezing",
+            "mcgill_dimension": "sensory"
+        },
+        "alarmante": {
+            "english": "frightful",
+            "mcgill_dimension": "sensory"
+        },
+        "lacerante": {
+            "english": "lancinating",
+            "mcgill_dimension": "sensory"
+        },
+        "mordicante": {
+            "english": "gnawing",
+            "mcgill_dimension": "sensory"
+        },
+        "agotador": {
+            "english": "gruelling",
+            "mcgill_dimension": "sensory"
+        },
+        "caliente": {
+            "english": "hot",
+            "mcgill_dimension": "sensory"
+        },
+        "doler": {
+            "english": "to hurt",
+            "mcgill_dimension": "sensory"
+        },
+        "intenso": {
+            "english": "intense",
+            "mcgill_dimension": "sensory"
+        },
+        "comezón": {
+            "english": "itch",
+            "mcgill_dimension": "sensory"
+        },
+        "picante": {
+            "english": "itchy",
+            "mcgill_dimension": "sensory"
+        },
+        "saltón": {
+            "english": "jumping",
+            "mcgill_dimension": "sensory"
+        },
+        "matar": {
+            "english": "kill",
+            "mcgill_dimension": "sensory"
+        },
+        "molesto": {
+            "english": "nagging",
+            "mcgill_dimension": "sensory"
+        },
+        "dar náuseas": {
+            "english": "nauseating",
+            "mcgill_dimension": "sensory"
+        },
+        "penetrante": {
+            "english": "penetrating",
+            "mcgill_dimension": "sensory"
+        },
+        "regular": {
+            "english": "periodic",
+            "mcgill_dimension": "sensory"
+        },
+        "periódico": {
+            "english": "periodic",
+            "mcgill_dimension": "sensory"
+        },
+        "pellizcante": {
+            "english": "pinching",
+            "mcgill_dimension": "sensory"
+        },
+        "latiendo": {
+            "english": "pounding",
+            "mcgill_dimension": "sensory"
+        },
+        "hacer presión sobre": {
+            "english": "pressing",
+            "mcgill_dimension": "sensory"
+        },
+        "tensar": {
+            "english": "pulling",
+            "mcgill_dimension": "sensory"
+        },
+        "palpitar": {
+            "english": "pulsing",
+            "mcgill_dimension": "sensory"
+        },
+        "temblando": {
+            "english": "quivering",
+            "mcgill_dimension": "sensory"
+        },
+        "irradiar": {
+            "english": "radiating",
+            "mcgill_dimension": "sensory"
+        },
+        "ronca": {
+            "english": "raspy",
+            "mcgill_dimension": "sensory"
+        },
+        "rítmico": {
+            "english": "rhythmic",
+            "mcgill_dimension": "sensory"
+        },
+        "hirviente": {
+            "english": "scalding",
+            "mcgill_dimension": "sensory"
+        },
+        "ardiente": {
+            "english": "searing",
+            "mcgill_dimension": "sensory"
+        },
+        "seco": {
+            "english": "smarting",
+            "mcgill_dimension": "sensory"
+        },
+        "adolorido": {
+            "english": "sore",
+            "mcgill_dimension": "sensory"
+        },
+        "severo": {
+            "english": "splitting",
+            "mcgill_dimension": "sensory"
+        },
+        "que se extiende": {
+            "english": "spreading",
+            "mcgill_dimension": "sensory"
+        },
+        "apretar": {
+            "english": "squeezing",
+            "mcgill_dimension": "sensory"
+        },
+        "tirante": {
+            "english": "taut",
+            "mcgill_dimension": "sensory"
+        },
+        "desgarrador": {
+            "english": "wrenching",
+            "mcgill_dimension": "sensory"
+        },
+        "sensible": {
+            "english": "tender",
+            "mcgill_dimension": "sensory"
+        },
+        "aterrador": {
+            "english": "terrifying",
+            "mcgill_dimension": "sensory"
+        },
+        "punzante": {
+            "english": "throbbing",
+            "mcgill_dimension": "sensory"
+        },
+        "firme": {
+            "english": "unyielding",
+            "mcgill_dimension": "sensory"
+        },
+        "cansarse": {
+            "english": "to tire",
+            "mcgill_dimension": "sensory"
+        },
+        "torturante": {
+            "english": "torturing",
+            "mcgill_dimension": "sensory"
+        },
+        "maligno": {
+            "english": "vicious",
+            "mcgill_dimension": "sensory"
+        },
+        "la cabeza": {
+            "english": "Head",
+            "mcgill_dimension": "sensory"
+        },
+        "el cuello": {
+            "english": "Neck",
+            "mcgill_dimension": "sensory"
+        },
+        "la cara": {
+            "english": "Face",
+            "mcgill_dimension": "sensory"
+        },
+        "las manos": {
+            "english": "Hands",
+            "mcgill_dimension": "sensory"
+        },
+        "los brazos": {
+            "english": "Arms",
+            "mcgill_dimension": "sensory"
+        },
+        "la espalda": {
+            "english": "Back",
+            "mcgill_dimension": "sensory"
+        },
+        "las piernas": {
+            "english": "Legs",
+            "mcgill_dimension": "sensory"
+        },
+        "los pies": {
+            "english": "Feet",
+            "mcgill_dimension": "sensory"
+        },
+        "el pecho": {
+            "english": "Chest",
+            "mcgill_dimension": "sensory"
+        },
+        "el abdomen": {
+            "english": "Abdomen",
+            "mcgill_dimension": "sensory"
+        },
+        "los pulmones": {
+            "english": "lungs",
+            "mcgill_dimension": "sensory"
+        },
+        "el corazón": {
+            "english": "heart",
+            "mcgill_dimension": "sensory"
+        },
+        "angustioso": {
+            "english": "distressing",
+            "mcgill_dimension": "sensory"
+        },
+        "escalofrio": {
+            "english": "chill",
+            "mcgill_dimension": "sensory"
+        },
+        "migraña": {
+            "english": "Throbbing headache",
+            "mcgill_dimension": "sensory"
+        },
+        "Nervios": {
+            "english": "anxious",
+            "mcgill_dimension": "sensory"
+        },
+        "susto": {
+            "english": "anxiety",
+            "mcgill_dimension": "sensory"
+        },
+        "tenso": {
+            "english": "muscle tension",
+            "mcgill_dimension": "sensory"
+        },
+        "irritarse": {
+            "english": "irritated",
+            "mcgill_dimension": "sensory"
+        },
+        "entumir": {
+            "english": "Fall asleep",
+            "mcgill_dimension": "sensory"
+        },
+    },
+    "affective": {
+        "fastidioso": {
+            "english": "annoying",
+            "mcgill_dimension": "sensory"
+        },
+        "atroz": {
+            "english": "miserable",
+            "mcgill_dimension": "sensory"
+        },
+        "pesado": {
+            "english": "troublesome",
+            "mcgill_dimension": "sensory"
+        },
+        "insoportable": {
+            "english": "unbearable",
+            "mcgill_dimension": "sensory"
+        },
+    },
+}
+
+
+# HMONG Pain Descriptors
+HMONG_PAIN_DESCRIPTORS = {
+    "neuropathic": {
+        "Plev": {
+            "english": "stinging",
+            "mcgill_dimension": "sensory"
+        },
+        "Muab Nkaug": {
+            "english": "stabbing",
+            "mcgill_dimension": "sensory"
+        },
+        "Kub Heev": {
+            "english": "burning",
+            "mcgill_dimension": "sensory"
+        },
+        "Loog": {
+            "english": "numb",
+            "mcgill_dimension": "sensory"
+        },
+        "Mob ntse": {
+            "english": "picking and pricking",
+            "mcgill_dimension": "sensory"
+        },
+        "Txais hluas taws xob": {
+            "english": "receive an electric shock",
+            "mcgill_dimension": "sensory"
+        },
+        "Nkaug": {
+            "english": "stabbing",
+            "mcgill_dimension": "sensory"
+        },
+        "Khaus": {
+            "english": "tingling",
+            "mcgill_dimension": "sensory"
+        },
+        "Mob": {
+            "english": "stinging",
+            "mcgill_dimension": "sensory"
+        },
+    },
+    "nociceptive": {
+        "Rub Leeg": {
+            "english": "tugging",
+            "mcgill_dimension": "sensory"
+        },
+        "leg": {
+            "english": "twisted",
+            "mcgill_dimension": "sensory"
+        },
+        "De": {
+            "english": "pinching",
+            "mcgill_dimension": "sensory"
+        },
+        "Ntuag": {
+            "english": "tearing",
+            "mcgill_dimension": "sensory"
+        },
+        "Raug Ntuag": {
+            "english": "be torn",
+            "mcgill_dimension": "sensory"
+        },
+        "Piam": {
+            "english": "broken",
+            "mcgill_dimension": "sensory"
+        },
+        "Khaus Khaus": {
+            "english": "be scratched",
+            "mcgill_dimension": "sensory"
+        },
+        "Tig": {
+            "english": "wriggle,",
+            "mcgill_dimension": "sensory"
+        },
+        "Obtuse": {
+            "english": "obtuse",
+            "mcgill_dimension": "sensory"
+        },
+        "Tawm": {
+            "english": "sticking out",
+            "mcgill_dimension": "sensory"
+        },
+        "Plev": {
+            "english": "get stung",
+            "mcgill_dimension": "sensory"
+        },
+        "Txias": {
+            "english": "feel a chill",
+            "mcgill_dimension": "sensory"
+        },
+        "Tawg": {
+            "english": "cracking",
+            "mcgill_dimension": "sensory"
+        },
+        "Nkau": {
+            "english": "penetrating",
+            "mcgill_dimension": "sensory"
+        },
+        "Cheeb yob tsis tau": {
+            "english": "having a convulsive fit",
+            "mcgill_dimension": "sensory"
+        },
+        "Hnyav": {
+            "english": "feel heavy",
+            "mcgill_dimension": "sensory"
+        },
+        "Nyob qis tab sis kho": {
+            "english": "be low but steady",
+            "mcgill_dimension": "sensory"
+        },
+        "Nqaij Khov": {
+            "english": "feels like frostbite",
+            "mcgill_dimension": "sensory"
+        },
+        "Hnov nqaij khaus ntawm ib cheem tsam": {
+            "english": "tingle, feel a twinge in the area",
+            "mcgill_dimension": "sensory"
+        },
+        "Mob, Loog": {
+            "english": "aching, throbbing",
+            "mcgill_dimension": "sensory"
+        },
+        "Muab tswj": {
+            "english": "be twisted",
+            "mcgill_dimension": "sensory"
+        },
+        "Tsw muaj zog": {
+            "english": "pungent",
+            "mcgill_dimension": "sensory"
+        },
+        "Mob": {
+            "english": "throbbing",
+            "mcgill_dimension": "sensory"
+        },
+        "Tev": {
+            "english": "peeling",
+            "mcgill_dimension": "sensory"
+        },
+        "Pleb": {
+            "english": "cracking",
+            "mcgill_dimension": "sensory"
+        },
+        "Nyob ruaj khov": {
+            "english": "be ground",
+            "mcgill_dimension": "sensory"
+        },
+        "Muab Tswj": {
+            "english": "be twisted",
+            "mcgill_dimension": "sensory"
+        },
+        "Txawv": {
+            "english": "out of place",
+            "mcgill_dimension": "sensory"
+        },
+        "Ntog": {
+            "english": "falling out,",
+            "mcgill_dimension": "sensory"
+        },
+        "Suab Tawg": {
+            "english": "creaking",
+            "mcgill_dimension": "sensory"
+        },
+        "Chob": {
+            "english": "poking",
+            "mcgill_dimension": "sensory"
+        },
+        "ci ntsa iab": {
+            "english": "flickering",
+            "mcgill_dimension": "sensory"
+        },
+        "Tshee": {
+            "english": "quivering",
+            "mcgill_dimension": "sensory"
+        },
+        "Co heev": {
+            "english": "pulsing",
+            "mcgill_dimension": "sensory"
+        },
+        "Ntaus": {
+            "english": "pounding",
+            "mcgill_dimension": "sensory"
+        },
+        "Teeb ntsai": {
+            "english": "flashing",
+            "mcgill_dimension": "sensory"
+        },
+        "La la Li": {
+            "english": "boring",
+            "mcgill_dimension": "sensory"
+        },
+        "Tho": {
+            "english": "drilling",
+            "mcgill_dimension": "sensory"
+        },
+        "Nkaug": {
+            "english": "lancinating",
+            "mcgill_dimension": "sensory"
+        },
+        "Hlai": {
+            "english": "lacerating",
+            "mcgill_dimension": "sensory"
+        },
+        "Tom": {
+            "english": "gnawing",
+            "mcgill_dimension": "sensory"
+        },
+        "Mob qaib": {
+            "english": "cramping",
+            "mcgill_dimension": "sensory"
+        },
+        "Tswj": {
+            "english": "wrenching",
+            "mcgill_dimension": "sensory"
+        },
+        "Kub Heev": {
+            "english": "scalding",
+            "mcgill_dimension": "sensory"
+        },
+        "Hlawv": {
+            "english": "searing",
+            "mcgill_dimension": "sensory"
+        },
+        "Mos Mos": {
+            "english": "tender",
+            "mcgill_dimension": "sensory"
+        },
+        "Rub nruj": {
+            "english": "taut",
+            "mcgill_dimension": "sensory"
+        },
+        "Ua pa hnyav": {
+            "english": "rasping",
+            "mcgill_dimension": "sensory"
+        },
+        "Mob heev": {
+            "english": "sickening",
+            "mcgill_dimension": "sensory"
+        },
+        "Tsim Txos": {
+            "english": "grueling",
+            "mcgill_dimension": "sensory"
+        },
+        "Hnyav heev": {
+            "english": "intense",
+            "mcgill_dimension": "sensory"
+        },
+        "Kis log Tuag": {
+            "english": "radiating",
+            "mcgill_dimension": "sensory"
+        },
+        "Rub": {
+            "english": "drawing",
+            "mcgill_dimension": "sensory"
+        },
+        "Thab": {
+            "english": "nagging",
+            "mcgill_dimension": "sensory"
+        },
+        "Tsis zoo siab": {
+            "english": "dreadful",
+            "mcgill_dimension": "sensory"
+        },
+    },
+}

Backend/scripts/parse_multilingual_data.py

@@ -0,0 +1,132 @@
+"""
+Parse multilingual pain descriptor data from xlsx
+Generate Python dictionaries for each language
+"""
+import pandas as pd
+import json
+
+def categorize_pain_type(english_word):
+    """Categorize pain descriptor into neuropathic, nociceptive, or affective"""
+    neuropathic_keywords = [
+        'sharp', 'shooting', 'burning', 'tingling', 'numb', 'electric', 
+        'stabbing', 'pricking', 'shock', 'sting', 'piercing', 'needle'
+    ]
+    
+    nociceptive_keywords = [
+        'aching', 'sore', 'throbbing', 'cramping', 'pressing', 'dull',
+        'heavy', 'tight', 'tender', 'stiff', 'pulling', 'squeezing'
+    ]
+    
+    affective_keywords = [
+        'exhausting', 'tiring', 'unbearable', 'miserable', 'annoying',
+        'troublesome', 'depressing', 'frustrating', 'worrying', 'frightening'
+    ]
+    
+    word_lower = english_word.lower()
+    
+    # Check each category
+    if any(kw in word_lower for kw in neuropathic_keywords):
+        return 'neuropathic'
+    elif any(kw in word_lower for kw in nociceptive_keywords):
+        return 'nociceptive'
+    elif any(kw in word_lower for kw in affective_keywords):
+        return 'affective'
+    else:
+        return 'nociceptive'  # Default to nociceptive
+
+def parse_sheet(xlsx_path, sheet_name, english_col, foreign_col):
+    """Parse a specific sheet and return structured data"""
+    df = pd.read_excel(xlsx_path, sheet_name=sheet_name)
+    
+    # Special handling for Korean sheet (header is in first row)
+    if sheet_name == 'ko-en':
+        # First row contains data, not headers
+        # Read without header
+        df = pd.read_excel(xlsx_path, sheet_name=sheet_name, header=None)
+        # Assume column 0 is Korean, column 1 is English
+        df.columns = ['Korean', 'English'] + [f'Col{i}' for i in range(len(df.columns) - 2)]
+        english_col = 'English'
+        foreign_col = 'Korean'
+    
+    # Remove rows with NaN in critical columns
+    if english_col not in df.columns or foreign_col not in df.columns:
+        print(f"⚠️  Warning: Expected columns not found in {sheet_name}")
+        print(f"    Available columns: {list(df.columns)}")
+        return {'neuropathic': {}, 'nociceptive': {}, 'affective': {}}
+    
+    df = df.dropna(subset=[english_col, foreign_col])
+    
+    pain_dict = {
+        'neuropathic': {},
+        'nociceptive': {},
+        'affective': {}
+    }
+    
+    for _, row in df.iterrows():
+        english = str(row[english_col]).strip()
+        foreign = str(row[foreign_col]).strip()
+        
+        # Skip empty or invalid entries
+        if not english or not foreign or english == 'nan' or foreign == 'nan':
+            continue
+            
+        # Categorize
+        category = categorize_pain_type(english)
+        
+        # Add to dictionary (without snomed_ct)
+        pain_dict[category][foreign] = {
+            'english': english,
+            'mcgill_dimension': 'sensory'  # Default, can be refined
+        }
+    
+    return pain_dict
+
+def main():
+    xlsx_path = r'c:\Users\ChaCha ship\Documents\Github\PainReport\Backend\data\questionnaire_form.xlsx'
+    
+    # Parse each language sheet with correct column names
+    # Format: (sheet_name, english_column, foreign_column)
+    languages = {
+        'chinese': ('cn-en', 'English', 'Chinese'),
+        'korean': ('ko-en', 'English', 'Korean'),  # Will be handled specially
+        'spanish': ('es-en', 'English', 'Spanish'),
+        'hmong': ('hmong-en', 'English pain words', 'Hmong pain words')
+    }
+    
+    results = {}
+    
+    for lang_name, (sheet_name, english_col, foreign_col) in languages.items():
+        print(f"\n{'='*60}")
+        print(f"Parsing {lang_name.upper()} ({sheet_name})")
+        print(f"{'='*60}")
+        
+        pain_dict = parse_sheet(xlsx_path, sheet_name, english_col, foreign_col)
+        results[lang_name] = pain_dict
+        
+        # Print statistics
+        total = sum(len(pain_dict[cat]) for cat in pain_dict)
+        print(f"Total terms: {total}")
+        print(f"  - Neuropathic: {len(pain_dict['neuropathic'])}")
+        print(f"  - Nociceptive: {len(pain_dict['nociceptive'])}")
+        print(f"  - Affective: {len(pain_dict['affective'])}")
+        
+        # Show samples
+        if len(pain_dict['neuropathic']) > 0:
+            print(f"\nSample neuropathic terms:")
+            for i, (foreign, data) in enumerate(list(pain_dict['neuropathic'].items())[:3]):
+                print(f"  {foreign} -> {data['english']}")
+    
+    # Save to JSON for inspection
+    import os
+    scripts_dir = os.path.dirname(os.path.abspath(__file__))
+    output_path = os.path.join(scripts_dir, 'multilingual_pain_data.json')
+    
+    with open(output_path, 'w', encoding='utf-8') as f:
+        json.dump(results, f, ensure_ascii=False, indent=2)
+    
+    print(f"\n\n✅ Multilingual data saved to: {output_path}")
+    
+    return results
+
+if __name__ == '__main__':
+    main()

Backend/services/conversation_service.py

@@ -0,0 +1,52 @@
+import os
+from openai import OpenAI
+from dotenv import load_dotenv
+import json
+from typing import List, Dict
+
+load_dotenv()
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+PLACEHOLDER_IMAGES = {
+    "sharp": "/images/sharp.gif",
+    "dull": "/images/dull.jpg",
+    "burning": "/images/burning.gif",
+    "tingling": "/images/Tingling.jpg", 
+    "throbbing": "/images/throbbing.jpg",
+    "radiating": "/images/radiating.gif",
+    "pulsing": "/images/pulsing.gif",
+    "pounding": "/images/pounding.gif"
+}
+
+def generateFollowUpQuestions(converHistory: List[Dict]) -> dict:
+    """Generate bilingual visual pain assessment question using available GIF animations"""
+    
+    # Fixed bilingual question using available GIFs
+    result = {
+        "question": "Which image best describes your pain sensation? | 哪个图像最能描述您的疼痛感觉？",
+        "question_type": "quality",
+        "options": [
+            {
+                "id": "A",
+                "text": "Sharp, stabbing pain | 尖锐刺痛感",
+                "image_key": "sharp",
+                "image_url": "/images/sharp.gif"
+            },
+            {
+                "id": "B", 
+                "text": "Pulsing, throbbing pain | 搏动性疼痛",
+                "image_key": "pulsing",
+                "image_url": "/images/pulsing.gif"
+            },
+            {
+                "id": "C",
+                "text": "Burning, hot sensation | 灼烧样疼痛", 
+                "image_key": "burning",
+                "image_url": "/images/burning.gif"
+            }
+        ],
+        "round_number": 1
+    }
+    
+    return result
+            

Backend/services/llm_service.py

@@ -0,0 +1,796 @@
+import os
+from openai import OpenAI
+from dotenv import load_dotenv
+import json
+
+load_dotenv()
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+def analyzePainDescription(text: str) ->dict:
+    
+    system_prompt = """You are an expert Medical Anthropologist specializing in cross-cultural pain expression.
+
+    Your task is to analyze a patient's transcript by decomposing it into FOUR analytical layers, and then output a structured JSON representation.
+
+    ⚠️ Constraints:
+    - Do NOT act as a medical doctor or provide diagnosis.
+    - Do NOT infer beyond the given transcript.
+    - If uncertain, explicitly state "unknown" or explain uncertainty.
+    - Output MUST be valid JSON only. No extra text.
+
+    ---
+
+    ### Analytical Framework (MANDATORY)
+
+    You MUST analyze the transcript in the following four layers:
+
+    1. Linguistic Layer  
+    - Provide a literal translation preserving the patient's original wording and meaning.  
+    - Do NOT interpret or simplify.
+
+    2. Cultural-Semantic Layer  
+    - Identify culturally specific metaphors or expressions.  
+    - Explain what they mean in plain English.  
+    - Preserve original language for reference.
+
+    3. Clinical Abstraction Layer  
+    - Map the narrative into structured pain descriptors:
+    - sensory qualities (e.g., sharp, dull)
+    - affective qualities (e.g., tiring, distressing)
+    - temporal pattern (e.g., intermittent, constant)
+    - possible body location (if mentioned)
+    - If unclear, mark as "unknown"
+
+    4. Psychosocial Layer  
+    - Identify:
+    - emotional distress
+    - under-reporting (stoicism)
+    - communication risks
+    - Base ONLY on text evidence (no guessing)
+
+    ---
+
+    ### Output JSON Schema (STRICT)
+
+    {
+    "literal_translation": "...",
+    "metaphor_mapping": [
+        {
+        "original_phrase": "...",
+        "language": "...",
+        "literal_meaning": "...",
+        "interpreted_meaning": "..."
+        }
+    ],
+    "clinical_abstraction": {
+        "sensory": [],
+        "affective": [],
+        "temporal_pattern": "",
+        "body_location": "",
+        "intensity_estimate": ""
+    },
+    "psychological_and_stoicism_flags": {
+        "underreporting_risk": true,
+        "emotional_distress": true,
+        "communication_risk": "low",
+        "notes": ""
+    },
+    "physician_action_note": ""
+    }"""
+    
+    try:
+        response = client.chat.completions.create(
+            model="gpt-5.2",  # Use gpt-5.2 for the latest features
+            messages=[
+                {"role": "system", "content": system_prompt + "\n\n**CRITICAL**: Your response must be ONLY valid JSON. No additional text before or after the JSON."},
+                {"role": "user", "content": text}
+            ],
+            temperature=0.1  # Low temperature for consistency
+        )
+        
+        analysis = json.loads(response.choices[0].message.content)
+        return analysis
+    
+    except Exception as e:
+        raise Exception(f"Error analyzing pain description: {str(e)}")
+
+
+def match_pain_terms_from_vocabulary(text: str, vocabulary: list, language: str = "Chinese") -> dict:
+    """
+    Match pain terms from a provided vocabulary list in the patient's text.
+    
+    This replaces the old entity extraction approach. Instead of asking LLM to extract terms,
+    we provide a curated vocabulary and ask it to identify which terms are present.
+    
+    Benefits:
+    - No hallucination (LLM chooses from given list)
+    - No unmapped terms (all terms are in dictionary)
+    - Language-specific vocabulary reduces token usage
+    - Translation handled by dictionary (100% accurate)
+    
+    Args:
+        text: Patient's pain description
+        vocabulary: List of pain terms in patient's language (from our dictionary)
+        language: Language name for context
+        
+    Returns:
+        Dictionary with:
+        - matched_terms: List of terms from vocabulary found in text
+        - location: Body part mentioned
+        - duration_phrase: Time expression
+        - intensity: Pain intensity if stated
+        - emotion_keywords: Emotional words
+        - functional_impact: Activity limitations
+        
+    Example:
+        >>> vocab = ["火辣辣的疼", "麻的", "刺痛", "酸痛"]
+        >>> result = match_pain_terms_from_vocabulary("腿火辣辣的疼，还有点麻", vocab, "Chinese")
+        >>> # Returns: {"matched_terms": ["火辣辣的疼", "麻的"], ...}
+    """
+    
+    # Format vocabulary for prompt (limit to prevent token overflow)
+    vocab_str = "\n".join([f"  - {term}" for term in vocabulary[:200]])  # Max 200 terms
+    
+    system_prompt = f"""You are a medical term matcher for {language} pain descriptions.
+
+**YOUR TASK**: Identify which pain terms from the provided vocabulary appear in the patient's text.
+
+**VOCABULARY** (pain descriptors in {language}):
+{vocab_str}
+
+**MATCHING RULES**:
+1. **Exact and Fuzzy Matching ONLY**:
+   - Exact: If patient says "火辣辣的疼" and it's in vocabulary → MATCH ✅
+   - Fuzzy: If patient says "火辣辣的" or "有点麻", match "火辣辣的疼" or "麻的" ✅
+   - Core matching: "麻" can match "麻的", "一抽一抽" can match "一抽一抽的痛"
+
+2. **CRITICAL - NO INTERPRETATION**:
+   - ❌ DO NOT interpret metaphors (e.g., "蚂蚁在爬" should NOT match "痒的" even if it sounds itchy)
+   - ❌ DO NOT infer meaning (e.g., "像被火烧" should NOT match "火辣辣的" unless text contains "火辣")
+   - ❌ DO NOT translate descriptions to medical terms
+   - ✅ ONLY match if the ACTUAL WORDS appear in text (with fuzzy tolerance for suffixes)
+
+3. **What to Match**:
+   - Pain quality words that LITERALLY appear in text
+   - DO NOT match: connectors (还有, 而且), fillers (那个, 嗯), modifiers alone (有点, 很)
+
+3. **Additional Extraction** (structured fields):
+   - location: Body part (腿, 腰, knee, back, etc.)
+   - duration_phrase: Time (四个月, 3 months, 一周)
+   - intensity: Numeric (0-10) or qualitative if clearly stated
+   - emotion_keywords: Emotional words (郁闷, depressed, 害怕)
+   - functional_impact: Activity limitations (睡不着, can't walk, 影响工作)
+
+**OUTPUT FORMAT** (JSON only):
+{{
+  "matched_terms": ["term1 from vocabulary", "term2 from vocabulary"],
+  "location": "body part or 'Not stated'",
+  "duration_phrase": "time phrase or 'Not stated'",
+  "intensity": "intensity or 'Not stated'",
+  "emotion_keywords": ["emotion1", "emotion2"],
+  "functional_impact": "impact or null"
+}}
+
+**EXAMPLES**:
+
+Example 1:
+Input: "我的腿火辣辣的疼，还有点麻"
+Vocabulary contains: ["火辣辣的疼", "麻的", "刺痛"]
+Output: {{
+  "matched_terms": ["火辣辣的疼", "麻的"],
+  "location": "腿",
+  "duration_phrase": "Not stated",
+  "intensity": "Not stated",
+  "emotion_keywords": [],
+  "functional_impact": null
+}}
+
+Example 2:
+Input: "腰部到腿部触电一样麻痛，四个月了，睡不着，很郁闷"
+Vocabulary contains: ["触电一样", "麻痛", "郁闷"]
+Output: {{
+  "matched_terms": ["触电一样", "麻痛"],
+  "location": "腰部到腿部",
+  "duration_phrase": "四个月",
+  "intensity": "Not stated",
+  "emotion_keywords": ["郁闷"],
+  "functional_impact": "睡不着"
+}}
+
+Example 3 (IMPORTANT - NO INTERPRETATION):
+Input: "腿部火辣辣的疼，好像浑身有蚂蚁在爬"
+Vocabulary contains: ["火辣辣的疼", "麻的", "痒的", "刺痛"]
+Output: {{
+  "matched_terms": ["火辣辣的疼"],
+  "location": "腿部",
+  "duration_phrase": "Not stated",
+  "intensity": "Not stated",
+  "emotion_keywords": [],
+  "functional_impact": null
+}}
+NOTE: "蚂蚁在爬" is a metaphor describing sensation, but "蚂蚁" does not appear in vocabulary.
+DO NOT match "痒的" even though ants crawling sounds itchy - no literal word match!
+The metaphor "蚂蚁在爬" will be handled separately as an unmapped unique description.
+"""
+    
+    try:
+        response = client.chat.completions.create(
+            model="gpt-5.2",
+            messages=[
+                {"role": "system", "content": system_prompt + "\n\n**CRITICAL**: Return ONLY valid JSON. No extra text."},
+                {"role": "user", "content": text}
+            ],
+            temperature=0.1
+        )
+        
+        result = json.loads(response.choices[0].message.content)
+        return result
+    
+    except Exception as e:
+        # Fallback: return empty matches
+        return {
+            "matched_terms": [],
+            "location": "Not stated",
+            "duration_phrase": "Not stated",
+            "intensity": "Not stated",
+            "emotion_keywords": [],
+            "functional_impact": None
+        }
+
+
+def extract_pain_entities_constrained(text: str) -> dict:
+    """
+    LLM-based Named Entity Recognition for pain descriptions.
+    
+    STRICT CONSTRAINTS:
+    - ONLY extract entities present in text
+    - NO medical reasoning or diagnosis
+    - NO speculation beyond explicit patient statements
+    - Output must conform to predefined fields
+    
+    This function is part of the neuro-symbolic architecture where LLM is used
+    ONLY for narrow-scope entity extraction, not clinical decision-making.
+    
+    Args:
+        text: Raw patient pain description (Chinese or multilingual)
+        
+    Returns:
+        Dictionary with extracted entities (not clinical conclusions)
+        
+    Example:
+        >>> entities = extract_pain_entities_constrained("Electric shock-like pain in lower back for 4 months")
+        >>> # Returns: {"pain_descriptors": ["electric shock-like"], "location": "lower back", ...}
+    """
+    
+    system_prompt = """You are a medical NER (Named Entity Recognition) system.
+
+**YOUR ONLY TASK**: Extract factual entities from patient text.
+
+**STRICT RULES**:
+1. ONLY extract information explicitly stated in the text
+2. DO NOT make medical diagnoses or clinical interpretations
+3. DO NOT infer pain type classifications (e.g., neuropathic vs nociceptive)
+4. DO NOT add medical reasoning or recommendations
+5. Mark fields as "Not stated" if not explicitly mentioned
+
+**WHAT TO EXTRACT**:
+- **location**: Anatomical body parts mentioned (腿, 腰, knee, back, etc.)
+- **duration_phrase**: Time expressions (四个月, 3 months, 一周, etc.)
+- **intensity**: Numeric scores (0-10) or qualitative terms if clearly stated
+- **emotion_keywords**: Emotional words (郁闷, depressed, 害怕, anxious, etc.)
+- **functional_impact**: Activity limitations (睡不着, can't walk, 影响工作, etc.)
+- **pain_descriptors**: OPTIONAL - only extract if patient uses vivid/unique descriptions not in standard medical terminology
+
+**NOTE ON pain_descriptors**: 
+  • Our system has a comprehensive pain term dictionary (152 Chinese terms, 131 Korean, 74 Spanish)
+  • Dictionary matching works directly on original text - no extraction needed for standard terms
+  • ONLY extract pain_descriptors if patient uses creative/unique expressions like:
+    - "像被火烧一样" (creative metaphor)
+    - "说不出来的难受" (hard to describe)
+    - "怪怪的感觉" (unusual sensation)
+  • For standard terms like "火辣辣的疼", "触电一样", "麻" - leave pain_descriptors EMPTY
+  • Dictionary will find them automatically
+
+**PROHIBITED**:
+- Medical diagnoses
+- Pain classification
+- Clinical interpretations
+- Recommendations
+- Inferences beyond stated text
+
+**OUTPUT FORMAT** (JSON only):
+{
+  "pain_descriptors": [],  // Usually EMPTY - dictionary handles standard terms
+  "location": "anatomical location or 'Not stated'",
+  "duration_phrase": "exact time phrase or 'Not stated'",
+  "intensity": "numeric value or qualitative term if stated, else 'Not stated'",
+  "emotion_keywords": ["emotional words patient used"],
+  "functional_impact": "impact on activities if mentioned, else null"
+}
+
+**EXAMPLE 1** (Chinese - standard terms, pain_descriptors EMPTY):
+Input: "我的腿火辣辣的疼，还有点麻"
+Output: {
+  "pain_descriptors": [],
+  "location": "腿",
+  "duration_phrase": "Not stated",
+  "intensity": "Not stated",
+  "emotion_keywords": [],
+  "functional_impact": null
+}
+Note: "火辣辣的疼" and "麻" are in dictionary - no need to extract
+
+**EXAMPLE 2** (Chinese - extract only unique expressions):
+Input: "腰部到腿部说不出来的难受感觉，四个月了，晚上睡不着，心情很郁闷"
+Output: {
+  "pain_descriptors": ["说不出来的难受感觉"],
+  "location": "腰部到腿部",
+  "duration_phrase": "四个月",
+  "intensity": "Not stated",
+  "emotion_keywords": ["郁闷"],
+  "functional_impact": "晚上睡不着"
+}
+Note: "说不出来的难受感觉" is unique/creative - extract it
+
+**EXAMPLE 3** (English - focus on structure):
+Input: "My lower back has been aching for 3 months, I'm exhausted"
+Output: {
+  "pain_descriptors": [],
+  "location": "lower back",
+  "duration_phrase": "3 months",
+  "intensity": "Not stated",
+  "emotion_keywords": ["exhausted"],
+  "functional_impact": null
+}
+Note: "aching" is standard - dictionary handles it
+"""
+    
+    try:
+        response = client.chat.completions.create(
+            model="gpt-5.2",  # Use gpt-5.2 for the latest features
+            messages=[
+                {"role": "system", "content": system_prompt + "\n\n**CRITICAL**: Your response must be ONLY valid JSON. No additional text before or after the JSON."},
+                {"role": "user", "content": text}
+            ],
+            temperature=0.1  # Low temperature for consistency
+        )
+        
+        entities = json.loads(response.choices[0].message.content)
+        return entities
+    
+    except Exception as e:
+        raise Exception(f"Error in LLM entity extraction: {str(e)}")
+
+
+def normalize_transcription(text: str, language: str = "Chinese") -> dict:
+    """
+    Normalize speech-to-text transcription using LLM to correct errors and standardize expressions.
+    
+    This preprocessing step improves ontology matching accuracy by:
+    1. Correcting common Whisper transcription errors
+    2. Standardizing colloquial/oral expressions to medical terminology
+    3. Fixing incomplete grammar while preserving original meaning
+    4. Normalizing pain descriptors to match ontology terms
+    
+    Args:
+        text: Original transcription from Whisper
+        language: Patient's language (Chinese, Korean, Spanish, Hmong, English)
+        
+    Returns:
+        Dictionary with:
+        - original: Original transcription
+        - normalized: Cleaned and standardized text
+        - corrections: List of changes made (for transparency)
+        
+    Example:
+        >>> result = normalize_transcription("Leg... uh... burning really badly", "English")
+        >>> # Returns: {
+        >>>   "original": "Leg... uh... burning really badly",
+        >>>   "normalized": "Leg burning pain",
+        >>>   "corrections": ["removed filler words", "standardized expression"]
+        >>> }
+    """
+    
+    system_prompt = f"""You are a medical transcription normalization expert for {language} pain descriptions.
+
+**YOUR TASK**: Clean and standardize speech-to-text transcription while preserving the patient's original pain descriptors.
+
+**NORMALIZATION RULES**:
+
+1. **Fix Transcription Errors**:
+   - Correct common Whisper errors (homophones, misheard words)
+   - Examples:
+     * Chinese: "一揪一揪" → "一抽一抽" (throbbing)
+     * Korean: "따금거리다" → "따끔거리다" (stinging)
+     * Spanish: "quemasón" → "quemazón" (burning)
+   
+   **SPECIAL: Traditional Chinese → Simplified Chinese Conversion**:
+   - Whisper may output Traditional Chinese based on speaker accent (Taiwan/Hong Kong)
+   - Our pain dictionary uses ONLY Simplified Chinese - conversion is REQUIRED
+   - Convert Traditional characters to Simplified:
+     * 還 → 还, 點 → 点, 個 → 个, 頭 → 头, 麻 → 麻 (already same)
+     * 癢 → 痒, 脹 → 胀, 緊 → 紧, 軟 → 软, 腫 → 肿
+     * 鬱悶 → 郁闷, 難受 → 难受, 嚴重 → 严重
+   - Examples:
+     * "我的腿火辣辣的疼，還有點麻" → "我的腿火辣辣的疼，还有点麻"
+     * "頭很痛" → "头很痛"
+     * "感覺很難受" → "感觉很难受"
+
+2. **Standardize Pain Descriptors**:
+   - Keep vivid pain terms intact (these are medically valuable)
+   - Convert colloquial to standard forms:
+     * Chinese: "疼得不行" → "剧烈疼痛"
+     * Korean: "너무 아파" → "심한 통증"
+     * Spanish: "me duele muchísimo" → "dolor intenso"
+
+3. **Clean Up Grammar**:
+   - Remove filler words ("那个", "嗯", "uh", "like")
+   - Complete incomplete sentences
+   - Fix word order errors
+   - But DO NOT change pain descriptors
+    
+4. **Preserve Original Meaning**:
+   - DO NOT add medical interpretations
+   - DO NOT change the severity described
+   - DO NOT invent information not in original text
+
+5. **Standardize Body Part Names**:
+   - Chinese: "腿" → "腿部", "肚子" → "腹部"
+   - Keep other details as-is
+
+**OUTPUT FORMAT** (JSON only):
+{{
+  "original": "original transcription text",
+  "normalized": "cleaned and standardized text",
+  "corrections": [
+    "fix: description of change made",
+    "standardize: description of change"
+  ],
+  "confidence": "high/medium/low (based on # of corrections)"
+}}
+
+**EXAMPLES**:
+
+Input: "腿那个...怎么说...火辣辣的，疼死了"
+Output: {{
+  "original": "腿那个...怎么说...火辣辣的，疼死了",
+  "normalized": "腿部火辣辣的疼",
+  "corrections": ["removed filler words '那个', '怎么说'", "standardized '腿' to '腿部'", "converted '疼死了' to '疼'"],
+  "confidence": "high"
+}}
+
+Input: "我的腿火辣辣的疼，還有點麻"
+Output: {{
+  "original": "我的腿火辣辣的疼，還有點麻",
+  "normalized": "我的腿火辣辣的疼，还有点麻",
+  "corrections": ["converted Traditional Chinese to Simplified: 還→还, 點→点"],
+  "confidence": "high"
+}}
+
+Input: "頭很痛，感覺很難受"
+Output: {{
+  "original": "頭很痛，感覺很難受",
+  "normalized": "头很痛，感觉很难受",
+  "corrections": ["converted Traditional Chinese: 頭→头, 難→难"],
+  "confidence": "high"
+}}
+
+Input: "허리가 따금거려요, 너무 아파요"
+Output: {{
+  "original": "허리가 따금거려요, 너무 아파요",
+  "normalized": "허리가 따끔거리고 심하게 아프다",
+  "corrections": ["corrected '따금거려요' to '따끔거리고'", "standardized '너무 아파요' to '심하게 아프다'"],
+  "confidence": "high"
+}}
+
+Input: "Me duele la espalda, como quemasón"
+Output: {{
+  "original": "Me duele la espalda, como quemasón",
+  "normalized": "Dolor de espalda con quemazón",
+  "corrections": ["standardized sentence structure", "corrected 'quemasón' to 'quemazón'"],
+  "confidence": "high"
+}}
+"""
+    
+    try:
+        response = client.chat.completions.create(
+            model="gpt-5.2",
+            messages=[
+                {"role": "system", "content": system_prompt + "\n\n**CRITICAL**: Return ONLY valid JSON. No extra text."},
+                {"role": "user", "content": text}
+            ],
+            temperature=0.2  # Slightly higher for natural corrections
+        )
+        
+        result = json.loads(response.choices[0].message.content)
+        return result
+    
+    except Exception as e:
+        # Fallback: return original text if normalization fails
+        return {
+            "original": text,
+            "normalized": text,
+            "corrections": [f"normalization_failed: {str(e)}"],
+            "confidence": "low"
+        }
+
+
+def translate_pain_description(text: str, source_language: str, matched_terms: list, mappings: list) -> str:
+    """
+    Translate patient's pain description to English using matched term translations as reference.
+    
+    This creates a natural English translation that incorporates the medical terminology
+    already mapped from our dictionary. Ensures consistency between term mappings and full sentence.
+    
+    Args:
+        text: Patient's pain description (in source language)
+        source_language: Detected language name ("Chinese", "Korean", etc.)
+        matched_terms: List of pain terms matched from vocabulary
+        mappings: List of ontology mappings with original_term and mapped_english
+        
+    Returns:
+        English translation string
+        
+    Example:
+        >>> text = "我的腿火辣辣的疼，还有点麻"
+        >>> matched_terms = ["火辣辣的疼", "麻的"]
+        >>> mappings = [
+        ...   {"original_term": "火辣辣的疼", "mapped_english": "burning"},
+        ...   {"original_term": "麻的", "mapped_english": "numb"}
+        ... ]
+        >>> translate_pain_description(text, "Chinese", matched_terms, mappings)
+        "My leg has burning pain and feels a bit numb"
+    """
+    
+    # Build reference translation dictionary from mappings
+    term_translation_ref = {}
+    for mapping in mappings:
+        original = mapping.get('original_term', '')
+        english = mapping.get('mapped_english', '')
+        if original and english:
+            term_translation_ref[original] = english
+    
+    # Format term references for prompt
+    term_refs = "\n".join([f"  - '{original}' = '{english}'" for original, english in term_translation_ref.items()])
+    
+    if not term_refs:
+        term_refs = "(No pain-specific terms mapped)"
+    
+    system_prompt = f"""You are a medical translator specializing in pain assessment.
+
+**YOUR TASK**: Translate the patient's {source_language} pain description into natural medical English.
+
+**CRITICAL REQUIREMENT**: You MUST use the provided term translations from our medical dictionary.
+These translations are standardized medical terminology (McGill Pain Questionnaire) and MUST be used exactly.
+
+**PROVIDED TERM TRANSLATIONS** (USE THESE EXACTLY):
+{term_refs}
+
+**TRANSLATION RULES**:
+
+1. **Use Dictionary Terms Exactly**:
+   - When translating matched pain terms, use ONLY the provided English translation
+   - Example: If "火辣辣的疼" → "burning", translate as "burning pain" NOT "fiery pain" or "burning hot"
+   
+2. **Create Natural English**:
+   - Produce fluent, natural medical English
+   - Maintain professional but clear tone
+   - Use proper medical grammar
+
+3. **Preserve All Information**:
+   - Include body location, duration, intensity if mentioned
+   - Keep emotional and functional impact details
+   - Maintain original meaning and severity
+
+4. **Structure**:
+   - Use clear, concise sentences
+   - Follow standard medical description format: Location + Pain Quality + Duration + Impact
+
+5. **DO NOT**:
+   - Add medical interpretations or diagnoses
+   - Change pain severity or characteristics
+   - Invent information not in original
+
+**OUTPUT**: Return ONLY the English translation text. No JSON, no additional formatting.
+
+**EXAMPLES**:
+
+Example 1:
+Input ({source_language}): "我的腿火辣辣的疼，还有点麻"
+Term References: "火辣辣的疼"="burning", "麻的"="numb"
+Output: "My leg has burning pain and feels a bit numb"
+
+Example 2:
+Input ({source_language}): "腰部到腿部触电一样的痛，四个月了，晚上睡不着，很郁闷"
+Term References: "触电一样"="electric-shock-like"
+Output: "Electric-shock-like pain from lower back to legs for 4 months, can't sleep at night, feeling very depressed"
+
+Example 3:
+Input ({source_language}): "膝盖一抽一抽的痛，走路困难"
+Term References: "一抽一抽的痛"="throbbing"
+Output: "Throbbing pain in knee, difficulty walking"
+"""
+    
+    try:
+        response = client.chat.completions.create(
+            model="gpt-5.2",
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": f"Translate: {text}"}
+            ],
+            temperature=0.2
+        )
+        
+        translation = response.choices[0].message.content.strip()
+        
+        # Remove quotes if LLM wrapped the output
+        if translation.startswith('"') and translation.endswith('"'):
+            translation = translation[1:-1]
+        
+        return translation
+    
+    except Exception as e:
+        # Fallback: just return the original text
+        return text
+
+
+def generate_comprehensive_report(
+    original_text: str,
+    structured_data: dict,
+    ontology_mappings: list,
+    clinical_recommendations: list,
+    detected_language: str = "Chinese",  # New parameter: detected language
+    semantic_analysis: dict = None  # New parameter: semantic distance analysis
+) -> str:
+    """
+    Generate comprehensive multilingual clinical report using GPT after rule-based analysis.
+    
+    Called AFTER neuro-symbolic pipeline completes. Supports multiple languages:
+    Chinese (中文), Korean (한국어), Spanish (Español), Hmong, English
+    
+    Args:
+        original_text: Patient's original pain description
+        structured_data: PainOntology data (dict format)
+        ontology_mappings: List of term mappings (original_term → mapped_english)
+        clinical_recommendations: List of rule-triggered recommendations
+        detected_language: Language detected from input (default: "Chinese")
+        semantic_analysis: Optional semantic distance analysis for unmapped terms
+        
+    Returns:
+        Comprehensive bilingual clinical report (original language + English)
+    """
+    
+    # Determine bilingual header format based on language
+    language_headers = {
+        "Chinese": "中文",
+        "Korean": "한국어", 
+        "Spanish": "Español",
+        "Hmong": "Hmoob",
+        "English": "English"
+    }
+    
+    native_lang = language_headers.get(detected_language, "原语言")
+    
+    # If English input, report is English-only
+    is_english_only = (detected_language == "English")
+    
+    system_prompt = f"""You are a medical report writer for multilingual pain assessment.
+
+**INPUT LANGUAGE**: {detected_language}
+**OUTPUT FORMAT**: {"English only (no translation needed)" if is_english_only else f"Bilingual ({native_lang} + English)"}
+
+**YOUR TASK**: Create a well-structured clinical report with THREE sections:
+
+**SECTION 1: Translation & Terminology Mapping {"| 翻译与术语映射" if not is_english_only else ""}**
+- Explain how patient's expressions were mapped to standardized medical terminology
+- {"List Original " + detected_language + " terms → English translations" if not is_english_only else "Show pain descriptors used"}
+- Highlight culturally-specific metaphors if present
+- Be clear and structured
+
+**SECTION 2: Clinical Assessment {"| 临床评估" if not is_english_only else ""}**
+- Summarize pain characteristics: type, location, duration, intensity
+- Explain pain classification (neuropathic/nociceptive) in simple terms
+- Describe emotional and functional impacts
+- Be empathetic and clear
+
+**SECTION 3: Treatment Recommendations {"| 治疗建议" if not is_english_only else ""}**
+- Explain each recommended intervention and WHY
+- Reference clinical rules or guidelines that triggered recommendations
+- Provide actionable guidance
+- Be supportive
+
+**FORMATTING REQUIREMENTS**:
+- {"Bilingual headings (" + native_lang + " | English)" if not is_english_only else "English headings"}
+- Professional but accessible language
+- Concise paragraphs
+- Bullet points for clarity
+- Total: 300-500 words
+
+**TONE**: Professional, empathetic, culturally sensitive
+
+**IMPORTANT**:
+- Base ENTIRELY on provided data - do NOT invent
+- If no recommendations, provide supportive general guidance
+- Maintain medical accuracy while patient-friendly
+- {"Use both " + detected_language + " and English for key medical terms" if not is_english_only else "Use clear medical English"}"""
+
+    # Prepare mappings summary (handle different field names)
+    mappings_summary = "\n".join([
+        f"- '{m.get('original_term', m.get('chinese_input', 'N/A'))}' → '{m.get('mapped_english', 'N/A')}' ({m.get('pain_type', m.get('dimension', 'N/A'))})"
+        for m in ontology_mappings
+    ]) if ontology_mappings else "No term mappings available"
+    
+    recommendations_summary = "\n".join([
+        f"- {rec.get('triggered_by_rule', 'N/A')}: {rec.get('recommendation', 'N/A')}\n  Evidence: {rec.get('evidence', {})}"
+        for rec in clinical_recommendations
+    ]) if clinical_recommendations else "No specific recommendations triggered"
+    
+    # Prepare semantic analysis summary
+    semantic_summary = ""
+    if semantic_analysis and semantic_analysis.get('unmapped_analysis'):
+        semantic_items = []
+        for item in semantic_analysis['unmapped_analysis']:
+            original = item['original_term']
+            matches = item['closest_matches']
+            confidence = item['confidence']
+            top_match = matches[0]['term'] if matches else 'N/A'
+            score = matches[0]['score'] if matches else 0
+            semantic_items.append(
+                f"  • '{original}' → closest: '{top_match}' (similarity: {score:.2f}, confidence: {confidence})"
+            )
+        semantic_summary = f"\n\n**SEMANTIC ANALYSIS** (Unmapped Terms - AI Interpretation):\n" + "\n".join(semantic_items)
+        semantic_summary += "\n  Note: These are AI-suggested interpretations based on semantic similarity, not exact matches from the medical dictionary."
+    
+    user_prompt = f"""**PATIENT'S ORIGINAL DESCRIPTION** ({detected_language}):
+{original_text}
+
+**STRUCTURED CLINICAL DATA**:
+- Pain Type: {structured_data.get('pain_type', 'N/A')}
+- Location: {structured_data.get('location', 'N/A')}
+- Temporal Pattern: {structured_data.get('temporal_pattern', 'N/A')}
+- Intensity: {structured_data.get('intensity', 'N/A')}
+- Emotional Impact: {structured_data.get('emotion', 'None detected')}
+- Functional Impact: {structured_data.get('functional_impact', 'Not stated')}
+
+**TERM MAPPINGS** ({detected_language} → English):
+{mappings_summary}{semantic_summary}
+
+**CLINICAL RECOMMENDATIONS** (From rule engine):
+{recommendations_summary}
+
+Please generate a comprehensive {"bilingual" if not is_english_only else ""} clinical report."""
+
+    try:
+        response = client.chat.completions.create(
+            model="gpt-5.2",
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ],
+            temperature=0.3
+        )
+        
+        report = response.choices[0].message.content
+        return report
+    
+    except Exception as e:
+        # Fallback: structured template
+        fallback_report = f"""**Clinical Report | 临床报告**
+
+**Patient Description** ({detected_language}):
+{original_text}
+
+**Assessment | 评估**:
+- Pain Type: {structured_data.get('pain_type', 'N/A')}
+- Location: {structured_data.get('location', 'N/A')}
+- Duration: {structured_data.get('temporal_pattern', 'N/A')}
+
+**Term Mappings | 术语映射**:
+{mappings_summary}
+
+**Recommendations | 建议**:
+{recommendations_summary}
+
+(Note: GPT report generation failed: {str(e)})"""
+        
+        return fallback_report

Backend/services/neuro_symbolic_service.py

@@ -0,0 +1,304 @@
+"""
+Neuro-symbolic pain assessment service.
+
+Integrates LLM extraction with ontology mapping and rule-based reasoning.
+This is the main entry point for the upgraded pain assessment system.
+
+Architecture:
+- Neural: LLM for narrow-scope entity extraction
+- Symbolic: Dictionary-based ontology mapping + rule-based clinical reasoning
+- Output: Fully explainable clinical recommendations with evidence chains
+"""
+
+import sys
+import os
+
+# Add Backend to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from pipeline.pain_assessment_pipeline import PainAssessmentPipeline
+from models.pain_schema import ExplainableReport
+from services.llm_service import (
+    extract_pain_entities_constrained, 
+    normalize_transcription,
+    match_pain_terms_from_vocabulary,
+    translate_pain_description
+)
+from utils.language_detector import detect_language, get_language_name
+
+
+# Initialize pipeline (singleton pattern for performance)
+_pipeline = None
+
+
+def get_pipeline() -> PainAssessmentPipeline:
+    """
+    Get or create pipeline instance.
+    
+    Uses singleton pattern to avoid reinitializing the rule engine
+    on every request (improves performance).
+    
+    Returns:
+        PainAssessmentPipeline instance
+    """
+    global _pipeline
+    if _pipeline is None:
+        _pipeline = PainAssessmentPipeline(verbose=True)
+    return _pipeline
+
+
+def analyze_pain_neuro_symbolic(patient_text: str) -> dict:
+    """
+    Main entry point for neuro-symbolic pain assessment.
+    
+    This function replaces the pure LLM analysis from the old system.
+    It implements a complete neuro-symbolic hybrid architecture:
+    
+    1. LLM extracts entities (narrow-scope NER only)
+    2. Ontology mapping converts Chinese to English medical terms
+    3. Data is structured into validated Pydantic model
+    4. Rule engine applies deterministic clinical logic
+    5. Complete reasoning chain is generated for explainability
+    
+    Args:
+        patient_text: Raw patient pain description (Chinese or multilingual)
+        
+    Returns:
+        Dictionary representation of ExplainableReport containing:
+        - structured_data: Normalized pain ontology (PainOntology)
+        - ontology_mapping_trace: Chinese→English mapping details
+        - clinical_recommendations: Rule-triggered recommendations with evidence
+        - reasoning_chain: Step-by-step explanation of decision process
+        - physician_summary: Human-readable clinical summary
+        
+    Example:
+        >>> result = analyze_pain_neuro_symbolic("Lower back electric-shock pain for 4 months, feeling depressed")
+        >>> print(result['structured_data']['pain_type'])
+        'Neuropathic (Electric-shock-like)'
+        >>> print(result['clinical_recommendations'][0]['triggered_by_rule'])
+        'RULE_A: Chronic Pain + Depression'
+    """
+    try:
+        # Step 0: Detect language for normalization
+        detected_lang = detect_language(patient_text)
+        language_name = get_language_name(detected_lang)
+        
+        # Step 1: Normalize transcription (fix Whisper errors & standardize expressions)
+        print(f"[Neuro-Symbolic Service] Normalizing {language_name} transcription...")
+        normalization_result = normalize_transcription(patient_text, language_name)
+        
+        original_text = normalization_result.get("original", patient_text)
+        normalized_text = normalization_result.get("normalized", patient_text)
+        corrections = normalization_result.get("corrections", [])
+        normalization_confidence = normalization_result.get("confidence", "unknown")
+        
+        print(f"[Neuro-Symbolic Service] Applied {len(corrections)} corrections (confidence: {normalization_confidence})")
+        
+        # Step 2: Load vocabulary for detected language
+        print(f"[Neuro-Symbolic Service] Loading {language_name} pain vocabulary...")
+        from ontology.pain_mapping_multilingual import LANGUAGE_DESCRIPTORS
+        
+        vocabulary_dict = LANGUAGE_DESCRIPTORS.get(detected_lang, {})
+        vocabulary_list = list(vocabulary_dict.keys())
+        
+        if not vocabulary_list:
+            print(f"[Neuro-Symbolic Service] WARNING: No vocabulary for {language_name}, using English fallback")
+            vocabulary_list = []
+        else:
+            print(f"[Neuro-Symbolic Service] Loaded {len(vocabulary_list)} terms for {language_name}")
+        
+        # Step 3: LLM term matching (with vocabulary)
+        print("[Neuro-Symbolic Service] Matching pain terms from vocabulary...")
+        
+        llm_match_result = match_pain_terms_from_vocabulary(
+            normalized_text, 
+            vocabulary_list, 
+            language_name
+        )
+        
+        matched_terms = llm_match_result.get('matched_terms', [])
+        print(f"[Neuro-Symbolic Service] LLM matched {len(matched_terms)} terms: {matched_terms}")
+        
+        # Step 4: Translate matched terms using dictionary
+        print("[Neuro-Symbolic Service] Translating matched terms...")
+        ontology_mappings = []
+        
+        for term in matched_terms:
+            if term in vocabulary_dict:
+                term_data = vocabulary_dict[term]
+                ontology_mappings.append({
+                    "original_term": term,
+                    "matched_text": term,
+                    "mapped_english": term_data["english"],
+                    "dimension": term_data.get("dimension", "sensory"),
+                    "pain_type": term_data.get("pain_type"),
+                    "confidence": "high",  # High confidence because it's from dictionary
+                    "mcgill_dimension": term_data.get("mcgill_dimension", "sensory"),
+                    "detected_language": detected_lang
+                })
+        
+        print(f"[Neuro-Symbolic Service] Translated {len(ontology_mappings)} terms to English")
+        
+        # Step 4.5: Extract unique/unmapped pain descriptors (creative expressions not in dictionary)
+        print("[Neuro-Symbolic Service] Extracting unique pain descriptors...")
+        from services.llm_service import extract_pain_entities_constrained
+        unique_entities = extract_pain_entities_constrained(normalized_text)
+        unique_descriptors = unique_entities.get("pain_descriptors", [])
+        
+        # These are creative/metaphorical descriptions not in our dictionary
+        # Examples: "好像蚂蚁在爬", "说不出来的难受", "像被火烧一样"
+        # V2: Will use multilingual dictionary (Chinese/Korean/Spanish/Hmong) for semantic matching
+        if unique_descriptors:
+            print(f"[Neuro-Symbolic Service] Found {len(unique_descriptors)} unique descriptors: {unique_descriptors}")
+            print(f"[Neuro-Symbolic Service] → Will match against multilingual pain dictionary ({language_name})")
+        
+        # Prepare LLM entities for pipeline
+        llm_entities = {
+            "pain_descriptors": unique_descriptors,  # Original native language text (for multilingual semantic analysis V2)
+            "location": llm_match_result.get("location", "Not stated"),
+            "duration_phrase": llm_match_result.get("duration_phrase", "Not stated"),
+            "intensity": llm_match_result.get("intensity", "Not stated"),
+            "emotion_keywords": llm_match_result.get("emotion_keywords", []),
+            "functional_impact": llm_match_result.get("functional_impact")
+        }
+        
+        # Step 5: Execute complete pipeline (ontology mapping + rule engine)
+        print("[Neuro-Symbolic Service] Executing pipeline...")
+        pipeline = get_pipeline()
+        report: ExplainableReport = pipeline.execute_with_mappings(
+            normalized_text, 
+            llm_entities,
+            ontology_mappings  # Pass pre-computed mappings
+        )
+        
+        # Step 6: Translate full sentence to English (if not English)
+        english_translation = None
+        if detected_lang != 'en':
+            print(f"[Neuro-Symbolic Service] Translating from {language_name} to English...")
+            english_translation = translate_pain_description(
+                normalized_text,
+                language_name,
+                matched_terms,
+                ontology_mappings
+            )
+            print(f"[Neuro-Symbolic Service] Translation: {english_translation}")
+        
+        # Step 7: Convert Pydantic models to dictionary for API response
+        return {
+            "status": "success",
+            "transcription": {
+                "original": original_text,
+                "normalized": normalized_text,
+                "english_translation": english_translation,  # NEW: Full sentence translation
+                "corrections_applied": corrections,
+                "normalization_confidence": normalization_confidence,
+                "language_detected": language_name,
+                "vocabulary_size": len(vocabulary_list),
+                "matched_terms_count": len(matched_terms)
+            },
+            "structured_data": report.structured_data.model_dump(),
+            "ontology_mapping_trace": report.ontology_mapping_trace,
+            "clinical_recommendations": [
+                rec.model_dump() for rec in report.clinical_recommendations
+            ],
+            "reasoning_chain": report.reasoning_chain,
+            "physician_summary": report.physician_summary
+        }
+    
+    except Exception as e:
+        # Return error with detailed information for debugging
+        import traceback
+        return {
+            "status": "error",
+            "message": f"Pipeline execution failed: {str(e)}",
+            "error_type": type(e).__name__,
+            "traceback": traceback.format_exc()
+        }
+
+
+def get_system_info() -> dict:
+    """
+    Get information about the neuro-symbolic system configuration.
+    
+    Useful for debugging, monitoring, and documentation.
+    
+    Returns:
+        Dictionary with system metadata
+    """
+    pipeline = get_pipeline()
+    
+    return {
+        "system_name": "Neuro-Symbolic Pain Assessment System",
+        "version": "1.0.0",
+        "architecture": "Hybrid (Neural + Symbolic)",
+        "components": {
+            "neural": {
+                "llm_model": "GPT-5.2",
+                "purpose": "Named Entity Recognition only",
+                "temperature": 0.1
+            },
+            "symbolic": {
+                "ontology_mappings": "Chinese↔English pain descriptors",
+                "rule_engine": "Deterministic If-Then clinical rules",
+                "knowledge_bases": [
+                    "McGill Pain Questionnaire (SF-MPQ)",
+                    "SNOMED CT",
+                    "Wisconsin Medical Examining Board Guidelines"
+                ]
+            }
+        },
+        "pipeline_info": pipeline.get_pipeline_info(),
+        "capabilities": [
+            "Cross-cultural pain assessment (Chinese→English)",
+            "Deterministic clinical reasoning",
+            "Complete explainability with evidence chains",
+            "Neuropathic vs Nociceptive pain classification",
+            "Guideline-based clinical recommendations"
+        ],
+        "limitations": [
+            "Ontology coverage limited to defined descriptors",
+            "Rule engine contains 4 clinical rules (expandable)",
+            "Requires manual review for unmapped terms",
+            "Not a diagnostic tool - for triage and assessment only"
+        ]
+    }
+
+
+def validate_input(patient_text: str) -> tuple[bool, str]:
+    """
+    Validate patient input before processing.
+    
+    Args:
+        patient_text: Raw patient input
+        
+    Returns:
+        Tuple of (is_valid, error_message)
+        If valid, error_message is empty string
+    """
+    if not patient_text or not patient_text.strip():
+        return False, "Input text is empty"
+    
+    if len(patient_text) < 5:
+        return False, "Input text too short (minimum 5 characters)"
+    
+    if len(patient_text) > 10000:
+        return False, "Input text too long (maximum 10000 characters)"
+    
+    return True, ""
+
+
+# Batch processing support (for future use)
+def analyze_pain_batch(patient_texts: list[str]) -> list[dict]:
+    """
+    Process multiple patient descriptions in batch.
+    
+    Args:
+        patient_texts: List of patient pain descriptions
+        
+    Returns:
+        List of analysis results (one per input)
+    """
+    results = []
+    for text in patient_texts:
+        results.append(analyze_pain_neuro_symbolic(text))
+    return results

Backend/services/semantic_distance_service.py

@@ -0,0 +1,124 @@
+from openai import OpenAI
+import numpy as np
+from typing import List, Dict
+import os
+
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+# Embed the dictionary terms once and cache them for future use
+DICTIONARY_EMBEDDINGS_CACHE = None
+
+def get_standard_pain_terms():
+    """Return a list of standard pain terms for semantic distance calculation."""
+    return [
+        "burning", "tingling", "shooting", "stabbing", "aching", 
+        "throbbing", "sharp", "dull", "cramping", "electric-shock-like",
+        "pricking", "numb", "crawling", "tight", "heavy"
+    ]
+
+def precompute_dictionary_embeddings():
+    """Precompute and cache dictionary embeddings at system startup."""
+    global DICTIONARY_EMBEDDINGS_CACHE
+    
+    terms = get_standard_pain_terms()
+    response = client.embeddings.create(
+        model="text-embedding-3-small",  # inexpensive
+        input=terms
+    )
+    
+    DICTIONARY_EMBEDDINGS_CACHE = {
+        "terms": terms,
+        "embeddings": [item.embedding for item in response.data]
+    }
+    print(f"[Init] Cached {len(terms)} dictionary embeddings")
+
+def calculate_semantic_distances(
+    unmapped_terms: List[str],
+    patient_text: str,
+    language: str,
+    translated_terms: List[str] = None  # Pre-translated terms (optional)
+) -> Dict:
+    """
+    Calculate semantic distances only for unmapped terms.
+    
+    Args:
+        unmapped_terms: Original pain expressions (any language)
+        patient_text: Full patient text (for context)
+        language: Detected language name
+        translated_terms: Optional pre-translated English versions of unmapped_terms
+                         If provided, will use these directly instead of translating again
+    
+    Returns:
+        Dictionary with unmapped_analysis containing similarity scores
+    """
+    if not unmapped_terms:
+        return None
+    
+    # Ensure dictionary embeddings are loaded
+    if DICTIONARY_EMBEDDINGS_CACHE is None:
+        precompute_dictionary_embeddings()
+    
+    # Use pre-translated terms if provided, otherwise translate now
+    if translated_terms and len(translated_terms) == len(unmapped_terms):
+        print(f"[Semantic Distance] Using pre-translated terms")
+        terms_to_embed = translated_terms
+    elif language != "English":
+        print(f"[Semantic Distance] Translating {len(unmapped_terms)} non-English terms to English...")
+        translated_terms = []
+        for term in unmapped_terms:
+            try:
+                # Quick translation to English for semantic matching
+                response = client.chat.completions.create(
+                    model="gpt-4o-mini",  # Use faster model for translation
+                    messages=[
+                        {"role": "system", "content": "Translate pain descriptions to concise medical English. Output ONLY the translation, no explanations."},
+                        {"role": "user", "content": f"Translate to medical English: {term}"}
+                    ],
+                    temperature=0.1,
+                    max_tokens=50
+                )
+                translated = response.choices[0].message.content.strip().strip('"\'')
+                translated_terms.append(translated)
+                print(f"[Semantic Distance]   '{term[:40]}...' → '{translated}'")
+            except Exception as e:
+                print(f"[Semantic Distance] Translation failed for '{term[:40]}...', using original")
+                translated_terms.append(term)
+        
+        terms_to_embed = translated_terms
+    else:
+        terms_to_embed = unmapped_terms
+    
+    # Get embeddings for (translated) unmapped terms
+    response = client.embeddings.create(
+        model="text-embedding-3-small",
+        input=terms_to_embed
+    )
+    unmapped_embeddings = [item.embedding for item in response.data]
+    
+    # Calculate similarities
+    results = []
+    for i, original_term in enumerate(unmapped_terms):
+        similarities = []
+        for j, dict_term in enumerate(DICTIONARY_EMBEDDINGS_CACHE["terms"]):
+            score = cosine_similarity(
+                unmapped_embeddings[i],
+                DICTIONARY_EMBEDDINGS_CACHE["embeddings"][j]
+            )
+            similarities.append({"term": dict_term, "score": round(score, 3)})
+        
+        # Top 3
+        top_matches = sorted(similarities, key=lambda x: x['score'], reverse=True)[:3]
+        confidence = "high" if top_matches[0]['score'] > 0.75 else \
+                     "medium" if top_matches[0]['score'] > 0.60 else "low"
+        
+        results.append({
+            "original_term": original_term,
+            "translated_term": terms_to_embed[i] if language != "English" else None,
+            "closest_matches": top_matches,
+            "confidence": confidence
+        })
+    
+    return {"unmapped_analysis": results}
+
+def cosine_similarity(a, b):
+    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

Backend/services/semantic_distance_service_biolord.py

@@ -0,0 +1,320 @@
+"""
+Semantic Distance Service (Version 3 - BioLORD Medical Specialist)
+
+Uses BioLORD-2023-M (Medical Language Model) for semantic similarity calculation.
+BioLORD is specifically trained on medical ontologies and achieves SOTA performance
+on medical semantic similarity tasks (MedSTS, EHR-Rel-B).
+
+**Why BioLORD-2023-M:**
+- SOTA on MedSTS (Medical Semantic Text Similarity) benchmark
+- Trained on medical concept definitions from AGCT (Auto-Clinical Terminology)
+- 50+ language support including Chinese, Korean, Spanish
+- Understands medical ontology hierarchies
+- 5-6x better accuracy on medical concept similarity vs general models
+
+**Architecture (Same-Language Matching):**
+1. Chinese patient "蚂蚁爬" → BioLORD embedding (768-dim)
+2. Compare with Chinese McGill translations → Match "蚁爬感"
+3. Return English StandardTerm: "formication"
+
+**Key Difference from System Dictionary:**
+- System dictionary: multilingual_pain_data.json (used by main pipeline)
+- This service: McGill translations (auxiliary/fallback matching)
+- No duplication - serves as complement when system dictionary has no match
+
+**Advantages over OpenAI embeddings:**
+- ✅ Medical domain expertise (trained on UMLS/AGCT)
+- ✅ Better understanding of pain terminology nuances
+- ✅ Fully local deployment (no API costs, complete privacy)
+- ✅ Offline capability
+- ✅ Consistent performance (no API rate limits)
+
+**Cost:** FREE after initial model download (~1GB one-time)
+"""
+
+import numpy as np
+from sentence_transformers import SentenceTransformer
+from typing import List, Dict
+import os
+
+# Import McGill Pain Questionnaire translations (auxiliary matching, not system dictionary)
+from ontology.mcgill_translations import (
+    CHINESE_MCGILL,
+    KOREAN_MCGILL,
+    SPANISH_MCGILL,
+    HMONG_MCGILL
+)
+
+# Global model instance (loaded once at startup)
+_biolord_model = None
+
+# Cache for McGill multilingual embeddings (same-language medical matching)
+MCGILL_EMBEDDINGS_CACHE = {}
+
+
+def load_biolord_model():
+    """
+    Load BioLORD-2023-M model from Hugging Face.
+    
+    Model will be downloaded to ~/.cache/huggingface/ on first run.
+    Subsequent runs load from local cache (instant).
+    
+    Model size: ~1GB
+    Download time: ~2-5 minutes (one-time, depends on internet speed)
+    """
+    global _biolord_model
+    
+    if _biolord_model is not None:
+        return _biolord_model
+    
+    print("[BioLORD] Loading BioLORD-2023-M model...")
+    print("[BioLORD]   Model: FremyCompany/BioLORD-2023-M")
+    print("[BioLORD]   Size: ~1GB (downloads to ~/.cache/huggingface/)")
+    
+    try:
+        _biolord_model = SentenceTransformer("FremyCompany/BioLORD-2023-M")
+        print("[BioLORD] ✓ Model loaded successfully")
+        print(f"[BioLORD]   Embedding dimension: {_biolord_model.get_sentence_embedding_dimension()}")
+        return _biolord_model
+    
+    except Exception as e:
+        print(f"[BioLORD] ❌ Failed to load model: {e}")
+        print("[BioLORD]   Falling back to OpenAI embeddings...")
+        raise
+
+
+def precompute_dictionary_embeddings():
+    """
+    Precompute BioLORD embeddings for McGill Pain Questionnaire translations.
+    
+    **Same-Language Medical Matching:**
+    - Chinese patient "蚂蚁爬" → Chinese McGill "蚁爬感" → English "formication"
+    - Korean patient "개미 감각" → Korean McGill "개미가 기어가는 느낌" → English "formication"
+    
+    **Why McGill translations (not system dictionary):**
+    System already uses multilingual_pain_data.json. This serves as auxiliary/fallback
+    using standardized McGill medical terminology when primary dictionary has no match.
+    """
+    global MCGILL_EMBEDDINGS_CACHE
+    
+    # Load BioLORD model
+    try:
+        model = load_biolord_model()
+    except Exception as e:
+        print(f"[BioLORD] Cannot precompute embeddings - model load failed: {e}")
+        return
+    
+    # Language configurations - McGill translations for auxiliary matching
+    language_configs = {
+        'zh': {'name': 'Chinese', 'mcgill': CHINESE_MCGILL},
+        'ko': {'name': 'Korean', 'mcgill': KOREAN_MCGILL},
+        'es': {'name': 'Spanish', 'mcgill': SPANISH_MCGILL},
+        'hmong': {'name': 'Hmong', 'mcgill': HMONG_MCGILL}
+    }
+    
+    print(f"[BioLORD] Precomputing McGill translations for {len(language_configs)} languages...")
+    print(f"[BioLORD]   Source: McGill Pain Questionnaire (auxiliary matching)")
+    
+    for lang_code, config in language_configs.items():
+        mcgill_dict = config['mcgill']
+        lang_name = config['name']
+        
+        if not mcgill_dict:
+            print(f"[BioLORD]   ⚠️ {lang_name}: No McGill translations, skipping")
+            continue
+        
+        # Extract all McGill terms + aliases in native language
+        all_terms = []
+        term_metadata = []
+        
+        for native_term, metadata in mcgill_dict.items():
+            # Add main McGill term
+            all_terms.append(native_term)
+            term_metadata.append({
+                "native_term": native_term,
+                "english": metadata["english"],
+                "pain_type": metadata["type"],
+                "dimension": metadata["dimension"],
+                "is_alias": False
+            })
+            
+            # Add aliases
+            for alias in metadata.get("aliases", []):
+                all_terms.append(alias)
+                term_metadata.append({
+                    "native_term": alias,
+                    "english": metadata["english"],
+                    "pain_type": metadata["type"],
+                    "dimension": metadata["dimension"],
+                    "is_alias": True,
+                    "parent_term": native_term
+                })
+        
+        if not all_terms:
+            print(f"[BioLORD]   ⚠️ {lang_name}: No terms extracted, skipping")
+            continue
+        
+        print(f"[BioLORD]   {lang_name} McGill: Processing {len(all_terms)} terms...")
+        
+        # Generate embeddings using BioLORD (medical-grade within-language understanding)
+        try:
+            embeddings = model.encode(
+                all_terms,
+                batch_size=32,
+                show_progress_bar=False,
+                convert_to_numpy=True
+            )
+            
+            MCGILL_EMBEDDINGS_CACHE[lang_code] = {
+                "terms": all_terms,
+                "embeddings": embeddings,
+                "metadata": term_metadata
+            }
+            
+            print(f"[BioLORD]   ✓ {lang_name}: Cached {len(all_terms)} McGill terms")
+            
+        except Exception as e:
+            print(f"[BioLORD]   ❌ {lang_name}: Embedding failed - {e}")
+    
+    total_terms = sum(len(cache["terms"]) for cache in MCGILL_EMBEDDINGS_CACHE.values())
+    print(f"[BioLORD] ✓ Total: Cached {total_terms} McGill terms across {len(MCGILL_EMBEDDINGS_CACHE)} languages")
+    print(f"[BioLORD] 🎯 Same-language medical semantic matching ready (auxiliary service)")
+    print(f"[BioLORD] 📋 Complements system dictionary (multilingual_pain_data.json)")
+
+
+def cosine_similarity(vec1, vec2):
+    """Calculate cosine similarity between two vectors."""
+    vec1 = np.array(vec1)
+    vec2 = np.array(vec2)
+    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))
+
+
+def calculate_semantic_distances(
+    unmapped_terms: List[str],
+    patient_text: str,
+    language: str,
+    translated_terms: List[str] = None
+) -> Dict:
+    """
+    Calculate semantic distances using BioLORD medical embeddings.
+    
+    **Same-Language Medical Matching:**
+    Uses McGill translations for auxiliary matching when system dictionary has no match.
+    
+    Example:
+    - Chinese patient: "像蚂蚁在爬" 
+    - BioLORD → Chinese McGill: "蚁爬感" (formication)
+    - Return: English standard term "formication"
+    
+    **Advantage over cross-lingual:**
+    BioLORD medical training excels at understanding medical semantics WITHIN each language.
+    
+    Args:
+        unmapped_terms: Pain expressions not found in system dictionary
+        patient_text: Full patient text (for context)
+        language: Detected language name (e.g., "Chinese", "Korean", "Spanish")
+        translated_terms: [DEPRECATED] Not used
+    
+    Returns:
+        Dictionary with medical-semantic analysis using McGill auxiliary matching
+    """
+    if not unmapped_terms:
+        return None
+    
+    # Map language names to codes
+    language_map = {
+        "Chinese": "zh",
+        "Korean": "ko",
+        "Spanish": "es",
+        "Hmong": "hmong",
+        "English": "en"
+    }
+    
+    lang_code = language_map.get(language, "en")
+    
+    # Skip for English or unsupported languages
+    if lang_code == "en":
+        print(f"[BioLORD] Skipping - English terms already standardized")
+        return None
+    
+    # Check if we have McGill translations for this language
+    if lang_code not in MCGILL_EMBEDDINGS_CACHE:
+        print(f"[BioLORD] ⚠️ No McGill translations cached for {language}")
+        return None
+    
+    # Load model if not already loaded
+    try:
+        model = load_biolord_model()
+    except Exception as e:
+        print(f"[BioLORD] ❌ Model not available: {e}")
+        return None
+    
+    # Get language-specific McGill cache
+    lang_cache = MCGILL_EMBEDDINGS_CACHE[lang_code]
+    
+    print(f"[BioLORD] Same-language matching: {len(unmapped_terms)} {language} terms → {language} McGill")
+    print(f"[BioLORD]   Target: {len(lang_cache['terms'])} McGill translations")
+    
+    # Generate embeddings for patient's terms using BioLORD
+    unmapped_embeddings = model.encode(
+        unmapped_terms,
+        batch_size=16,
+        show_progress_bar=False,
+        convert_to_numpy=True
+    )
+    
+    # Calculate same-language medical-semantic similarities
+    results = []
+    for i, patient_term in enumerate(unmapped_terms):
+        similarities = []
+        
+        # Compare patient's term with same-language McGill translations
+        for j, mcgill_data in enumerate(lang_cache["metadata"]):
+            score = cosine_similarity(
+                unmapped_embeddings[i],
+                lang_cache["embeddings"][j]
+            )
+            
+            similarities.append({
+                "native_term": mcgill_data["native_term"],
+                "english": mcgill_data["english"],
+                "pain_type": mcgill_data["pain_type"],
+                "dimension": mcgill_data["dimension"],
+                "is_alias": mcgill_data.get("is_alias", False),
+                "score": float(score)
+            })
+        
+        # Sort by similarity (highest first)
+        similarities.sort(key=lambda x: x["score"], reverse=True)
+        top_matches = similarities[:3]
+        
+        # Determine confidence level
+        best_score = top_matches[0]["score"]
+        if best_score > 0.75:
+            confidence = "high"
+        elif best_score > 0.60:
+            confidence = "medium"
+        else:
+            confidence = "low"
+        
+        # Same-language result: patient's language → same language McGill → English
+        result = {
+            "original_term": patient_term,  # e.g., "蚂蚁爬"
+            "matched_mcgill_native": top_matches[0]["native_term"],  # e.g., "蚁爬感"
+            "matched_standard_english": top_matches[0]["english"],  # e.g., "formication"
+            "closest_matches": top_matches,
+            "confidence": confidence,
+            "language": lang_code,
+            "model": "BioLORD-2023-M (same-language)"
+        }
+        
+        results.append(result)
+        
+        print(f"[BioLORD]   '{patient_term}' → '{top_matches[0]['native_term']}' ({top_matches[0]['english']}) [score: {best_score:.3f}, {confidence}]")
+    
+    return {
+        "unmapped_analysis": results,
+        "model_used": "BioLORD-2023-M",
+        "matching_strategy": "same-language-mcgill",
+        "language": language
+    }

Backend/services/semantic_distance_service_v2.py

@@ -0,0 +1,259 @@
+"""
+Semantic Distance Service (Version 2 - Multilingual)
+
+Uses OpenAI embeddings to calculate semantic similarity between patient's 
+unmapped pain expressions and our multilingual medical pain dictionary.
+
+**Improved Architecture (User-Suggested):**
+1. Patient expression (any language) → Compare with native language dictionary embeddings
+2. Find best matching term in native language dictionary (e.g., Korean "따끔거리다")
+3. Use dictionary's standard English translation (e.g., "Pricking")
+4. NO GPT translation needed - uses pre-defined medical translations
+
+**Supported Languages:**
+- Chinese (中文): 373+ terms from CHINESE_PAIN_DESCRIPTORS
+- Korean (한국어): 131+ terms from KOREAN_PAIN_DESCRIPTORS  
+- Spanish (Español): 74+ terms from SPANISH_PAIN_DESCRIPTORS
+- Hmong: Terms from HMONG_PAIN_DESCRIPTORS
+- English: Pass-through (no mapping needed)
+
+Advantages:
+- Native language → Native language semantic space (more accurate)
+- Medical-grade English translations (standardized)
+- Faster (no GPT translation API calls)
+- Cost-effective (~$0.02 per 1M tokens for embeddings only)
+
+Cost: ~$0.02 per 1M tokens (text-embedding-3-small)
+"""
+
+import numpy as np
+from openai import OpenAI
+from typing import List, Dict
+import os
+from ontology.pain_mapping_multilingual import (
+    CHINESE_PAIN_DESCRIPTORS,
+    KOREAN_PAIN_DESCRIPTORS,
+    SPANISH_PAIN_DESCRIPTORS,
+    HMONG_PAIN_DESCRIPTORS
+)
+
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+# Cache for dictionary embeddings (precomputed at startup)
+# Structure: {language_code: {terms: [...], embeddings: [...], metadata: [...]}}
+DICTIONARY_EMBEDDINGS_CACHE = {}
+
+
+def precompute_dictionary_embeddings():
+    """
+    Precompute embeddings for ALL multilingual pain terms at app startup.
+    
+    Processes dictionaries for:
+    - Chinese (中文): ~373 terms + aliases
+    - Korean (한국어): ~131 terms + aliases
+    - Spanish (Español): ~74 terms + aliases
+    - Hmong: All defined terms
+    
+    Each language gets its own embedding cache for accurate native-language matching.
+    """
+    global DICTIONARY_EMBEDDINGS_CACHE
+    
+    # Language configurations
+    language_configs = {
+        'zh': {'name': 'Chinese', 'descriptors': CHINESE_PAIN_DESCRIPTORS},
+        'ko': {'name': 'Korean', 'descriptors': KOREAN_PAIN_DESCRIPTORS},
+        'es': {'name': 'Spanish', 'descriptors': SPANISH_PAIN_DESCRIPTORS},
+        'hmong': {'name': 'Hmong', 'descriptors': HMONG_PAIN_DESCRIPTORS}
+    }
+    
+    print(f"[Semantic Distance V2] Precomputing embeddings for {len(language_configs)} languages...")
+    
+    for lang_code, config in language_configs.items():
+        descriptors = config['descriptors']
+        lang_name = config['name']
+        
+        if not descriptors:
+            print(f"[Semantic Distance V2]   ⚠️ {lang_name}: No descriptors found, skipping")
+            continue
+        
+        # Extract all terms + aliases from dictionary
+        all_terms = []
+        term_metadata = []  # Store: term → English translation + metadata
+        
+        for term_key, metadata in descriptors.items():
+            # Add main term
+            all_terms.append(term_key)
+            term_metadata.append({
+                "native_term": term_key,
+                "english": metadata.get("english", metadata.get("mapped_english", "Unknown")),
+                "pain_type": metadata.get("pain_type", "unknown"),
+                "dimension": metadata.get("dimension", "sensory"),
+                "is_alias": False
+            })
+            
+            # Add aliases if available
+            for alias in metadata.get("aliases", []):
+                all_terms.append(alias)
+                term_metadata.append({
+                    "native_term": alias,
+                    "english": metadata.get("english", metadata.get("mapped_english", "Unknown")),
+                    "pain_type": metadata.get("pain_type", "unknown"),
+                    "dimension": metadata.get("dimension", "sensory"),
+                    "is_alias": True,
+                    "parent_term": term_key
+                })
+        
+        if not all_terms:
+            print(f"[Semantic Distance V2]   ⚠️ {lang_name}: No terms extracted, skipping")
+            continue
+        
+        print(f"[Semantic Distance V2]   {lang_name}: Processing {len(all_terms)} terms...")
+        
+        # Batch API call to get embeddings for all terms in this language
+        try:
+            response = client.embeddings.create(
+                model="text-embedding-3-small",
+                input=all_terms
+            )
+            
+            embeddings = [item.embedding for item in response.data]
+            
+            DICTIONARY_EMBEDDINGS_CACHE[lang_code] = {
+                "terms": all_terms,
+                "embeddings": embeddings,
+                "metadata": term_metadata
+            }
+            
+            print(f"[Semantic Distance V2]   ✓ {lang_name}: Cached {len(all_terms)} term embeddings")
+            
+        except Exception as e:
+            print(f"[Semantic Distance V2]   ❌ {lang_name}: Embedding failed - {e}")
+    
+    total_terms = sum(len(cache["terms"]) for cache in DICTIONARY_EMBEDDINGS_CACHE.values())
+    print(f"[Semantic Distance V2] ✓ Total: Cached {total_terms} terms across {len(DICTIONARY_EMBEDDINGS_CACHE)} languages")
+
+
+def calculate_semantic_distances(
+    unmapped_terms: List[str],
+    patient_text: str,
+    language: str,
+    translated_terms: List[str] = None  # Deprecated parameter (backward compatibility)
+) -> Dict:
+    """
+    Calculate semantic distances for unmapped pain expressions in ANY supported language.
+    
+    **Multilingual Flow:**
+    1. Chinese patient: "像有成千上万只蚂蚁在皮肤下面爬来爬去"
+       → Compare with Chinese dictionary → Match "蚂蚁爬" → Return "Formication (crawling)"
+    
+    2. Korean patient: "허리가 따끔거리듯이 아프다"
+       → Compare with Korean dictionary → Match "따끔거리다" → Return "Pricking"
+    
+    3. Spanish patient: "dolor punzante en la espalda"
+       → Compare with Spanish dictionary → Match "punzante" → Return "Stabbing"
+    
+    Args:
+        unmapped_terms: Original pain expressions in patient's native language
+        patient_text: Full patient text (for logging)
+        language: Detected language name (e.g., "Chinese", "Korean", "Spanish", "Hmong")
+        translated_terms: [DEPRECATED] Pre-translated terms (no longer used)
+    
+    Returns:
+        Dictionary with unmapped_analysis containing:
+        - original_term: Patient's native language expression
+        - matched_native_term: Best matching dictionary term (native language)
+        - standard_english: Dictionary's medical English translation
+        - closest_matches: Top 3 similar dictionary terms
+        - confidence: high/medium/low based on similarity score
+        - language: Detected language code
+    """
+    if not unmapped_terms:
+        return None
+    
+    # Map language names to codes
+    language_map = {
+        "Chinese": "zh",
+        "Korean": "ko",
+        "Spanish": "es",
+        "Hmong": "hmong",
+        "English": "en"
+    }
+    
+    lang_code = language_map.get(language, "en")
+    
+    # Skip semantic analysis for English (already standardized) or unsupported languages
+    if lang_code == "en":
+        print(f"[Semantic Distance V2] Skipping - English terms already standardized")
+        return None
+    
+    # Ensure dictionary embeddings are loaded
+    if not DICTIONARY_EMBEDDINGS_CACHE:
+        precompute_dictionary_embeddings()
+    
+    # Check if this language is supported
+    if lang_code not in DICTIONARY_EMBEDDINGS_CACHE:
+        print(f"[Semantic Distance V2] ⚠️ Language '{language}' ({lang_code}) not supported - no dictionary available")
+        return None
+    
+    lang_cache = DICTIONARY_EMBEDDINGS_CACHE[lang_code]
+    
+    print(f"[Semantic Distance V2] Analyzing {len(unmapped_terms)} {language} unmapped terms...")
+    print(f"[Semantic Distance V2]   Using {language} dictionary: {len(lang_cache['terms'])} terms")
+    
+    # Get embeddings for patient's unmapped terms (in their native language)
+    response = client.embeddings.create(
+        model="text-embedding-3-small",
+        input=unmapped_terms
+    )
+    unmapped_embeddings = [item.embedding for item in response.data]
+    
+    # Calculate similarities between patient terms and dictionary
+    results = []
+    for i, patient_term in enumerate(unmapped_terms):
+        similarities = []
+        
+        # Compare with all dictionary terms in this language
+        for j, dict_data in enumerate(lang_cache["metadata"]):
+            score = cosine_similarity(
+                unmapped_embeddings[i],
+                lang_cache["embeddings"][j]
+            )
+            similarities.append({
+                "native_term": dict_data["native_term"],
+                "english": dict_data["english"],
+                "pain_type": dict_data["pain_type"],
+                "dimension": dict_data["dimension"],
+                "score": round(score, 3)
+            })
+        
+        # Get Top 3 matches
+        top_matches = sorted(similarities, key=lambda x: x['score'], reverse=True)[:3]
+        
+        # Determine confidence level
+        best_score = top_matches[0]['score']
+        if best_score > 0.75:
+            confidence = "high"
+        elif best_score > 0.60:
+            confidence = "medium"
+        else:
+            confidence = "low"
+        
+        # Log best match
+        print(f"[Semantic Distance V2]   '{patient_term[:50]}' → '{top_matches[0]['native_term']}' "
+              f"({top_matches[0]['english']}) [score: {best_score:.3f}]")
+        
+        results.append({
+            "original_term": patient_term,  # Patient's native language expression
+            "matched_native_term": top_matches[0]['native_term'],  # Best dictionary term (native)
+            "standard_english": top_matches[0]['english'],  # Medical English translation
+            "closest_matches": top_matches,  # Top 3 for display
+            "confidence": confidence,
+            "language": lang_code
+        })
+    
+    return {"unmapped_analysis": results}
+
+
+def cosine_similarity(a, b):
+    """Calculate cosine similarity between two vectors."""
+    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

Backend/services/whisper_service.py

@@ -0,0 +1,27 @@
+import os
+
+from openai import OpenAI
+from typing import Optional
+from dotenv import load_dotenv
+load_dotenv()  # Load environment variables from .env file
+
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+def transcribeAudio(audioBytes: bytes, language: Optional[str] = None) -> dict:
+    try:
+        audioFile = ("audio.mp3", audioBytes, "audio/mpeg")
+        
+        response = client.audio.transcriptions.create(
+            model="whisper-1",
+            file=audioFile,
+            language=language,
+            response_format = "json"
+        )
+        return {
+            "text": response.text,
+            "language": language or "auto-detected"
+
+        }
+        
+    except Exception as e:
+        raise Exception(f"Error transcribing audio: {str(e)}")

Backend/test_multilingual_pipeline.py

@@ -0,0 +1,112 @@
+"""
+Test multilingual pipeline with sample inputs from each language
+"""
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from pipeline.pain_assessment_pipeline import PainAssessmentPipeline
+
+def test_multilingual_pipeline():
+    """Test pipeline with different languages"""
+    
+    pipeline = PainAssessmentPipeline(verbose=True)
+    
+    print("\n" + "=" * 80)
+    print("PIPELINE INFORMATION")
+    print("=" * 80)
+    info = pipeline.get_pipeline_info()
+    for key, value in info.items():
+        print(f"{key}: {value}")
+    
+    # Test cases for each language
+    test_cases = [
+        {
+            "language": "Chinese",
+            "text": "我有火辣辣的疼痛，已经好几个月了，腰部很难受",
+            "llm_entities": {
+                "pain_descriptors": ["火辣辣"],
+                "location": "腰部",
+                "duration_phrase": "好几个月",
+                "emotion_keywords": ["难受"],
+                "functional_impact": None,
+                "intensity": "Moderate to severe"
+            }
+        },
+        {
+            "language": "Korean",
+            "text": "허리가 따끔거리다",
+            "llm_entities": {
+                "pain_descriptors": ["따끔거리다"],
+                "location": "허리",
+                "duration_phrase": None,
+                "emotion_keywords": [],
+                "functional_impact": None,
+                "intensity": "Moderate"
+            }
+        },
+        {
+            "language": "Spanish",
+            "text": "Tengo un dolor agudo y punzante en la espalda",
+            "llm_entities": {
+                "pain_descriptors": ["agudo", "punzante"],
+                "location": "la espalda",
+                "duration_phrase": None,
+                "emotion_keywords": [],
+                "functional_impact": None,
+                "intensity": "Severe"
+            }
+        },
+        {
+            "language": "Hmong",
+            "text": "Kuv mob Kub Heev heev",
+            "llm_entities": {
+                "pain_descriptors": ["Kub Heev"],
+                "location": None,
+                "duration_phrase": None,
+                "emotion_keywords": [],
+                "functional_impact": None,
+                "intensity": "Severe"
+            }
+        }
+    ]
+    
+    for i, test_case in enumerate(test_cases, 1):
+        print("\n" + "=" * 80)
+        print(f"TEST CASE {i}: {test_case['language']}")
+        print("=" * 80)
+        print(f"Input: {test_case['text']}")
+        print()
+        
+        try:
+            report = pipeline.execute(
+                test_case['text'],
+                test_case['llm_entities']
+            )
+            
+            print("\n--- STRUCTURED DATA ---")
+            print(f"Pain Type: {report.structured_data.pain_type}")
+            print(f"Location: {report.structured_data.location}")
+            print(f"Temporal Pattern: {report.structured_data.temporal_pattern}")
+            
+            print("\n--- ONTOLOGY MAPPINGS ---")
+            for mapping in report.ontology_mapping_trace:
+                print(f"  {mapping.get('original_term', mapping.get('chinese_input', 'N/A'))} "
+                      f"→ {mapping['mapped_english']} ({mapping.get('pain_type', 'N/A')})")
+            
+            print("\n--- RECOMMENDATIONS ---")
+            if report.clinical_recommendations:
+                for rec in report.clinical_recommendations:
+                    print(f"  • {rec.recommendation}")
+            else:
+                print("  • Standard assessment recommended")
+            
+            print(f"\n✅ {test_case['language']} test PASSED")
+            
+        except Exception as e:
+            print(f"\n❌ {test_case['language']} test FAILED: {e}")
+            import traceback
+            traceback.print_exc()
+
+if __name__ == '__main__':
+    test_multilingual_pipeline()

Backend/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility functions for the PainReport system"""

Backend/utils/language_detector.py

@@ -0,0 +1,112 @@
+"""
+Language Detection Utility
+Detects the language of input text for multilingual pain assessment
+Supports: Chinese, Korean, Spanish, Hmong, English
+"""
+import re
+from typing import Literal
+
+LanguageCode = Literal['zh', 'ko', 'es', 'hmong', 'en']
+
+def detect_language(text: str) -> LanguageCode:
+    """
+    Detect the primary language of the input text.
+    
+    Uses character-based heuristics:
+    - Chinese: CJK Unified Ideographs (U+4E00–U+9FFF)
+    - Korean: Hangul Syllables (U+AC00–U+D7A3)
+    - Spanish: Spanish-specific characters (ñ, á, é, í, ó, ú, ü, ¿, ¡)
+    - Hmong: Latin script with specific patterns
+    - English: Default fallback
+    
+    Args:
+        text: Input text to detect language from
+        
+    Returns:
+        Language code: 'zh', 'ko', 'es', 'hmong', or 'en'
+    """
+    if not text or not text.strip():
+        return 'en'
+    
+    # Count characters by script
+    chinese_chars = len(re.findall(r'[\u4e00-\u9fff]', text))
+    korean_chars = len(re.findall(r'[\uac00-\ud7a3]', text))
+    spanish_chars = len(re.findall(r'[ñáéíóúü¿¡]', text, re.IGNORECASE))
+    
+    # Total characters (excluding whitespace)
+    total_chars = len(re.findall(r'\S', text))
+    
+    if total_chars == 0:
+        return 'en'
+    
+    # Chinese detection (>30% CJK characters)
+    if chinese_chars / total_chars > 0.3:
+        return 'zh'
+    
+    # Korean detection (>30% Hangul characters)
+    if korean_chars / total_chars > 0.3:
+        return 'ko'
+    
+    # Spanish detection (Spanish-specific characters OR common Spanish words)
+    spanish_keywords = [
+        'tengo', 'dolor', 'muy', 'que', 'para', 'con', 'por',
+        'esta', 'tiene', 'cuando', 'donde', 'como', 'agudo', 'punzante'
+    ]
+    text_lower = text.lower()
+    spanish_word_matches = sum(1 for kw in spanish_keywords if f' {kw} ' in f' {text_lower} ')
+    
+    if spanish_chars > 0 or spanish_word_matches >= 2:
+        return 'es'
+    
+    # Hmong detection (heuristic: common Hmong words)
+    hmong_keywords = [
+        'mob', 'txoj', 'kev', 'kuv', 'koj', 'nws', 'lawv',
+        'ntawm', 'rau', 'los', 'thiab', 'muaj', 'yog', 'tsis'
+    ]
+    text_lower = text.lower()
+    hmong_matches = sum(1 for kw in hmong_keywords if kw in text_lower)
+    
+    if hmong_matches >= 2:  # At least 2 Hmong keywords
+        return 'hmong'
+    
+    # Default to English
+    return 'en'
+
+def get_language_name(code: LanguageCode) -> str:
+    """
+    Get full language name from language code.
+    
+    Args:
+        code: Language code
+        
+    Returns:
+        Full language name
+    """
+    names = {
+        'zh': 'Chinese',
+        'ko': 'Korean',
+        'es': 'Spanish',
+        'hmong': 'Hmong',
+        'en': 'English'
+    }
+    return names.get(code, 'Unknown')
+
+# Test cases
+if __name__ == '__main__':
+    test_cases = [
+        ("我有火辣辣的疼痛", "zh"),
+        ("허리가 따끔거리듯이 아프다", "ko"),
+        ("Tengo un dolor agudo y punzante", "es"),
+        ("Kuv mob mob heev", "hmong"),
+        ("I have a sharp stabbing pain", "en"),
+        ("My back hurts so bad", "en"),
+    ]
+    
+    print("Language Detection Tests:")
+    print("=" * 60)
+    for text, expected in test_cases:
+        detected = detect_language(text)
+        status = "✅" if detected == expected else "❌"
+        print(f"{status} '{text}'")
+        print(f"   Expected: {expected}, Detected: {detected} ({get_language_name(detected)})")
+        print()

Backend/utils/report_generator.py

@@ -0,0 +1,292 @@
+from typing import Dict, List, Any
+import os
+from openai import OpenAI
+
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass  # dotenv not available, use system env vars
+
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+
+def generate_comprehensive_report(
+        original_text: str,
+        structured_data: Dict[str, Any],
+        ontology_mappings: List[Dict],
+        clinical_recommendations: List[Dict],
+        detected_language: str,
+        semantic_analysis: Dict = None
+    
+)  -> str:
+    """
+    Generate comprehensive clinical report using Medical Anthropologist framework.
+    
+    Uses detailed 4-layer analysis (linguistic, cultural, clinical, psychosocial).
+    Outputs as Markdown text for frontend display.
+    
+    Args:
+        original_text: Patient's original pain description
+        structured_data: Structured PainOntology data
+        ontology_mappings: Ontology mapping trace
+        clinical_recommendations: List of triggered recommendations
+        detected_language: Detected language name
+        semantic_analysis: Optional semantic distance analysis for unmapped terms
+        
+    Returns:
+        Markdown-formatted clinical report for frontend rendering
+    """
+    
+    # Prepare ontology mappings summary (MAPPED TERMS ONLY - exact dictionary matches)
+    mapped_terms_summary = []
+    for mapping in ontology_mappings[:10]:  # Limit to first 10
+        # Skip suggestions - only show exact/direct mappings
+        if mapping.get('is_suggestion') or mapping.get('confidence') == 'suggestion_only':
+            continue
+        
+        original = mapping.get('original_term', '')
+        english = mapping.get('mapped_english', '')
+        pain_type = mapping.get('pain_type', '')
+        if original and english:
+            mapped_terms_summary.append(f"  - '{original}' → {english} ({pain_type})")
+    
+    mappings_text = '\n'.join(mapped_terms_summary) if mapped_terms_summary else "  (No direct dictionary mappings found)"
+    
+    # Prepare recommendations summary
+    rec_summary = []
+    for rec in clinical_recommendations:
+        rule = rec.get('triggered_by_rule', 'Clinical Recommendation')
+        text = rec.get('recommendation', '')
+        rec_summary.append(f"  - {rule}: {text}")
+    
+    recs_text = '\n'.join(rec_summary) if rec_summary else "  (Standard pain assessment recommended)"
+    
+    # Prepare UNMAPPED terms semantic analysis summary
+    unmapped_text = ""
+    if semantic_analysis and semantic_analysis.get('unmapped_analysis'):
+        semantic_items = []
+        for item in semantic_analysis['unmapped_analysis']:
+            original = item['original_term']
+            matches = item['closest_matches']
+            confidence = item['confidence']
+            if matches:
+                # Show ALL top matches (usually top 3)
+                match_list = []
+                for i, match in enumerate(matches[:3], 1):
+                    # V2: Use new field names (native_term + english)
+                    native = match.get('native_term', match.get('chinese_term', match.get('term', 'Unknown')))
+                    english = match.get('english', '')
+                    match_list.append(f"    {i}. {native} ({english}) - similarity: {match['score']:.3f}")
+                
+                semantic_items.append(
+                    f"  - Original: '{original}'\n"
+                    f"    Confidence: {confidence}\n"
+                    f"    Top matches:\n" + '\n'.join(match_list)
+                )
+        if semantic_items:
+            unmapped_text = "\n\n===== UNMAPPED TERMS - SEMANTIC DISTANCE ANALYSIS (AI-Assisted Interpretation) =====\n"
+            unmapped_text += "These terms were NOT found in the standard medical dictionary. AI semantic analysis suggests possible matches:\n\n"
+            unmapped_text += '\n'.join(semantic_items)
+            unmapped_text += "\n\n  ⚠️ Important: These are AI-generated suggestions based on semantic similarity, NOT exact dictionary matches.\n  Scores closer to 1.0 indicate stronger semantic relationship. Always verify with clinical context."
+    
+    prompt = f"""You are an expert Medical Anthropologist specializing in cross-cultural pain expression.
+
+Your goal is to translate cultural pain metaphors into structured medical ontologies.
+⚠️ DO NOT act as a doctor making a final diagnosis.
+⚠️ DO NOT infer beyond the given information.
+
+===== PATIENT INPUT =====
+Language: {detected_language}
+Original Words: "{original_text}"
+
+===== STRUCTURED CLINICAL DATA (from neuro-symbolic pipeline) =====
+Pain Type: {structured_data.get('pain_type', 'Not specified')}
+Location: {structured_data.get('location', 'Not specified')}
+Temporal Pattern: {structured_data.get('temporal_pattern', 'Not specified')}
+Intensity: {structured_data.get('intensity', 'Not stated')}
+Emotional Impact: {structured_data.get('emotion', 'None noted')}
+Functional Impact: {structured_data.get('functional_impact', 'None noted')}
+
+===== MAPPED TERMS (Direct Matches from Medical Dictionary) =====
+{mappings_text}{unmapped_text}
+
+===== CLINICAL RECOMMENDATIONS (from rule engine) =====
+{recs_text}
+
+===== YOUR TASK =====
+Generate a comprehensive clinical report using this MANDATORY four-layer analytical framework:
+
+**Layer 1: Linguistic Layer (Patient's Voice)**
+- Provide literal translation preserving the patient's EXACT wording
+- Keep cultural expressions intact (e.g., "死疼死疼的", "불같이 아파요")
+- Do NOT simplify or standardize the patient's words
+
+**Layer 2: Cultural-Semantic Layer**
+- Identify any culturally specific metaphors or expressions
+- Explain their clinical meaning
+- If no cultural metaphors exist, clearly state that
+
+**Layer 3: Clinical Abstraction Layer (McGill Pain Questionnaire)**
+- Sensory qualities (e.g., sharp, burning, aching)
+- Affective qualities (e.g., tiring, distressing)
+- Temporal pattern and intensity
+- Body location
+
+**Layer 4: Psychosocial Layer**
+- Emotional distress indicators
+- Under-reporting risk (stoicism patterns)
+- Communication considerations
+
+**Layer 5: Semantic Distance Analysis (CRITICAL - if applicable)**
+- IF semantic analysis data is provided in the input:
+  - Display EACH unmapped term's semantic similarity scores
+  - Show the top 3 closest medical terms with similarity scores
+  - Include confidence levels (high/medium/low)
+  - Explain in plain language what the similarity scores suggest
+- IF no semantic analysis data: skip this layer entirely
+
+===== OUTPUT FORMAT =====
+Generate in clear Markdown format with these sections:
+
+**📝 Patient's Description (Literal Translation)**
+[First quote patient's exact words in original language, then provide word-for-word English translation preserving sentence structure and cultural expressions]
+Example format:
+> Original: "死疼死疼的，真的受不了了"
+> English: "Deadly painful, deadly painful, really can't bear it anymore"
+
+**🔗 Cultural Expression Analysis**
+[Analyze any cultural metaphors. If none: "No specific cultural metaphors identified."]
+
+**🏥 McGill Pain Assessment**
+- **Sensory Qualities:** [list descriptors]
+- **Affective Qualities:** [list descriptors]  
+- **Temporal Pattern:** [pattern]
+- **Location:** [body location]
+- **Intensity:** [severity estimate]
+
+**🧠 Psychosocial Considerations**
+- **Emotional Distress:** [Yes/No with brief evidence]
+- **Under-reporting Risk:** [Low/Medium/High with reasoning]
+- **Communication Notes:** [any relevant observations]
+
+**🔬 Semantic Distance Analysis (AI-Based Interpretation)**
+[ONLY include this section IF semantic analysis data exists in the input]
+For each unmapped creative expression/metaphor:
+- **Original Term:** [patient's exact words]
+- **Top 3 Similar Medical Terms:** 
+  1. [term] (similarity: X.XX, confidence: high/medium/low)
+  2. [term] (similarity: X.XX)
+  3. [term] (similarity: X.XX)
+- **Clinical Interpretation:** [1-sentence plain-language explanation of what these similarities suggest about the pain quality]
+
+[If NO semantic analysis data provided, completely omit this section]
+
+**⚕️ Clinical Action Plan**
+[Synthesize the clinical recommendations above into 2-3 actionable sentences]
+
+===== CRITICAL RULES =====
+1. Preserve patient's exact words and emotional tone
+2. Base all assessments on actual evidence - don't speculate
+3. If no cultural metaphors, state clearly
+4. Integrate the provided clinical recommendations
+5. **MANDATORY: If semantic analysis data is provided above, you MUST include the "🔬 Semantic Distance Analysis" section with all similarity scores displayed clearly**
+6. Keep report professional but comprehensive
+
+Generate the report now:"""
+
+    try:
+        response = client.chat.completions.create(
+            model='gpt-5.2',
+            messages=[
+                {"role": "system", "content": "You are a Medical Anthropologist generating clinical reports. Output clear Markdown text. ALWAYS include the Clinical Action Plan section at the end."},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=0.2,
+            max_completion_tokens=2500  # Increased for longer reports
+        )
+
+        return response.choices[0].message.content
+        
+    except Exception as e:
+        print(f"[Warning] Report generation error: {e}")
+        # Fallback to template matching new format
+        return f"""**📝 Patient's Description**
+"{original_text[:300]}..."
+
+**🔗 Cultural Expression Analysis**
+Unable to analyze cultural expressions at this time.
+
+**🏥 McGill Pain Assessment**
+- **Sensory Qualities:** Based on structured data
+- **Pain Type:** {structured_data.get('pain_type', 'Not specified')}
+- **Location:** {structured_data.get('location', 'Not specified')}
+- **Temporal Pattern:** {structured_data.get('temporal_pattern', 'Not specified')}
+- **Intensity:** {structured_data.get('intensity', 'Not stated')}
+
+**🧠 Psychosocial Considerations**
+- **Emotional Distress:** {'Yes' if structured_data.get('emotion') else 'Unknown'}
+- **Functional Impact:** {structured_data.get('functional_impact', 'Not noted')}
+
+**⚕️ Clinical Action Plan**
+{chr(10).join([f"- {rec.get('recommendation', '')}" for rec in clinical_recommendations[:3]]) if clinical_recommendations else 'Standard pain assessment and management recommended.'}
+
+(Note: Full anthropological analysis unavailable. Using template fallback.)
+"""
+
+
+def translate_to_english_simple(text: str) -> str:
+    """
+    Simple translation utility to convert short phrases to English.
+    
+    Used for translating intensity levels, functional impacts, etc.
+    If text is already in English, returns it unchanged.
+    
+    Args:
+        text: Short text to translate (e.g., "很痛", "difficulty walking")
+        
+    Returns:
+        English translation or original text if already English
+    """
+    if not text or text.strip() == "":
+        return text
+    
+    # Quick check: if text is already mostly English (ASCII), return as-is
+    try:
+        text.encode('ascii')
+        return text  # Already English
+    except UnicodeEncodeError:
+        pass  # Contains non-ASCII, needs translation
+    
+    system_prompt = """You are a medical translator. Translate the given text into concise medical English.
+
+Rules:
+- Keep it brief and clinical
+- Preserve medical meaning
+- If already English, return unchanged
+- Output ONLY the translation, no explanations"""
+    
+    try:
+        response = client.chat.completions.create(
+            model="gpt-5.2",
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": text}
+            ],
+            temperature=0.1,
+            max_tokens=50
+        )
+        
+        translation = response.choices[0].message.content.strip()
+        
+        # Remove quotes if present
+        if translation.startswith('"') and translation.endswith('"'):
+            translation = translation[1:-1]
+        if translation.startswith("'") and translation.endswith("'"):
+            translation = translation[1:-1]
+            
+        return translation
+    
+    except Exception as e:
+        # Fallback: return original
+        return text

Frontend/demo.html

@@ -0,0 +1,942 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Neuro-Symbolic Pain Assessment System - Demo</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+
+        .container {
+            max-width: 1400px;
+            margin: 0 auto;
+        }
+
+        .header {
+            text-align: center;
+            color: white;
+            margin-bottom: 30px;
+        }
+
+        .header h1 {
+            font-size: 2.5em;
+            margin-bottom: 10px;
+        }
+
+        .header p {
+            font-size: 1.2em;
+            opacity: 0.9;
+        }
+
+        .modules {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            grid-template-rows: auto auto;
+            gap: 20px;
+            margin-bottom: 20px;
+        }
+
+        .module-1 {
+            grid-column: 1;
+            grid-row: 1;
+        }
+
+        .module-2 {
+            grid-column: 1;
+            grid-row: 2;
+        }
+
+        .report-panel {
+            grid-column: 2;
+            grid-row: 1 / span 2;
+        }
+
+        .module {
+            background: white;
+            border-radius: 15px;
+            padding: 25px;
+            box-shadow: 0 10px 30px rgba(0, 0, 0, 0.3);
+        }
+
+        .module h2 {
+            color: #667eea;
+            margin-bottom: 15px;
+            font-size: 1.5em;
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+
+        .module-badge {
+            background: #667eea;
+            color: white;
+            padding: 5px 12px;
+            border-radius: 20px;
+            font-size: 0.7em;
+        }
+
+        textarea {
+            width: 100%;
+            padding: 15px;
+            border: 2px solid #e0e0e0;
+            border-radius: 8px;
+            font-size: 16px;
+            resize: vertical;
+            min-height: 120px;
+            font-family: inherit;
+        }
+
+        textarea:focus {
+            outline: none;
+            border-color: #667eea;
+        }
+
+        button {
+            background: #667eea;
+            color: white;
+            border: none;
+            padding: 12px 30px;
+            border-radius: 8px;
+            font-size: 16px;
+            cursor: pointer;
+            transition: all 0.3s;
+            margin-top: 10px;
+        }
+
+        button:hover {
+            background: #5568d3;
+            transform: translateY(-2px);
+            box-shadow: 0 5px 15px rgba(102, 126, 234, 0.4);
+        }
+
+        button:disabled {
+            background: #ccc;
+            cursor: not-allowed;
+            transform: none;
+        }
+
+        .result {
+            margin-top: 20px;
+            padding: 20px;
+            background: #f8f9fa;
+            border-radius: 8px;
+            border-left: 4px solid #667eea;
+            max-height: 600px;
+            overflow-y: auto;
+        }
+
+        .result h3 {
+            color: #667eea;
+            margin-bottom: 10px;
+        }
+
+        .result-section {
+            margin-bottom: 15px;
+        }
+
+        .result-section h4 {
+            color: #444;
+            margin-bottom: 8px;
+            font-size: 1.1em;
+        }
+
+        .mapping-item {
+            background: white;
+            padding: 10px;
+            margin: 5px 0;
+            border-radius: 5px;
+            border-left: 3px solid #28a745;
+        }
+
+        .recommendation-item {
+            background: #fff3cd;
+            padding: 15px;
+            margin: 10px 0;
+            border-radius: 5px;
+            border-left: 4px solid #ffc107;
+        }
+
+        .reasoning-chain {
+            background: white;
+            padding: 10px;
+            margin: 5px 0;
+            border-left: 3px solid #17a2b8;
+            font-family: 'Courier New', monospace;
+            font-size: 0.9em;
+        }
+
+        .question-options {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 15px;
+            margin-top: 15px;
+        }
+
+        .option-card {
+            background: white;
+            border: 2px solid #e0e0e0;
+            border-radius: 10px;
+            padding: 15px;
+            cursor: pointer;
+            transition: all 0.3s;
+            text-align: center;
+        }
+
+        .option-card:hover {
+            border-color: #667eea;
+            transform: translateY(-3px);
+            box-shadow: 0 5px 15px rgba(102, 126, 234, 0.3);
+        }
+
+        .option-card.selected {
+            border-color: #667eea;
+            background: #f0f4ff;
+        }
+
+        .option-image {
+            width: 100%;
+            height: 150px;
+            object-fit: cover;
+            border-radius: 8px;
+            margin-bottom: 10px;
+        }
+
+        .loading {
+            text-align: center;
+            padding: 20px;
+            color: #667eea;
+        }
+
+        .spinner {
+            border: 4px solid #f3f3f3;
+            border-top: 4px solid #667eea;
+            border-radius: 50%;
+            width: 40px;
+            height: 40px;
+            animation: spin 1s linear infinite;
+            margin: 0 auto;
+        }
+
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+
+        .badge {
+            display: inline-block;
+            padding: 3px 8px;
+            border-radius: 12px;
+            font-size: 0.8em;
+            font-weight: bold;
+            margin-left: 5px;
+        }
+
+        .badge-neuropathic {
+            background: #dc3545;
+            color: white;
+        }
+
+        .badge-nociceptive {
+            background: #fd7e14;
+            color: white;
+        }
+
+        .badge-affective {
+            background: #6f42c1;
+            color: white;
+        }
+
+        .example-buttons {
+            display: flex;
+            gap: 10px;
+            margin-top: 10px;
+            flex-wrap: wrap;
+        }
+
+        .example-btn {
+            background: #f8f9fa;
+            color: #667eea;
+            border: 1px solid #667eea;
+            padding: 8px 15px;
+            font-size: 14px;
+        }
+
+        .example-btn:hover {
+            background: #667eea;
+            color: white;
+        }
+
+        /* New styles for improved readability */
+        details {
+            cursor: pointer;
+            user-select: none;
+        }
+
+        details summary {
+            padding: 8px;
+            border-radius: 6px;
+            background: rgba(0,0,0,0.02);
+            transition: background 0.2s;
+        }
+
+        details summary:hover {
+            background: rgba(0,0,0,0.05);
+        }
+
+        details[open] summary {
+            margin-bottom: 10px;
+            border-bottom: 1px solid rgba(0,0,0,0.1);
+        }
+
+        .result-section {
+            padding: 20px;
+            margin-bottom: 15px;
+            border-radius: 12px;
+        }
+
+        /* Smooth scrollbar for results */
+        .result::-webkit-scrollbar {
+            width: 8px;
+        }
+
+        .result::-webkit-scrollbar-track {
+            background: #f1f1f1;
+            border-radius: 4px;
+        }
+
+        .result::-webkit-scrollbar-thumb {
+            background: #667eea;
+            border-radius: 4px;
+        }
+
+        .result::-webkit-scrollbar-thumb:hover {
+            background: #5568d3;
+        }
+
+        @media (max-width: 1024px) {
+            .modules {
+                grid-template-columns: 1fr;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🏥 Neuro-Symbolic Pain Assessment System</h1>
+            <p>Hybrid AI Architecture: LLM Entity Extraction + Deterministic Clinical Reasoning</p>
+        </div>
+
+        <div class="modules">
+            <!-- MODULE 1: Text + Voice Input (Left Top) -->
+            <div class="module module-1">
+                <h2>
+                    <span class="module-badge">Module 1</span>
+                    Pain Assessment Pipeline
+                </h2>
+                
+                <p style="margin-bottom: 15px; color: #666;">
+                    Enter a pain description to see the complete neuro-symbolic analysis pipeline in action.
+                </p>
+
+                <textarea id="painInput" placeholder="Example: I've had constant electric-shock-like pain in my lower back for 4 months, can't sleep at night, feeling very depressed..."></textarea>
+
+                <div class="example-buttons">
+                    <button class="example-btn" onclick="loadExample('neuropathic')">Example: Neuropathic</button>
+                    <button class="example-btn" onclick="loadExample('chronic')">Example: Chronic Pain</button>
+                    <button class="example-btn" onclick="loadExample('chinese')">Example: Chinese</button>
+                </div>
+
+                <button id="analyzeBtn" onclick="analyzePain()">🔬 Analyze Pain Description</button>
+
+                <!-- Voice Recording -->
+                <div style="margin-top: 15px; padding: 15px; background: #f0f4ff; border-radius: 8px; border: 2px dashed #667eea;">
+                    <p style="margin-bottom: 10px; color: #667eea; font-weight: bold;">🎙️ OR Record Your Voice:</p>
+                    <div style="display: flex; gap: 10px; align-items: center;">
+                        <button id="recordBtn" onclick="toggleRecording()" style="background: #dc3545;">
+                            🎙️ Start Recording
+                        </button>
+                        <span id="recordStatus" style="color: #666;">Ready to record</span>
+                    </div>
+                    <audio id="audioPlayback" controls style="width: 100%; margin-top: 10px; display: none;"></audio>
+                </div>
+
+                <!-- Structured Data Results -->
+                <div id="pipelineResult"></div>
+            </div>
+
+            <!-- MODULE 2: Visual Q&A (Left Bottom) -->
+            <div class="module module-2">
+                <h2>
+                    <span class="module-badge" style="background: #28a745;">Module 2</span>
+                    Visual Follow-up Questions
+                </h2>
+
+                <p style="margin-bottom: 15px; color: #666;">
+                    Interactive image-based pain assessment for better characterization.
+                </p>
+
+                <button onclick="generateQuestion()">🖼️ Generate Visual Question</button>
+
+                <div id="questionResult"></div>
+            </div>
+
+            <!-- Right Panel: Clinical Report (Full Height) -->
+            <div class="module report-panel">
+                <h2>
+                    <span class="module-badge" style="background: #13547a;">📋 Report</span>
+                    Physician Summary (Clinical Report)
+                </h2>
+
+                <p style="margin-bottom: 15px; color: #666;">
+                    Comprehensive medical anthropologist analysis with 4-layer framework.
+                </p>
+
+                <div id="physicianReport"></div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        const API_BASE = 'http://localhost:8000';
+
+        // Example texts
+        const examples = {
+            neuropathic: "I've had constant electric-shock-like tingling pain in my lower back and legs for 4 months. The pain wakes me up at night, I can't sleep properly. Feeling exhausted and depressed.",
+            chronic: "My knees have been aching constantly for several months now. The pain is dull and throbbing, especially during the night. I'm exhausted from dealing with it.",
+            chinese: "最近四个月腰部到腿部总是像触电一样的麻痛，晚上痛得睡不着，心情很郁闷"
+        };
+
+        function loadExample(type) {
+            document.getElementById('painInput').value = examples[type];
+        }
+
+        async function analyzePain() {
+            const text = document.getElementById('painInput').value.trim();
+            if (!text) {
+                alert('Please enter a pain description');
+                return;
+            }
+
+            const resultDiv = document.getElementById('pipelineResult');
+            const btn = document.getElementById('analyzeBtn');
+            
+            btn.disabled = true;
+            resultDiv.innerHTML = '<div class="loading"><div class="spinner"></div><p>Analyzing pain description...</p></div>';
+
+            try {
+                const response = await fetch(`${API_BASE}/api/analyze-text-neuro-symbolic`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ text })
+                });
+
+                const data = await response.json();
+
+                if (data.status === 'success') {
+                    displayPipelineResult(data);
+                } else {
+                    resultDiv.innerHTML = `<div class="result"><h3>❌ Error</h3><p>${data.message}</p></div>`;
+                }
+            } catch (error) {
+                resultDiv.innerHTML = `<div class="result"><h3>❌ Connection Error</h3><p>Make sure the backend server is running on ${API_BASE}</p></div>`;
+            } finally {
+                btn.disabled = false;
+            }
+        }
+
+        /**
+         * Parse bilingual text format: "原文 [English translation]"
+         * Returns object with {original, translation} or {original: text} if no translation
+         */
+        function parseBilingualText(text) {
+            if (!text) return { original: '' };
+            
+            // Check for format: "原文 [English translation]"
+            const match = text.match(/^(.+?)\s*\[(.+?)\]$/);
+            if (match) {
+                return {
+                    original: match[1].trim(),
+                    translation: match[2].trim()
+                };
+            }
+            
+            // No translation format, return as-is
+            return { original: text };
+        }
+
+        /**
+         * Format bilingual text for display: large original + small translation
+         */
+        function formatBilingualDisplay(text) {
+            const parsed = parseBilingualText(text);
+            
+            if (parsed.translation) {
+                // Has translation - display original prominently with translation below
+                return `
+                    <div style="font-size: 1.05em; font-weight: 600; margin-top: 4px; line-height: 1.4;">
+                        ${parsed.original}
+                    </div>
+                    <div style="font-size: 0.8em; color: rgba(255,255,255,0.75); margin-top: 4px; font-style: italic;">
+                        ${parsed.translation}
+                    </div>
+                `;
+            } else {
+                // No translation - display plain text
+                return `<div style="font-size: 1.05em; font-weight: 600; margin-top: 4px;">${parsed.original}</div>`;
+            }
+        }
+
+        function displayPipelineResult(data) {
+            const resultDiv = document.getElementById('pipelineResult');
+            
+            // Validate data structure
+            if (!data || !data.structured_data) {
+                resultDiv.innerHTML = `<div class="result"><h3>⚠️ Analysis Issue</h3><p>Unable to process the pain description. Please try again with more details.</p></div>`;
+                return;
+            }
+            
+            const sd = data.structured_data;
+            const mappings = data.ontology_mapping_trace || [];
+            const recommendations = data.clinical_recommendations || [];
+            const reasoning = data.reasoning_chain || [];
+            const transcription = data.transcription || null;
+
+            let html = '<div class="result">';
+            html += '<h3 style="color: #28a745;">✅ Analysis Complete</h3>';
+
+            // Transcription Normalization (if available)
+            if (transcription && transcription.original !== transcription.normalized) {
+                html += '<div class="result-section" style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border: none; box-shadow: 0 4px 6px rgba(0,0,0,0.1);">';
+                html += '<h4 style="color: white; margin-bottom: 15px;">📝 Speech Recognition & Correction</h4>';
+                
+                html += '<div style="background: rgba(255,255,255,0.15); padding: 12px; border-radius: 8px; margin-bottom: 12px;">';
+                html += '<div style="font-size: 0.85em; opacity: 0.9; margin-bottom: 5px;">🎤 Original Transcription</div>';
+                html += `<div style="font-size: 1em; font-style: italic;">${transcription.original}</div>`;
+                html += '</div>';
+                
+                html += '<div style="text-align: center; margin: 10px 0; opacity: 0.7;">⬇️</div>';
+                
+                html += '<div style="background: rgba(255,255,255,0.25); padding: 12px; border-radius: 8px; border: 2px solid rgba(255,255,255,0.4);">';
+                html += '<div style="font-size: 0.85em; opacity: 0.9; margin-bottom: 5px;">✨ AI-Enhanced</div>';
+                html += `<div style="font-size: 1.1em; font-weight: 600;">${transcription.normalized}</div>`;
+                html += '</div>';
+                
+                // English Translation (if available)
+                if (transcription.english_translation) {
+                    html += '<div style="text-align: center; margin: 10px 0; opacity: 0.7;">⬇️</div>';
+                    
+                    html += '<div style="background: rgba(255,255,255,0.35); padding: 12px; border-radius: 8px; border: 2px solid rgba(255,255,255,0.6);">';
+                    html += '<div style="font-size: 0.85em; opacity: 0.9; margin-bottom: 5px;">🌐 English Translation</div>';
+                    html += `<div style="font-size: 1.1em; font-weight: 600;">${transcription.english_translation}</div>`;
+                    html += '</div>';
+                }
+                
+                if (transcription.corrections_applied && transcription.corrections_applied.length > 0) {
+                    html += '<details style="margin-top: 15px; cursor: pointer;">';
+                    html += '<summary style="font-size: 0.9em; opacity: 0.9;">🔧 Optimization Details (' + transcription.corrections_applied.length + ' items)</summary>';
+                    html += '<div style="background: rgba(0,0,0,0.1); padding: 10px; border-radius: 6px; margin-top: 8px;">';
+                    transcription.corrections_applied.forEach(correction => {
+                        html += `<div style="padding: 4px 0; font-size: 0.85em;">• ${correction}</div>`;
+                    });
+                    html += '</div></details>';
+                }
+                html += '</div>';
+            }
+
+            // Pain Assessment Summary (Main Card)
+            html += '<div class="result-section" style="background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%); color: white; border: none; box-shadow: 0 4px 6px rgba(0,0,0,0.1);">';
+            html += '<h4 style="color: white; margin-bottom: 15px;">🩺 Pain Assessment Results</h4>';
+            
+            // Pain Type with visual indicator
+            const painTypeColor = sd.pain_type && sd.pain_type.toLowerCase().includes('neuropathic') ? '#ff6b6b' : 
+                                  sd.pain_type && sd.pain_type.toLowerCase().includes('nociceptive') ? '#4ecdc4' : '#95e1d3';
+            html += '<div style="background: rgba(255,255,255,0.2); padding: 15px; border-radius: 8px; margin-bottom: 12px;">';
+            html += `<div style="font-size: 0.9em; opacity: 0.9; margin-bottom: 5px;">Pain Type</div>`;
+            html += `<div style="font-size: 1.3em; font-weight: 700; display: flex; align-items: center;">`;
+            html += `<span style="background: ${painTypeColor}; width: 12px; height: 12px; border-radius: 50%; display: inline-block; margin-right: 10px;"></span>`;
+            html += `${sd.pain_type || 'Not detected'}`;
+            html += `</div></div>`;
+            
+            // Grid layout for other info
+            html += '<div style="display: grid; grid-template-columns: 1fr 1fr; gap: 10px;">';
+            
+            if (sd.location && sd.location !== 'Not specified') {
+                html += '<div style="background: rgba(255,255,255,0.15); padding: 10px; border-radius: 6px;">';
+                html += '<div style="font-size: 0.85em; opacity: 0.9;">📍 Location</div>';
+                html += `<div style="font-size: 1.05em; font-weight: 600; margin-top: 4px;">${sd.location}</div>`;
+                html += '</div>';
+            }
+            
+            if (sd.temporal_pattern && sd.temporal_pattern !== 'Not specified') {
+                html += '<div style="background: rgba(255,255,255,0.15); padding: 10px; border-radius: 6px;">';
+                html += '<div style="font-size: 0.85em; opacity: 0.9;">⏱️ Temporal Pattern</div>';
+                html += `<div style="font-size: 1.05em; font-weight: 600; margin-top: 4px;">${sd.temporal_pattern}</div>`;
+                html += '</div>';
+            }
+            
+            if (sd.intensity && sd.intensity !== 'Not stated') {
+                html += '<div style="background: rgba(255,255,255,0.15); padding: 10px; border-radius: 6px;">';
+                html += '<div style="font-size: 0.85em; opacity: 0.9;">💪 Intensity</div>';
+                html += formatBilingualDisplay(sd.intensity);
+                html += '</div>';
+            }
+            
+            if (sd.emotion && sd.emotion !== 'None detected') {
+                html += '<div style="background: rgba(255,255,255,0.15); padding: 10px; border-radius: 6px;">';
+                html += '<div style="font-size: 0.85em; opacity: 0.9;">😔 Emotional Impact</div>';
+                html += `<div style="font-size: 1.05em; font-weight: 600; margin-top: 4px;">${sd.emotion}</div>`;
+                html += '</div>';
+            }
+            
+            if (sd.functional_impact && sd.functional_impact !== 'Not stated') {
+                html += '<div style="background: rgba(255,255,255,0.15); padding: 10px; border-radius: 6px; grid-column: 1 / -1;">';
+                html += '<div style="font-size: 0.85em; opacity: 0.9;">🚶 Functional Impact</div>';
+                html += formatBilingualDisplay(sd.functional_impact);
+                html += '</div>';
+            }
+            
+            html += '</div></div>';
+
+            // Unmapped/Unique Pain Descriptors (if any)
+            // Check if pain_type contains [Unmapped terms: ...]
+            if (sd.pain_type && sd.pain_type.includes('[Unmapped terms:')) {
+                const unmappedMatch = sd.pain_type.match(/\[Unmapped terms: ([^\]]+)\]/);
+                if (unmappedMatch) {
+                    const unmappedTerms = unmappedMatch[1].split(', ');
+                    html += '<div class="result-section" style="background: #fff3cd; border-left: 4px solid #ffc107; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">';
+                    html += '<h4 style="color: #856404; margin-bottom: 15px;">⚠️ Unique Pain Descriptors (Not in Medical Dictionary)</h4>';
+                    html += '<div style="color: #856404; line-height: 1.6; margin-bottom: 10px;">The patient used creative/metaphorical expressions that are not in our standardized pain terminology database. These should be noted for clinical context:</div>';
+                    unmappedTerms.forEach(term => {
+                        html += `<div style="background: #ffffff; padding: 10px 12px; border-radius: 6px; margin-bottom: 8px; border-left: 3px solid #ffc107; font-weight: 500; color: #333;">`;
+                        html += `📝 "${term.trim()}"`;
+                        html += `</div>`;
+                    });
+                    html += '<div style="font-size: 0.85em; color: #856404; margin-top: 10px; font-style: italic;">💡 Recommendation: Consider asking follow-up questions to understand these expressions in clinical terms.</div>';
+                    html += '</div>';
+                }
+            }
+
+            // Physician Summary moved to right panel - display it there instead
+            if (data.physician_summary) {
+                displayPhysicianReport(data.physician_summary);
+            }
+
+            // Clinical Recommendations (if available)
+            if (recommendations.length > 0) {
+                html += '<div class="result-section" style="background: #fff; border-left: 4px solid #ff6b6b; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">';
+                html += '<h4 style="color: #ff6b6b; margin-bottom: 15px;">💡 Clinical Recommendations</h4>';
+                recommendations.forEach(rec => {
+                    html += `<div style="background: #fff5f5; padding: 15px; border-radius: 8px; margin-bottom: 10px; border-left: 3px solid #ff6b6b;">`;
+                    html += `<div style="font-weight: 600; color: #333; margin-bottom: 8px;">${rec.triggered_by_rule || 'Clinical Recommendation'}</div>`;
+                    html += `<div style="color: #555; line-height: 1.6;">${rec.recommendation}</div>`;
+                    html += `<div style="margin-top: 8px; font-size: 0.85em; color: #999;">Confidence: ${rec.confidence || 'medium'}</div>`;
+                    html += `</div>`;
+                });
+                html += '</div>';
+            }
+
+            // Ontology Mappings (Collapsible Technical Details)
+            if (mappings.length > 0) {
+                // Separate confirmed mappings from suggestions
+                const confirmedMappings = mappings.filter(m => !m.is_suggestion);
+                const suggestedMappings = mappings.filter(m => m.is_suggestion);
+                
+                html += '<div class="result-section" style="background: #f8f9fa; border: 1px solid #e9ecef;">';
+                html += '<details style="cursor: pointer;">';
+                html += '<summary style="font-weight: 600; color: #495057; padding: 5px 0; user-select: none;">🔬 Terminology Mapping Details (' + confirmedMappings.length + ' confirmed';
+                if (suggestedMappings.length > 0) {
+                    html += ', ' + suggestedMappings.length + ' suggested';
+                }
+                html += ') ▼</summary>';
+                html += '<div style="margin-top: 15px; padding-top: 15px; border-top: 1px solid #dee2e6;">';
+                
+                // Display confirmed mappings
+                if (confirmedMappings.length > 0) {
+                    html += '<div style="margin-bottom: 20px;">';
+                    html += '<div style="font-size: 0.9em; color: #28a745; font-weight: 600; margin-bottom: 10px;">✅ Confirmed Mappings (Dictionary Matches)</div>';
+                    confirmedMappings.forEach(m => {
+                        const badgeClass = m.pain_type === 'neuropathic' ? 'badge-neuropathic' : 
+                                         m.pain_type === 'nociceptive' ? 'badge-nociceptive' : 'badge-affective';
+                        html += `<div style="background: white; padding: 12px; border-radius: 6px; margin-bottom: 8px; border-left: 3px solid #28a745;">`;
+                        html += `<div style="display: flex; align-items: center; justify-content: space-between;">`;
+                        html += `<div><strong style="color: #495057;">"${m.original_term || m.chinese_input}"</strong> → <strong style="color: #007bff;">${m.mapped_english}</strong></div>`;
+                        html += `<span class="badge ${badgeClass}" style="margin-left: 10px;">${m.pain_type || m.dimension}</span>`;
+                        html += `</div>`;
+                        if (m.matched_text && m.matched_text !== m.original_term) {
+                            html += `<div style="margin-top: 5px; font-size: 0.85em; color: #6c757d;">Matched: "${m.matched_text}"</div>`;
+                        }
+                        html += `</div>`;
+                    });
+                    html += '</div>';
+                }
+                
+                // Display suggested mappings (warnings)
+                if (suggestedMappings.length > 0) {
+                    html += '<div style="margin-top: 15px; padding-top: 15px; border-top: 2px dashed #ffc107;">';
+                    html += '<div style="font-size: 0.9em; color: #856404; font-weight: 600; margin-bottom: 10px;">⚠️ Similarity Suggestions (Not in Dictionary)</div>';
+                    html += '<div style="background: #fff3cd; padding: 12px; border-radius: 6px; margin-bottom: 10px; font-size: 0.85em; color: #856404;">';
+                    html += '💡 These terms were not found in our medical dictionary. The system suggests similar terms below, but these are NOT definitive mappings. Clinical review is required.';
+                    html += '</div>';
+                    
+                    suggestedMappings.forEach(m => {
+                        html += `<div style="background: #fff3cd; padding: 12px; border-radius: 6px; margin-bottom: 8px; border-left: 3px dashed #ffc107;">`;
+                        html += `<div style="display: flex; align-items: center; justify-content: space-between;">`;
+                        html += `<div><strong style="color: #856404;">"${m.original_term}"</strong> <span style="opacity: 0.7;">→ might be similar to →</span> <strong style="color: #d39e00;">${m.mapped_english}</strong></div>`;
+                        html += `<span class="badge" style="background: #ffc107; color: #000; margin-left: 10px;">suggestion</span>`;
+                        html += `</div>`;
+                        if (m.similarity_reason) {
+                            html += `<div style="margin-top: 8px; font-size: 0.85em; color: #856404; background: rgba(255,255,255,0.5); padding: 6px 8px; border-radius: 4px;">`;
+                            html += `🔍 Similarity: ${m.similarity_reason}`;
+                            html += `</div>`;
+                        }
+                        if (m.suggestion_note) {
+                            html += `<div style="margin-top: 8px; font-size: 0.8em; color: #856404; font-style: italic;">`;
+                            html += `${m.suggestion_note}`;
+                            html += `</div>`;
+                        }
+                        html += `</div>`;
+                    });
+                    html += '</div>';
+                }
+                
+                html += '</div></details></div>';
+            }
+
+            // Reasoning Chain (Collapsible Technical Details)
+            if (reasoning.length > 0) {
+                html += '<div class="result-section" style="background: #f8f9fa; border: 1px solid #e9ecef;">';
+                html += '<details style="cursor: pointer;">';
+                html += '<summary style="font-weight: 600; color: #495057; padding: 5px 0; user-select: none;">🧠 AI Reasoning Process (' + reasoning.length + ' steps) ▼</summary>';
+                html += '<div style="margin-top: 15px; padding-top: 15px; border-top: 1px solid #dee2e6;">';
+                reasoning.forEach((step, index) => {
+                    // Parse and format reasoning steps
+                    let formattedStep = step.replace(/===/g, '').replace(/\n\n/g, '<br>');
+                    const isHeader = step.includes('===') || step.match(/^[A-Z\s]+$/);
+                    const style = isHeader ? 
+                        'background: #e7f3ff; padding: 8px 12px; border-radius: 4px; font-weight: 600; color: #0066cc; margin: 10px 0 5px 0;' :
+                        'background: white; padding: 10px 12px; border-radius: 4px; color: #495057; margin: 5px 0; border-left: 2px solid #dee2e6; font-family: monospace; font-size: 0.9em; white-space: pre-wrap;';
+                    html += `<div style="${style}">${formattedStep}</div>`;
+                });
+                html += '</div></details></div>';
+            }
+
+            html += '</div>';
+            resultDiv.innerHTML = html;
+        }
+
+        function displayPhysicianReport(summary) {
+            const reportDiv = document.getElementById('physicianReport');
+            
+            let html = '<div style="background: rgba(255,255,255,0.95); color: #333; padding: 20px; border-radius: 8px; line-height: 1.6;">';
+            
+            // Clean up excessive whitespace first
+            let cleanedSummary = summary
+                .replace(/\n{3,}/g, '\n\n')  // Replace 3+ newlines with 2
+                .trim();
+            
+            // Enhanced Markdown formatting with better spacing
+            let formattedSummary = cleanedSummary
+                // Headers (## ) - with proper spacing
+                .replace(/^## (.+)$/gm, '<h3 style="color: #667eea; margin: 25px 0 12px 0; font-size: 1.3em; font-weight: 600;">$1</h3>')
+                // Horizontal rules (---) - thinner with less margin
+                .replace(/^---$/gm, '<hr style="border: none; border-top: 1px solid #e0e0e0; margin: 15px 0;">')
+                // Blockquotes (> ) - more compact
+                .replace(/^> (.+)$/gm, '<div style="border-left: 3px solid #667eea; padding: 8px 12px; margin: 8px 0; background: #f8f9fa; color: #555; font-style: italic; border-radius: 3px;">$1</div>')
+                // Bold (**text**)
+                .replace(/\*\*(.+?)\*\*/g, '<strong style="color: #333;">$1</strong>')
+                // Unordered lists (- ) - more compact
+                .replace(/^- (.+)$/gm, '<li style="margin: 3px 0 3px 20px; line-height: 1.5;">$1</li>')
+                // Wrap consecutive <li> in <ul> with tighter spacing
+                .replace(/(<li[^>]*>.*?<\/li>\s*)+/g, '<ul style="list-style-type: disc; margin: 8px 0; padding-left: 0;">$&</ul>')
+                // Convert remaining double newlines to paragraph breaks (smaller gap)
+                .replace(/\n\n/g, '<div style="height: 10px;"></div>')
+                // Convert single newlines to line breaks
+                .replace(/\n/g, '<br>');
+            
+            html += formattedSummary;
+            html += '</div>';
+            
+            reportDiv.innerHTML = html;
+        }
+
+        async function generateQuestion() {
+            const resultDiv = document.getElementById('questionResult');
+            resultDiv.innerHTML = '<div class="loading"><div class="spinner"></div><p>Generating visual question...</p></div>';
+
+            try {
+                const response = await fetch(`${API_BASE}/api/follow-up`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ history: [] })
+                });
+
+                const data = await response.json();
+
+                if (data.status === 'success') {
+                    displayQuestion(data.followup);
+                } else {
+                    resultDiv.innerHTML = `<div class="result"><h3>❌ Error</h3><p>${data.message}</p></div>`;
+                }
+            } catch (error) {
+                resultDiv.innerHTML = `<div class="result"><h3>❌ Connection Error</h3><p>${error.message}</p></div>`;
+            }
+        }
+
+        function displayQuestion(question) {
+            const resultDiv = document.getElementById('questionResult');
+            
+            let html = '<div class="result">';
+            html += `<h3 style="line-height: 1.6;">❓ ${question.question}</h3>`;
+            html += '<div class="question-options">';
+            
+            question.options.forEach(option => {
+                // Split bilingual text for better display
+                const textParts = option.text.split('|').map(t => t.trim());
+                const displayText = textParts.length > 1 
+                    ? `<strong>${option.id}</strong>: ${textParts[0]}<br><span style="color: #666; font-size: 0.9em;">${textParts[1]}</span>`
+                    : `<strong>${option.id}</strong>: ${option.text}`;
+                
+                html += `<div class="option-card" onclick="selectOption(this, '${option.id}')">`;
+                html += `<img src="${API_BASE}${option.image_url}" class="option-image" alt="${option.text}">`;
+                html += `<p>${displayText}</p>`;
+                html += `</div>`;
+            });
+            
+            html += '</div>';
+            html += '</div>';
+            
+            resultDiv.innerHTML = html;
+        }
+
+        function selectOption(element, optionId) {
+            document.querySelectorAll('.option-card').forEach(card => {
+                card.classList.remove('selected');
+            });
+            element.classList.add('selected');
+            console.log('Selected option:', optionId);
+        }
+
+        // Audio Recording Functions
+        let mediaRecorder;
+        let audioChunks = [];
+
+        async function toggleRecording() {
+            const btn = document.getElementById('recordBtn');
+            const status = document.getElementById('recordStatus');
+            const audioPlayback = document.getElementById('audioPlayback');
+
+            if (!mediaRecorder || mediaRecorder.state === 'inactive') {
+                // Start recording
+                try {
+                    const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+                    mediaRecorder = new MediaRecorder(stream);
+                    audioChunks = [];
+
+                    mediaRecorder.ondataavailable = (event) => {
+                        audioChunks.push(event.data);
+                    };
+
+                    mediaRecorder.onstop = async () => {
+                        const audioBlob = new Blob(audioChunks, { type: 'audio/webm' });
+                        const audioUrl = URL.createObjectURL(audioBlob);
+                        
+                        audioPlayback.src = audioUrl;
+                        audioPlayback.style.display = 'block';
+                        
+                        status.textContent = 'Processing audio...';
+                        status.style.color = '#007bff';
+                        
+                        await analyzeAudio(audioBlob);
+                    };
+
+                    mediaRecorder.start();
+                    btn.textContent = '⏹️ Stop Recording';
+                    btn.style.background = '#dc3545';
+                    status.textContent = 'Recording... speak now';
+                    status.style.color = '#dc3545';
+                } catch (error) {
+                    alert('Microphone access denied: ' + error.message);
+                }
+            } else {
+                // Stop recording
+                mediaRecorder.stop();
+                mediaRecorder.stream.getTracks().forEach(track => track.stop());
+                btn.textContent = '🎙️ Start Recording';
+                btn.style.background = '#28a745';
+                status.textContent = 'Analyzing...';
+                status.style.color = '#007bff';
+            }
+        }
+
+        async function analyzeAudio(audioBlob) {
+            const resultDiv = document.getElementById('pipelineResult');
+            const status = document.getElementById('recordStatus');
+
+            resultDiv.innerHTML = '<div class="loading"><div class="spinner"></div><p>Transcribing and analyzing audio...</p></div>';
+
+            try {
+                const formData = new FormData();
+                formData.append('file', audioBlob, 'recording.webm');
+
+                const response = await fetch(`${API_BASE}/api/analyze-audio-neuro-symbolic`, {
+                    method: 'POST',
+                    body: formData
+                });
+
+                const data = await response.json();
+
+                if (data.status === 'success') {
+                    // Show normalized transcription in input field (cleaner for display)
+                    if (data.transcription) {
+                        // Use normalized text if available, otherwise fall back to original
+                        const displayText = data.transcription.normalized || data.transcription.original || data.transcription;
+                        document.getElementById('painInput').value = displayText;
+                    }
+                    
+                    // Display results only if structured data exists
+                    if (data.structured_data) {
+                        displayPipelineResult(data);
+                        status.textContent = 'Analysis complete!';
+                        status.style.color = '#28a745';
+                    } else {
+                        // Show transcription but indicate analysis failed
+                        const transcriptionText = data.transcription?.normalized || data.transcription?.original || data.transcription || 'Unknown';
+                        resultDiv.innerHTML = `<div class="result">
+                            <h3>⚠️ Transcription Only</h3>
+                            <p><strong>Transcribed text:</strong> ${transcriptionText}</p>
+                            <p style="color: #666; margin-top: 10px;">Analysis could not be completed. The system may not recognize the pain description yet.</p>
+                        </div>`;
+                        status.textContent = 'Transcription done, analysis incomplete';
+                        status.style.color = '#ff9800';
+                    }
+                } else {
+                    resultDiv.innerHTML = `<div class="result"><h3>❌ Error</h3><p>${data.message || 'Unknown error'}</p></div>`;
+                    status.textContent = 'Error occurred';
+                    status.style.color = '#dc3545';
+                }
+            } catch (error) {
+                resultDiv.innerHTML = `<div class="result"><h3>❌ Connection Error</h3><p>${error.message}</p></div>`;
+                status.textContent = 'Connection failed';
+                status.style.color = '#dc3545';
+            }
+        }
+
+        // Load first example on page load
+        window.onload = () => {
+            loadExample('neuropathic');
+        };
+    </script>
+</body>
+</html>

Procfile

@@ -0,0 +1 @@
+web: cd Backend && uvicorn main:app --host 0.0.0.0 --port $PORT

app.py

@@ -0,0 +1,126 @@
+"""
+Gradio Demo for Multilingual Pain Assessment System
+Powered by BioLORD-2023-M medical embeddings
+"""
+
+import gradio as gr
+import requests
+import os
+import sys
+
+# Add Backend to path
+sys.path.append("./Backend")
+
+# For local testing
+API_URL = os.getenv("API_URL", "http://localhost:8000")
+
+def analyze_pain(text, language):
+    """Analyze pain description using the backend API."""
+    try:
+        response = requests.post(
+            f"{API_URL}/analyze_pain_text",
+            json={"text": text},
+            timeout=60
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            return result.get("report", "No report generated")
+        else:
+            return f"Error: {response.status_code} - {response.text}"
+    
+    except Exception as e:
+        return f"Error connecting to backend: {str(e)}\n\nMake sure the backend server is running:\ncd Backend && python main.py"
+
+
+# Example pain descriptions in different languages
+examples = [
+    ["腰部和腿部最近一周特别难受。感觉像有成千上万只蚂蚁在皮肤下面爬来爬去，停不下来；有时突然像被针戳了一下，会猛地跳起来。", "Chinese"],
+    ["허리와 다리가 최근 일주일 동안 특히 불편합니다. 피부 아래 수천 마리의 개미가 기어다니는 느낌이 들고, 때때로 갑자기 바늘에 찔린 것처럼 아파요.", "Korean"],
+    ["La espalda y las piernas han sido especialmente difíciles de soportar esta última semana. Se siente como si hubiera miles de hormigas arrastrándose bajo la piel, sin poder detenerse.", "Spanish"],
+    ["My lower back and legs have been especially hard to bear this past week. It feels like thousands of ants crawling under the skin, unable to stop.", "English"]
+]
+
+# Build Gradio interface
+with gr.Blocks(title="Pain Assessment System") as demo:
+    gr.Markdown("""
+    # 🏥 Multilingual Pain Assessment System
+    
+    Powered by **BioLORD-2023-M** medical embeddings and **GPT-5.2**
+    
+    ### Supported Languages:
+    - 🇨🇳 Chinese (中文)
+    - 🇰🇷 Korean (한국어)
+    - 🇪🇸 Spanish (Español)
+    - 🇻🇳 Hmong
+    - 🇺🇸 English
+    
+    ### How it works:
+    1. Enter patient's pain description in any supported language
+    2. BioLORD analyzes medical semantics
+    3. GPT-5.2 generates comprehensive clinical report
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            text_input = gr.Textbox(
+                label="Patient's Pain Description",
+                placeholder="Enter pain description in any language...",
+                lines=8
+            )
+            
+            language_input = gr.Dropdown(
+                choices=["Chinese", "Korean", "Spanish", "Hmong", "English"],
+                label="Language (optional - auto-detected)",
+                value="Chinese"
+            )
+            
+            submit_btn = gr.Button("Analyze Pain", variant="primary")
+        
+        with gr.Column():
+            output = gr.Markdown(
+                label="Clinical Report",
+                value="*Report will appear here...*"
+            )
+    
+    # Examples
+    gr.Examples(
+        examples=examples,
+        inputs=[text_input, language_input],
+        outputs=output,
+        fn=analyze_pain,
+        cache_examples=False
+    )
+    
+    # Event handlers
+    submit_btn.click(
+        fn=analyze_pain,
+        inputs=[text_input, language_input],
+        outputs=output
+    )
+    
+    gr.Markdown("""
+    ---
+    ### 🔬 Model Information
+    
+    - **Embeddings**: BioLORD-2023-M (SOTA on MedSTS medical semantic similarity)
+    - **Report Generation**: GPT-5.2
+    - **Dictionary**: 362 multilingual pain terms
+    - **Accuracy**: 85-92% on medical synonym matching
+    
+    ### ℹ️ About
+    This system maps patient's pain expressions to standardized medical terminology using:
+    - **Semantic Distance Analysis**: BioLORD understands medical concepts beyond literal text
+    - **Knowledge Graph Integration**: Aligned with medical ontologies (UMLS/AGCT)
+    - **Cultural Sensitivity**: Preserves metaphors and cultural expressions
+    
+    **Privacy**: BioLORD embeddings run locally. GPT-5.2 API used for report generation only.
+    """)
+
+# Launch
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )

quick_test.py

@@ -0,0 +1,180 @@
+"""
+Quick Test Script - Direct Pipeline Usage Without Server
+For development testing, no OpenAI API Key required
+"
+import sys
+import os
+
+# Add Backend to path
+sys.path.append(os.path.join(os.path.dirname(__file__), 'Backend'))
+
+from pipeline.pain_assessment_pipeline import PainAssessmentPipeline
+
+def test_quick():
+    """Quick test using mocked LLM output"""
+    
+    print("="*70)
+    print("🧪 Quick Test (No OpenAI API Required)")
+    print("="*70)
+    
+    # Initialize pipeline
+    pipeline = PainAssessmentPipeline(verbose=True)
+    
+    # Test cases
+    test_cases = [
+        {
+            "name": "中文 - 慢性神经病理性疼痛",
+            "text": "我有火辣辣的疼痛，已经好几个月了，腰部很难受",
+            "llm_entities": {
+                "pain_descriptors": ["火辣辣的疼痛"],
+                "location": "腰部",
+                "duration_phrase": "好几个月",
+                "emotion_keywords": ["难受"],
+                "functional_impact": None,
+                "intensity": "Moderate to severe"
+            }
+        },
+        {
+            "name": "韩语 - 刺痛",
+            "text": "허리가 따끔거리다",
+            "llm_entities": {
+                "pain_descriptors": ["따끔거리다"],
+                "location": "허리",
+                "duration_phrase": None,
+                "emotion_keywords": [],
+                "functional_impact": None,
+                "intensity": "Moderate"
+            }
+        },
+        {
+            "name": "西班牙语 - 急性疼痛",
+            "text": "Tengo un dolor agudo y punzante en la espalda",
+            "llm_entities": {
+                "pain_descriptors": ["agudo", "punzante"],
+                "location": "la espalda",
+                "duration_phrase": None,
+                "emotion_keywords": [],
+                "functional_impact": None,
+                "intensity": "Severe"
+            }
+        },
+        {
+            "name": "苗族语 - 灼烧痛",
+            "text": "Kuv mob Kub Heev heev",
+            "llm_entities": {
+                "pain_descriptors": ["Kub Heev"],
+                "location": None,
+                "duration_phrase": None,
+                "emotion_keywords": [],
+                "functional_impact": None,
+                "intensity": "Severe"
+            }
+        }
+    ]
+    
+    passed = 0
+    failed = 0
+    
+    for test in test_cases:
+        print("\n" + "="*70)
+        print(f"Test: {test['name']}")
+        print("-"*70)
+        print(f"Input: {test['text']}")
+        
+        try:
+            # Execute pipeline with mocked LLM output
+            report = pipeline.execute(
+                test['text'],
+                test['llm_entities']
+            )
+            
+            print(f"\n✅ Test Passed")
+            print(f"\n📋 Analysis Results:")
+            print(f"  Pain Type: {report.structured_data.pain_type}")
+            print(f"  Location: {report.structured_data.location}")
+            print(f"  Temporal Pattern: {report.structured_data.temporal_pattern}")
+            
+            if report.ontology_mapping_trace:
+                print(f"\n🔄 Ontology Mappings ({len(report.ontology_mapping_trace)} items):")
+                for mapping in report.ontology_mapping_trace:
+                    lang = mapping.get('detected_language', '?')
+                    print(f"  [{lang}] {mapping['original_term']} → "
+                          f"{mapping['mapped_english']} ({mapping.get('pain_type', 'N/A')})")
+            
+            if report.clinical_recommendations:
+                print(f"\n💊 Clinical Recommendations ({len(report.clinical_recommendations)} items):")
+                for i, rec in enumerate(report.clinical_recommendations, 1):
+                    print(f"\n  {i}. {rec.recommendation[:80]}...")
+                    print(f"     Rule: {rec.triggered_by_rule}")
+            else:
+                print(f"\n💊 Clinical Recommendations: Standard assessment")
+            
+            passed += 1
+            
+        except Exception as e:
+            print(f"\n❌ Test Failed: {e}")
+            import traceback
+            traceback.print_exc()
+            failed += 1
+    
+    # Summary
+    print("="*70)
+    print("📊 Test Summary")
+    print("="*70)
+    print(f"Passed: {passed}/{passed+failed}")
+    print(f"Failed: {failed}/{passed+failed}")
+    
+    if failed == 0:
+        print("\n✅ All tests passed!")
+    else:
+        print(f"\n⚠️  {failed} test(s) failed")
+    
+    return failed == 0
+
+
+def show_system_info():
+    """Display system information"""
+    print("\n" + "="*70)
+    print("📊 System Information")
+    print("="*70)
+    
+    pipeline = PainAssessmentPipeline(verbose=False)
+    info = pipeline.get_pipeline_info()
+    
+    print(f"Pipeline Version: {info['pipeline_version']}")
+    print(f"Architecture: {info['architecture']}")
+    print(f"Supported Languages: {', '.join(info['supported_languages'])}")
+    print(f"\nOntology Coverage:")
+    print(f"  Total: {info['ontology_coverage']['total_descriptors']} terms")
+    print(f"  Chinese: {info['ontology_coverage']['chinese_terms']}")
+    print(f"  Korean: {info['ontology_coverage']['korean_terms']}")
+    print(f"  Spanish: {info['ontology_coverage']['spanish_terms']}")
+    print(f"  Hmong: {info['ontology_coverage']['hmong_terms']}")
+    print(f"\nClinical Rules: {info['rule_count']}")
+    print(f"  {', '.join(info['active_rules'])}")
+
+
+if __name__ == "__main__":
+    print("="*70)
+    print("🚀 Multilingual Pain Assessment - Quick Test")
+    print("="*70)
+    print("\n💡 Note: This test does not require OpenAI API Key")
+    print("   Uses predefined LLM output to simulate complete pipeline")
+    
+    # Display system information
+    show_system_info()
+    
+    # Run tests
+    success = test_quick()
+    
+    if success:
+        print("\n" + "="*70)
+        print("🎉 System working properly!")
+        print("="*70)
+        print("\nNext Steps:")
+        print("  1. Set OPENAI_API_KEY environment variable")
+        print("  2. Start server: python Backend/main.py")
+        print("  3. Test full API: python test_api.py")
+        print("\nDetailed docs: HOW_TO_START.md")
+    
+    sys.exit(0 if success else 1)

requirements.txt

@@ -0,0 +1,12 @@
+fastapi==0.110.0
+uvicorn[standard]==0.27.1
+python-multipart==0.0.9
+openai>=1.30.0
+python-dotenv==1.0.1
+pydantic>=2.0
+numpy>=1.24.0
+faiss-cpu>=1.7.4
+sentence-transformers>=2.3.0
+torch>=2.0.0
+scikit-learn>=1.3.0
+gradio>=4.0.0

start_server.bat

@@ -0,0 +1,47 @@
+@echo off
+echo ========================================
+echo Multilingual Pain Assessment System
+echo ========================================
+echo.
+
+REM Check if .env file exists
+if not exist "Backend\.env" (
+    echo [WARNING] Backend\.env file not found
+    echo [INFO] Creating .env file from template...
+    copy Backend\.env.example Backend\.env >nul 2>&1
+    echo.
+    echo [IMPORTANT] Please edit Backend\.env and add your OpenAI API Key:
+    echo    1. Open file: Backend\.env
+    echo    2. Replace "your-openai-api-key-here" with your actual API Key
+    echo    3. Save the file and run this script again
+    echo.
+    echo Get API Key at: https://platform.openai.com/api-keys
+    echo.
+    pause
+    notepad Backend\.env
+    exit /b 1
+)
+
+REM Check if .env has real API Key configured
+findstr /C:"your-openai-api-key-here" Backend\.env >nul
+if %errorlevel% equ 0 (
+    echo [ERROR] Please configure OpenAI API Key first
+    echo.
+    echo Edit Backend\.env file:
+    echo    OPENAI_API_KEY=sk-your-real-api-key-here
+    echo.
+    echo Opening editor now...
+    notepad Backend\.env
+    pause
+    exit /b 1
+)
+
+echo .env file configured
+echo Starting server...
+echo go http://localhost:8000/docs to access API docs
+echo.
+
+cd Backend
+python main.py
+
+pause

test_api.py

@@ -0,0 +1,166 @@
+"""
+Simple API Test Script - Multilingual Pain Assessment System Demo
+"""
+import requests
+import json
+
+BASE_URL = "http://localhost:8000"
+
+
+def test_health():
+    """Check server health status"""
+    try:
+        response = requests.get(f"{BASE_URL}/health", timeout=5)
+        print("✅ Server is running")
+        print(f"   Version: {response.json()['version']}")
+        return True
+    except requests.exceptions.ConnectionError:
+        print("❌ Server not running")
+        print("   Please start server: python Backend/main.py")
+        return False
+    except Exception as e:
+        print(f"❌ Connection error: {e}")
+        return False
+
+
+def test_system_info():
+    """Get system information"""
+    print("\n" + "="*70)
+    print("📊 System Information")
+    print("="*70)
+    
+    try:
+        response = requests.get(f"{BASE_URL}/api/system-info")
+        data = response.json()
+        
+        if data["status"] == "success":
+            info = data["system_info"]["pipeline_info"]
+            print(f"Version: {info['pipeline_version']}")
+            print(f"Architecture: {info['architecture']}")
+            print(f"Supported Languages: {', '.join(info['supported_languages'])}")
+            print(f"\nOntology Coverage:")
+            print(f"  - Total: {info['ontology_coverage']['total_descriptors']} terms")
+            print(f"  - Chinese: {info['ontology_coverage']['chinese_terms']}")
+            print(f"  - Korean: {info['ontology_coverage']['korean_terms']}")
+            print(f"  - Spanish: {info['ontology_coverage']['spanish_terms']}")
+            print(f"  - Hmong: {info['ontology_coverage']['hmong_terms']}")
+    except Exception as e:
+        print(f"❌ Failed to get system info: {e}")
+
+
+def test_analysis(language_name, text):
+    """Test pain analysis"""
+    print("\n" + "="*70)
+    print(f"🌐 Testing {language_name}")
+    print("="*70)
+    print(f"Input: {text}")
+    
+    try:
+        response = requests.post(
+            f"{BASE_URL}/api/analyze-text-neuro-symbolic",
+            json={"text": text},
+            timeout=30
+        )
+        
+        result = response.json()
+        
+        if result["status"] == "success":
+            print("\n✅ Analysis succeeded!")
+            
+            # Display structured data
+            data = result["structured_data"]
+            print(f"\n📋 Structured Data:")
+            print(f"  Pain Type: {data['pain_type']}")
+            print(f"  Location: {data['location']}")
+            print(f"  Temporal Pattern: {data['temporal_pattern']}")
+            print(f"  Intensity: {data['intensity']}")
+            if data['emotion']:
+                print(f"  Emotion: {data['emotion']}")
+            
+            # Display ontology mappings
+            if result["ontology_mapping_trace"]:
+                print(f"\n🔄 Ontology Mappings ({len(result['ontology_mapping_trace'])} items):")
+                for mapping in result["ontology_mapping_trace"]:
+                    lang_code = mapping.get('detected_language', '?')
+                    print(f"  - [{lang_code}] {mapping['original_term']} → "
+                          f"{mapping['mapped_english']} ({mapping.get('pain_type', 'N/A')})")
+            
+            # Display clinical recommendations
+            if result["clinical_recommendations"]:
+                print(f"\n💊 Clinical Recommendations ({len(result['clinical_recommendations'])} items):")
+                for i, rec in enumerate(result["clinical_recommendations"], 1):
+                    print(f"\n  {i}. {rec['recommendation'][:100]}...")
+                    print(f"     Rule: {rec['triggered_by_rule']}")
+                    print(f"     Evidence: {rec['evidence']}")
+            else:
+                print("\n💊 Clinical Recommendations: Standard assessment recommended")
+            
+            return True
+        else:
+            print(f"\n❌ Analysis failed: {result.get('message')}")
+            return False
+            
+    except requests.exceptions.Timeout:
+        print("\n❌ Request timeout (OpenAI API might be slow)")
+        return False
+    except Exception as e:
+        print(f"\n❌ Error: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def main():
+    """Main test function"""
+    print("="*70)
+    print("🚀 Multilingual Pain Assessment System - API Test")
+    print("="*70)
+    
+    # 1. Check server
+    if not test_health():
+        return
+    
+    # 2. Get system info
+    test_system_info()
+    
+    # 3. Test different languages
+    test_cases = [
+        {
+            "name": "Chinese 🇨🇳",
+            "text": "我有火辣辣的疼痛，已经好几个月了，腰部很难受"
+        },
+        {
+            "name": "Korean 🇰🇷",
+            "text": "허리가 따끔거리듯이 아프다"
+        },
+        {
+            "name": "Spanish 🇪🇸",
+            "text": "Tengo un dolor agudo y punzante en la espalda"
+        },
+        {
+            "name": "Hmong",
+            "text": "Kuv mob Kub Heev heev"
+        }
+    ]
+    
+    passed = 0
+    total = len(test_cases)
+    
+    for test_case in test_cases:
+        if test_analysis(test_case["name"], test_case["text"]):
+            passed += 1
+    
+    # Summary
+    print("\n" + "="*70)
+    print("📊 Test Summary")
+    print("="*70)
+    print(f"Passed: {passed}/{total}")
+    
+    if passed == total:
+        print("✅ All tests passed!")
+    else:
+        print(f"⚠️  {total - passed} test(s) failed")
+
+
+if __name__ == "__main__":
+    main()

test_biolord.py

@@ -0,0 +1,132 @@
+"""
+BioLORD Model Test Script
+测试BioLORD-2023-M模型加载和基本功能
+"""
+
+import os
+os.environ["EMBEDDING_MODEL"] = "biolord"
+
+print("=" * 60)
+print("🧪 BioLORD-2023-M 模型测试")
+print("=" * 60)
+
+# Test 1: Import test
+print("\n[1/4] 测试导入...")
+try:
+    from sentence_transformers import SentenceTransformer
+    import numpy as np
+    from sklearn.metrics.pairwise import cosine_similarity
+    print("✅ 所有依赖导入成功")
+except Exception as e:
+    print(f"❌ 导入失败: {e}")
+    exit(1)
+
+# Test 2: Model loading
+print("\n[2/4] 加载BioLORD-2023-M模型...")
+print("⚠️  首次运行会下载~1GB模型，需要2-5分钟...")
+try:
+    model = SentenceTransformer("FremyCompany/BioLORD-2023-M")
+    print(f"✅ 模型加载成功！")
+    print(f"   - 嵌入维度: {model.get_sentence_embedding_dimension()}")
+    print(f"   - 最大序列长度: {model.max_seq_length}")
+except Exception as e:
+    print(f"❌ 模型加载失败: {e}")
+    exit(1)
+
+# Test 3: Embedding generation
+print("\n[3/4] 测试多语言疼痛表达嵌入...")
+test_expressions = {
+    "中文": "像有成千上万只蚂蚁在皮肤下面爬来爬去",
+    "韩文": "허리가 따끔거리듯이 아프다",
+    "西班牙语": "dolor punzante en la espalda",
+    "英文": "stabbing pain in the lower back"
+}
+
+try:
+    for lang, text in test_expressions.items():
+        embedding = model.encode(text, convert_to_numpy=True)
+        print(f"✅ {lang}: 生成 {len(embedding)}-维向量")
+except Exception as e:
+    print(f"❌ 嵌入生成失败: {e}")
+    exit(1)
+
+# Test 4: Medical similarity test
+print("\n[4/4] 测试医学语义相似度...")
+print("比较: '刺痛' vs '钝痛' vs '蚂蚁爬'")
+
+try:
+    terms = ["刺痛", "钝痛", "像蚂蚁在爬"]
+    embeddings = model.encode(terms, convert_to_numpy=True)
+    
+    # Calculate similarity matrix
+    similarity_matrix = cosine_similarity(embeddings)
+    
+    print("\n相似度矩阵:")
+    print("           刺痛    钝痛    蚂蚁爬")
+    for i, term in enumerate(terms):
+        row = f"{term:8s} "
+        for j in range(len(terms)):
+            row += f"{similarity_matrix[i][j]:.3f}  "
+        print(row)
+    
+    # Medical dictionary test
+    print("\n\n测试与医学词典匹配:")
+    patient_expr = "像成千上万只蚂蚁在皮肤下爬"
+    medical_terms = {
+        "蚊虫叮咬的刺疼": "stinging",
+        "蚂蚁爬感": "formication",
+        "麻木感": "numbness",
+        "刺痛": "stabbing"
+    }
+    
+    patient_emb = model.encode([patient_expr], convert_to_numpy=True)[0]
+    dict_texts = list(medical_terms.keys())
+    dict_embs = model.encode(dict_texts, convert_to_numpy=True)
+    
+    scores = cosine_similarity([patient_emb], dict_embs)[0]
+    ranked = sorted(zip(dict_texts, medical_terms.values(), scores), key=lambda x: x[2], reverse=True)
+    
+    print(f"\n患者表达: '{patient_expr}'")
+    print("\n最匹配的医学术语:")
+    for i, (chinese, english, score) in enumerate(ranked[:3], 1):
+        confidence = "HIGH" if score > 0.75 else "MEDIUM" if score > 0.60 else "LOW"
+        print(f"  {i}. {chinese} ({english})")
+        print(f"     相似度: {score:.3f} [{confidence}]")
+    
+    print("\n✅ 医学语义理解测试通过！")
+    
+except Exception as e:
+    print(f"❌ 相似度测试失败: {e}")
+    exit(1)
+
+# Test 5: Test integration with service
+print("\n\n[5/5] 测试与系统集成...")
+try:
+    import sys
+    sys.path.append("./Backend")
+    
+    from services.semantic_distance_service_biolord import load_biolord_model, precompute_dictionary_embeddings
+    
+    print("加载BioLORD服务...")
+    model = load_biolord_model()
+    print("✅ 服务加载成功")
+    
+    print("\n预计算多语言词典嵌入...")
+    precompute_dictionary_embeddings()
+    print("✅ 词典嵌入预计算完成")
+    
+except Exception as e:
+    print(f"❌ 系统集成测试失败: {e}")
+    import traceback
+    traceback.print_exc()
+    exit(1)
+
+# Success summary
+print("\n" + "=" * 60)
+print("🎉 所有测试通过！BioLORD模型已就绪")
+print("=" * 60)
+print("\n下一步:")
+print("1. 启动服务器: cd Backend && python main.py")
+print("2. 测试API: 发送疼痛描述到 /analyze_pain_text")
+print("3. 查看语义分析结果（使用BioLORD医学嵌入）")
+print("\n提示: 环境变量 EMBEDDING_MODEL=biolord 已启用")

test_mcgill_matching.py

@@ -0,0 +1,147 @@
+"""
+Test: BioLORD Same-Language McGill Matching
+
+Tests the new architecture:
+- Chinese patient terms → Chinese McGill translations → English standard terms
+- Uses auxiliary McGill dictionary (not system's multilingual_pain_data.json)
+"""
+
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'Backend'))
+
+from services.semantic_distance_service_biolord import (
+    load_biolord_model,
+    precompute_dictionary_embeddings,
+    calculate_semantic_distances,
+    MCGILL_EMBEDDINGS_CACHE
+)
+
+def test_mcgill_matching():
+    """Test same-language McGill matching with Chinese examples."""
+    
+    print("=" * 80)
+    print("BioLORD: Same-Language McGill Matching Test")
+    print("=" * 80)
+    print()
+    
+    # Load model and precompute McGill embeddings
+    print("Step 1: Loading BioLORD model...")
+    try:
+        model = load_biolord_model()
+        print(f"✓ Model loaded: {model.get_sentence_embedding_dimension()}-dim embeddings\n")
+    except Exception as e:
+        print(f"✗ Failed to load model: {e}")
+        return
+    
+    print("Step 2: Precomputing McGill translations...")
+    precompute_dictionary_embeddings()
+    print()
+    
+    # Check what McGill terms were loaded
+    if 'zh' in MCGILL_EMBEDDINGS_CACHE:
+        zh_cache = MCGILL_EMBEDDINGS_CACHE['zh']
+        print(f"Chinese McGill: {len(zh_cache['terms'])} terms loaded")
+        print(f"Sample terms: {zh_cache['terms'][:10]}")
+        print()
+    
+    # Test cases: real patient expressions
+    test_cases = [
+        {
+            "term": "蚂蚁爬",
+            "description": "Basic formication expression",
+            "expected": "formication"
+        },
+        {
+            "term": "像蚂蚁在爬",
+            "description": "More detailed formication",
+            "expected": "formication"
+        },
+        {
+            "term": "有时候像是蚂蚁爬",
+            "description": "Contextual formication phrase",
+            "expected": "formication"
+        },
+        {
+            "term": "火辣辣的疼",
+            "description": "Burning pain (colloquial)",
+            "expected": "burning"
+        },
+        {
+            "term": "麻木",
+            "description": "Numbness",
+            "expected": "numbness"
+        },
+        {
+            "term": "针扎感",
+            "description": "Pins and needles / tingling",
+            "expected": "pins and needles"
+        },
+        {
+            "term": "电击一样",
+            "description": "Electric shock sensation",
+            "expected": "electric shock"
+        }
+    ]
+    
+    print("=" * 80)
+    print("Test Results: Chinese → Chinese McGill → English")
+    print("=" * 80)
+    print()
+    
+    correct = 0
+    total = len(test_cases)
+    
+    for i, test in enumerate(test_cases, 1):
+        print(f"Test {i}/{total}: {test['description']}")
+        print(f"  Patient term: {test['term']}")
+        print(f"  Expected English: {test['expected']}")
+        
+        # Test using calculate_semantic_distances
+        result = calculate_semantic_distances(
+            unmapped_terms=[test['term']],
+            patient_text=test['term'],
+            language="Chinese"
+        )
+        
+        if result and 'unmapped_analysis' in result:
+            analysis = result['unmapped_analysis'][0]
+            matched_english = analysis['matched_standard_english']
+            matched_native = analysis.get('matched_mcgill_native', 'N/A')
+            confidence = analysis['confidence']
+            score = analysis['closest_matches'][0]['score']
+            
+            is_correct = matched_english == test['expected']
+            status = "✓ CORRECT" if is_correct else f"✗ WRONG (got: {matched_english})"
+            
+            if is_correct:
+                correct += 1
+            
+            print(f"  Matched McGill (中文): {matched_native}")
+            print(f"  Matched English: {matched_english}")
+            print(f"  Confidence: {confidence} (score: {score:.3f})")
+            print(f"  {status}")
+            
+            # Show top 3 matches
+            print(f"  Top 3 matches:")
+            for j, match in enumerate(analysis['closest_matches'][:3], 1):
+                print(f"    {j}. {match['native_term']} ({match['english']}) - {match['score']:.3f}")
+        else:
+            print(f"  ✗ No result returned")
+        
+        print()
+    
+    print("=" * 80)
+    print(f"Final Score: {correct}/{total} correct ({correct/total*100:.1f}%)")
+    print("=" * 80)
+    
+    # Compare with expected performance
+    if correct >= total * 0.8:
+        print("✓ EXCELLENT: Same-language matching working as expected!")
+    elif correct >= total * 0.6:
+        print("⚠ GOOD: Most matches correct, may need tuning")
+    else:
+        print("✗ NEEDS IMPROVEMENT: Many incorrect matches")
+
+if __name__ == "__main__":
+    test_mcgill_matching()

test_report.py

@@ -0,0 +1,80 @@
+"""
+Test script to verify report generation is using the new Medical Anthropologist prompt
+"""
+import sys
+import os
+sys.path.append('Backend')
+
+# Load .env from Backend directory
+try:
+    from dotenv import load_dotenv
+    load_dotenv('Backend/.env')
+except ImportError:
+    print("Note: dotenv not available, using system environment variables")
+
+# Now import after dotenv is loaded
+from utils.report_generator import generate_comprehensive_report
+
+# Test data
+test_original_text = "我这两天一直觉得肚子钝痛，不是那种特别剧烈的，就是一直隐隐作痛。有时候会觉得按到那个部位的时候会更明显一点，躺着会好一点，还挺烦有点受不了的感觉。"
+
+test_structured_data = {
+    'pain_type': 'Nociceptive (aching, dull, tingling, constant, tender)',
+    'location': 'Abdomen',
+    'temporal_pattern': 'Constant',
+    'intensity': '不是那种特别剧烈的 [Not that particularly severe]',
+    'emotion': 'exhausted, depressed',
+    'functional_impact': '走路或者按到那个的时候会更明显一点，躺着会好一点 [more noticeable when walking or pressing the area, better when lying down]'
+}
+
+test_ontology_mappings = [
+    {'original_term': '钝痛', 'mapped_english': 'dull', 'pain_type': 'nociceptive'},
+    {'original_term': '隐隐作痛', 'mapped_english': 'aching', 'pain_type': 'nociceptive'},
+    {'original_term': '一直', 'mapped_english': 'constant', 'pain_type': 'temporal'}
+]
+
+test_clinical_recommendations = [
+    {
+        'triggered_by_rule': 'Nociceptive Pain Assessment',
+        'recommendation': 'Standard pain assessment and management pathway recommended. Consider detailed clinical interview for further characterization.',
+        'confidence': 'medium'
+    }
+]
+
+test_detected_language = 'Chinese'
+
+print("=" * 80)
+print("TESTING REPORT GENERATOR")
+print("=" * 80)
+print("\nCalling generate_comprehensive_report()...\n")
+
+try:
+    report = generate_comprehensive_report(
+        original_text=test_original_text,
+        structured_data=test_structured_data,
+        ontology_mappings=test_ontology_mappings,
+        clinical_recommendations=test_clinical_recommendations,
+        detected_language=test_detected_language
+    )
+    
+    print("=" * 80)
+    print("GENERATED REPORT:")
+    print("=" * 80)
+    print(report)
+    print("\n" + "=" * 80)
+    
+    # Check if it's using the new format
+    if "📝 Patient's Description" in report:
+        print("✅ SUCCESS: Using new Medical Anthropologist format!")
+    elif "Patient Presentation:" in report:
+        print("❌ FAIL: Still using old template format!")
+        print("\nThis means the function is hitting the exception handler.")
+    else:
+        print("⚠️ UNKNOWN: Cannot determine format")
+        
+except Exception as e:
+    print(f"❌ ERROR: {e}")
+    import traceback
+    traceback.print_exc()
+
+print("=" * 80)