deploy

.gitignore

@@ -0,0 +1,113 @@
+# -----------------------
+# Python / Flask basics
+# -----------------------
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual envs
+.venv/
+venv/
+env/
+ENV/
+
+# Build / packaging
+build/
+dist/
+*.egg-info/
+.eggs/
+pip-wheel-metadata/
+
+# Testing / coverage
+.pytest_cache/
+pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+.tox/
+
+# Type checkers / linters (optional but handy)
+.mypy_cache/
+.dmypy.json
+.pytype/
+.ruff_cache/
+
+# Jupyter
+.ipynb_checkpoints/
+*.ipynb  # ignore notebooks unless you intend to track them
+
+# Logs & PIDs
+logs/
+*.log
+*.log.*
+*.pid
+
+# OS-specific
+.DS_Store
+Thumbs.db
+
+# IDE / Editor
+.vscode/
+.idea/
+*.iml
+*.code-workspace
+
+# -----------------------
+# App-specific
+# -----------------------
+
+# Local environment files (keep examples if you want)
+.env
+.env.*
+!.env.example
+
+# Credentials / keys (VERY IMPORTANT)
+*.pem
+*.p12
+*.key
+*.crt
+*.cer
+*.der
+*.pfx
+*.enc
+*service-account*.json
+*credentials*.json
+*credential*.json
+*-sa.json
+*secret*.json
+learnenglish-ai-*.json
+gcloud*.json
+
+# Runtime/state files
+sessions.json
+*.sqlite
+*.sqlite3
+*.db
+*.bak
+*.sql
+*.csv
+*.tsv
+*.parquet
+
+# Media / generated assets
+static/videos/
+static/audio/
+static/transcripts/
+uploads/
+tmp/
+temp/
+*.tmp
+
+# MoviePy / temp renders
+*.moviepy_temp*
+
+# -----------------------
+# Optional (Docker / Node)
+# -----------------------
+docker-compose.override.yml
+*.local.yml
+
+node_modules/
+npm-debug.log*
+yarn-error.log*
+pnpm-debug.log*

Dockerfile

@@ -0,0 +1,30 @@
+# Minimal Dockerfile for Flask app on Hugging Face Spaces (no DB/ODBC bits)
+
+FROM python:3.11-slim
+
+# Avoid interactive prompts
+ENV DEBIAN_FRONTEND=noninteractive
+
+# (Optional) system tools you may want; safe to keep
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl ca-certificates \
+ && rm -rf /var/lib/apt/lists/*
+
+# Workdir
+WORKDIR /app
+
+# Install Python deps
+COPY requirements.txt /app/
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy app
+COPY server.py /app/
+
+# HF injects PORT; default for local run
+ENV PORT=7860
+
+# Expose for clarity (optional)
+EXPOSE 7860
+
+# Start the app
+CMD ["python", "server.py"]

requirements.txt

@@ -0,0 +1,6 @@
+flask==3.0.3
+flask-cors==4.0.1
+pyodbc==5.1.0
+pydantic==2.8.2
+langchain-core==0.2.38
+langchain-openai==0.2.3

server.py

@@ -0,0 +1,658 @@
+# server.py
+import os, uuid, json, random, threading, hashlib
+from typing import Dict, List, Optional, Literal
+from datetime import datetime
+
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import pyodbc
+
+# ---------- Optional LLM deps (fallback if missing) ----------
+try:
+    from pydantic import BaseModel, Field
+    from langchain_core.prompts import ChatPromptTemplate
+    from langchain_core.output_parsers import PydanticOutputParser
+    from langchain_openai import ChatOpenAI
+    HAS_LLM_STACK = True
+except Exception:
+    HAS_LLM_STACK = False
+
+# ==============================
+# Configuration / DB Connection
+# ==============================
+SQL_DRIVER   = os.getenv("PYMATCH_SQL_DRIVER", "{SQL Server}")
+SQL_SERVER   = os.getenv("PYMATCH_SQL_SERVER", "localhost\SQLEXPRESS")
+SQL_DB       = os.getenv("PYMATCH_SQL_DB", "PyMatch")
+SQL_TRUSTED  = os.getenv("PYMATCH_SQL_TRUSTED", "yes")  # yes/no
+
+PROGRESS_TBL = os.getenv("PYMATCH_PROGRESS_TABLE", "LLMGeneratedQuestions")
+
+def get_db_connection():
+    return pyodbc.connect(
+        f"DRIVER={SQL_DRIVER};"
+        f"SERVER={SQL_SERVER};"
+        f"DATABASE={SQL_DB};"
+        f"Trusted_Connection={SQL_TRUSTED};"
+    )
+
+# ==========
+# Flask App
+# ==========
+app = Flask(__name__)
+CORS(app, resources={r"/*": {"origins": "*"}})
+
+# ==========
+# Utilities
+# ==========
+def hash_password(password: str) -> str:
+    return hashlib.sha256(password.encode("utf-8")).hexdigest()
+
+def row_to_dict(cursor, row) -> Dict:
+    if row is None:
+        return {}
+    cols = [col[0] for col in cursor.description]
+    return {cols[i]: row[i] for i in range(len(cols))}
+
+# =======================
+# 1) AUTH / SIGNUP (auth)
+# =======================
+@app.post("/api/signup")
+def signup():
+    data = request.get_json(force=True) or {}
+    name = data.get("name")
+    email = data.get("email")
+    password = data.get("password")
+
+    if not name or not email or not password:
+        return jsonify({"error": "Name, email, and password are required."}), 400
+
+    password_hash = hash_password(password)
+
+    try:
+        conn = get_db_connection()
+        cur = conn.cursor()
+        cur.execute("""
+            INSERT INTO Users (name, email, password)
+            VALUES (?, ?, ?)
+        """, (name, email, password_hash))
+        conn.commit()
+        return jsonify({"message": "User created successfully."}), 201
+    except pyodbc.Error as e:
+        return jsonify({"error": f"DB error: {e}"}), 500
+    finally:
+        try: conn.close()
+        except: pass
+
+# ==================================================
+# 2) ROLE SELECTION + STATIC QUESTION FETCH + SAVE
+#    (from app.py)
+# ==================================================
+@app.post("/api/questions/select-role")
+def select_role():
+    data = request.get_json(force=True) or {}
+    user_id   = data.get("user_id")
+    role_name = data.get("role_name")
+    assigned_at = data.get("assigned_at")  # ISO or None
+
+    if not user_id or not role_name:
+        return jsonify({"error": "User ID and role name are required."}), 400
+
+    try:
+        conn = get_db_connection()
+        cur = conn.cursor()
+        cur.execute("""
+            INSERT INTO UserRoles (user_id, role_name, assigned_at)
+            VALUES (?, ?, ?)
+        """, (user_id, role_name, assigned_at))
+        conn.commit()
+        return jsonify({"message": "Role assigned successfully."}), 201
+    except pyodbc.Error as e:
+        return jsonify({"error": str(e)}), 500
+    finally:
+        try: conn.close()
+        except: pass
+
+@app.get("/api/questions/<role>")
+def get_questions(role):
+    if role not in ["marriage", "interview", "partnership"]:
+        return jsonify({"error": "Invalid role"}), 400
+
+    try:
+        conn = get_db_connection()
+        cur = conn.cursor()
+        cur.execute("""
+            SELECT question, options, input_type, column_key
+            FROM RoleQuestions
+            WHERE role_name = ?
+            ORDER BY id
+        """, (role,))
+        rows = cur.fetchall()
+        out = []
+        for r in rows:
+            label = r[0]
+            options = (r[1].split(",") if r[1] else [])
+            input_type = r[2]
+            column_key = r[3]
+            out.append({
+                "label": label,
+                "options": options,
+                "input_type": input_type,
+                "column_key": column_key
+            })
+        return jsonify(out), 200
+    except pyodbc.Error as e:
+        return jsonify({"error": str(e)}), 500
+    finally:
+        try: conn.close()
+        except: pass
+
+@app.post("/api/questions/submit-answers/<role>")
+def submit_answers(role):
+    data = request.get_json(force=True) or {}
+    user_id = data.get("user_id")
+    if not user_id:
+        return jsonify({"error": "User ID is required."}), 400
+
+    role_fields = {
+        "marriage": [
+            "full_name","date_of_birth","age_range","gender","current_city_country","marital_status",
+            "education_level","employment_status","number_of_siblings","family_type","hobbies_interests",
+            "conflict_approach","financial_style","income_range","relocation_willingness","created_at"
+        ],
+        "interview": [
+            "full_name","date_of_birth","gender","current_location","target_role_title",
+            "seniority_level","total_experience_years","key_skills","highest_education_level",
+            "work_location_preference","expected_salary_range","team_size_experience",
+            "leadership_experience_years","employment_type_preference","willingness_to_relocate","created_at"
+        ],
+        "partnership": [
+            "full_name","date_of_birth","gender","current_location","current_profession_business",
+            "years_of_experience_in_industry","business_domain","business_size","roles_you_offer",
+            "roles_expected_from_partner","time_commitment_per_week","partnership_structure_preference",
+            "prior_partnership_experience","decision_making_style","risk_appetite","created_at"
+        ]
+    }
+    if role not in role_fields:
+        return jsonify({"error": "Invalid role."}), 400
+
+    for f in role_fields[role]:
+        if f not in data:
+            return jsonify({"error": f"{f} is required."}), 400
+
+    table_name = {
+        "marriage": "Marriage",
+        "interview": "Interview",
+        "partnership": "Partnership"
+    }[role]
+
+    placeholders = ", ".join(["?"] * (len(role_fields[role]) + 1))
+    query = f"INSERT INTO {table_name} (user_id, {', '.join(role_fields[role])}) VALUES ({placeholders})"
+    values = [user_id] + [data[f] for f in role_fields[role]]
+
+    try:
+        conn = get_db_connection()
+        cur = conn.cursor()
+        cur.execute(query, values)
+        conn.commit()
+        return jsonify({"message": f"{role.capitalize()} record added successfully."}), 201
+    except pyodbc.Error as e:
+        return jsonify({"error": str(e)}), 500
+    finally:
+        try: conn.close()
+        except: pass
+
+# ===========================================
+# 3) LLM BATCH Q-GEN + COLOR % PERSIST (LLM)
+# ===========================================
+COLOR_KEYS = ["blue", "green", "red", "yellow"]
+DOMAINS = ["general","marriage","interview","partnership","team","ceo","assistant"]
+
+TOPIC_BANK_BY_DOMAIN = {
+    "general":     ["team project deadline","budget overrun","new product idea","customer complaint","ambiguous requirements","unexpected risk","weekend planning","office relocation","time conflict","hiring a teammate","learning a new tool","meeting preparation"],
+    "marriage":    ["household budget plan","holiday travel decision","child's school choice","conflict about chores","time with in-laws","health and fitness routine","weekend family schedule","saving vs spending debate","home renovation plan","vacation destination"],
+    "interview":   ["role requirement clarity","skill gap discussion","offer negotiation","portfolio review","coding challenge approach","stakeholder communication","deadline pressure scenario","ambiguity in task","peer collaboration","culture add vs fit"],
+    "partnership": ["profit sharing plan","conflict resolution policy","market expansion idea","operating cadence","risk management","hiring first employee","brand positioning","cashflow crunch","vendor selection","equity vesting scheme"],
+    "team":        ["sprint planning","retrospective outcomes","cross-team dependency","onboarding a new hire","resource reallocation","release checklist","incident postmortem","documentation debt","stand-up time change","QA escape defect"],
+    "ceo":         ["board meeting prep","fundraising strategy","executive hiring plan","product pivot decision","crisis PR briefing","M&A target review","runway and burn trade-off","OKR reset","market entry analysis","high-churn quarter response"],
+    "assistant":   ["calendar conflicts","travel itinerary","email triage and drafting","vendor coordination","expense report backlog","event logistics","visitor gatekeeping","task prioritization","confidential document handling","household maintenance scheduling"],
+}
+COLOR_PHRASES_BY_DOMAIN = {
+    "general":     {"blue":"numbers-heavy decision","green":"process and scheduling","red":"people and action","yellow":"new ideas and ambiguity"},
+    "marriage":    {"blue":"evidence-based family decision","green":"routine and planning at home","red":"direct discussion and action","yellow":"creative family options"},
+    "interview":   {"blue":"evidence-based hiring decision","green":"process for structured evaluation","red":"decisive selection and expectation setting","yellow":"creative role fit and growth potential"},
+    "partnership": {"blue":"data-driven partnership choice","green":"operating process and governance","red":"stakeholder alignment and action plan","yellow":"vision and new market ideas"},
+    "team":        {"blue":"metric-driven team choice","green":"structured workflow and checklist","red":"alignment and decisive action","yellow":"brainstorming and experimentation"},
+    "ceo":         {"blue":"data-informed strategic choice","green":"operating cadence and process","red":"leadership move with stakeholders","yellow":"vision and bold direction"},
+    "assistant":   {"blue":"fact-checked admin decision","green":"organized logistics and sequencing","red":"proactive stakeholder handling","yellow":"flexible options and ideas"},
+}
+MAX_QUESTIONS = int(os.getenv("PYMATCH_MAX_QUESTIONS", "50"))
+DEFAULT_BATCH_SIZE = int(os.getenv("PYMATCH_BATCH_SIZE", "10"))
+
+# ---- LLM chain (optional) ----
+PARSER_BATCH = None
+CHAIN_BATCH = None
+if HAS_LLM_STACK and os.getenv("OPENAI_API_KEY"):
+    class Option(BaseModel):
+        text: str
+        color: Literal["blue","green","red","yellow"]
+
+    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 short situational questions to reveal four colors:\n"
+        "- blue=analytical, data-driven\n- green=organized, process-oriented\n"
+        "- red=decisive, action & people\n- yellow=creative, big-picture\n"
+        "Rules:\n"
+        "1) STRICT JSON only, matching the schema.\n"
+        "2) <=20 words for the question; <=12 words per option.\n"
+        "3) Exactly one option for each color.\n"
+        "4) Simple English. No personal data.\n"
+        "Output must be valid JSON."
+    )
+    USER_PROMPT_BATCH = (
+        "User state (JSON): {state}\n"
+        "Themes (array of short strings): {themes_json}\n\n"
+        "{format_instructions}\n\n"
+        "Write ONE question per theme. The number of items must equal the number of themes."
+    )
+    PARSER_BATCH = PydanticOutputParser(pydantic_object=BatchQA)
+
+    def build_batch_chain():
+        llm = ChatOpenAI(
+            model="gpt-4o-mini",
+            temperature=0.7,
+            max_retries=2,
+            timeout=30,
+            model_kwargs={"response_format": {"type": "json_object"}},
+        )
+        prompt = ChatPromptTemplate.from_messages([
+            ("system", SYSTEM_PROMPT),
+            ("user", USER_PROMPT_BATCH),
+        ])
+        # prompt | llm | parser  => RunnableSequence (no .right attribute)
+        return prompt | llm | PARSER_BATCH
+
+    CHAIN_BATCH = build_batch_chain()
+
+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",
+    }
+    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})
+    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:
+    keys_in_priority = [
+        "age_range","current_city_country","values","goals","communication_style",
+        "conflict_approach","financial_style","target_role_title","seniority_level",
+        "total_experience_years","skills","preferred_industries","work_location_preference",
+        "business_domain","venture_stage","roles_you_offer","roles_expected_from_partner",
+        "risk_appetite","decision_making_style","reporting_cadence","user_id"
+    ]
+    out = {}
+    for k in keys_in_priority:
+        if k in profile and profile[k] not in (None, "", []):
+            out[k] = profile[k]
+    return out
+
+def offline_generate_batch(themes: List[str], state: Dict) -> List[Dict]:
+    role = state.get("role", "general")
+    prof = state.get("profile", {}) or {}
+    hint = prof.get("target_role_title") or prof.get("business_domain") or prof.get("values") or ""
+    hint_text = f" ({hint})" if isinstance(hint, str) and hint else ""
+    items = []
+    for theme in themes:
+        q = f"For {role}{hint_text}: in a {theme}, what do you do first?"
+        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"},
+        ]
+        random.shuffle(opts)
+        items.append({"question": q, "options": opts, "source": "fallback"})
+    return items
+
+def generate_batch_questions(themes: List[str], state: Dict) -> List[Dict]:
+    # Try LLM path first
+    if CHAIN_BATCH is not None and PARSER_BATCH is not None:
+        try:
+            payload = {
+                "state": json.dumps(state, ensure_ascii=False),
+                "themes_json": json.dumps(themes, ensure_ascii=False),
+                "format_instructions": PARSER_BATCH.get_format_instructions(),
+            }
+            # CHAIN_BATCH = prompt | llm | PARSER_BATCH  -> returns parsed object (BatchQA or dict)
+            result = CHAIN_BATCH.invoke(payload)
+
+            if hasattr(result, "items"):
+                items_raw = result.items  # Pydantic BatchQA.items
+            elif isinstance(result, dict) and "items" in result:
+                items_raw = result["items"]
+            else:
+                items_raw = []
+
+            items: List[Dict] = []
+            for qa in items_raw:
+                out = qa.dict() if hasattr(qa, "dict") else dict(qa)
+                out["options"] = ensure_valid_colors(out.get("options", []))
+                out["source"] = "llm"
+                items.append(out)
+
+            if items:
+                return items
+        except Exception as e:
+            print("LLM batch generation failed:", e)
+
+    # Fallback generator (always returns items if themes not empty)
+    return offline_generate_batch(themes, state)
+
+class SessionState:
+    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.profile = profile or {}
+        self.n_questions = max(1, min(n_questions, MAX_QUESTIONS))
+        self.batch_size = max(1, batch_size)
+        self.asked = 0
+        self.color_counts = {c: 0 for c in COLOR_KEYS}
+        self.history: List[Dict] = []
+        self.queue: List[Dict] = []
+        self.finished = False
+
+    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()}
+        dominant = max(self.color_counts, key=self.color_counts.get) if total else None
+        return {
+            "asked": self.asked,
+            "dominant": dominant,
+            "mix": mix_percentages,
+            "domain": self.domain,
+            "role": self.role,
+            "profile": summarize_profile(self.profile),
+        }
+
+    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:
+            serializable = {sid: s.__dict__ for sid, s in SESSIONS.items()}
+            tmp = SESSIONS_FILE + ".tmp"
+            with open(tmp, "w", encoding="utf-8") as f:
+                json.dump(serializable, f, ensure_ascii=False, indent=2, default=str)
+            os.replace(tmp, SESSIONS_FILE)
+    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:
+    llm_id = str(uuid.uuid4())
+    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))
+    try:
+        conn = get_db_connection()
+        cur = conn.cursor()
+        # Try with llm_id; if identity error, retry without it
+        try:
+            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))
+            conn.commit()
+            return True
+        except pyodbc.Error as e:
+            if "IDENTITY_INSERT" in str(e) or "(544)" in str(e):
+                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))
+                conn.commit()
+                return True
+            else:
+                print("Persist failed:", e)
+                return False
+    except Exception as ex:
+        print("Persist final progress failed:", ex)
+        return False
+    finally:
+        try: conn.close()
+        except: pass
+
+# -------------------------
+# Profile fetch by role/id
+# -------------------------
+def fetch_profile_for_role(user_id: str, role: str) -> Dict:
+    """
+    Reads the correct table based on role and returns a dict of the latest row for that user.
+    Tables: Marriage | Interview | Partnership
+    """
+    table = {
+        "marriage": "Marriage",
+        "interview": "Interview",
+        "partnership": "Partnership"
+    }.get(role.lower())
+
+    if not table:
+        return {}
+
+    try:
+        conn = get_db_connection()
+        cur = conn.cursor()
+        # Prefer latest by created_at if present
+        cur.execute(f"""
+            SELECT TOP 1 *
+            FROM {table}
+            WHERE user_id = ?
+            ORDER BY created_at DESC
+        """, (user_id,))
+        row = cur.fetchone()
+        if row is None:
+            return {}
+        prof = row_to_dict(cur, row)
+        # Normalize hobbies_interests if it exists
+        if "hobbies_interests" in prof and isinstance(prof["hobbies_interests"], str):
+            if prof["hobbies_interests"].strip().startswith("["):
+                try:
+                    prof["hobbies_interests"] = json.loads(prof["hobbies_interests"])
+                except Exception:
+                    prof["hobbies_interests"] = [s.strip() for s in prof["hobbies_interests"].split(",") if s.strip()]
+            else:
+                prof["hobbies_interests"] = [s.strip() for s in prof["hobbies_interests"].split(",") if s.strip()]
+        prof["user_id"] = str(user_id)
+        return prof
+    except pyodbc.Error as e:
+        print("Profile fetch error:", e)
+        return {}
+    finally:
+        try: conn.close()
+        except: pass
+
+# -------------------
+# Theme chooser
+# -------------------
+def choose_themes(sess: SessionState, k: int) -> List[str]:
+    topics = TOPIC_BANK_BY_DOMAIN.get(sess.role, TOPIC_BANK_BY_DOMAIN["general"])
+    phrases = COLOR_PHRASES_BY_DOMAIN.get(sess.role, COLOR_PHRASES_BY_DOMAIN["general"])
+    themes: List[str] = []
+    for _ in range(k):
+        # bias to least-chosen color to balance
+        target = min(sess.color_counts, key=lambda c: sess.color_counts[c])
+        topic = random.choice(topics)
+        phrase = phrases[target]
+        themes.append(f"{phrase} around {topic}")
+    return themes
+
+# ---------------
+# Health / Home
+# ---------------
+@app.get("/health")
+def health():
+    return {
+        "status": "ok",
+        "llm": ("openai" if CHAIN_BATCH is not None else "offline-fallback"),
+        "has_openai_key": bool(os.getenv("OPENAI_API_KEY")),
+        "db": {"server": SQL_SERVER, "database": SQL_DB, "table": PROGRESS_TBL},
+    }
+
+@app.get("/")
+def home():
+    return {
+        "message": "Unified Py-Match Service",
+        "try": [
+            "POST /api/signup",
+            "POST /api/questions/select-role",
+            "GET  /api/questions/<role>",
+            "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 })"
+        ]
+    }
+
+# -------------------------
+# LLM Session: start / next
+# -------------------------
+@app.post("/llm/start")
+def llm_start():
+    """
+    Starts a session by fetching the profile for (user_id, role),
+    then generating the first question batch. No need to send profile in body.
+    Body:
+      { "user_id": "1", "role": "marriage", "n_questions": 5, "batch_size": 5 }
+    """
+    data = request.get_json(force=True) or {}
+    user_id = str(data.get("user_id") or "").strip()
+    role_in = (data.get("role") or "general").lower()
+    n_req   = int(data.get("n_questions", 15))
+    b_req   = int(data.get("batch_size", DEFAULT_BATCH_SIZE))
+
+    if not user_id:
+        return jsonify({"error": "user_id is required"}), 400
+    if role_in not in DOMAINS:
+        return jsonify({"error": f"Invalid role. Allowed: {', '.join(DOMAINS)}"}), 400
+
+    # Fetch profile from the correct table based on role
+    profile = fetch_profile_for_role(user_id, role_in)
+
+    # Create session
+    sid = str(uuid.uuid4())
+    sess = SessionState(n_questions=n_req, batch_size=b_req, domain=role_in, role=role_in, profile=profile)
+    SESSIONS[sid] = sess
+
+    to_generate = min(sess.batch_size, sess.remaining())
+    themes = choose_themes(sess, to_generate)
+    queue = generate_batch_questions(themes, sess.to_min_state())
+    if not queue:
+        return jsonify({"error": "Question generation failed"}), 500
+    sess.queue = queue
+
+    # Serve first question
+    first = sess.queue.pop(0)
+    sess.asked += 1
+    save_sessions()
+
+    return jsonify({
+        "session_id": sid,
+        "index": 1,
+        "total": sess.n_questions,
+        "question": first["question"],
+        "options": first["options"],
+        "source": first.get("source", "unknown"),
+        "role": sess.role,
+        "profile_used": bool(profile)  # helpful flag
+    })
+
+@app.post("/llm/next")
+def llm_next():
+    """
+    Continue a running session with user's selected color.
+    Body:
+      { "session_id": "...", "selected_color": "blue|green|red|yellow" }
+    """
+    data = request.get_json(force=True) or {}
+    sid = data.get("session_id")
+    color = str(data.get("selected_color") or "").lower()
+
+    if not sid or sid not in SESSIONS:
+        return jsonify({"error": "Invalid or missing session_id"}), 400
+    if color not in COLOR_KEYS:
+        return jsonify({"error": "selected_color must be blue|green|red|yellow"}), 400
+
+    sess = SESSIONS[sid]
+    if sess.finished:
+        return jsonify({"done": True, "message": "Session already finished."})
+
+    # record answer
+    sess.color_counts[color] += 1
+    sess.history.append({"selected_color": color})
+
+    # finished?
+    if sess.asked >= sess.n_questions:
+        sess.finished = True
+        mix = sess.to_min_state()["mix"]
+        user_id = (sess.profile or {}).get("user_id")
+        db_ok = persist_final_progress(user_id=user_id, role=sess.role, mix=mix)
+        save_sessions()
+        return jsonify({"done": True, "message": "No more questions.", "mix": mix, "db_write": "ok" if db_ok else "failed"})
+
+    # ensure queue; refill if needed
+    if not sess.queue:
+        to_generate = min(sess.batch_size, sess.remaining())
+        themes = choose_themes(sess, to_generate)
+        sess.queue = generate_batch_questions(themes, sess.to_min_state())
+        if not sess.queue:
+            return jsonify({"error": "Question generation failed"}), 500
+
+    nxt = sess.queue.pop(0)
+    sess.asked += 1
+    save_sessions()
+
+    return jsonify({
+        "session_id": sid,
+        "index": sess.asked,
+        "total": sess.n_questions,
+        "question": nxt["question"],
+        "options": nxt["options"],
+        "progress": sess.to_min_state()["mix"],
+        "source": nxt.get("source", "unknown"),
+        "role": sess.role
+    })
+
+# =========
+# Run app
+# =========
+# if __name__ == "__main__":
+#     app.run(host="0.0.0.0", port=5000, debug=True)
+
+if __name__ == "__main__":
+    import os
+    # Default to 5000 for local runs; HF Spaces injects PORT=7860 automatically
+    port = int(os.getenv("PORT", "5000"))
+    app.run(host="0.0.0.0", port=port, debug=False)
+