backend fix

app.py

@@ -1,18 +1,45 @@
 APP_BUILD = "HF-BUILD-2025-12-15-01"
 print("✅ RUNNING APP BUILD:", APP_BUILD, "FILE:", __file__)
-# app.py (HF-safe updated version)
+
+# app.py (HF-safe + corrected health + debug routes)
 import os
 import datetime
 import traceback
+
 from flask import Flask, jsonify, request
 from flask_cors import CORS
 
+# FAISS / knowledge
+from faiss_service import FAISS_INDEX, TEXT_CHUNKS, HAS_FAISS, knowledge
+
+# Config
 from config import (
-    SQL_DRIVER, SQL_SERVER, SQL_DB, SQL_TRUSTED, SQL_USER, SQL_PASSWORD,
-    SQL_PORT, SQL_ENCRYPT, SQL_TRUSTCERT, IS_HUGGING_FACE
+    SQL_DRIVER,
+    SQL_SERVER,
+    SQL_DB,
+    SQL_TRUSTED,
+    SQL_USER,
+    SQL_PASSWORD,
+    SQL_PORT,
+    SQL_ENCRYPT,
+    SQL_TRUSTCERT,
+    IS_HUGGING_FACE,
+    PROGRESS_TBL,  # make sure this exists in config.py
 )
+
 from models import db
 
+# LLM / chain imports (safe if module not present)
+try:
+    from llm_service import CHAIN_BATCH
+    try:
+        from llm_service import llm_chain
+    except ImportError:
+        llm_chain = None
+except ImportError:
+    CHAIN_BATCH = None
+    llm_chain = None
+
 
 def create_app():
     app = Flask(__name__)
@@ -28,7 +55,7 @@ def create_app():
     # ----------------------------
     @app.before_request
     def log_request_info():
-        print(f"\n{'='*60}")
+        print(f"\n{'=' * 60}")
         print("📥 INCOMING REQUEST:")
         print(f"   Time: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
         print(f"   Method: {request.method}")
@@ -38,7 +65,7 @@ def create_app():
         if request.user_agent:
             print(f"   User Agent: {request.user_agent.string[:80]}...")
         print(f"   Referrer: {request.referrer}")
-        print(f"{'='*60}")
+        print(f"{'=' * 60}")
 
     # ----------------------------
     # DB init
@@ -60,7 +87,7 @@ def create_app():
         import routes as routes_module
         print("✅ DEBUG: Imported routes module")
 
-        # Get blueprints safely (if a blueprint is not created due to import error, it may be None)
+        # Get blueprints safely (None means missing)
         candidates = [
             ("auth_bp", getattr(routes_module, "auth_bp", None), "/api"),
             ("profiles_bp", getattr(routes_module, "profiles_bp", None), None),
@@ -69,8 +96,10 @@ def create_app():
             ("llm_bp", getattr(routes_module, "llm_bp", None), None),
         ]
 
-        print("✅ DEBUG: Blueprint objects (None means failed):",
-              [bp.name if bp else None for _, bp, _ in candidates])
+        print(
+            "✅ DEBUG: Blueprint objects (None means failed):",
+            [bp.name if bp else None for _, bp, _ in candidates],
+        )
 
         for name, bp, prefix in candidates:
             if bp is None:
@@ -95,92 +124,126 @@ def create_app():
         print(f"❌ DEBUG: Failed to import routes or register blueprints: {e}")
         traceback.print_exc()
 
-    # ----------------------------
+    # ------------------------------------------------------------------
     # Debug endpoints (always available)
-    # ----------------------------
-    @app.get("/api/health")
+    # ------------------------------------------------------------------
+    @app.get("/api/_routes")
+    @app.get("/debug/routes")
+    def list_routes():
+        routes_list = []
+        for rule in app.url_map.iter_rules():
+            routes_list.append(
+                {
+                    "endpoint": rule.endpoint,
+                    "methods": sorted(list(rule.methods)),
+                    "rule": str(rule),
+                }
+            )
+
+        has_double_api = any(r["rule"].startswith("/api/api/") for r in routes_list)
+
+        return jsonify(
+            {
+                "count": len(routes_list),
+                "has_double_api_prefix": has_double_api,
+                "routes": sorted(routes_list, key=lambda x: x["rule"]),
+            }
+        )
+
+    # ------------------------------------------------------------------
+    # Health endpoint (both /health and /api/health to avoid breaking clients)
+    # ------------------------------------------------------------------
     @app.get("/health")
+    @app.get("/api/health")
     def health():
-        # Keep this endpoint simple and safe (do not crash if optional imports fail)
-        faiss_loaded = False
-        knowledge_loaded = False
+        # LLM mode
         llm_mode = "offline-fallback"
-
         try:
-            from llm_service import CHAIN_BATCH
             if CHAIN_BATCH is not None:
                 llm_mode = "openai"
         except Exception:
             pass
 
-        try:
-            from faiss_service import knowledge, TEXT_CHUNKS
-            faiss_loaded = bool(TEXT_CHUNKS) and len(TEXT_CHUNKS) > 0
-            knowledge_loaded = knowledge is not None and hasattr(knowledge, "indices") and len(knowledge.indices) > 0
-        except Exception:
-            pass
-
-        return jsonify({
-            "status": "ok",
-            "huggingface": bool(IS_HUGGING_FACE),
-            "llm": llm_mode,
-            "has_openai_key": bool(os.getenv("OPENAI_API_KEY")),
-            "db": {"server": SQL_SERVER, "database": SQL_DB},
-            "faiss_loaded": faiss_loaded,
-            "knowledge_base_loaded": knowledge_loaded,
-            "blueprints": blueprint_status
-        })
-
-    @app.get("/api/_routes")
-    @app.get("/debug/routes")
-    def list_routes():
-        routes_list = []
-        for rule in app.url_map.iter_rules():
-            routes_list.append({
-                "endpoint": rule.endpoint,
-                "methods": sorted(list(rule.methods)),
-                "rule": str(rule)
-            })
+        # FAISS status
+        faiss_chunks = len(TEXT_CHUNKS) if TEXT_CHUNKS is not None else 0
+        faiss_loaded = bool(HAS_FAISS and FAISS_INDEX is not None and faiss_chunks > 0)
 
-        # Detect a common mistake: /api/api/...
-        has_double_api = any(r["rule"].startswith("/api/api/") for r in routes_list)
+        # Knowledge base status
+        if knowledge is not None and hasattr(knowledge, "indices"):
+            knowledge_indices_count = len(getattr(knowledge, "indices", []))
+            knowledge_loaded = knowledge_indices_count > 0
+        else:
+            knowledge_indices_count = 0
+            knowledge_loaded = False
 
-        return jsonify({
-            "count": len(routes_list),
-            "has_double_api_prefix": has_double_api,
-            "routes": sorted(routes_list, key=lambda x: x["rule"])
-        })
+        return jsonify(
+            {
+                "status": "ok",
+                "huggingface": bool(IS_HUGGING_FACE),  # keep this line (as you requested)
+                "llm": llm_mode,
+                "has_openai_key": bool(os.getenv("OPENAI_API_KEY")),
+                "db": {
+                    "server": SQL_SERVER,
+                    "database": SQL_DB,
+                    "table": PROGRESS_TBL,
+                },
+                "faiss_available": HAS_FAISS,
+                "faiss_loaded": faiss_loaded,
+                "faiss_chunks": faiss_chunks,
+                "knowledge_base_loaded": knowledge_loaded,
+                "knowledge_indices": knowledge_indices_count,
+                "blueprints": blueprint_status,
+            }
+        )
 
+    # ------------------------------------------------------------------
+    # Home endpoint
+    # ------------------------------------------------------------------
     @app.get("/")
     def home():
-        return jsonify({
-            "message": "Unified Py-Match Service (FAISS-enabled)",
-            "try": [
-                "GET  /api/health",
-                "GET  /api/_routes",
-                "POST /api/signup",
-                "POST /api/login",
-                "GET  /api/questions/marriage",
-                "GET  /api/questions/existing-profile/marriage/<user_id>",
-                "GET  /api/expectation-questions",
-                "GET  /api/existing-preferences/<user_id>",
-            ]
-        })
+        return jsonify(
+            {
+                "message": "Unified Py-Match Service (FAISS-enabled)",
+                "try": [
+                    "GET  /health",
+                    "GET  /api/health",
+                    "GET  /api/_routes",
+                    "GET  /debug/routes",
+                    "POST /api/signup",
+                    "POST /api/login",
+                    "GET  /api/questions/marriage",
+                    "GET  /api/questions/existing-profile/marriage/<user_id>",
+                    "GET  /api/expectation-questions",
+                    "GET  /api/existing-preferences/<user_id>",
+                    "POST /api/questions/submit-answers/<role>",
+                    "POST /llm/start   (body: { user_id, role, n_questions, batch_size })",
+                    "POST /llm/next    (body: { session_id, selected_color })",
+                    "GET  /api/match/<user_id> (query: ?role=<role>&limit=<num>)",
+                ],
+            }
+        )
 
-    # ----------------------------
+    # ------------------------------------------------------------------
     # Error handlers
-    # ----------------------------
+    # ------------------------------------------------------------------
     @app.errorhandler(404)
     def not_found(error):
         return jsonify({"error": "Endpoint not found", "path": request.path}), 404
 
     @app.errorhandler(405)
     def method_not_allowed(error):
-        return jsonify({
-            "error": "Method not allowed",
-            "message": f"Method {request.method} not allowed for {request.path}",
-            "allowed_methods": getattr(error, "valid_methods", [])
-        }), 405
+        return (
+            jsonify(
+                {
+                    "error": "Method not allowed",
+                    "message": f"Method {request.method} not allowed for {request.path}",
+                    "allowed_methods": (
+                        error.valid_methods if hasattr(error, "valid_methods") else []
+                    ),
+                }
+            ),
+            405,
+        )
 
     @app.errorhandler(500)
     def internal_error(error):
@@ -189,10 +252,11 @@ def create_app():
     return app
 
 
-app = create_app()
-
 if __name__ == "__main__":
-    print(f"\n{'='*60}")
+    app = create_app()
+
+    print(f"\n{'=' * 60}")
     print("🚀 Flask server starting...")
-    print(f"{'='*60}")
+    print(f"{'=' * 60}")
+
     app.run(host="0.0.0.0", port=5000, debug=True)

config.py

@@ -21,7 +21,7 @@ if IS_HUGGING_FACE:
     DEFAULT_SQL_TRUSTED = "yes"  # Use SQL authentication on Hugging Face
 else:
     # Local development configuration
-    DEFAULT_SQL_SERVER = "localhost\sqlexpress"
+    DEFAULT_SQL_SERVER = "PYKARA"
     DEFAULT_SQL_DB = "Py_Match"
     DEFAULT_SQL_TRUSTED = "yes"  # Use Windows authentication locally
 

faiss_service.py

@@ -4,7 +4,13 @@ import json
 import pickle
 import random
 from typing import Dict, List, Tuple, Optional
+import re
+from collections import defaultdict
 
+import os
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+FAISS_INDEX_PATH = os.path.join(BASE_DIR, "faiss_index_file.index")  # Direct path
 # Try importing faiss
 try:
     import faiss
@@ -108,8 +114,104 @@ def try_load_chunks_from_disk(index_path: str) -> List[str]:
                 print(f"Failed to load chunks from {c}:", e)
     return []
 
+# Add this to faiss_service.py after the imports
+
+
+
+def extract_color_behaviors_from_chunks(chunks: List[str]) -> Dict[str, List[str]]:
+    """
+    Extract color-specific behaviors from book chunks
+    Returns: {"blue": [behaviors], "green": [behaviors], "red": [behaviors], "yellow": [behaviors]}
+    """
+    color_keywords = {
+        "blue": [
+            "analytical", "fact-based", "data", "research", "analyze", "logic", 
+            "detail", "thorough", "precision", "evidence", "numbers", "verify",
+            "critical", "skeptical", "methodical", "systematic", "investigate",
+            "examine", "study", "proof", "accuracy", "rational", "reasoning"
+        ],
+        "green": [
+            "organized", "process", "systematic", "routine", "plan", "structure",
+            "reliable", "consistent", "predictable", "bureaucratic", "procedural",
+            "methodical", "step-by-step", "orderly", "structured", "traditional",
+            "stable", "secure", "dependable", "regulated", "formal", "order"
+        ],
+        "red": [
+            "decisive", "action-oriented", "direct", "results", "take charge",
+            "impulsive", "controlling", "dominant", "assertive", "leadership",
+            "quick", "immediate", "practical", "hands-on", "confrontational",
+            "bold", "forceful", "authoritative", "dynamic", "active", "energetic"
+        ],
+        "yellow": [
+            "creative", "big-picture", "visionary", "innovative", "ideas",
+            "unrealistic", "scattered", "enthusiastic", "optimistic", "inspiring",
+            "imaginative", "exploratory", "experimental", "spontaneous", "free-thinking",
+            "inventive", "original", "artistic", "expressive", "playful", "curious"
+        ]
+    }
+    
+    color_behaviors = defaultdict(list)
+    
+    for chunk in chunks:
+        sentences = re.split(r'[.!?]+', chunk)
+        for sentence in sentences:
+            sentence = sentence.strip()
+            if len(sentence.split()) < 5 or len(sentence.split()) > 25:
+                continue  # Skip too short or too long sentences
+                
+            sentence_lower = sentence.lower()
+            
+            # Find which color this sentence describes
+            for color, keywords in color_keywords.items():
+                if any(keyword in sentence_lower for keyword in keywords):
+                    # Clean and format the behavior
+                    behavior = sentence.strip()
+                    # Remove quotes if present
+                    behavior = behavior.replace('"', '').replace("'", "")
+                    # Capitalize first letter
+                    if behavior and behavior[0].islower():
+                        behavior = behavior[0].upper() + behavior[1:]
+                    
+                    # Avoid duplicates
+                    if behavior not in color_behaviors[color]:
+                        color_behaviors[color].append(behavior)
+                    
+                    break
+    
+    return dict(color_behaviors)
+
+def load_color_examples():
+    """
+    Load color examples from the book chunks
+    """
+    global COLOR_EXAMPLES
+    
+    if not TEXT_CHUNKS:
+        print("No text chunks loaded - cannot extract color examples")
+        COLOR_EXAMPLES = None
+        return
+    
+    try:
+        COLOR_EXAMPLES = extract_color_behaviors_from_chunks(TEXT_CHUNKS)
+        print(f"Loaded color examples from book: {', '.join([f'{color}: {len(examples)}' for color, examples in COLOR_EXAMPLES.items()])}")
+        
+        # Debug: Show sample behaviors
+        print("\n=== SAMPLE COLOR EXAMPLES ===")
+        for color, examples in COLOR_EXAMPLES.items():
+            print(f"\n{color.upper()} (first 3 examples):")
+            for i, example in enumerate(examples[:3], 1):
+                print(f"  {i}. {example}")
+        print("=============================\n")
+    except Exception as e:
+        print(f"Failed to extract color examples: {e}")
+        COLOR_EXAMPLES = None
+
+# Initialize COLOR_EXAMPLES
+COLOR_EXAMPLES = None
+
+# Update load_faiss_index to also load color examples
 def load_faiss_index(index_path: str):
-    global FAISS_INDEX, TEXT_CHUNKS
+    global FAISS_INDEX, TEXT_CHUNKS, COLOR_EXAMPLES
     if not HAS_FAISS:
         print("FAISS not installed. Skipping index load.")
         return
@@ -118,14 +220,19 @@ def load_faiss_index(index_path: str):
         return
     try:
         FAISS_INDEX = faiss.read_index(index_path)
-        # try to load chunks from companion files
         TEXT_CHUNKS = try_load_chunks_from_disk(index_path)
-        if not TEXT_CHUNKS:
-            print("Warning: Faiss index loaded but no companion text chunks found.")
-            print("Provide a companion .chunks.json or .chunks.pkl file with a list of text chunks.")
+        if TEXT_CHUNKS:
+            print(f"Loaded {len(TEXT_CHUNKS)} text chunks")
+            # Extract color examples from chunks
+            load_color_examples()
+        else:
+            print("Warning: No text chunks found.")
+            COLOR_EXAMPLES = None
     except Exception as e:
         print("Failed to load faiss index:", e)
         FAISS_INDEX = None
+        COLOR_EXAMPLES = None
+
 
 def get_nearest_context(query_emb: List[float] = None, k: int = 5, query_vector: Optional[List[float]] = None):
     """Return concatenated top-k chunks for a query."""
@@ -157,6 +264,22 @@ def get_faiss_context(k=3):
 
 # Initialize knowledge base only if FAISS is available
 knowledge = None
+
+# --- Auto-load main FAISS index on import ---
+if HAS_FAISS:
+    try:
+        if os.path.exists(FAISS_INDEX_PATH):
+            print(f"[faiss_service] Loading FAISS index from: {FAISS_INDEX_PATH}")
+            load_faiss_index(FAISS_INDEX_PATH)
+        else:
+            print(f"[faiss_service] FAISS index file NOT found at: {FAISS_INDEX_PATH}")
+    except Exception as e:
+        print(f"[faiss_service] Error while loading FAISS index: {e}")
+else:
+    print("[faiss_service] FAISS not installed, index will not be loaded.")
+
+
+
 if HAS_FAISS:
     knowledge = KnowledgeSource()
 else:
@@ -165,4 +288,7 @@ else:
     class DummyKnowledge:
         def get_relevant_context(self, *args, **kwargs):
             return []
-    knowledge = DummyKnowledge()
+    knowledge = DummyKnowledge()
+
+
+   

llm_service.py

@@ -1,4 +1,3 @@
-# llm_service.py
 import pyodbc
 import os
 import json
@@ -22,16 +21,21 @@ except Exception:
     HAS_LLM_STACK = False
     HAS_LLM = False
 
+
 class Option(BaseModel):
     text: str
     color: str
 
+
 class QAItem(BaseModel):
     question: str
     options: List[Option] = Field(min_items=4, max_items=4)
 
+
 class BatchQA(BaseModel):
     items: List[QAItem] = Field(..., min_items=1)
+
+
 SYSTEM_PROMPT = (
     "You write marriage compatibility assessment questions that reveal four personality colors through forced choices:\n"
     "- blue=analytical, fact-based (positive: thorough, precise | negative: overly critical, data-obsessed)\n"
@@ -65,8 +69,7 @@ SYSTEM_PROMPT = (
 
 USER_PROMPT_BATCH = (
     "Context (from Surrounded by Idiots or other corpus):\n{context}\n\n"
-    "Question Type: {question_type}\n\n"  # Add this line
-    
+    "Question Type: {question_type}\n\n"
     "User Profile (Current Background):\n"
     "- Education: {education}\n"
     "- Employment: {employment}\n"
@@ -89,12 +92,10 @@ USER_PROMPT_BATCH = (
     "Themes (array of short strings): {themes_json}\n"
     "Previously asked questions: {previous_questions}\n\n"
     "{format_instructions}\n\n"
-    
     "Generate {question_type} questions:\n"
     "- If QUESTION TYPE is 'profile': Generate 5 questions using ONLY profile data (education, employment, hobbies, family background, current lifestyle)\n"
     "- If QUESTION TYPE is 'expectation': Generate 5 questions using ONLY expectation data (conflict style, financial preferences, values, deal breakers)\n"
     "- If QUESTION TYPE is 'character': Generate 10 questions about CURRENT behavior in various life situations\n\n"
-    
     "CRITICAL RULES:\n"
     "1) DO NOT use prefixes like 'Based on your profile' or 'Considering your expectations'\n"
     "2) Questions should be natural and flow conversationally\n"
@@ -113,7 +114,7 @@ CHAIN_BATCH = None
 if HAS_LLM_STACK and os.getenv("OPENAI_API_KEY"):
     try:
         PARSER_BATCH = PydanticOutputParser(pydantic_object=BatchQA)
-        
+
         def build_batch_chain():
             llm = ChatOpenAI(
                 model="gpt-4o-mini",
@@ -122,10 +123,12 @@ if HAS_LLM_STACK and os.getenv("OPENAI_API_KEY"):
                 timeout=30,
                 model_kwargs={"response_format": {"type": "json_object"}},
             )
-            prompt = ChatPromptTemplate.from_messages([
-                ("system", SYSTEM_PROMPT),
-                ("user", USER_PROMPT_BATCH),
-            ])
+            prompt = ChatPromptTemplate.from_messages(
+                [
+                    ("system", SYSTEM_PROMPT),
+                    ("user", USER_PROMPT_BATCH),
+                ]
+            )
             return prompt | llm | PARSER_BATCH
 
         CHAIN_BATCH = build_batch_chain()
@@ -133,50 +136,88 @@ if HAS_LLM_STACK and os.getenv("OPENAI_API_KEY"):
         print("Failed to build CHAIN_BATCH:", e)
         CHAIN_BATCH = None
 
+
 def ensure_valid_colors(options: List[Dict]) -> List[Dict]:
     seen, fixed = set(), []
     defaults = {
-        "blue": "Verify facts and numbers",
-        "green": "Outline a clear process",
-        "red": "Coordinate people and act",
-        "yellow": "Propose a fresh idea",
+        "blue": "Check facts and numbers",
+        "green": "Make a step-by-step plan",
+        "red": "Get people together and act",
+        "yellow": "Think of a new idea",
     }
     for o in options:
         c = str(o.get("color", "")).lower()
         t = str(o.get("text", "")).strip()
         if c in COLOR_KEYS and c not in seen and t:
-            seen.add(c); fixed.append({"text": t[:80], "color": c})
+            seen.add(c)
+            fixed.append({"text": t[:80], "color": c})
     for c in COLOR_KEYS:
         if c not in seen:
             fixed.append({"text": defaults[c], "color": c})
     return fixed[:4]
 
+
 def summarize_profile(profile: Dict) -> Dict:
     """Extract all non-PII columns from Marriage table for LLM context"""
     out: Dict = {}
-    
+
     # All columns from Marriage table (excluding PII where possible)
     marriage_columns = [
-        "user_id", "full_name", "gender", "current_city", "marital_status",
-        "education_level", "employment_status", "number_of_siblings", "family_type",
-        "hobbies_interests", "conflict_approach", "financial_style", "income_range",
-        "relocation_willingness", "height", "skin_tone", "languages_spoken", "country",
-        "blood_group", "religion", "dual_citizenship", "siblings_position",
-        "parents_living_status", "live_with_parents", "support_parents_financially",
-        "family_communication_frequency", "food_preference", "smoking_habit",
-        "alcohol_habit", "daily_routine", "fitness_level", "own_pets", "travel_preference",
-        "relaxation_mode", "job_role", "work_experience_years", "career_aspirations",
-        "field_of_study", "remark", "children_timeline", "open_to_adoption",
-        "deal_breakers", "other_non_negotiables", "health_constraints", "live_with_inlaws"
+        "user_id",
+        "full_name",
+        "gender",
+        "current_city",
+        "marital_status",
+        "education_level",
+        "employment_status",
+        "number_of_siblings",
+        "family_type",
+        "hobbies_interests",
+        "conflict_approach",
+        "financial_style",
+        "income_range",
+        "relocation_willingness",
+        "height",
+        "skin_tone",
+        "languages_spoken",
+        "country",
+        "blood_group",
+        "religion",
+        "dual_citizenship",
+        "siblings_position",
+        "parents_living_status",
+        "live_with_parents",
+        "support_parents_financially",
+        "family_communication_frequency",
+        "food_preference",
+        "smoking_habit",
+        "alcohol_habit",
+        "daily_routine",
+        "fitness_level",
+        "own_pets",
+        "travel_preference",
+        "relaxation_mode",
+        "job_role",
+        "work_experience_years",
+        "career_aspirations",
+        "field_of_study",
+        "remark",
+        "children_timeline",
+        "open_to_adoption",
+        "deal_breakers",
+        "other_non_negotiables",
+        "health_constraints",
+        "live_with_inlaws",
     ]
-    
+
     for col in marriage_columns:
         v = profile.get(col)
         if v not in (None, "", []):
             out[col] = v
-    
+
     return out
 
+
 def offline_generate_batch(themes: List[str], state: Dict, context: str = "") -> List[Dict]:
     prof = state.get("profile", {}) or {}
     name = prof.get("full_name") or "Partner"
@@ -206,7 +247,7 @@ def offline_generate_batch(themes: List[str], state: Dict, context: str = "") ->
 
         # incorporate small bit from context if available (first 120 chars)
         if context:
-            ctx_snip = context.replace('\n', ' ')[:120]
+            ctx_snip = context.replace("\n", " ")[:120]
             q = f"{q} (Note: {ctx_snip})"
 
         # Keep concise
@@ -214,161 +255,191 @@ def offline_generate_batch(themes: List[str], state: Dict, context: str = "") ->
             q = " ".join(q.split()[:20])
 
         opts = [
-            {"text": "Check data and facts", "color": "blue"},
-            {"text": "Draft a step-by-step plan", "color": "green"},
-            {"text": "Align people and act", "color": "red"},
-            {"text": "Brainstorm bold ideas", "color": "yellow"},
+            {"text": "Check facts and numbers", "color": "blue"},
+            {"text": "Make a step-by-step plan", "color": "green"},
+            {"text": "Get people together and act", "color": "red"},
+            {"text": "Think of new ideas", "color": "yellow"},
         ]
         random.shuffle(opts)
         items.append({"question": q, "options": opts, "source": "fallback"})
     return items
 
 
-def generate_category_specific_options(question_type: str, question_text: str, profile_data: Dict = None, expectation_data: Dict = None) -> List[Dict]:
-    """
-    Generate options tailored to the question category and content
-    """
+def generate_category_specific_options(
+    question_type: str,
+    question_text: str,
+    profile_data: Dict = None,
+    expectation_data: Dict = None,
+) -> List[Dict]:
+    """Generate options tailored to the question category and content"""
     question_lower = question_text.lower()
-    
+
     # Extract key themes from question for better contextualization
     themes_in_question = []
-    for theme in ["learning", "problem", "conflict", "money", "family", "work", "social", "stress", "decision", "plan"]:
+    for theme in [
+        "learning",
+        "problem",
+        "conflict",
+        "money",
+        "family",
+        "work",
+        "social",
+        "stress",
+        "decision",
+        "plan",
+    ]:
         if theme in question_lower:
             themes_in_question.append(theme)
-    
-    # Default option templates for each color
+
+    # Default option templates for each color (Simple English)
     base_options = {
         "blue": {
-            "profile": "Research thoroughly and analyze all available data",
-            "expectation": "Gather detailed information before forming an opinion",
-            "character": "Analyze the situation carefully with facts and logic"
+            "profile": "Study all the facts and think carefully",
+            "expectation": "Get all the details before deciding",
+            "character": "Look at the facts and think it through",
         },
         "green": {
-            "profile": "Follow a structured, step-by-step approach",
-            "expectation": "Establish clear rules and procedures",
-            "character": "Create an organized plan and stick to it"
+            "profile": "Follow a clear, step-by-step way",
+            "expectation": "Set clear rules and follow them",
+            "character": "Make a plan and stick to it",
         },
         "red": {
-            "profile": "Take decisive action to address the situation",
-            "expectation": "Take charge and make things happen quickly",
-            "character": "Act immediately and coordinate people involved"
+            "profile": "Do something right away to fix it",
+            "expectation": "Take charge and get things done fast",
+            "character": "Act now and get people to help",
         },
         "yellow": {
-            "profile": "Explore creative possibilities and new approaches",
-            "expectation": "Consider innovative solutions and future potential",
-            "character": "Brainstorm creative ideas and possibilities"
-        }
+            "profile": "Try new ways and think differently",
+            "expectation": "Think of new ideas and what could be",
+            "character": "Think of creative ideas and new ways",
+        },
     }
-    
-    # Contextual variations based on question themes
+
+    # Contextual variations based on question themes (Simple English)
     contextual_variations = {
         "learning": {
-            "blue": "Study methodically and verify all information",
-            "green": "Follow the curriculum in an organized manner",
-            "red": "Jump into practical application immediately",
-            "yellow": "Explore unconventional learning methods"
+            "blue": "Study in a careful, organized way",
+            "green": "Follow the lessons step by step",
+            "red": "Start doing it right away to learn",
+            "yellow": "Try different ways to learn",
         },
         "problem": {
-            "blue": "Analyze root causes with data",
-            "green": "Systematically troubleshoot each component",
-            "red": "Take immediate corrective action",
-            "yellow": "Find innovative workarounds"
+            "blue": "Look at all the facts to find why",
+            "green": "Fix each part one by one",
+            "red": "Do something now to fix it",
+            "yellow": "Find a new way around it",
         },
         "conflict": {
-            "blue": "Analyze perspectives logically",
-            "green": "Establish fair mediation process",
-            "red": "Address it directly and decisively",
-            "yellow": "Find creative compromise"
+            "blue": "Think about each side fairly",
+            "green": "Find a fair way to solve it",
+            "red": "Face it directly and fix it",
+            "yellow": "Find a new way to agree",
         },
         "money": {
-            "blue": "Analyze financial data thoroughly",
-            "green": "Budget systematically and track expenses",
-            "red": "Make decisive investment choices",
-            "yellow": "Explore unconventional earning opportunities"
+            "blue": "Look at all the money details",
+            "green": "Plan spending and track costs",
+            "red": "Make quick money choices",
+            "yellow": "Think of new ways to earn",
         },
         "family": {
-            "blue": "Analyze family dynamics logically",
-            "green": "Maintain family traditions and routines",
-            "red": "Take leadership in family matters",
-            "yellow": "Introduce new family activities"
-        }
+            "blue": "Think about family matters clearly",
+            "green": "Keep family ways and routines",
+            "red": "Take the lead in family things",
+            "yellow": "Try new family activities",
+        },
     }
-    
+
     # Start with base options for the category
     options = []
     for color in COLOR_KEYS:
         base_text = base_options[color][question_type]
-        
+
         # Add contextual variation if theme matches
         for theme, variations in contextual_variations.items():
             if theme in themes_in_question:
                 base_text = variations[color]
                 break
-        
-        # Add shadow/negative aspects for realism
+
+        # Add shadow/negative aspects for realism (Simple English)
         shadow_aspects = {
             "blue": {
-                "profile": " (but can get stuck in analysis)",
-                "expectation": " (but may overanalyze)",
-                "character": " (but can be overly critical)"
+                "profile": " (but can overthink things)",
+                "expectation": " (but can think too much)",
+                "character": " (but can be too picky)",
             },
             "green": {
-                "profile": " (but can be too rigid)",
-                "expectation": " (but may create bureaucracy)",
-                "character": " (but can resist change)"
+                "profile": " (but can be too strict)",
+                "expectation": " (but can make too many rules)",
+                "character": " (but can hate change)",
             },
             "red": {
-                "profile": " (but can be impulsive)",
-                "expectation": " (but may be controlling)",
-                "character": " (but can overlook details)"
+                "profile": " (but can act too fast)",
+                "expectation": " (but can be too bossy)",
+                "character": " (but can miss details)",
             },
             "yellow": {
-                "profile": " (but can be unrealistic)",
-                "expectation": " (but may lack follow-through)",
-                "character": " (but can be scattered)"
-            }
+                "profile": " (but can dream too much)",
+                "expectation": " (but can forget to finish)",
+                "character": " (but can be all over the place)",
+            },
         }
-        
+
         # Only add shadow aspects occasionally (30% chance) for variety
         if random.random() < 0.3:
             shadow = shadow_aspects[color][question_type]
-            # Ensure we don't exceed word limit
+            # Ensure we do not exceed word limit
             if len(base_text.split()) + len(shadow.split()) <= 15:
                 base_text += shadow
-        
-        options.append({
-            "text": base_text[:80],  # Limit length
-            "color": color
-        })
-    
-    return options
 
+        options.append(
+            {
+                "text": base_text[:80],  # Limit length
+                "color": color,
+            }
+        )
+
+    return options
 
 
+def get_book_based_options(
+    question_type: str, question_text: str
+) -> List[Dict]:
+    """
+    Return four options (one per color) for book-based mode.
 
+    For now this simply delegates to generate_category_specific_options so
+    that the function always exists and never raises NameError.
+    Later you can replace this logic to actually use Surrounded-by-Idiots
+    COLOR_EXAMPLES from faiss_service if you want.
+    """
+    return generate_category_specific_options(question_type, question_text, None, None)
 
 
-def generate_batch_questions(themes: List[str], state: Dict, context: str = "", previous_questions: List[str] = None) -> List[Dict]:
+def generate_batch_questions(
+    themes: List[str],
+    state: Dict,
+    context: str = "",
+    previous_questions: List[str] = None,
+) -> List[Dict]:
     # Extract ALL data from Marriage table
     profile = state.get("profile", {})
     user_id = profile.get("user_id")
-    
+
     try:
         from database import fetch_expectation_data
+
         expectation_data = fetch_expectation_data(user_id) if user_id else {}
     except ImportError:
         expectation_data = {}
-    
+
     # Extract ALL profile data from Marriage table
     profile_data = {
         # Personal Information
         "full_name": profile.get("full_name", "Not specified"),
-        
         "gender": profile.get("gender", "Not specified"),
         "current_city": profile.get("current_city", "Not specified"),
         "country": profile.get("country", "Not specified"),
         "marital_status": profile.get("marital_status", "Not specified"),
-        
         # Education & Career
         "education_level": profile.get("education_level", "Not specified"),
         "employment_status": profile.get("employment_status", "Not specified"),
@@ -377,23 +448,24 @@ def generate_batch_questions(themes: List[str], state: Dict, context: str = "",
         "career_aspirations": profile.get("career_aspirations", "Not specified"),
         "field_of_study": profile.get("field_of_study", "Not specified"),
         "income_range": profile.get("income_range", "Not specified"),
-        
         # Family & Background
         "number_of_siblings": profile.get("number_of_siblings", "Not specified"),
         "family_type": profile.get("family_type", "Not specified"),
         "siblings_position": profile.get("siblings_position", "Not specified"),
         "parents_living_status": profile.get("parents_living_status", "Not specified"),
         "live_with_parents": profile.get("live_with_parents", "Not specified"),
-        "support_parents_financially": profile.get("support_parents_financially", "Not specified"),
-        "family_communication_frequency": profile.get("family_communication_frequency", "Not specified"),
-        
+        "support_parents_financially": profile.get(
+            "support_parents_financially", "Not specified"
+        ),
+        "family_communication_frequency": profile.get(
+            "family_communication_frequency", "Not specified"
+        ),
         # Physical & Health
         "height": profile.get("height", "Not specified"),
         "skin_tone": profile.get("skin_tone", "Not specified"),
         "blood_group": profile.get("blood_group", "Not specified"),
         "health_constraints": profile.get("health_constraints", "Not specified"),
         "fitness_level": profile.get("fitness_level", "Not specified"),
-        
         # Lifestyle & Habits
         "hobbies_interests": str(profile.get("hobbies_interests", "Not specified")),
         "conflict_approach": profile.get("conflict_approach", "Not specified"),
@@ -405,26 +477,22 @@ def generate_batch_questions(themes: List[str], state: Dict, context: str = "",
         "own_pets": profile.get("own_pets", "Not specified"),
         "travel_preference": profile.get("travel_preference", "Not specified"),
         "relaxation_mode": profile.get("relaxation_mode", "Not specified"),
-        
         # Languages & Relocation
         "languages_spoken": profile.get("languages_spoken", "Not specified"),
         "relocation_willingness": profile.get("relocation_willingness", "Not specified"),
-        
         # Religion & Citizenship
         "religion": profile.get("religion", "Not specified"),
         "dual_citizenship": profile.get("dual_citizenship", "Not specified"),
-        
         # Relationship Preferences
         "children_timeline": profile.get("children_timeline", "Not specified"),
         "open_to_adoption": profile.get("open_to_adoption", "Not specified"),
         "deal_breakers": profile.get("deal_breakers", "Not specified"),
         "other_non_negotiables": profile.get("other_non_negotiables", "Not specified"),
         "live_with_inlaws": profile.get("live_with_inlaws", "Not specified"),
-        
         # Additional Info
         "remark": profile.get("remark", "Not specified"),
     }
-    
+
     # Extract ALL expectation data from ExpectationResponse table
     expectation_data_dict = {
         # Basic Preferences
@@ -433,75 +501,108 @@ def generate_batch_questions(themes: List[str], state: Dict, context: str = "",
         "pref_current_city": expectation_data.get("pref_current_city", "Not specified"),
         "pref_countries": expectation_data.get("pref_countries", "Not specified"),
         "pref_languages": expectation_data.get("pref_languages", "Not specified"),
-        "pref_education_level": expectation_data.get("pref_education_level", "Not specified"),
-        "pref_employment_status": expectation_data.get("pref_employment_status", "Not specified"),
-        
+        "pref_education_level": expectation_data.get(
+            "pref_education_level", "Not specified"
+        ),
+        "pref_employment_status": expectation_data.get(
+            "pref_employment_status", "Not specified"
+        ),
         # Health & Lifestyle
         "health_constraints": expectation_data.get("health_constraints", "Not specified"),
         "pref_diet": expectation_data.get("pref_diet", "Not specified"),
         "accept_smoking": expectation_data.get("accept_smoking", "Not specified"),
         "accept_alcohol": expectation_data.get("accept_alcohol", "Not specified"),
         "pref_fitness": expectation_data.get("pref_fitness", "Not specified"),
-        
         # Family & Living
         "pref_family_type": expectation_data.get("pref_family_type", "Not specified"),
         "live_with_inlaws": expectation_data.get("live_with_inlaws", "Not specified"),
         "children_timeline": expectation_data.get("children_timeline", "Not specified"),
         "open_to_adoption": expectation_data.get("open_to_adoption", "Not specified"),
-        "pref_live_with_parents": expectation_data.get("pref_live_with_parents", "Not specified"),
-        "financial_support_to_parents": expectation_data.get("financial_support_to_parents", "Not specified"),
-        
+        "pref_live_with_parents": expectation_data.get(
+            "pref_live_with_parents", "Not specified"
+        ),
+        "financial_support_to_parents": expectation_data.get(
+            "financial_support_to_parents", "Not specified"
+        ),
         # Conflict & Finance
-        "pref_conflict_approach": expectation_data.get("pref_conflict_approach", "Not specified"),
-        "pref_financial_style": expectation_data.get("pref_financial_style", "Not specified"),
+        "pref_conflict_approach": expectation_data.get(
+            "pref_conflict_approach", "Not specified"
+        ),
+        "pref_financial_style": expectation_data.get(
+            "pref_financial_style", "Not specified"
+        ),
         "pref_income_range": expectation_data.get("pref_income_range", "Not specified"),
-        
         # Values & Compatibility
-        "religion_alignment": expectation_data.get("religion_alignment", "Not specified"),
-        "pref_shared_hobbies": expectation_data.get("pref_shared_hobbies", "Not specified"),
+        "religion_alignment": expectation_data.get(
+            "religion_alignment", "Not specified"
+        ),
+        "pref_shared_hobbies": expectation_data.get(
+            "pref_shared_hobbies", "Not specified"
+        ),
         "travel_pref": expectation_data.get("travel_pref", "Not specified"),
         "pet_pref": expectation_data.get("pet_pref", "Not specified"),
-        
         # Career & Relocation
-        "pref_partner_relocation": expectation_data.get("pref_partner_relocation", "Not specified"),
-        "pref_career_aspirations": expectation_data.get("pref_career_aspirations", "Not specified"),
-        
+        "pref_partner_relocation": expectation_data.get(
+            "pref_partner_relocation", "Not specified"
+        ),
+        "pref_career_aspirations": expectation_data.get(
+            "pref_career_aspirations", "Not specified"
+        ),
         # Additional Preferences
         "marital_status": expectation_data.get("marital_status", "Not specified"),
         "skin_tone": expectation_data.get("skin_tone", "Not specified"),
         "daily_routine": expectation_data.get("daily_routine", "Not specified"),
-        "family_communication_frequency": expectation_data.get("family_communication_frequency", "Not specified"),
+        "family_communication_frequency": expectation_data.get(
+            "family_communication_frequency", "Not specified"
+        ),
         "relaxation_mode": expectation_data.get("relaxation_mode", "Not specified"),
-        
         # Non-negotiables
         "deal_breakers": expectation_data.get("deal_breakers", "Not specified"),
-        "other_non_negotiables": expectation_data.get("other_non_negotiables", "Not specified"),
-        
+        "other_non_negotiables": expectation_data.get(
+            "other_non_negotiables", "Not specified"
+        ),
         # Summary
         "expectation_summary": expectation_data.get("expectation_summary", "Not specified"),
         "_mandatory_fields": expectation_data.get("_mandatory_fields", "Not specified"),
     }
-    
+
+    # Check if we have book-based options
+    try:
+        from faiss_service import COLOR_EXAMPLES
+
+        use_book_options = COLOR_EXAMPLES is not None
+        if use_book_options:
+            print("Using book-based options from 'Surrounded by Idiots'")
+    except ImportError:
+        use_book_options = False
+
     if CHAIN_BATCH is not None and PARSER_BATCH is not None:
         try:
             items: List[Dict] = []
-            
+
             # 1. PROFILE-BASED QUESTIONS (5 questions) - Using ALL Marriage table columns
             profile_prompt = {
                 "state": json.dumps(state, ensure_ascii=False),
                 "themes_json": json.dumps(["profile"] * 5, ensure_ascii=False),
-                "previous_questions": json.dumps(previous_questions or [], ensure_ascii=False),
+                "previous_questions": json.dumps(
+                    previous_questions or [], ensure_ascii=False
+                ),
                 "format_instructions": PARSER_BATCH.get_format_instructions(),
                 "context": "Generate 5 PROFILE-BASED questions using ALL available user background information.",
                 "question_type": "profile",
-                
                 # Use ALL profile data
                 "education": f"{profile_data['education_level']} | {profile_data['field_of_study']}",
                 "employment": f"{profile_data['employment_status']} | {profile_data['job_role']} ({profile_data['work_experience_years']} years)",
-                "hobbies": profile_data['hobbies_interests'],
+                "hobbies": profile_data["hobbies_interests"],
                 "family_type": f"{profile_data['family_type']} | Siblings: {profile_data['number_of_siblings']} | Position: {profile_data['siblings_position']}",
-                "current_lifestyle": f"City: {profile_data['current_city']}, {profile_data['country']} | Height: {profile_data['height']} | Languages: {profile_data['languages_spoken']} | Religion: {profile_data['religion']} | Fitness: {profile_data['fitness_level']} | Diet: {profile_data['food_preference']} | Habits: Smoking: {profile_data['smoking_habit']}, Alcohol: {profile_data['alcohol_habit']}",
-                
+                "current_lifestyle": (
+                    "City: "
+                    f"{profile_data['current_city']}, {profile_data['country']} | "
+                    f"Height: {profile_data['height']} | Languages: {profile_data['languages_spoken']} | "
+                    f"Religion: {profile_data['religion']} | Fitness: {profile_data['fitness_level']} | "
+                    f"Diet: {profile_data['food_preference']} | Habits: Smoking: {profile_data['smoking_habit']}, "
+                    f"Alcohol: {profile_data['alcohol_habit']}"
+                ),
                 # Expectation data marked as irrelevant
                 "conflict_style": "IRRELEVANT_FOR_PROFILE_QUESTIONS",
                 "financial_style": "IRRELEVANT_FOR_PROFILE_QUESTIONS",
@@ -514,127 +615,211 @@ def generate_batch_questions(themes: List[str], state: Dict, context: str = "",
                 "ambition_pref": "IRRELEVANT_FOR_PROFILE_QUESTIONS",
                 "deal_breakers": "IRRELEVANT_FOR_PROFILE_QUESTIONS",
             }
-            
+
             result = CHAIN_BATCH.invoke(profile_prompt)
             profile_items = get_items_from_result(result)
-            
+
             for qa in profile_items[:5]:
                 out = qa.dict() if hasattr(qa, "dict") else dict(qa)
-                out["options"] = generate_category_specific_options(
-                    "profile", 
-                    out.get("question", ""),
-                    profile_data,
-                    None
+
+                # Get options from book if available
+                if use_book_options:
+                    options = get_book_based_options("profile", out.get("question", ""))
+                    if options and len(options) == 4:
+                        out["options"] = options
+                    else:
+                        # Fallback to generated options
+                        out["options"] = generate_category_specific_options(
+                            "profile", out.get("question", ""), profile_data, None
+                        )
+                else:
+                    out["options"] = generate_category_specific_options(
+                        "profile", out.get("question", ""), profile_data, None
+                    )
+
+                out["source"] = (
+                    "llm_profile_book" if use_book_options else "llm_profile"
                 )
-                out["source"] = "llm_profile"
                 out["question_type"] = "profile"
                 random.shuffle(out["options"])
                 items.append(out)
-            
+
             # 2. EXPECTATION-BASED QUESTIONS (5 questions) - Using ALL ExpectationResponse columns
             expectation_prompt = {
                 "state": json.dumps(state, ensure_ascii=False),
                 "themes_json": json.dumps(["expectation"] * 5, ensure_ascii=False),
-                "previous_questions": json.dumps([q["question"] for q in items] + (previous_questions or []), ensure_ascii=False),
+                "previous_questions": json.dumps(
+                    [q["question"] for q in items] + (previous_questions or []),
+                    ensure_ascii=False,
+                ),
                 "format_instructions": PARSER_BATCH.get_format_instructions(),
                 "context": "Generate 5 EXPECTATION-BASED questions using ALL relationship preferences and expectations.",
                 "question_type": "expectation",
-                
                 # Minimal profile context
                 "education": "Background context only",
                 "employment": "Background context only",
                 "hobbies": "Background context only",
                 "family_type": "Background context only",
                 "current_lifestyle": "General context",
-                
                 # Use ALL expectation data
                 "conflict_style": f"{expectation_data_dict['pref_conflict_approach']}",
-                "financial_style": f"{expectation_data_dict['pref_financial_style']} | Income: {expectation_data_dict['pref_income_range']}",
-                "income_range": expectation_data_dict['pref_income_range'],
-                "relocation_willingness": f"{expectation_data_dict['pref_partner_relocation']}",
-                "family_values": f"{expectation_data_dict['pref_family_type']} | Live with in-laws: {expectation_data_dict['live_with_inlaws']} | Children timeline: {expectation_data_dict['children_timeline']}",
-                "core_values": f"Religion: {expectation_data_dict['religion_alignment']} | Deal breakers: {expectation_data_dict['deal_breakers']}",
-                "lifestyle_pref": f"Fitness: {expectation_data_dict['pref_fitness']} | Diet: {expectation_data_dict['pref_diet']} | Daily routine: {expectation_data_dict['daily_routine']}",
-                "social_pref": f"Hobbies: {expectation_data_dict['pref_shared_hobbies']} | Travel: {expectation_data_dict['travel_pref']} | Pets: {expectation_data_dict['pet_pref']}",
-                "ambition_pref": f"Career: {expectation_data_dict['pref_career_aspirations']} | Education: {expectation_data_dict['pref_education_level']}",
-                "deal_breakers": f"{expectation_data_dict['deal_breakers']} | Other non-negotiables: {expectation_data_dict['other_non_negotiables']}",
+                "financial_style": (
+                    f"{expectation_data_dict['pref_financial_style']} | "
+                    f"Income: {expectation_data_dict['pref_income_range']}"
+                ),
+                "income_range": expectation_data_dict["pref_income_range"],
+                "relocation_willingness": (
+                    f"{expectation_data_dict['pref_partner_relocation']}"
+                ),
+                "family_values": (
+                    f"{expectation_data_dict['pref_family_type']} | "
+                    f"Live with in-laws: {expectation_data_dict['live_with_inlaws']} | "
+                    f"Children timeline: {expectation_data_dict['children_timeline']}"
+                ),
+                "core_values": (
+                    f"Religion: {expectation_data_dict['religion_alignment']} | "
+                    f"Deal breakers: {expectation_data_dict['deal_breakers']}"
+                ),
+                "lifestyle_pref": (
+                    f"Fitness: {expectation_data_dict['pref_fitness']} | "
+                    f"Diet: {expectation_data_dict['pref_diet']} | "
+                    f"Daily routine: {expectation_data_dict['daily_routine']}"
+                ),
+                "social_pref": (
+                    f"Hobbies: {expectation_data_dict['pref_shared_hobbies']} | "
+                    f"Travel: {expectation_data_dict['travel_pref']} | "
+                    f"Pets: {expectation_data_dict['pet_pref']}"
+                ),
+                "ambition_pref": (
+                    f"Career: {expectation_data_dict['pref_career_aspirations']} | "
+                    f"Education: {expectation_data_dict['pref_education_level']}"
+                ),
+                "deal_breakers": (
+                    f"{expectation_data_dict['deal_breakers']} | "
+                    f"Other non-negotiables: {expectation_data_dict['other_non_negotiables']}"
+                ),
             }
-            
+
             result = CHAIN_BATCH.invoke(expectation_prompt)
             expectation_items = get_items_from_result(result)
-            
+
             for qa in expectation_items[:5]:
                 out = qa.dict() if hasattr(qa, "dict") else dict(qa)
-                out["options"] = generate_category_specific_options(
-                    "expectation", 
-                    out.get("question", ""),
-                    None,
-                    expectation_data_dict
+
+                # Get options from book if available
+                if use_book_options:
+                    options = get_book_based_options("expectation", out.get("question", ""))
+                    if options and len(options) == 4:
+                        out["options"] = options
+                    else:
+                        out["options"] = generate_category_specific_options(
+                            "expectation",
+                            out.get("question", ""),
+                            None,
+                            expectation_data_dict,
+                        )
+                else:
+                    out["options"] = generate_category_specific_options(
+                        "expectation",
+                        out.get("question", ""),
+                        None,
+                        expectation_data_dict,
+                    )
+
+                out["source"] = (
+                    "llm_expectation_book" if use_book_options else "llm_expectation"
                 )
-                out["source"] = "llm_expectation"
                 out["question_type"] = "expectation"
                 random.shuffle(out["options"])
                 items.append(out)
-            
+
             # 3. CHARACTER-BASED QUESTIONS (10 questions) - Using data from BOTH tables
             character_prompt = {
                 "state": json.dumps(state, ensure_ascii=False),
                 "themes_json": json.dumps(themes[:10], ensure_ascii=False),
-                "previous_questions": json.dumps([q["question"] for q in items] + (previous_questions or []), ensure_ascii=False),
+                "previous_questions": json.dumps(
+                    [q["question"] for q in items] + (previous_questions or []),
+                    ensure_ascii=False,
+                ),
                 "format_instructions": PARSER_BATCH.get_format_instructions(),
-                "context": context[:2000] + "\n\nGenerate 10 CHARACTER-BASED questions using ALL available data.",
+                "context": context[:2000]
+                + "\n\nGenerate 10 CHARACTER-BASED questions using ALL available data.",
                 "question_type": "character",
-                
                 # All data from Marriage table
-                "education": profile_data['education_level'],
-                "employment": profile_data['employment_status'],
-                "hobbies": profile_data['hobbies_interests'],
-                "family_type": profile_data['family_type'],
-                "current_lifestyle": f"{profile_data['current_city']}, {profile_data['country']} | {profile_data['daily_routine']} | Relaxation: {profile_data['relaxation_mode']}",
-                
+                "education": profile_data["education_level"],
+                "employment": profile_data["employment_status"],
+                "hobbies": profile_data["hobbies_interests"],
+                "family_type": profile_data["family_type"],
+                "current_lifestyle": (
+                    f"{profile_data['current_city']}, {profile_data['country']} | "
+                    f"{profile_data['daily_routine']} | Relaxation: {profile_data['relaxation_mode']}"
+                ),
                 # All data from ExpectationResponse table
-                "conflict_style": expectation_data_dict['pref_conflict_approach'],
-                "financial_style": expectation_data_dict['pref_financial_style'],
-                "income_range": expectation_data_dict['pref_income_range'],
-                "relocation_willingness": expectation_data_dict['pref_partner_relocation'],
-                "family_values": expectation_data_dict['pref_family_type'],
-                "core_values": expectation_data_dict['religion_alignment'],
-                "lifestyle_pref": expectation_data_dict['pref_fitness'],
-                "social_pref": expectation_data_dict['pref_shared_hobbies'],
-                "ambition_pref": expectation_data_dict['pref_career_aspirations'],
-                "deal_breakers": expectation_data_dict['deal_breakers'],
+                "conflict_style": expectation_data_dict["pref_conflict_approach"],
+                "financial_style": expectation_data_dict["pref_financial_style"],
+                "income_range": expectation_data_dict["pref_income_range"],
+                "relocation_willingness": expectation_data_dict[
+                    "pref_partner_relocation"
+                ],
+                "family_values": expectation_data_dict["pref_family_type"],
+                "core_values": expectation_data_dict["religion_alignment"],
+                "lifestyle_pref": expectation_data_dict["pref_fitness"],
+                "social_pref": expectation_data_dict["pref_shared_hobbies"],
+                "ambition_pref": expectation_data_dict["pref_career_aspirations"],
+                "deal_breakers": expectation_data_dict["deal_breakers"],
             }
-            
+
             result = CHAIN_BATCH.invoke(character_prompt)
             character_items = get_items_from_result(result)
-            
+
             for qa in character_items[:10]:
                 out = qa.dict() if hasattr(qa, "dict") else dict(qa)
-                out["options"] = generate_category_specific_options(
-                    "character", 
-                    out.get("question", ""),
-                    profile_data,
-                    expectation_data_dict
+
+                # Get options from book if available
+                if use_book_options:
+                    options = get_book_based_options("character", out.get("question", ""))
+                    if options and len(options) == 4:
+                        out["options"] = options
+                    else:
+                        out["options"] = generate_category_specific_options(
+                            "character",
+                            out.get("question", ""),
+                            profile_data,
+                            expectation_data_dict,
+                        )
+                else:
+                    out["options"] = generate_category_specific_options(
+                        "character",
+                        out.get("question", ""),
+                        profile_data,
+                        expectation_data_dict,
+                    )
+
+                out["source"] = (
+                    "llm_character_book" if use_book_options else "llm_character"
                 )
-                out["source"] = "llm_character"
                 out["question_type"] = "character"
                 random.shuffle(out["options"])
                 items.append(out)
-            
+
             # Verify we have exactly 20 questions
             if len(items) == 20:
                 return items[:20]
             else:
-                # If LLM didn't generate enough, fill with fallback
-                return fill_missing_questions(items, themes, state, profile_data, expectation_data_dict, context)
-                
+                # If LLM did not generate enough, fill with fallback
+                return fill_missing_questions(
+                    items, themes, state, profile_data, expectation_data_dict, context
+                )
+
         except Exception as e:
             print("LLM batch generation failed:", e)
-            return generate_fallback_with_distribution(themes, state, profile_data, expectation_data_dict, context)
+            return generate_fallback_with_distribution(
+                themes, state, profile_data, expectation_data_dict, context
+            )
     else:
-        return generate_fallback_with_distribution(themes, state, profile_data, expectation_data_dict, context)
-
-
+        return generate_fallback_with_distribution(
+            themes, state, profile_data, expectation_data_dict, context
+        )
 
 
 def get_items_from_result(result):
@@ -646,92 +831,125 @@ def get_items_from_result(result):
     else:
         return []
 
-def fill_missing_questions(current_items: List[Dict], themes: List[str], state: Dict, 
-                          profile_data: Dict, expectation_data: Dict, context: str = "") -> List[Dict]:
+
+def fill_missing_questions(
+    current_items: List[Dict],
+    themes: List[str],
+    state: Dict,
+    profile_data: Dict,
+    expectation_data: Dict,
+    context: str = "",
+) -> List[Dict]:
     """Fill missing questions to reach 20 total"""
     items = current_items.copy()
-    
+
     # Count current distribution
     profile_count = sum(1 for q in items if q.get("question_type") == "profile")
     expectation_count = sum(1 for q in items if q.get("question_type") == "expectation")
     character_count = sum(1 for q in items if q.get("question_type") == "character")
-    
+
     # Fill profile questions if needed
     while profile_count < 5:
         profile_q = generate_profile_question(state, profile_data)
         items.append(profile_q)
         profile_count += 1
-    
+
     # Fill expectation questions if needed
     while expectation_count < 5:
         expectation_q = generate_expectation_question(state, expectation_data)
         items.append(expectation_q)
         expectation_count += 1
-    
+
     # Fill character questions if needed
     while character_count < 10:
         theme = themes[character_count % len(themes)] if themes else "daily situation"
         character_q = generate_character_question(theme, state)
         items.append(character_q)
         character_count += 1
-    
+
     return items[:20]
 
+
 def generate_profile_question(state: Dict, profile_data: Dict) -> Dict:
     """Generate a single profile question"""
     prof = state.get("profile", {})
     name = prof.get("full_name") or "Partner"
-    
+
     profile_topics = [
-        ("education", f"How does your educational background shape how you approach complex information?"),
-        ("employment", f"What methods from your professional life do you apply to personal challenges?"),
-        ("hobbies", f"How do your personal interests influence your approach to new experiences?"),
-        ("family", f"What communication patterns from your family background feel most natural to you?"),
-        ("background", f"How does your personal history affect your current decision-making style?")
+        (
+            "education",
+            "How does your education background shape how you approach complex information?",
+        ),
+        (
+            "employment",
+            "What methods from your work life do you use for personal challenges?",
+        ),
+        (
+            "hobbies",
+            "How do your hobbies change the way you try new experiences?",
+        ),
+        (
+            "family",
+            "What communication style from your family feels most natural to you?",
+        ),
+        (
+            "background",
+            "How does your personal history affect your current decision-making style?",
+        ),
     ]
-    
-    topic_idx = len([q for q in state.get("history", []) if q.get("question_type") == "profile"])
+
+    topic_idx = len(
+        [q for q in state.get("history", []) if q.get("question_type") == "profile"]
+    )
     if topic_idx >= len(profile_topics):
         topic_idx = 0
-    
+
     topic, question = profile_topics[topic_idx]
-    
+
     # Generate contextual options
     options = generate_category_specific_options("profile", question, profile_data, None)
     random.shuffle(options)
-    
+
     return {
         "question": question,
         "options": options,
         "source": "fallback_profile",
-        "question_type": "profile"
+        "question_type": "profile",
     }
 
+
 def generate_expectation_question(state: Dict, expectation_data: Dict) -> Dict:
     """Generate a single expectation question"""
     expectation_topics = [
-        ("conflict", f"When tensions arise, what's your instinctive approach to resolution?"),
-        ("values", f"How do your core principles guide your everyday choices?"),
-        ("finance", f"What mindset drives your approach to shared financial decisions?"),
-        ("balance", f"How do you navigate between personal needs and relationship commitments?"),
-        ("dealbreakers", f"What boundaries are non-negotiable for you in close relationships?")
+        (
+            "conflict",
+            "When tensions arise, what is your most natural way to handle them?",
+        ),
+        ("values", "How do your core principles guide your everyday choices?"),
+        ("finance", "What mindset guides your shared financial decisions?"),
+        ("balance", "How do you balance your needs with your partner's needs?"),
+        ("dealbreakers", "What personal boundaries feel completely non-negotiable to you?"),
     ]
-    
-    topic_idx = len([q for q in state.get("history", []) if q.get("question_type") == "expectation"])
+
+    topic_idx = len(
+        [q for q in state.get("history", []) if q.get("question_type") == "expectation"]
+    )
     if topic_idx >= len(expectation_topics):
         topic_idx = 0
-    
+
     topic, question = expectation_topics[topic_idx]
-    
+
     # Generate contextual options
-    options = generate_category_specific_options("expectation", question, None, expectation_data)
+    options = generate_category_specific_options(
+        "expectation", question, None, expectation_data
+    )
     random.shuffle(options)
-    
+
     return {
         "question": question,
         "options": options,
         "source": "fallback_expectation",
-        "question_type": "expectation"
+        "question_type": "expectation",
     }
 
 
@@ -739,108 +957,127 @@ def generate_character_question(theme: str, state: Dict) -> Dict:
     """Generate a single character question"""
     prof = state.get("profile", {})
     name = prof.get("full_name") or "Partner"
-    
+
     short_theme = theme.split(" around ")[-1].strip()[:50]
-    question = f"When {short_theme}, what's your typical response?"
-    
+    question = f"When {short_theme}, what is your typical response?"
+
     # Generate contextual options
     options = generate_category_specific_options("character", question, None, None)
     random.shuffle(options)
-    
+
     return {
         "question": question,
         "options": options,
         "source": "fallback_character",
-        "question_type": "character"
+        "question_type": "character",
     }
 
 
-
-
-def generate_fallback_with_distribution(themes: List[str], state: Dict, profile_data: Dict, expectation_data: Dict, context: str = "") -> List[Dict]:
+def generate_fallback_with_distribution(
+    themes: List[str],
+    state: Dict,
+    profile_data: Dict,
+    expectation_data: Dict,
+    context: str = "",
+) -> List[Dict]:
     """
-    Fallback generator that enforces the 5-5-10 distribution
+    Fallback generator that enforces the 5-5-10 distribution.
+
+    This version does NOT access missing keys like 'education' directly.
+    It uses generic wording so it never raises KeyError even if
+    profile_data or expectation_data is empty or partial.
     """
-    items = []
-    prof = state.get("profile", {}) or {}
-    name = prof.get("full_name") or "Partner"
-    
-    # 1. Generate 5 PROFILE-BASED questions
-    profile_sources = [
-        ("education", f"How does your {profile_data['education']} background influence your approach to learning new things?"),
-        ("employment", f"Given your work as {profile_data['employment']}, what problem-solving methods do you typically use?"),
-        ("hobbies", f"When engaging in {profile_data['hobbies']}, how do you typically organize your activity?"),
-        ("family_type", f"Growing up in a {profile_data['family_type']} family, what communication patterns feel most natural to you?"),
-        ("current_city", f"Living in {profile_data['current_city']}, how do you adapt to your daily environment?")
+    items: List[Dict] = []
+
+    # 1. Generate 5 PROFILE-BASED questions (generic but aligned with concept)
+    profile_questions = [
+        "How does your education background influence the way you learn new things?",
+        "How does your main work or job affect how you solve problems?",
+        "How do your hobbies or interests change the way you try new things?",
+        "How does your family background shape your way of talking and listening?",
+        "How does your living place and daily life affect your choices?",
     ]
-    
-    for source, question in profile_sources:
+
+    for q in profile_questions:
         opts = [
-            {"text": "Analyze data and research thoroughly before deciding", "color": "blue"},
-            {"text": "Create a structured plan and follow established procedures", "color": "green"},
-            {"text": "Take immediate action and coordinate with people involved", "color": "red"},
-            {"text": "Brainstorm creative approaches and explore possibilities", "color": "yellow"},
+            {"text": "Look at facts and think before deciding", "color": "blue"},
+            {"text": "Make a clear plan and follow it", "color": "green"},
+            {"text": "Act now and involve people", "color": "red"},
+            {"text": "Think of new and different ways", "color": "yellow"},
         ]
         random.shuffle(opts)
-        items.append({
-            "question": question,
-            "options": opts,
-            "source": "fallback_profile",
-            "question_type": "profile"
-        })
-    
-    # 2. Generate 5 EXPECTATION-BASED questions
-    expectation_sources = [
-        ("conflict_style", f"When facing disagreement ({expectation_data['conflict_style']}), how do you typically respond?"),
-        ("financial_style", f"Regarding money matters ({expectation_data['financial_style']}), what's your immediate reaction to financial decisions?"),
-        ("family_values", f"Considering your family values ({expectation_data['family_values']}), how do you approach family-related decisions?"),
-        ("work_life", f"With your work-life preference ({expectation_data['lifestyle_pref']}), how do you manage daily priorities?"),
-        ("deal_breakers", f"Given your deal breakers ({expectation_data['deal_breakers'][:50] if expectation_data['deal_breakers'] else 'certain boundaries'}), how do you establish personal limits?")
+        items.append(
+            {
+                "question": q,
+                "options": opts,
+                "source": "fallback_profile",
+                "question_type": "profile",
+            }
+        )
+
+    # 2. Generate 5 EXPECTATION-BASED questions (generic expectation focus)
+    expectation_questions = [
+        "When there is conflict in a relationship, what do you usually do first?",
+        "When you and your partner handle money, what feels most natural to you?",
+        "When your values and your partner's values differ, how do you respond?",
+        "How do you balance work, rest, and time with your partner?",
+        "When a personal boundary is close to being crossed, what do you usually do?",
     ]
-    
-    for source, question in expectation_sources:
+
+    for q in expectation_questions:
         opts = [
-            {"text": "Gather all relevant information and analyze carefully", "color": "blue"},
-            {"text": "Follow a systematic process to evaluate options", "color": "green"},
-            {"text": "Make a quick decision and implement immediately", "color": "red"},
-            {"text": "Consider innovative solutions and future possibilities", "color": "yellow"},
+            {"text": "Check all facts before reacting", "color": "blue"},
+            {"text": "Use a calm, step-by-step way", "color": "green"},
+            {"text": "Decide fast and take action", "color": "red"},
+            {"text": "Look for a new creative solution", "color": "yellow"},
         ]
         random.shuffle(opts)
-        items.append({
-            "question": question,
-            "options": opts,
-            "source": "fallback_expectation",
-            "question_type": "expectation"
-        })
-    
+        items.append(
+            {
+                "question": q,
+                "options": opts,
+                "source": "fallback_expectation",
+                "question_type": "expectation",
+            }
+        )
+
     # 3. Generate 10 CHARACTER-BASED questions from themes
-    for i, theme in enumerate(themes[:10]):  # Use first 10 themes
-        short = theme.split(" around ")[-1].strip()
+    for i, theme in enumerate(themes[:10] or ["daily situation"] * 10):
+        short = theme.split(" around ")[-1].strip() or "a daily situation"
         question = f"When dealing with {short}, what is your typical approach?"
-        
+
         opts = [
-            {"text": "Research facts and analyze details before acting", "color": "blue"},
-            {"text": "Develop a step-by-step plan and follow it", "color": "green"},
-            {"text": "Take charge and coordinate people to solve it", "color": "red"},
-            {"text": "Explore creative ideas and unconventional solutions", "color": "yellow"},
+            {"text": "Look at facts and details first", "color": "blue"},
+            {"text": "Make a step-by-step plan", "color": "green"},
+            {"text": "Take charge and move things forward", "color": "red"},
+            {"text": "Think of new and different ideas", "color": "yellow"},
         ]
         random.shuffle(opts)
-        items.append({
-            "question": question,
-            "options": opts,
-            "source": "fallback_character",
-            "question_type": "character"
-        })
-    
+        items.append(
+            {
+                "question": question,
+                "options": opts,
+                "source": "fallback_character",
+                "question_type": "character",
+            }
+        )
+
     # Ensure we have exactly 20 questions
     return items[:20]
 
 
 class SessionState:
-    def __init__(self, n_questions: int, batch_size: int, domain: str = "general", role: Optional[str] = None, profile: Optional[Dict] = None):
+    def __init__(
+        self,
+        n_questions: int,
+        batch_size: int,
+        domain: str = "general",
+        role: Optional[str] = None,
+        profile: Optional[Dict] = None,
+    ):
         domain = (domain or role or "general").lower()
         self.domain = domain if domain in DOMAINS else "general"
-        self.role = (role or self.domain)
+        self.role = role or self.domain
         self.profile = profile or {}
         self.n_questions = max(1, min(n_questions, MAX_QUESTIONS))
         self.batch_size = max(1, batch_size)
@@ -850,11 +1087,14 @@ class SessionState:
         self.queue: List[Dict] = []
         self.finished = False
         self.used_topics: List[str] = []
-        self.history_of_questions: List[str] = []  # Add this line to track question texts
+        # Track question texts, used by LLM prompt
+        self.history_of_questions: List[str] = []
 
     def to_min_state(self) -> Dict:
         total = sum(self.color_counts.values()) or 1
-        mix_percentages = {k: round((v / total) * 100, 2) for k, v in self.color_counts.items()}
+        mix_percentages = {
+            k: round((v / total) * 100, 2) for k, v in self.color_counts.items()
+        }
         dominant = max(self.color_counts, key=self.color_counts.get) if total else None
         return {
             "asked": self.asked,
@@ -868,10 +1108,12 @@ class SessionState:
     def remaining(self) -> int:
         return self.n_questions - self.asked
 
+
 SESSIONS_FILE = os.getenv("PYMATCH_SESSIONS_FILE", "sessions.json")
 _sessions_lock = threading.Lock()
 SESSIONS: Dict[str, SessionState] = {}
 
+
 def save_sessions():
     try:
         with _sessions_lock:
@@ -883,34 +1125,56 @@ def save_sessions():
     except Exception as e:
         print("Failed to save sessions:", e)
 
+
 def persist_final_progress(user_id: Optional[str], role: str, mix: Dict[str, float]) -> bool:
     from database import get_db_connection
     from config import PROGRESS_TBL
-    
+
     llm_id = str(uuid.uuid4())
-    blue   = float(mix.get("blue", 0.0))
-    green  = float(mix.get("green", 0.0))
+    blue = float(mix.get("blue", 0.0))
+    green = float(mix.get("green", 0.0))
     yellow = float(mix.get("yellow", 0.0))
-    red    = float(mix.get("red", 0.0))
+    red = float(mix.get("red", 0.0))
     try:
         conn = get_db_connection()
         cur = conn.cursor()
         # Try with llm_id; if identity error, retry without it
         try:
-            cur.execute(f"""
+            cur.execute(
+                f"""
                 INSERT INTO [dbo].[{PROGRESS_TBL}]
                   ([llm_id],[user_id],[role],[blue],[green],[yellow],[red],[created_at])
                 VALUES (?,?,?,?,?,?,?,SYSUTCDATETIME())
-            """, (llm_id, str(user_id) if user_id is not None else None, role, blue, green, yellow, red))
+            """,
+                (
+                    llm_id,
+                    str(user_id) if user_id is not None else None,
+                    role,
+                    blue,
+                    green,
+                    yellow,
+                    red,
+                ),
+            )
             conn.commit()
             return True
         except pyodbc.Error as e:
             if "IDENTITY_INSERT" in str(e) or "(544)" in str(e):
-                cur.execute(f"""
+                cur.execute(
+                    f"""
                     INSERT INTO [dbo].[{PROGRESS_TBL}]
                       ([user_id],[role],[blue],[green],[yellow],[red],[created_at])
                     VALUES (?,?,?,?,?,?,SYSUTCDATETIME())
-                """, (str(user_id) if user_id is not None else None, role, blue, green, yellow, red))
+                """,
+                    (
+                        str(user_id) if user_id is not None else None,
+                        role,
+                        blue,
+                        green,
+                        yellow,
+                        red,
+                    ),
+                )
                 conn.commit()
                 return True
             else:
@@ -920,29 +1184,38 @@ def persist_final_progress(user_id: Optional[str], role: str, mix: Dict[str, flo
         print("Persist final progress failed:", ex)
         return False
     finally:
-        try: conn.close()
-        except: pass
+        try:
+            conn.close()
+        except Exception:
+            pass
+
 
 def choose_themes(sess, k: int) -> List[str]:
-    """
-    Instead of generic topic banks, use FAISS to retrieve text chunks from the document.
-    """
+    """Choose k themes, preferably from FAISS TEXT_CHUNKS, else generic list."""
     try:
         from faiss_service import HAS_FAISS, FAISS_INDEX, TEXT_CHUNKS
-        
+
         if HAS_FAISS and FAISS_INDEX is not None and TEXT_CHUNKS:
             # Just grab k random chunks from the indexed document
             selected = random.sample(TEXT_CHUNKS, min(k, len(TEXT_CHUNKS)))
-            # Wrap them as "themes" but really they're just context
+            # Wrap them as "themes" but really they are just context text
             return selected
     except ImportError:
         pass
-    
+
     # fallback: use generic themes
     fallback_themes = [
-        "communication style", "conflict resolution", "decision making",
-        "problem solving", "team collaboration", "personal values",
-        "work habits", "social interaction", "stress management",
-        "goal setting", "time management", "relationship dynamics"
+        "communication style",
+        "conflict resolution",
+        "decision making",
+        "problem solving",
+        "team collaboration",
+        "personal values",
+        "work habits",
+        "social interaction",
+        "stress management",
+        "goal setting",
+        "time management",
+        "relationship dynamics",
     ]
-    return random.sample(fallback_themes, min(k, len(fallback_themes)))
+    return random.sample(fallback_themes, min(k, len(fallback_themes)))

routes/auth_routes.py

@@ -60,7 +60,7 @@ def get_db_connection():
 
     # Read settings from environment variables
     SQL_DRIVER = os.getenv("PYMATCH_SQL_DRIVER", "ODBC Driver 17 for SQL Server")
-    SQL_SERVER = os.getenv("PYMATCH_SQL_SERVER", r"localhost\sqlexpress")
+    SQL_SERVER = os.getenv("PYMATCH_SQL_SERVER", r"PYKARA")
     SQL_DB = os.getenv("PYMATCH_SQL_DB", "Py_Match")
     SQL_TRUSTED = os.getenv("PYMATCH_SQL_TRUSTED", "yes").lower()
 

routes/matching_routes.py

@@ -333,4 +333,101 @@ def unified_match(user_id=None):
             "matches": matches_by_range,
             "count": len(expectation_matches),
             "mode": "expectation"
-        })
+        })
+
+
+@matching_bp.get("/compatibility-explanation")
+def get_compatibility_explanation():
+    user_id = request.args.get("user_id", type=int)
+    target_user_id = request.args.get("target_user_id", type=int)
+    mode = request.args.get("mode", "expectation-only")
+
+    if not user_id or not target_user_id:
+        return jsonify({"error": "user_id and target_user_id are required"}), 400
+
+    try:
+        # TAB 1 → EXPECTATION ONLY (Rule-based)
+        if mode == "expectation-only":
+            exp_user = fetch_expectation_data(user_id)
+            profile_user = fetch_marriage_profile_data(target_user_id)
+
+            explanations = generate_expectation_explanation(exp_user, profile_user)
+
+            return jsonify({
+                "mode": "expectation-only",
+                "explanations": explanations,
+                "source": "expectation-fallback"
+            })
+
+        # TAB 2 → CHARACTER ONLY (LLM-ONLY)
+        elif mode == "character":
+            llm1 = LLMGeneratedQuestions.query.filter_by(user_id=user_id).first()
+            llm2 = LLMGeneratedQuestions.query.filter_by(user_id=target_user_id).first()
+
+            if not (llm1 and llm2):
+                return jsonify({
+                    "mode": "character",
+                    "explanations": [
+                        "Character analysis unavailable - no personality data found for one or both users."
+                    ],
+                    "source": "error"
+                })
+
+            u_vec = llm1.color_vec()
+            v_vec = llm2.color_vec()
+
+            print(f"🎯 Generating AI character analysis for users {user_id} and {target_user_id}...")
+            character_explanations = generate_character_llm_explanation(u_vec, v_vec)
+
+            return jsonify({
+                "mode": "character",
+                "explanations": character_explanations,
+                "source": "character-llm"
+            })
+
+        # TAB 3 → EXPECTATION + CHARACTER (Mixed)
+        elif mode == "expectation":
+            exp_user = fetch_expectation_data(user_id)
+            profile_user = fetch_marriage_profile_data(target_user_id)
+
+            expectation_part = generate_expectation_explanation(exp_user, profile_user)
+
+            llm1 = LLMGeneratedQuestions.query.filter_by(user_id=user_id).first()
+            llm2 = LLMGeneratedQuestions.query.filter_by(user_id=target_user_id).first()
+
+            character_explanations = []
+            if llm1 and llm2:
+                try:
+                    u_vec = llm1.color_vec()
+                    v_vec = llm2.color_vec()
+                    character_explanations = generate_character_llm_explanation(u_vec, v_vec)
+                    source_type = "character-llm"
+                except Exception as e:
+                    print(f"🔴 LLM failed, using backend fallback: {e}")
+                    character_explanations = generate_character_fallback_explanation(u_vec, v_vec)
+                    source_type = "character-fallback"
+            else:
+                character_explanations = ["Character analysis unavailable for this user."]
+                source_type = "error"
+
+            final_output = expectation_part + ["", "🧠 **AI Character Insights**"] + character_explanations
+
+            return jsonify({
+                "mode": "expectation",
+                "explanations": final_output,
+                "source": source_type
+            })
+
+        else:
+            return jsonify({"error": "Invalid mode"}), 400
+
+    except Exception as e:
+        print(f"🔴 Error in compatibility explanation: {e}")
+        return jsonify({
+            "explanations": [f"❌ Service temporarily unavailable: {str(e)}"],
+            "source": "error"
+        }), 500
+
+
+
+