Add remaining agents to Hugging Face Space

AIDual/app/main.py

@@ -0,0 +1,177 @@
+from fastapi import FastAPI, APIRouter, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from pydantic import BaseModel, Field
+from typing import List, Optional
+import os
+import sys
+import json
+from dotenv import load_dotenv, find_dotenv
+
+ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+if ROOT_DIR not in sys.path:
+    sys.path.append(ROOT_DIR)
+
+load_dotenv(find_dotenv(), override=True)
+
+
+class Citation(BaseModel):
+    title: str
+    source: str
+    snippet: str
+
+
+class CompareRequest(BaseModel):
+    question: str
+    top_k: int = Field(default=3, ge=1, le=10)
+    context: Optional[str] = None
+
+
+class CompareResponse(BaseModel):
+    question: str
+    fine_tuned_answer: str
+    rag_answer: str
+    rag_citations: List[Citation] = []
+
+
+from openai import OpenAI
+
+
+FT_SYSTEM = (
+    "You are a simulated fine‑tuned enterprise assistant. Produce a polished, executive‑ready answer in 3–6 concise bullet points. "
+    "Tone: confident, specific, policy‑style. Avoid generic guidance like 'consult HR'. If information is unclear, state a reasonable enterprise default and mark it as typical practice. "
+    "Formatting: bullets only, no preamble or epilogue."
+)
+
+RAG_SYSTEM = (
+    "You are a RAG assistant. Answer STRICTLY from the provided context. If the context does not support an answer, say 'Not in context' and suggest where to look. "
+    "Output 3–6 concise bullets. After each bullet, include a citation tag like (Doc 1) or (Pasted) when derived from pasted context. "
+    "Do not invent facts. If documents conflict, note the discrepancy briefly and prefer the most specific statement."
+)
+
+
+class DualDemoService:
+    def __init__(self) -> None:
+        key = (os.getenv("OPENAI_API_KEY") or "").strip().strip('"').strip("'")
+        if not key:
+            raise RuntimeError("OPENAI_API_KEY is not set")
+        base_url = (os.getenv("OPENAI_BASE_URL") or "").strip().strip('"').strip("'") or None
+        kwargs = {"api_key": key}
+        if base_url:
+            kwargs["base_url"] = base_url
+        self.client = OpenAI(**kwargs)
+        self.model = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+        self.docs_dir = os.path.join(os.path.dirname(__file__), "static", "docs")
+
+    def _read_docs(self) -> List[dict]:
+        docs: List[dict] = []
+        if os.path.isdir(self.docs_dir):
+            for name in os.listdir(self.docs_dir):
+                path = os.path.join(self.docs_dir, name)
+                if os.path.isfile(path):
+                    try:
+                        with open(path, "r", encoding="utf-8", errors="ignore") as f:
+                            text = f.read()
+                        title = os.path.splitext(name)[0].replace("_", " ").title()
+                        docs.append({"title": title, "source": name, "text": text})
+                    except Exception:
+                        continue
+        return docs
+
+    def _retrieve(self, question: str, top_k: int, external_text: Optional[str] = None) -> List[Citation]:
+        tokens = [t.strip().lower() for t in question.split() if t.strip()]
+        candidates: List[tuple[int, dict]] = []
+        sources = []
+        if external_text and external_text.strip():
+            sources = [{"title": "Context", "source": "", "text": external_text}]
+        else:
+            sources = self._read_docs()
+        for doc in sources:
+            paragraphs = [p.strip() for p in doc["text"].split("\n\n") if p.strip()]
+            for para in paragraphs:
+                score = sum(1 for t in tokens if t in para.lower())
+                if score > 0:
+                    candidates.append((score, {"title": doc["title"], "source": doc["source"], "snippet": para[:800]}))
+        if not candidates and sources:
+            for doc in sources[:top_k]:
+                candidates.append((1, {"title": doc["title"], "source": doc["source"], "snippet": doc["text"][:800]}))
+        candidates.sort(key=lambda x: x[0], reverse=True)
+        cites: List[Citation] = []
+        seen = set()
+        for _, item in candidates:
+            key = (item["title"], item["source"], item["snippet"][:120])
+            if key in seen:
+                continue
+            seen.add(key)
+            cites.append(Citation(**item))
+            if len(cites) >= top_k:
+                break
+        return cites
+
+    def compare(self, req: CompareRequest) -> CompareResponse:
+        # 1) Fine-tuned simulation
+        ft = self.client.chat.completions.create(
+            model=self.model,
+            messages=[
+                {"role": "system", "content": FT_SYSTEM},
+                {"role": "user", "content": req.question},
+            ],
+            temperature=0.1,
+            response_format={"type": "text"},
+        ).choices[0].message.content or ""
+
+        # 2) RAG with inline context and structured output
+        citations = self._retrieve(req.question, req.top_k, req.context)
+        context = []
+        for i, c in enumerate(citations, start=1):
+            context.append(f"=== Doc {i} ===\nTitle: {c.title}\nSource: {c.source}\nExcerpt: {c.snippet}")
+        ctx = "\n\n".join(context)
+
+        rag_resp = self.client.chat.completions.create(
+            model=self.model,
+            messages=[
+                {"role": "system", "content": RAG_SYSTEM},
+                {"role": "system", "content": ctx},
+                {"role": "user", "content": req.question},
+            ],
+            temperature=0.0,
+            response_format={"type": "text"},
+        ).choices[0].message.content or ""
+
+        return CompareResponse(question=req.question, fine_tuned_answer=ft.strip(), rag_answer=rag_resp.strip(), rag_citations=citations)
+
+
+app = FastAPI(title="Dual Demo Bot (RAG vs Fine-Tuning)", version="0.1.0")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+router = APIRouter(prefix="/dual", tags=["dual"])
+
+
+@router.get("/health")
+def health() -> dict:
+    return {"status": "ok", "openai_key": bool(os.getenv("OPENAI_API_KEY")), "model": os.getenv("OPENAI_MODEL", "gpt-4o-mini")}
+
+
+@router.post("/compare", response_model=CompareResponse)
+def compare(payload: CompareRequest) -> CompareResponse:
+    try:
+        return DualDemoService().compare(payload)
+    except Exception as exc:
+        raise HTTPException(status_code=502, detail=f"Dual demo error: {exc}")
+
+
+app.include_router(router)
+
+
+@app.get("/", response_class=FileResponse)
+def index() -> FileResponse:
+    base = os.path.dirname(__file__)
+    return FileResponse(os.path.join(base, "static", "index.html"))
+
+

AIDual/app/static/docs/expenses.txt

@@ -0,0 +1,10 @@
+Expense Policy (excerpt)
+
+Submission: Expenses must be submitted within 30 days of the transaction date.
+Receipts: Itemized receipts required for charges above $25.
+Approvals: Manager approval required; >$1,000 needs Finance approval.
+Meals: Reasonable meal costs allowed; alcohol is not reimbursable.
+Tools: Use the Expenses app (Slack: /expenses) to file reports.
+Per-diem: See Travel Policy for daily allowances by region.
+
+

AIDual/app/static/docs/oncall.txt

@@ -0,0 +1,10 @@
+On‑Call Policy (excerpt)
+
+Coverage: Primary and secondary engineers are scheduled weekly.
+Handover: Include current incidents, known risks, and runbooks.
+SLA: P1 acknowledge within 5 minutes, restore within 1 hour.
+Escalation: Page secondary if no ack; page manager after 15 minutes.
+Compensation: Stipend plus overtime for P1/P2 work; see HR policy.
+Tools: Use Pager app for rotations and escalation paths.
+
+

AIDual/app/static/docs/policy.txt

@@ -0,0 +1,6 @@
+Password Reset Policy (excerpt)
+
+Users can reset passwords via the “Forgot Password” link. Tokens expire in 15 minutes. 
+Self-service resets are available for SSO and local accounts. Support may verify identity for manual resets.
+
+

AIDual/app/static/docs/travel.txt

@@ -0,0 +1,10 @@
+Travel Policy (excerpt)
+
+Booking: Book flights at least 14 days in advance via the corporate portal.
+Class: Economy for flights under 6 hours; Premium Economy allowed over 6 hours with approval.
+Hotels: Standard rooms only; nightly cap per city applies.
+Per-diem: Daily allowance covers meals and incidentals; see regional table.
+Ground: Ride‑share allowed; choose the least expensive safe option.
+Safety: Follow local advisories and log itineraries with the Travel Desk.
+
+

AIDual/app/static/index.html

@@ -0,0 +1,76 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8"/>
+  <meta name="viewport" content="width=device-width, initial-scale=1"/>
+  <title>Dual Demo Bot — RAG vs Fine‑Tuning</title>
+  <link rel="stylesheet" href="/static/suite.css"/>
+  <style>
+    .cols{display:grid;gap:16px;grid-template-columns:1fr;margin-top:12px}
+    @media (min-width:1000px){.cols{grid-template-columns:1fr 1fr}}
+    .answer{white-space:pre-wrap}
+    .cites{display:grid;gap:8px;margin-top:8px}
+    .cite{background:#fafafa;border:1px dashed var(--border);padding:8px;border-radius:8px}
+    .actions{display:flex;gap:12px;flex-wrap:wrap;margin-top:12px}
+  </style>
+</head>
+<body>
+  <div id="suite-shared-header"></div>
+  <div class="container">
+    <h1>RAG vs Fine‑Tuning — Dual Demo</h1>
+    <p class="muted">Ask any question. See a simulated Fine‑Tuned answer and a RAG answer side‑by‑side.</p>
+    <div class="card">
+      <label for="q">Your question</label>
+      <textarea id="q" rows="3" placeholder="How do we handle password resets?"></textarea>
+      <label for="ctx">Optional context (paste policy text, notes, docs)</label>
+      <textarea id="ctx" rows="6" placeholder="Paste any text here to power the RAG side..."></textarea>
+      <div class="form-row">
+        <div>
+          <label for="k">Citations</label>
+          <input id="k" type="number" min="1" max="10" value="3"/>
+        </div>
+      </div>
+      <div class="actions"><button id="run" class="btn">Compare</button></div>
+    </div>
+    <div class="cols">
+      <div class="card" id="ft"><h2>Fine‑Tuned</h2><div class="answer muted">(waiting)</div></div>
+      <div class="card" id="rag"><h2>RAG</h2><div class="answer muted">(waiting)</div><div class="cites" id="cites"></div></div>
+    </div>
+  </div>
+  <script src="/static/header.js"></script>
+  <script>
+    const run = document.getElementById('run');
+    const elQ = document.getElementById('q');
+    const elK = document.getElementById('k');
+    const elFT = document.querySelector('#ft .answer');
+    const elRAG = document.querySelector('#rag .answer');
+    const elC = document.getElementById('cites');
+    run.addEventListener('click', async ()=>{
+      elFT.textContent='(thinking...)';
+      elRAG.textContent='(thinking...)';
+      elC.innerHTML='';
+      try{
+        const res = await fetch('/dual/compare',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({question:elQ.value||'', context: (document.getElementById('ctx').value||''), top_k:parseInt(elK.value,10)||3})});
+        if(!res.ok) throw new Error(await res.text());
+        const data = await res.json();
+        elFT.textContent = data.fine_tuned_answer || '';
+        elRAG.textContent = data.rag_answer || '';
+        (data.rag_citations||[]).forEach(c=>{
+          const d=document.createElement('div');
+          d.className='cite';
+          const title = (c.title||'').replace(/</g,'&lt;').replace(/>/g,'&gt;');
+          const src = (c.source||'').replace(/</g,'&lt;').replace(/>/g,'&gt;');
+          const snip = (c.snippet||'').replace(/</g,'&lt;').replace(/>/g,'&gt;');
+          d.innerHTML = `<strong>${title}</strong> <span class="muted">(${src})</span><div class="muted" style="margin-top:6px;">${snip}</div>`;
+          elC.appendChild(d);
+        });
+      }catch(e){
+        elFT.textContent = `Error: ${String(e)}`;
+        elRAG.textContent = `Error: ${String(e)}`;
+      }
+    });
+  </script>
+</body>
+</html>
+
+

AIFit/app/main.py

@@ -0,0 +1,144 @@
+from fastapi import FastAPI, APIRouter, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from pydantic import BaseModel, Field
+from typing import List, Literal, Optional
+import os
+import sys
+import json
+from dotenv import load_dotenv, find_dotenv
+
+ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+if ROOT_DIR not in sys.path:
+    sys.path.append(ROOT_DIR)
+
+load_dotenv(find_dotenv(), override=True)
+
+
+class FitRequest(BaseModel):
+    product_name: Optional[str] = None
+    description: str = Field(..., description="Describe the product, users, core workflows, scale, data, constraints")
+
+
+class FitSummary(BaseModel):
+    verdict: Literal["must_have", "nice_to_have", "overkill"]
+    rationale: List[str]
+    suggested_ai_capabilities: List[str]
+    risks: List[str]
+    next_steps: List[str]
+
+
+from openai import OpenAI
+
+
+SYSTEM = (
+    "You are an impartial AI fit evaluator for product teams. Read the product description and decide whether AI is a "
+    "must_have, nice_to_have, or overkill. Be conservative and practical.\n\n"
+    "Decision criteria (apply all):\n"
+    "- Value vs. complexity: Does AI unlock step‑change outcomes (conversion, accuracy, cost, speed) vs simpler heuristics?\n"
+    "- Data readiness: Do we have sufficient labeled or implicit feedback, signal‑to‑noise, and a pathway to ongoing labels?\n"
+    "- Latency & scale: Can inference meet UX/SLA constraints (e.g., <100ms) at projected volumes and cost?\n"
+    "- Risk & safety: Failure modes, abuse, compliance/privacy, auditability, and the blast radius of wrong outputs.\n"
+    "- Maintenance: Who will own monitoring, retraining, and evaluation; can we sustain it?\n\n"
+    "Verdict guidelines:\n"
+    "- must_have: Clear business lift that non‑AI cannot match; data pathway exists; latency/cost acceptable.\n"
+    "- nice_to_have: Tangible benefits but not critical path; partial data; or constraints require phased pilot.\n"
+    "- overkill: Minimal incremental value vs rules/UI; no meaningful data; operational risk too high.\n\n"
+    "Output requirements:\n"
+    "- rationale: 3–6 crisp bullets mapping evidence to the verdict (no fluff, no repeating the prompt).\n"
+    "- suggested_ai_capabilities: 3–6 scoped items (e.g., ranking, extraction, anomaly detection), not vague 'use AI'.\n"
+    "- risks: 3–6 specific risks (data gaps, model drift, eval difficulty, privacy/SOC2/PII, hallucination impact).\n"
+    "- next_steps: 3–6 concrete actions (baseline heuristic, KPI definition, data/label plan, pilot scope, eval rubric).\n"
+    "Tone: executive‑ready, direct, and vendor‑agnostic. Do NOT upsell AI where ROI is weak."
+)
+
+
+class AIFitService:
+    def __init__(self) -> None:
+        key = (os.getenv("OPENAI_API_KEY") or "").strip().strip('"').strip("'")
+        if not key:
+            raise RuntimeError("OPENAI_API_KEY is not set")
+        base_url = (os.getenv("OPENAI_BASE_URL") or "").strip().strip('"').strip("'") or None
+        kwargs = {"api_key": key}
+        if base_url:
+            kwargs["base_url"] = base_url
+        self.client = OpenAI(**kwargs)
+        self.model = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+
+    def evaluate(self, req: FitRequest) -> FitSummary:
+        user = (
+            f"Product: {req.product_name or 'N/A'}\n" +
+            "Description:\n" + req.description.strip()
+        )
+        resp = self.client.chat.completions.create(
+            model=self.model,
+            messages=[
+                {"role": "system", "content": SYSTEM},
+                {"role": "user", "content": user},
+            ],
+            temperature=0.1,
+            response_format={
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "FitSummary",
+                    "schema": {
+                        "type": "object",
+                        "additionalProperties": False,
+                        "required": ["verdict", "rationale", "suggested_ai_capabilities", "risks", "next_steps"],
+                        "properties": {
+                            "verdict": {"type": "string", "enum": ["must_have", "nice_to_have", "overkill"]},
+                            "rationale": {"type": "array", "items": {"type": "string"}},
+                            "suggested_ai_capabilities": {"type": "array", "items": {"type": "string"}},
+                            "risks": {"type": "array", "items": {"type": "string"}},
+                            "next_steps": {"type": "array", "items": {"type": "string"}}
+                        }
+                    }
+                }
+            },
+        )
+        content = resp.choices[0].message.content
+        try:
+            data = json.loads(content)
+        except Exception:
+            start = content.find('{'); end = content.rfind('}')
+            if start != -1 and end != -1 and end > start:
+                data = json.loads(content[start:end+1])
+            else:
+                raise RuntimeError("Invalid JSON from model")
+        return FitSummary.model_validate(data)
+
+
+app = FastAPI(title="AI Fit Evaluator", version="0.1.0")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+router = APIRouter(prefix="/fit", tags=["fit"])
+
+
+@router.get("/health")
+def health() -> dict:
+    return {"status":"ok","openai_key": bool(os.getenv("OPENAI_API_KEY")), "model": os.getenv("OPENAI_MODEL","gpt-4o-mini")}
+
+
+@router.post("/evaluate", response_model=FitSummary)
+def evaluate(payload: FitRequest) -> FitSummary:
+    try:
+        return AIFitService().evaluate(payload)
+    except Exception as exc:
+        raise HTTPException(status_code=502, detail=f"Fit evaluator error: {exc}")
+
+
+app.include_router(router)
+
+
+@app.get("/", response_class=FileResponse)
+def index() -> FileResponse:
+    base = os.path.dirname(__file__)
+    return FileResponse(os.path.join(base, "static", "index.html"))
+
+

AIFit/app/static/index.html

@@ -0,0 +1,62 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8"/>
+  <meta name="viewport" content="width=device-width, initial-scale=1"/>
+  <title>AI Fit Evaluator</title>
+  <link rel="stylesheet" href="/static/suite.css"/>
+  <style>
+    .actions{display:flex;gap:12px;flex-wrap:wrap;margin-top:12px}
+    .pill{background:#fff;border:1px solid var(--border);border-radius:12px;padding:10px;margin-top:12px}
+    .pill .k{font-weight:800}
+    .pill .l{color:var(--muted);font-size:12px}
+  </style>
+</head>
+<body>
+  <div id="suite-shared-header"></div>
+  <div class="container">
+    <h1>AI Fit Evaluator</h1>
+    <p class="muted">Describe your product; get an honest verdict on whether AI is a must‑have, nice‑to‑have, or overkill.</p>
+    <div class="grid two-col">
+      <div class="card">
+        <label for="name">Product name (optional)</label>
+        <input id="name" type="text" placeholder="Acme Task Manager"/>
+        <label for="desc">Product description</label>
+        <textarea id="desc" rows="10" placeholder="Audience, workflows, where value is created, scale, data you have, constraints, latency needs..."></textarea>
+        <div class="actions">
+          <button id="eval" class="btn">Evaluate</button>
+        </div>
+      </div>
+      <div class="card" id="out" style="display:none"></div>
+    </div>
+  </div>
+  <script src="/static/header.js"></script>
+  <script>
+    const out=document.getElementById('out');
+    document.getElementById('eval').addEventListener('click', async ()=>{
+      const payload={product_name: (document.getElementById('name').value||null), description: (document.getElementById('desc').value||'')};
+      out.style.display='block'; out.innerHTML='<div class="muted">(evaluating...)</div>';
+      try{
+        const res=await fetch('/fit/evaluate',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(payload)});
+        if(!res.ok) throw new Error(await res.text());
+        const data=await res.json();
+        const verdictLabel = {must_have:'Must‑have', nice_to_have:'Nice‑to‑have', overkill:'Overkill'}[data.verdict] || data.verdict;
+        const list = (arr)=> (arr||[]).map(x=>`<li>${(x||'').replace(/</g,'&lt;').replace(/>/g,'&gt;')}</li>`).join('') || '<li class="muted">None</li>';
+        out.innerHTML=`
+          <div class="pill"><div class="k">Verdict: ${verdictLabel}</div><div class="l">Honest assessment based on value vs complexity and data readiness</div></div>
+          <h2>Rationale</h2>
+          <ul>${list(data.rationale)}</ul>
+          <h2>Suggested AI capabilities</h2>
+          <ul>${list(data.suggested_ai_capabilities)}</ul>
+          <h2>Risks</h2>
+          <ul>${list(data.risks)}</ul>
+          <h2>Next steps</h2>
+          <ul>${list(data.next_steps)}</ul>
+        `;
+      }catch(e){ out.innerHTML=`<div style="color:#b91c1c;">Error: ${String(e)}</div>`; }
+    });
+  </script>
+</body>
+</html>
+
+

AIHealthcare/app/main.py

@@ -0,0 +1,227 @@
+from fastapi import FastAPI, APIRouter, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from pydantic import BaseModel, Field
+from typing import List, Optional
+import os
+from dotenv import load_dotenv, find_dotenv
+
+
+# Load .env from project root; override shell for consistency
+ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+load_dotenv(find_dotenv(), override=True)
+
+
+class TriageRequest(BaseModel):
+    symptoms: str = Field(..., description="Patient-reported symptoms narrative")
+    age: Optional[int] = Field(None, description="Approximate age in years")
+    duration: Optional[str] = Field(None, description="Symptom duration, e.g., '2 days' or '3 weeks'")
+    risk_factors: Optional[str] = Field(None, description="Known conditions/meds e.g., 'asthma, diabetes' or 'pregnant'")
+
+
+class TriageResponse(BaseModel):
+    disposition: str  # urgent | routine | self-care
+    rationale: str
+    red_flags: List[str]
+    suggested_actions: List[str]
+    disclaimer: str
+
+
+app = FastAPI(title="AI Symptom Triage (Demo)", version="0.1.0")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+router = APIRouter(prefix="", tags=["triage"])
+
+
+@router.get("/health")
+def health() -> dict:
+    return {
+        "status": "ok",
+        "openai_key": bool(os.getenv("OPENAI_API_KEY")),
+        "model": os.getenv("OPENAI_MODEL", "gpt-4o-mini"),
+        "base_url": os.getenv("OPENAI_BASE_URL") or None,
+    }
+
+
+from openai import OpenAI
+import json
+import re
+
+
+SYSTEM_PROMPT = (
+    "You are a cautious, non‑diagnostic symptom triage assistant. Classify as 'urgent', 'routine', or 'self-care' "
+    "based on symptoms, duration, age, and risk factors. Output must be concise, safety‑first, and vendor‑agnostic.\n\n"
+    "Disposition rules (apply in order; if any red flag applies, mark 'urgent'):\n"
+    "- URGENT: chest pain/pressure; shortness of breath; severe headache or 'worst ever'; confusion; fainting; new weakness, numbness, facial droop, slurred speech; uncontrolled bleeding; severe dehydration (very dry mouth, no urine, dizziness); persistent high fever (>=39.4°C/103°F) with toxicity; severe abdominal pain; anaphylaxis signs (hives + breathing/swallowing difficulty, swelling); pregnancy complications (bleeding, severe abdominal pain, reduced fetal movement); suicidal ideation.\n"
+    "- ROUTINE: persistent or worsening symptoms without red flags (e.g., lingering cough, localized musculoskeletal pain, mild rash).\n"
+    "- SELF‑CARE: mild, self‑limited symptoms with no red flags (e.g., common cold signs, minor cuts with controlled bleeding).\n\n"
+    "Age/risk considerations:\n"
+    "- Infants/elderly, pregnancy, immunocompromised, or serious comorbidities warrant lower threshold for 'urgent'.\n"
+    "- Always adapt rationale to the provided age, duration, and risk factors.\n\n"
+    "Guidance format:\n"
+    "- rationale: 1–3 short sentences justifying disposition (mention key findings and uncertainties).\n"
+    "- red_flags: list only when present (name each one clearly).\n"
+    "- suggested_actions: actionable but non‑diagnostic (e.g., 'seek urgent care now', 'book primary care in 1–2 weeks', 'rest, fluids, OTC analgesic per label').\n"
+    "- disclaimer: include a clear statement that this is educational only, not medical advice, and to contact a clinician/emergency services when indicated.\n\n"
+    "Return STRICT JSON only matching the schema."
+)
+
+
+class SymptomTriageService:
+    def __init__(self) -> None:
+        key = os.getenv("OPENAI_API_KEY")
+        if not key:
+            raise RuntimeError("OPENAI_API_KEY is not set")
+        key = key.strip().strip('"').strip("'")
+        base_url = (os.getenv("OPENAI_BASE_URL") or "").strip().strip('"').strip("'") or None
+        kwargs = {"api_key": key}
+        if base_url:
+            kwargs["base_url"] = base_url
+        self.client = OpenAI(**kwargs)
+        self.model = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+
+    def assess(self, req: TriageRequest) -> TriageResponse:
+        user = (
+            f"Symptoms: {req.symptoms}\nAge: {req.age or 'unknown'}\nDuration: {req.duration or 'unknown'}\nRisk factors: {req.risk_factors or 'none'}"
+        )
+        try:
+            resp = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": SYSTEM_PROMPT},
+                    {"role": "user", "content": user},
+                ],
+                temperature=0.15,
+                response_format={
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": "TriageResponse",
+                        "schema": {
+                            "type": "object",
+                            "required": ["disposition", "rationale", "red_flags", "suggested_actions", "disclaimer"],
+                            "additionalProperties": False,
+                            "properties": {
+                                "disposition": {"type": "string", "enum": ["urgent", "routine", "self-care"]},
+                                "rationale": {"type": "string"},
+                                "red_flags": {"type": "array", "items": {"type": "string"}},
+                                "suggested_actions": {"type": "array", "items": {"type": "string"}},
+                                "disclaimer": {"type": "string"}
+                            }
+                        }
+                    }
+                }
+            )
+        except Exception:
+            resp = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": SYSTEM_PROMPT + "\nReturn ONLY JSON with disposition, rationale, red_flags[], suggested_actions[], disclaimer."},
+                    {"role": "user", "content": user},
+                ],
+                temperature=0.15,
+                response_format={"type": "json_object"},
+            )
+
+        content = resp.choices[0].message.content
+        try:
+            data = json.loads(content)
+        except Exception:
+            start = content.find("{")
+            end = content.rfind("}")
+            if start != -1 and end != -1 and end > start:
+                data = json.loads(content[start : end + 1])
+            else:
+                raise RuntimeError("Invalid JSON from model")
+        # Post-processing safety normalization
+        try:
+            text_blob = " ".join([
+                str(data.get("rationale") or ""),
+                str(data.get("suggested_actions") or ""),
+                str(data.get("red_flags") or ""),
+            ])
+            user_blob = " ".join([
+                req.symptoms or "",
+                req.duration or "",
+                req.risk_factors or "",
+                str(req.age or ""),
+            ]).lower()
+            # Normalize disposition synonyms
+            disp = (data.get("disposition") or "").strip().lower()
+            synonym_map = {
+                "self care": "self-care",
+                "selfcare": "self-care",
+                "non-urgent": "routine",
+                "non urgent": "routine",
+                "emergency": "urgent",
+                "er": "urgent",
+                "ed": "urgent",
+                "urgent care": "urgent",
+            }
+            disp = synonym_map.get(disp, disp)
+
+            red_keywords = [
+                r"chest\s*pain|pressure",
+                r"short(ness)?\s*of\s*breath|difficulty\s*(breathing|swallowing)",
+                r"worst\s*headache|severe\s*headache|stiff\s*neck",
+                r"confusion|faint(ing)?|passed\s*out",
+                r"weakness|numb(ness)?|facial\s*droop|slurred\s*speech|stroke",
+                r"uncontrolled\s*bleeding",
+                r"dehydration|no\s*urine|very\s*dry\s*mouth|dizziness",
+                r"high\s*fever|104|40\s*°?c",
+                r"severe\s*abdominal\s*pain",
+                r"anaphylaxis|hives",
+                r"pregnan|fetal|bleeding\s*during\s*pregnancy",
+                r"suicidal|self\s*h(arm|arming)",
+            ]
+            red_found: list[str] = []
+            for pat in red_keywords:
+                if re.search(pat, user_blob):
+                    red_found.append(pat)
+            red_flags = data.get("red_flags") or []
+            if red_found and disp != "urgent":
+                disp = "urgent"
+                # Ensure at least one human-readable red flag message
+                if not red_flags:
+                    red_flags = ["Detected potential red flags; seek urgent in‑person evaluation."]
+                rationale = (data.get("rationale") or "").strip()
+                prefix = "Red flags present; elevating to urgent. "
+                data["rationale"] = (prefix + rationale) if rationale else prefix
+            data["disposition"] = disp if disp in {"urgent", "routine", "self-care"} else "urgent" if red_found else "routine"
+            data["red_flags"] = red_flags
+            # Enforce a standard disclaimer if missing/weak
+            disclaimer = (data.get("disclaimer") or "").strip()
+            min_disclaimer = (
+                "This is an educational triage demo, not medical advice. If symptoms are severe or you are concerned, "
+                "seek care from a licensed clinician or emergency services."
+            )
+            if len(disclaimer) < 80:
+                data["disclaimer"] = min_disclaimer
+        except Exception:
+            pass
+
+        return TriageResponse.model_validate(data)
+
+
+@router.post("/assess", response_model=TriageResponse)
+def assess(payload: TriageRequest) -> TriageResponse:
+    try:
+        return SymptomTriageService().assess(payload)
+    except Exception as exc:
+        raise HTTPException(status_code=502, detail=f"Triage bot error: {exc}")
+
+
+app.include_router(router)
+
+
+@app.get("/", response_class=FileResponse)
+def index() -> FileResponse:
+    base = os.path.dirname(__file__)
+    return FileResponse(os.path.join(base, "static", "index.html"))
+
+

AIHealthcare/app/static/index.html

@@ -0,0 +1,89 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8"/>
+  <meta name="viewport" content="width=device-width, initial-scale=1"/>
+  <title>Symptom Triage (Demo)</title>
+  <link rel="stylesheet" href="/static/suite.css">
+  <style>
+    :root{--bg:#f7f7f8;--surface:#fff;--text:#0f172a;--muted:#6b7280;--border:#e5e7eb;--brand:#111827;--radius:12px;--space-1:8px;--space-2:12px;--space-3:16px;--space-4:24px;--space-5:32px}
+    *{box-sizing:border-box}
+    body{font-family:system-ui,Segoe UI,Roboto,Helvetica,Arial,sans-serif;background:var(--bg);color:var(--text);margin:0}
+    .site-header{position:sticky;top:0;background:var(--surface);border-bottom:1px solid var(--border);z-index:50}
+    .site-header .nav{display:flex;align-items:center;justify-content:space-between;max-width:1200px;margin:0 auto;padding:12px 24px}
+    .site-header .brand a{text-decoration:none;color:var(--text)}
+    .site-header .links{display:flex;gap:16px}
+    .site-header .links a{text-decoration:none;color:var(--muted);padding:6px 10px;border-radius:8px}
+    .site-header .links a:hover{background:#f3f4f6;color:var(--text)}
+    .container{max-width:900px;margin:0 auto;padding:var(--space-5) var(--space-5)}
+    .card{background:#fff;border:1px solid var(--border);border-radius:var(--radius);padding:var(--space-4)}
+    label{display:block;margin:var(--space-2) 0 var(--space-1);font-weight:600}
+    input,textarea{width:100%;padding:var(--space-2);border:1px solid var(--border);border-radius:8px;font-size:16px;background:#fff}
+    .grid{display:grid;grid-template-columns:1fr 1fr;gap:12px}
+    .btn{appearance:none;border:0;border-radius:8px;padding:10px 16px;font-weight:600;cursor:pointer;background:var(--brand);color:#fff}
+    .pill{display:inline-block;border-radius:999px;padding:4px 10px;font-size:12px;margin-right:6px}
+    .pill.urgent{background:#fee2e2;color:#991b1b}
+    .pill.routine{background:#e0e7ff;color:#3730a3}
+    .pill.selfcare{background:#dcfce7;color:#166534}
+    .muted{color:var(--muted)}
+  </style>
+</head>
+<body>
+  <div id="suite-shared-header"></div>
+  <script src="/static/header.js"></script>
+  <div class="container">
+    <h1>Symptom Triage (Demo)</h1>
+    <p class="muted">Educational demo — not medical advice. If this is an emergency, call your local emergency number.</p>
+    <div class="card">
+      <form id="form">
+        <label>Symptoms</label>
+        <textarea id="symptoms" rows="3" placeholder="Describe what's going on"></textarea>
+        <div class="grid">
+          <div>
+            <label>Age</label>
+            <input id="age" type="number" min="0" />
+          </div>
+          <div>
+            <label>Duration</label>
+            <input id="duration" placeholder="e.g., 2 days" />
+          </div>
+        </div>
+        <label>Risk factors (optional)</label>
+        <input id="risks" placeholder="e.g., asthma, pregnant" />
+        <div style="margin-top:12px"><button class="btn" type="submit">Assess</button></div>
+      </form>
+    </div>
+    <div id="out" style="margin-top:16px"></div>
+  </div>
+  <script>
+    const form = document.getElementById('form');
+    const out = document.getElementById('out');
+    form.addEventListener('submit', async (e)=>{
+      e.preventDefault();
+      out.innerHTML = '(assessing)';
+      const body = {
+        symptoms: document.getElementById('symptoms').value.trim(),
+        age: Number(document.getElementById('age').value||'') || undefined,
+        duration: document.getElementById('duration').value.trim() || undefined,
+        risk_factors: document.getElementById('risks').value.trim() || undefined,
+      };
+      const r = await fetch('/triage/assess', { method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify(body) });
+      const text = await r.text();
+      let data={}; try{ data = text ? JSON.parse(text) : {}; }catch{ data = { error:text } }
+      if(!r.ok){ out.textContent = 'Error: ' + (data.detail || text); return; }
+      const disp = (data.disposition||'').toLowerCase();
+      const pill = disp==='urgent'?'urgent':(disp==='self-care'?'selfcare':'routine');
+      out.innerHTML = `
+        <div class="card">
+          <p><span class="pill ${pill}">${data.disposition}</span></p>
+          <p>${data.rationale||''}</p>
+          ${ (data.red_flags||[]).length ? '<p><strong>Red flags</strong></p><ul>'+data.red_flags.map(x=>'<li>'+x+'</li>').join('')+'</ul>' : '' }
+          ${ (data.suggested_actions||[]).length ? '<p><strong>Suggested actions</strong></p><ul>'+data.suggested_actions.map(x=>'<li>'+x+'</li>').join('')+'</ul>' : '' }
+          <p class="muted" style="margin-top:8px">${data.disclaimer||''}</p>
+        </div>`;
+    });
+  </script>
+</body>
+</html>
+
+

AIQuiz/app/main.py

@@ -0,0 +1,220 @@
+from fastapi import FastAPI, APIRouter, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from pydantic import BaseModel, Field, conint
+from typing import List, Optional
+import os
+import sys
+import json
+from dotenv import load_dotenv, find_dotenv
+import difflib
+import re
+
+ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+if ROOT_DIR not in sys.path:
+    sys.path.append(ROOT_DIR)
+
+load_dotenv(find_dotenv(), override=True)
+
+
+class QuizState(BaseModel):
+    topic: str
+    level: conint(ge=1, le=5) = 3
+    questions_asked: conint(ge=0) = 0
+    correct: conint(ge=0) = 0
+    history: List[dict] = Field(default_factory=list)
+
+
+class NextQuestionRequest(BaseModel):
+    state: QuizState
+    last_answer: Optional[str] = None
+    last_choices: Optional[List[str]] = None
+    last_prompt: Optional[str] = None
+
+
+class Question(BaseModel):
+    prompt: str
+    choices: List[str]
+
+
+class NextQuestionResponse(BaseModel):
+    question: Question
+    state: QuizState
+    feedback: Optional[str] = None
+    correct_answer: Optional[str] = None
+    is_correct: Optional[bool] = None
+
+
+from openai import OpenAI
+
+
+SYSTEM_PROMPT = (
+    "You are an adaptive quiz tutor. Ask exactly one multiple-choice question at a time (4 choices), "
+    "and adjust difficulty (1-5) based on the learner's previous answer correctness. "
+    "If the previous answer was correct, slightly increase difficulty; if wrong, slightly decrease. "
+    "Keep questions concise and unambiguous. Provide short feedback referencing the correct answer. "
+    "CRITICAL: 'correct_answer' MUST be exactly one of the provided 'choices'. "
+    "Set 'is_correct' = (last_answer exactly equals correct_answer). "
+    "Feedback template: if correct -> 'Correct. Correct answer: <choice>. <one-line reason>'; "
+    "if wrong -> 'Incorrect. Correct answer: <choice>. <one-line reason>'. "
+    "Return STRICTLY VALID JSON per schema."
+)
+
+
+class AdaptiveQuizService:
+    def __init__(self) -> None:
+        key = (os.getenv("OPENAI_API_KEY") or "").strip().strip('"').strip("'")
+        if not key:
+            raise RuntimeError("OPENAI_API_KEY is not set")
+        base_url = (os.getenv("OPENAI_BASE_URL") or "").strip().strip('"').strip("'") or None
+        kwargs = {"api_key": key}
+        if base_url:
+            kwargs["base_url"] = base_url
+        self.client = OpenAI(**kwargs)
+        self.model = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+
+    def next(self, req: NextQuestionRequest) -> NextQuestionResponse:
+        payload = {
+            "topic": req.state.topic,
+            "level": req.state.level,
+            "questions_asked": req.state.questions_asked,
+            "correct": req.state.correct,
+            "history": req.state.history,
+            "last_answer": req.last_answer,
+            "last_choices": req.last_choices,
+            "last_prompt": req.last_prompt,
+        }
+        user_json = json.dumps(payload, ensure_ascii=False)
+        try:
+            resp = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": SYSTEM_PROMPT},
+                    {"role": "user", "content": user_json},
+                ],
+                temperature=0.2,
+                response_format={
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": "NextQuestionResponse",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": False,
+                            "required": ["question", "state"],
+                            "properties": {
+                                "question": {
+                                    "type": "object",
+                                    "required": ["prompt", "choices"],
+                                    "properties": {
+                                        "prompt": {"type": "string"},
+                                        "choices": {"type": "array", "minItems": 4, "maxItems": 4, "items": {"type": "string"}}
+                                    }
+                                },
+                                "state": {
+                                    "type": "object",
+                                    "required": ["topic", "level", "questions_asked", "correct", "history"],
+                                    "properties": {
+                                        "topic": {"type": "string"},
+                                        "level": {"type": "integer", "minimum": 1, "maximum": 5},
+                                        "questions_asked": {"type": "integer", "minimum": 0},
+                                        "correct": {"type": "integer", "minimum": 0},
+                                        "history": {"type": "array", "items": {"type": "object"}}
+                                    }
+                                },
+                                "feedback": {"type": "string"},
+                                "correct_answer": {"type": "string"},
+                                "is_correct": {"type": "boolean"}
+                            }
+                        }
+                    }
+                },
+            )
+            content = resp.choices[0].message.content
+            data = json.loads(content)
+        except Exception:
+            # Fallback parse
+            try:
+                start = content.find('{'); end = content.rfind('}')
+                if start != -1 and end != -1 and end > start:
+                    data = json.loads(content[start:end+1])
+                else:
+                    raise RuntimeError('Invalid JSON')
+            except Exception as exc:
+                raise RuntimeError(f"Adaptive quiz error: {exc}")
+        # Post-validate and normalize correctness deterministically
+        try:
+            prev_choices = req.last_choices or []
+            correct_answer = (data.get("correct_answer") or "").strip()
+            # Ensure correct_answer maps to one of previous choices (fuzzy-insensitive mapping)
+            def _normalize(s: str) -> str:
+                # Generic normalization only (no domain-specific mapping)
+                s = (s or "").lower()
+                s = re.sub(r"[^a-z0-9\s]", "", s)
+                s = re.sub(r"\s+", " ", s).strip()
+                return s
+            if prev_choices:
+                target = _normalize(correct_answer)
+                mapped = None
+                best = 0.0
+                for c in prev_choices:
+                    score = difflib.SequenceMatcher(None, _normalize(c), target).ratio()
+                    if score > best:
+                        best = score
+                        mapped = c
+                if not mapped:
+                    mapped = prev_choices[0]
+                correct_answer = mapped
+                data["correct_answer"] = correct_answer
+            # Compute is_correct if last_answer was provided
+            if req.last_answer is not None:
+                is_correct = (_normalize(req.last_answer) == _normalize(correct_answer))
+                data["is_correct"] = bool(is_correct)
+                # Standardize feedback if missing or unhelpful
+                if is_correct:
+                    default_fb = f"Correct. Correct answer: {correct_answer}."
+                else:
+                    default_fb = f"Incorrect. Correct answer: {correct_answer}."
+                fb = (data.get("feedback") or "").strip()
+                if not fb or correct_answer not in fb:
+                    data["feedback"] = default_fb
+        except Exception:
+            # Best-effort; proceed with whatever the model returned
+            pass
+
+        return NextQuestionResponse.model_validate(data)
+
+
+app = FastAPI(title="Adaptive Quiz Bot", version="0.1.0")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+router = APIRouter(prefix="/quiz", tags=["quiz"])
+
+
+@router.get("/health")
+def health() -> dict:
+    return {"status":"ok","openai_key": bool(os.getenv("OPENAI_API_KEY")), "model": os.getenv("OPENAI_MODEL","gpt-4o-mini")}
+
+
+@router.post("/next", response_model=NextQuestionResponse)
+def next_turn(payload: NextQuestionRequest) -> NextQuestionResponse:
+    try:
+        return AdaptiveQuizService().next(payload)
+    except Exception as exc:
+        raise HTTPException(status_code=502, detail=str(exc))
+
+
+app.include_router(router)
+
+
+@app.get("/", response_class=FileResponse)
+def index() -> FileResponse:
+    base = os.path.dirname(__file__)
+    return FileResponse(os.path.join(base, "static", "index.html"))
+
+

AIQuiz/app/static/index.html

@@ -0,0 +1,139 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8"/>
+  <meta name="viewport" content="width=device-width, initial-scale=1"/>
+  <title>Adaptive Quiz Bot</title>
+  <link rel="stylesheet" href="/static/suite.css"/>
+  <style>
+    .choice{display:block;background:#fff;border:1px solid var(--border);border-radius:10px;padding:10px;margin-top:8px;cursor:pointer}
+    .choice:hover{background:#f8fafc}
+    .choice.selected{outline:3px solid #6366f1}
+    .choice.correct{background:#ecfdf5;border-color:#22c55e}
+    .choice.wrong{background:#fef2f2;border-color:#ef4444}
+    .pill{background:#fff;border:1px solid var(--border);border-radius:12px;padding:10px}
+    .pill .k{font-weight:800}
+    .pill .l{color:var(--muted);font-size:12px}
+    .progress{height:8px;background:#eef2ff;border-radius:8px;overflow:hidden;margin:8px 0}
+    .progress .bar{height:100%;background:#6366f1;width:0%}
+    .actions{display:flex;gap:12px;flex-wrap:wrap;margin-top:12px}
+  </style>
+</head>
+<body>
+  <div id="suite-shared-header"></div>
+  <div class="container">
+    <h1>Adaptive Quiz Bot</h1>
+    <p class="muted">Ask 3 quiz questions and adjust difficulty in real time based on your answers.</p>
+    <div class="grid two-col">
+      <div class="card">
+        <label for="topic">Topic</label>
+        <input id="topic" type="text" placeholder="Machine Learning basics"/>
+        <div class="form-row">
+          <div>
+            <label for="level">Start difficulty (1-5)</label>
+            <input id="level" type="number" min="1" max="5" value="3"/>
+          </div>
+          <div>
+            <label for="num">Questions</label>
+            <input id="num" type="number" min="1" max="8" value="3"/>
+          </div>
+        </div>
+        <div class="actions"><button id="start" class="btn">Start</button></div>
+      </div>
+      <div class="card" id="play" style="display:none"></div>
+    </div>
+  </div>
+  <script src="/static/header.js"></script>
+  <script>
+    let state = null, remaining = 0, quizAsked = 0, quizCorrect = 0, total = 0;
+    const play = document.getElementById('play');
+    async function fetchNext(lastAnswer, lastChoices, lastPrompt){
+      const res = await fetch('/quiz/next', {method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify({state, last_answer: lastAnswer||null, last_choices: lastChoices||null, last_prompt: lastPrompt||null})});
+      if(!res.ok) throw new Error(await res.text());
+      const data = await res.json();
+      state = data.state || state || {};
+      return data;
+    }
+    function renderQuestion(data, reveal){
+      const q = data.question;
+      const feedback = data.feedback || '';
+      play.style.display='block';
+      play.innerHTML = `
+        <div class="pill" style="margin-bottom:8px;display:flex;gap:12px;align-items:center;">
+          <div class="k">Level ${state.level}</div>
+          <div class="l">Asked ${quizAsked}/${total} • Correct ${quizCorrect}</div>
+        </div>
+        <div class="progress"><div class="bar" style="width:${Math.min(100, Math.round((quizAsked/Math.max(1,total))*100))}%;"></div></div>
+        <div style="font-weight:700;margin-bottom:8px;">${q.prompt}</div>
+        <div id="choices"></div>
+        <div class="actions">
+          <button id="nextBtn" class="btn" type="button" disabled>Next</button>
+        </div>
+        ${reveal && feedback ? `<div class="muted" style="margin-top:8px;">${feedback}</div>` : ''}
+      `;
+      const box = play.querySelector('#choices');
+      let selected = null;
+      const nextBtn = play.querySelector('#nextBtn');
+      q.choices.forEach((c)=>{
+        const btn = document.createElement('button');
+        btn.className = 'choice';
+        btn.type = 'button';
+        btn.textContent = c;
+        btn.addEventListener('click', ()=>{
+          selected = c;
+          Array.from(box.children).forEach(el=>el.classList.remove('selected'));
+          btn.classList.add('selected');
+          nextBtn.disabled = false;
+        });
+        box.appendChild(btn);
+      });
+      let buffered = null;
+      nextBtn.addEventListener('click', async ()=>{
+        if(!selected) return;
+        // First click: submit and reveal on current view
+        if (!buffered) {
+          const lastChoices = Array.from(box.children).map(el=>el.textContent);
+          const lastPrompt = q.prompt;
+          try{ buffered = await fetchNext(selected, lastChoices, lastPrompt); }catch(e){ play.innerHTML = `<div style=\"color:#b91c1c;\">${String(e)}</div>`; return; }
+          // update counters
+          quizAsked++;
+          if (buffered.is_correct === true) quizCorrect++;
+          // highlight
+          const ca = buffered.correct_answer || '';
+          Array.from(box.children).forEach(el=>{
+            const val = el.textContent;
+            if (val === ca) el.classList.add('correct');
+            if (val === selected && val !== ca) el.classList.add('wrong');
+            el.disabled = true;
+          });
+          // show feedback
+          if (buffered.feedback) {
+            const fb = document.createElement('div'); fb.className='muted'; fb.style.marginTop='8px'; fb.textContent = buffered.feedback; play.appendChild(fb);
+          }
+          // progress + header refresh
+          const header = play.querySelector('.pill .l');
+          if (header) header.textContent = `Asked ${quizAsked}/${total} • Correct ${quizCorrect}`;
+          const bar = play.querySelector('.progress .bar'); if (bar) bar.style.width = `${Math.min(100, Math.round((quizAsked/Math.max(1,total))*100))}%`;
+          nextBtn.textContent = (remaining-1) <= 0 ? 'Finish' : 'Next';
+          remaining--;
+          return;
+        }
+        // Second click: render next question from buffer
+        if (remaining <= 0) {
+          play.innerHTML = `<div class=\"pill\" style=\"margin-top:12px;\"><div class=\"k\">Done!</div><div class=\"l\">Topic: ${state.topic} • Correct: ${quizCorrect}/${quizAsked}</div></div>`;
+          return;
+        }
+        const nextData = buffered; buffered = null; renderQuestion(nextData, false);
+      });
+    }
+    document.getElementById('start').addEventListener('click', async ()=>{
+      state = { topic: document.getElementById('topic').value || 'General knowledge', level: parseInt(document.getElementById('level').value||'3',10), questions_asked:0, correct:0, history:[] };
+      quizAsked = 0; quizCorrect = 0;
+      remaining = parseInt(document.getElementById('num').value||'3',10); total = remaining;
+      try{ const first = await fetchNext(null, null, null); renderQuestion(first, false); }catch(e){ play.style.display='block'; play.innerHTML = `<div style=\"color:#b91c1c;\">${String(e)}</div>`; }
+    });
+  </script>
+</body>
+</html>
+
+

AIRoute/app/main.py

@@ -0,0 +1,301 @@
+from fastapi import FastAPI, APIRouter, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from pydantic import BaseModel, Field, conint, confloat
+from typing import List, Optional, Tuple
+import os
+import sys
+import json
+from dotenv import load_dotenv, find_dotenv
+
+ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+if ROOT_DIR not in sys.path:
+    sys.path.append(ROOT_DIR)
+
+load_dotenv(find_dotenv(), override=True)
+
+
+class Address(BaseModel):
+    label: str
+    address: str
+
+
+class RouteRequest(BaseModel):
+    origin: Address
+    destinations: List[Address] = Field(min_items=1, max_items=8)
+    fuel_cost_per_km: confloat(ge=0) = 0.2
+    average_speed_kmph: confloat(ge=5, le=120) = 35.0
+
+
+class Stop(BaseModel):
+    order: conint(ge=1)
+    label: str
+    address: str
+    eta_minutes: conint(ge=0)
+    distance_km: confloat(ge=0)
+
+
+class GeoPoint(BaseModel):
+    label: str
+    address: str
+    lat: float
+    lng: float
+
+
+class RouteResponse(BaseModel):
+    summary: str
+    total_distance_km: confloat(ge=0)
+    total_time_minutes: conint(ge=0)
+    estimated_fuel_cost: confloat(ge=0)
+    estimated_savings: confloat(ge=0)
+    route: List[Stop]
+    maps_url: Optional[str] = None
+    points: Optional[List[GeoPoint]] = None
+    order: Optional[List[int]] = None
+    maps_embed_url: Optional[str] = None
+
+
+from openai import OpenAI
+
+
+GEOCODE_PROMPT = (
+    "You are a geocoding assistant. Convert each address to a clean, standardized form with latitude and longitude. "
+    "If uncertain, provide your best estimate based on the city and well-known landmarks. Return STRICT JSON only."
+)
+
+
+class RouteService:
+    def __init__(self) -> None:
+        key = (os.getenv("OPENAI_API_KEY") or "").strip().strip('"').strip("'")
+        if not key:
+            raise RuntimeError("OPENAI_API_KEY is not set")
+        base_url = (os.getenv("OPENAI_BASE_URL") or "").strip().strip('"').strip("'") or None
+        kwargs = {"api_key": key}
+        if base_url:
+            kwargs["base_url"] = base_url
+        self.client = OpenAI(**kwargs)
+        self.model = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+        self.maps_embed_key = (os.getenv("GOOGLE_MAPS_EMBED_KEY") or "").strip().strip('"').strip("'") or None
+
+    def optimize(self, req: RouteRequest) -> RouteResponse:
+        # 1) Geocode all points via model
+        points = [req.origin] + req.destinations
+        user_json = json.dumps({"points": [p.model_dump() for p in points]}, ensure_ascii=False)
+        try:
+            resp = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": GEOCODE_PROMPT},
+                    {"role": "user", "content": user_json},
+                ],
+                temperature=0.0,
+                response_format={
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": "GeoPoints",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": False,
+                            "required": ["points"],
+                            "properties": {
+                                "points": {
+                                    "type": "array",
+                                    "minItems": 2,
+                                    "items": {
+                                        "type": "object",
+                                        "required": ["label","address","lat","lng"],
+                                        "properties": {
+                                            "label": {"type": "string"},
+                                            "address": {"type": "string"},
+                                            "lat": {"type": "number"},
+                                            "lng": {"type": "number"}
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+            )
+            geo_content = resp.choices[0].message.content
+            geo_data = json.loads(geo_content)
+        except Exception as exc:
+            raise RuntimeError(f"Geocoding failed: {exc}")
+
+        geo_points = geo_data.get("points", [])
+        if len(geo_points) < 2:
+            raise RuntimeError("Not enough points after geocoding")
+
+        # 2) Build distance matrix using haversine
+        def haversine_km(a: Tuple[float, float], b: Tuple[float, float]) -> float:
+            from math import radians, sin, cos, asin, sqrt
+            lat1, lon1 = a
+            lat2, lon2 = b
+            R = 6371.0
+            dlat = radians(lat2 - lat1)
+            dlon = radians(lon2 - lon1)
+            lat1 = radians(lat1)
+            lat2 = radians(lat2)
+            h = sin(dlat/2)**2 + cos(lat1)*cos(lat2)*sin(dlon/2)**2
+            return 2*R*asin(sqrt(h))
+
+        coords = [(p["lat"], p["lng"]) for p in geo_points]
+        n = len(coords)
+        dist = [[0.0]*n for _ in range(n)]
+        for i in range(n):
+            for j in range(i+1, n):
+                d = haversine_km(coords[i], coords[j])
+                dist[i][j] = dist[j][i] = d
+
+        # 3) Naive sequence cost (origin -> input order)
+        naive_order = list(range(n))  # 0 origin, then in-given order
+        def path_cost(order: List[int]) -> float:
+            c = 0.0
+            for i in range(len(order)-1):
+                c += dist[order[i]][order[i+1]]
+            return c
+
+        naive_cost = path_cost(naive_order)
+
+        # 4) Heuristic route: nearest neighbor then 2-opt
+        remaining = list(range(1, n))
+        route = [0]
+        while remaining:
+            last = route[-1]
+            next_idx = min(remaining, key=lambda k: dist[last][k])
+            route.append(next_idx)
+            remaining.remove(next_idx)
+
+        def two_opt(order: List[int]) -> List[int]:
+            improved = True
+            best = order[:]
+            best_cost = path_cost(best)
+            while improved:
+                improved = False
+                for i in range(1, len(best)-2):
+                    for j in range(i+1, len(best)-1):
+                        if j - i == 1:
+                            continue
+                        new_order = best[:i] + best[i:j][::-1] + best[j:]
+                        new_cost = path_cost(new_order)
+                        if new_cost + 1e-6 < best_cost:
+                            best, best_cost = new_order, new_cost
+                            improved = True
+                # Cap iterations implicitly by convergence
+            return best
+
+        route = two_opt(route)
+
+        # 5) Compose response: distances/time per leg from origin to last stop
+        avg_speed = float(req.average_speed_kmph)
+        legs: List[Stop] = []
+        total_km = 0.0
+        total_min = 0
+        for order_idx in range(1, len(route)):
+            prev_i = route[order_idx-1]
+            curr_i = route[order_idx]
+            leg_km = dist[prev_i][curr_i]
+            leg_min = int(round((leg_km / max(1e-6, avg_speed)) * 60))
+            total_km += leg_km
+            total_min += leg_min
+            p = geo_points[curr_i]
+            legs.append(Stop(order=order_idx, label=p["label"], address=p["address"], eta_minutes=leg_min, distance_km=leg_km))
+
+        fuel_cost = round(total_km * float(req.fuel_cost_per_km), 2)
+        naive_cost_km = naive_cost
+        naive_fuel = round(naive_cost_km * float(req.fuel_cost_per_km), 2)
+        savings = max(0.0, naive_fuel - fuel_cost)
+
+        # 6) Google Maps URL (best-effort)
+        try:
+            from urllib.parse import quote
+            origin_addr = quote(geo_points[route[0]]["address"])  # should be origin
+            final_addr = quote(geo_points[route[-1]]["address"]) if len(route) > 1 else origin_addr
+            waypoints = []
+            if len(route) > 2:
+                for idx in route[1:-1]:
+                    waypoints.append(quote(geo_points[idx]["address"]))
+            wp = "%7C".join(waypoints)
+            maps_url = f"https://www.google.com/maps/dir/?api=1&origin={origin_addr}&destination={final_addr}" + (f"&waypoints={wp}" if wp else "")
+        except Exception:
+            maps_url = None
+
+        # Google Maps Embed API (optional, requires key)
+        maps_embed_url = None
+        try:
+            if self.maps_embed_key:
+                # Prefer lat,lng to avoid geocoding ambiguity on client
+                def latlng(i: int) -> str:
+                    p = geo_points[i]
+                    return f"{p['lat']},{p['lng']}"
+                origin_ll = latlng(route[0])
+                dest_ll = latlng(route[-1]) if len(route) > 1 else origin_ll
+                wps = "|".join(latlng(i) for i in route[1:-1]) if len(route) > 2 else ""
+                from urllib.parse import quote
+                wps_q = quote(wps, safe='|,')
+                maps_embed_url = (
+                    f"https://www.google.com/maps/embed/v1/directions?key={self.maps_embed_key}"
+                    f"&origin={quote(origin_ll)}&destination={quote(dest_ll)}" + (f"&waypoints={wps_q}" if wps else "")
+                )
+        except Exception:
+            maps_embed_url = None
+
+        summary = (
+            f"Optimized a route with {len(legs)} stops at ~{avg_speed:.0f} km/h. "
+            f"Estimated distance {total_km:.1f} km in {total_min} min. "
+            f"Fuel cost ${fuel_cost:.2f}. Compared to naive order (~{naive_cost_km:.1f} km), estimated savings ${savings:.2f}."
+        )
+
+        return RouteResponse(
+            summary=summary,
+            total_distance_km=round(total_km, 2),
+            total_time_minutes=int(total_min),
+            estimated_fuel_cost=fuel_cost,
+            estimated_savings=round(savings, 2),
+            route=legs,
+            maps_url=maps_url,
+            points=[GeoPoint(**p) for p in geo_points],
+            order=route,
+            maps_embed_url=maps_embed_url,
+        )
+
+
+app = FastAPI(title="Route Optimizer", version="0.1.0")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+router = APIRouter(prefix="/route", tags=["route"])
+
+
+@router.get("/health")
+def health() -> dict:
+    return {
+        "status": "ok",
+        "openai_key": bool(os.getenv("OPENAI_API_KEY")),
+        "model": os.getenv("OPENAI_MODEL", "gpt-4o-mini"),
+        "base_url": os.getenv("OPENAI_BASE_URL") or None,
+    }
+
+
+@router.post("/optimize", response_model=RouteResponse)
+def optimize(payload: RouteRequest) -> RouteResponse:
+    try:
+        return RouteService().optimize(payload)
+    except Exception as exc:
+        raise HTTPException(status_code=502, detail=f"Route optimizer error: {exc}")
+
+
+app.include_router(router)
+
+
+@app.get("/", response_class=FileResponse)
+def index() -> FileResponse:
+    base = os.path.dirname(__file__)
+    return FileResponse(os.path.join(base, "static", "index.html"))
+
+

AIRoute/app/static/index.html

@@ -0,0 +1,168 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8"/>
+  <meta name="viewport" content="width=device-width, initial-scale=1"/>
+  <title>Route Optimizer</title>
+  <link rel="stylesheet" href="/static/suite.css"/>
+  <style>
+    .mono{font-family:ui-monospace,Menlo,Consolas,monospace}
+    .grid.two-col{grid-template-columns:1fr}
+    @media (min-width:1000px){.grid.two-col{grid-template-columns:1fr 1fr}}
+    .stops{display:grid;gap:12px}
+    .actions{display:flex;gap:12px;flex-wrap:wrap;margin-top:12px}
+    .stats{display:grid;gap:12px;grid-template-columns:1fr 1fr; margin:8px 0}
+    @media (min-width:900px){.stats{grid-template-columns:repeat(4,1fr)}}
+    .pill{background:#fff;border:1px solid var(--border);border-radius:12px;padding:10px}
+    .pill .k{font-weight:800;font-size:18px}
+    .pill .l{color:var(--muted);font-size:12px;margin-top:4px}
+    .pill.good{border-color:#22c55e33;background:#ecfdf5}
+    .stop-remove{appearance:none;border:0;background:#f3f4f6;color:#111827;padding:8px 10px;border-radius:8px;font-weight:700;cursor:pointer}
+    .stop-remove:hover{background:#e5e7eb}
+  </style>
+</head>
+<body>
+  <div id="suite-shared-header"></div>
+  <div class="container">
+    <h1>Route Optimizer</h1>
+    <p class="muted">Enter origin and destinations to get the fastest route, ETAs, and savings.</p>
+    <div class="grid" id="grid">
+      <div class="card">
+        <div class="form-row">
+          <div>
+            <label for="originLabel">Origin label</label>
+            <input id="originLabel" type="text" placeholder="Warehouse"/>
+          </div>
+          <div>
+            <label for="origin">Origin address</label>
+            <input id="origin" type="text" placeholder="1600 Amphitheatre Pkwy, Mountain View, CA"/>
+          </div>
+        </div>
+        <label for="fuel">Fuel cost per km</label>
+        <input id="fuel" type="number" min="0" step="0.01" value="0.2"/>
+        <h2>Destinations</h2>
+        <div id="stops" class="stops"></div>
+        <div class="actions">
+          <button id="addStop" class="btn" type="button">Add destination</button>
+          <button id="optimize" class="btn" type="button">Optimize</button>
+        </div>
+      </div>
+      <div id="out" class="card" style="display:none"></div>
+    </div>
+  </div>
+  <script src="/static/header.js"></script>
+  <script>
+    const stopsEl = document.getElementById('stops');
+    const addStopBtn = document.getElementById('addStop');
+    const out = document.getElementById('out');
+    const grid = document.getElementById('grid');
+    function stopRow(i){
+      const wrap = document.createElement('div');
+      wrap.className='form-row';
+      wrap.innerHTML = `
+        <div>
+          <label>Label</label>
+          <input type="text" placeholder="Stop ${i+1}"/>
+        </div>
+        <div>
+          <label>Address</label>
+          <input type="text" placeholder="address line"/>
+        </div>
+        <div style="align-self:flex-end;">
+          <button class="stop-remove" type="button">Remove</button>
+        </div>
+      `;
+      wrap.querySelector('.stop-remove').addEventListener('click', ()=>{
+        wrap.remove();
+      });
+      return wrap;
+    }
+    function addStop(){
+      stopsEl.appendChild(stopRow(stopsEl.children.length));
+    }
+    addStopBtn.addEventListener('click', ()=>{
+      addStop();
+    });
+    // seed 5
+    for(let i=0;i<5;i++) addStop();
+
+    document.getElementById('optimize').addEventListener('click', async ()=>{
+      const origin = {
+        label: document.getElementById('originLabel').value || 'Origin',
+        address: document.getElementById('origin').value || ''
+      };
+      const dests = Array.from(stopsEl.children).map(row=>{
+        const inputs = row.querySelectorAll('input');
+        return { label: inputs[0].value || 'Stop', address: inputs[1].value || '' };
+      }).filter(d=>d.address.trim().length>0);
+      const fuel = parseFloat(document.getElementById('fuel').value || '0.2');
+      out.style.display='block';
+      grid.classList.add('two-col');
+      out.innerHTML = '<div class="muted">(optimizing...)</div>';
+      try{
+        const res = await fetch('/route/optimize', {method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify({origin, destinations:dests, fuel_cost_per_km:fuel})});
+        if(!res.ok) throw new Error(await res.text());
+        const data = await res.json();
+        const legs = (data.route||[]).map(s=>`<tr><td>${s.order}</td><td>${s.label}</td><td>${s.address}</td><td>${s.distance_km.toFixed(2)} km</td><td>${s.eta_minutes} min</td></tr>`).join('');
+        // Visual: simple SVG polyline map approximation using normalized lat/lng
+        let svg = '';
+        try{
+          const pts = (data.points||[]);
+          const ord = (data.order||[]);
+          if(pts.length && ord.length){
+            const lats = ord.map(i=>pts[i].lat);
+            const lngs = ord.map(i=>pts[i].lng);
+            const minLat=Math.min(...lats), maxLat=Math.max(...lats);
+            const minLng=Math.min(...lngs), maxLng=Math.max(...lngs);
+            const pad=12, W=440, H=280;
+            const norm=(lat,lng)=>[
+              pad + ( (lng-minLng)/(maxLng-minLng||1) )*(W-2*pad),
+              pad + ( 1-((lat-minLat)/(maxLat-minLat||1)) )*(H-2*pad)
+            ];
+            const pointsStr = ord.map(i=>{
+              const p = norm(pts[i].lat, pts[i].lng);
+              return p[0].toFixed(1)+','+p[1].toFixed(1);
+            }).join(' ');
+            const markers = ord.map((i,idx)=>{
+              const p = norm(pts[i].lat, pts[i].lng);
+              return `<circle cx="${p[0].toFixed(1)}" cy="${p[1].toFixed(1)}" r="4" fill="#111827"/><text x="${(p[0]+6).toFixed(1)}" y="${(p[1]-6).toFixed(1)}" font-size="10" fill="#111827">${idx}</text>`;
+            }).join('');
+            svg = `<svg viewBox="0 0 ${W} ${H}" style="width:100%;max-width:520px;border:1px solid var(--border);border-radius:8px;background:#fff">
+                     <polyline points="${pointsStr}" fill="none" stroke="#3b82f6" stroke-width="2"/>
+                     ${markers}
+                   </svg>`;
+          }
+        }catch(_){ svg=''; }
+
+        const stats = `
+          <div class="stats">
+            <div class="pill"><div class="k">${data.total_distance_km.toFixed(1)} km</div><div class="l">Distance</div></div>
+            <div class="pill"><div class="k">${data.total_time_minutes} min</div><div class="l">Time</div></div>
+            <div class="pill"><div class="k">$${data.estimated_fuel_cost.toFixed(2)}</div><div class="l">Fuel</div></div>
+            <div class="pill good"><div class="k">$${data.estimated_savings.toFixed(2)}</div><div class="l">Savings</div></div>
+          </div>`;
+
+        out.innerHTML = `
+          <div><strong>Summary</strong></div>
+          <p style="white-space:pre-wrap;">${(data.summary||'').replace(/</g,'&lt;').replace(/>/g,'&gt;')}</p>
+          ${stats}
+          ${svg ? `<div style=\"margin:8px 0;\"><strong>Route preview</strong></div>${svg}` : ''}
+          ${data.maps_embed_url ? `<div style=\"margin-top:8px;\"><strong>Google Maps</strong></div><iframe title=\"Route\" width=\"100%\" height=\"360\" style=\"border:0;border-radius:10px;\" loading=\"lazy\" referrerpolicy=\"no-referrer-when-downgrade\" src=\"${data.maps_embed_url}\"></iframe>` : (data.maps_url ? `<div style=\"margin-top:8px;\"><a class=\"btn\" href=\"${data.maps_url}\" target=\"_blank\" rel=\"noopener\">Open in Google Maps</a></div>` : '')}
+          <table class="table" style="margin-top:8px;">
+            <thead><tr><th>#</th><th>Label</th><th>Address</th><th>Distance</th><th>ETA</th></tr></thead>
+            <tbody>${legs}</tbody>
+          </table>
+          <div style="margin-top:8px;">
+            <strong>Total:</strong> ${data.total_distance_km.toFixed(2)} km, ${data.total_time_minutes} min
+          </div>
+          <div><strong>Fuel cost:</strong> $${data.estimated_fuel_cost.toFixed(2)} | <strong>Estimated savings:</strong> $${data.estimated_savings.toFixed(2)}</div>
+        `;
+      }catch(e){
+        out.innerHTML = `<div style="color:#b91c1c;">Error: ${String(e)}</div>`;
+      }
+    });
+  </script>
+</body>
+</html>
+
+

AISaas/app/main.py

@@ -0,0 +1,190 @@
+from fastapi import FastAPI, APIRouter, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from pydantic import BaseModel, Field, conint, confloat
+from typing import List, Optional
+import os
+import sys
+import json
+from dotenv import load_dotenv, find_dotenv
+
+ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+if ROOT_DIR not in sys.path:
+    sys.path.append(ROOT_DIR)
+
+load_dotenv(find_dotenv(), override=True)
+
+
+class ActivityEvent(BaseModel):
+    user_id: str
+    timestamp: str
+    event: str
+    meta: Optional[dict] = None
+
+
+class ChurnAnalysisRequest(BaseModel):
+    company: Optional[str] = None
+    lookback_days: conint(ge=7, le=365) = 90
+    events: List[ActivityEvent] = Field(default_factory=list)
+
+
+class AtRiskCustomer(BaseModel):
+    user_id: str
+    risk_score: confloat(ge=0.0, le=1.0)
+    signals: List[str]
+    recommended_actions: List[str]
+
+
+class ChurnAnalysisResponse(BaseModel):
+    summary: str
+    cohort: List[str] = []
+    at_risk: List[AtRiskCustomer]
+    global_recommendations: List[str]
+
+
+from openai import OpenAI
+
+
+SYSTEM_PROMPT = (
+    "You are a senior SaaS Churn Analyst. Your job is to review raw user activity logs and produce an executive-grade "
+    "churn-risk analysis that is precise, defensible, and actionable.\n\n"
+    "Guidelines:\n"
+    "- Be conservative; never invent facts. Base every claim on the provided logs only.\n"
+    "- Consider signals such as: dropping login frequency, no usage in lookback window, reduced feature adoption, loss of breadth (fewer distinct features), recent plan downgrade, failed billing, support tickets (severity), email unsubscribes, expiring or ended trials, lack of invites/seat growth.\n"
+    "- Calibrate risk_score as: 0.80–1.00 = high risk, 0.40–0.79 = medium, 0.00–0.39 = low. Use increments of ~0.05 and avoid rounding to 0 or 1 unless clearly warranted.\n"
+    "- For each at-risk user, include 3–6 concise signals. Each signal should reference specific evidence (event names, dates, simple counts) in plain text.\n"
+    "- Recommended actions must be practical and role-targeted (e.g., Customer Success email, in‑app nudge, tailored enablement, billing outreach) and limited to 3–5 per user.\n"
+    "- Keep the summary executive-friendly (5–8 sentences).\n"
+    "- Sort at_risk in descending risk_score. If no users are risky, return an empty list and explain why in the summary.\n\n"
+    "Return STRICTLY VALID JSON exactly matching the schema."
+)
+
+
+class ChurnPredictorService:
+    def __init__(self) -> None:
+        key = (os.getenv("OPENAI_API_KEY") or "").strip().strip('"').strip("'")
+        if not key:
+            raise RuntimeError("OPENAI_API_KEY is not set")
+        base_url = (os.getenv("OPENAI_BASE_URL") or "").strip().strip('"').strip("'") or None
+        kwargs = {"api_key": key}
+        if base_url:
+            kwargs["base_url"] = base_url
+        self.client = OpenAI(**kwargs)
+        self.model = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+
+    def analyze(self, req: ChurnAnalysisRequest) -> ChurnAnalysisResponse:
+        # Compose a compact event list for the model
+        lines = [
+            f"Company: {req.company or 'N/A'}",
+            f"Lookback days: {req.lookback_days}",
+            "Events: user_id | timestamp | event | meta",
+        ]
+        for ev in req.events[:2000]:
+            meta_str = json.dumps(ev.meta, ensure_ascii=False) if ev.meta else "{}"
+            meta_str = meta_str.replace("\n", " ")
+            lines.append(f"{ev.user_id} | {ev.timestamp} | {ev.event} | {meta_str}")
+        user_msg = "\n".join(lines)
+
+        try:
+            resp = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": SYSTEM_PROMPT},
+                    {"role": "user", "content": user_msg},
+                ],
+                temperature=0.1,
+                response_format={
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": "ChurnAnalysisResponse",
+                        "schema": {
+                            "type": "object",
+                            "additionalProperties": False,
+                            "required": ["summary", "at_risk", "global_recommendations"],
+                            "properties": {
+                                "summary": {"type": "string"},
+                                "cohort": {"type": "array", "items": {"type": "string"}},
+                                "at_risk": {
+                                    "type": "array",
+                                    "items": {
+                                        "type": "object",
+                                        "required": ["user_id", "risk_score", "signals", "recommended_actions"],
+                                        "properties": {
+                                            "user_id": {"type": "string"},
+                                            "risk_score": {"type": "number", "minimum": 0.0, "maximum": 1.0},
+                                            "signals": {"type": "array", "items": {"type": "string"}},
+                                            "recommended_actions": {"type": "array", "items": {"type": "string"}}
+                                        }
+                                    }
+                                },
+                                "global_recommendations": {"type": "array", "items": {"type": "string"}}
+                            }
+                        }
+                    }
+                },
+            )
+            content = resp.choices[0].message.content
+        except Exception:
+            resp = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": SYSTEM_PROMPT + "\nReturn ONLY JSON."},
+                    {"role": "user", "content": user_msg},
+                ],
+                temperature=0.2,
+                response_format={"type": "json_object"},
+            )
+            content = resp.choices[0].message.content
+
+        try:
+            data = json.loads(content)
+        except Exception:
+            start = content.find("{")
+            end = content.rfind("}")
+            if start != -1 and end != -1 and end > start:
+                data = json.loads(content[start : end + 1])
+            else:
+                raise RuntimeError("Invalid JSON from model")
+
+        return ChurnAnalysisResponse.model_validate(data)
+
+
+app = FastAPI(title="SaaS Churn Predictor", version="0.1.0")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+router = APIRouter(prefix="/saas", tags=["saas"])
+
+
+@router.get("/health")
+def health() -> dict:
+    return {
+        "status": "ok",
+        "openai_key": bool(os.getenv("OPENAI_API_KEY")),
+        "model": os.getenv("OPENAI_MODEL", "gpt-4o-mini"),
+        "base_url": os.getenv("OPENAI_BASE_URL") or None,
+    }
+
+
+@router.post("/analyze", response_model=ChurnAnalysisResponse)
+def analyze(payload: ChurnAnalysisRequest) -> ChurnAnalysisResponse:
+    try:
+        return ChurnPredictorService().analyze(payload)
+    except Exception as exc:
+        raise HTTPException(status_code=502, detail=f"Churn predictor error: {exc}")
+
+
+app.include_router(router)
+
+
+@app.get("/", response_class=FileResponse)
+def index() -> FileResponse:
+    base = os.path.dirname(__file__)
+    return FileResponse(os.path.join(base, "static", "index.html"))
+
+

AISaas/app/static/index.html

@@ -0,0 +1,99 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8"/>
+  <meta name="viewport" content="width=device-width, initial-scale=1"/>
+  <title>SaaS Churn Predictor</title>
+  <link rel="stylesheet" href="/static/suite.css"/>
+  <style>
+    .mono{font-family:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace}
+    .grid.two-col{grid-template-columns:1fr}
+    @media (min-width:1000px){.grid.two-col{grid-template-columns:1fr 1fr}}
+  </style>
+</head>
+<body>
+  <div id="suite-shared-header"></div>
+  <div class="container">
+    <h1>SaaS Churn Predictor</h1>
+    <p class="muted">Paste mock user activity logs; get at‑risk customers and actions.</p>
+
+    <div class="grid" id="grid">
+      <div class="card">
+        <div class="form-row">
+          <div>
+            <label for="company">Company (optional)</label>
+            <input id="company" type="text" placeholder="Acme SaaS"/>
+          </div>
+          <div>
+            <label for="lookback">Lookback (days)</label>
+            <input id="lookback" type="number" min="7" max="365" value="90"/>
+          </div>
+        </div>
+        <label for="events">User activity logs (JSON array)</label>
+        <textarea id="events" class="mono" rows="14" placeholder='[
+  {"user_id": "u_1", "timestamp": "2025-09-01T08:00:00Z", "event": "login"},
+  {"user_id": "u_1", "timestamp": "2025-09-05T12:14:00Z", "event": "feature_used", "meta": {"feature": "dashboards"}},
+  {"user_id": "u_2", "timestamp": "2025-09-02T09:10:00Z", "event": "support_ticket", "meta": {"severity": "medium"}}
+]'></textarea>
+        <button id="analyzeBtn" class="btn">Analyze</button>
+      </div>
+      <div class="card" id="output" style="display:none;"></div>
+    </div>
+  </div>
+  <script src="/static/header.js"></script>
+  <script>
+    const elCompany = document.getElementById('company');
+    const elLook = document.getElementById('lookback');
+    const elEvents = document.getElementById('events');
+    const elOut = document.getElementById('output');
+    document.getElementById('analyzeBtn').addEventListener('click', async () => {
+      let events = [];
+      try {
+        events = JSON.parse(elEvents.value || '[]');
+        if (!Array.isArray(events)) throw new Error('Events must be a JSON array');
+      } catch (e) {
+        elOut.style.display = 'block';
+        document.getElementById('grid').classList.add('two-col');
+        elOut.innerHTML = `<div style="color:#b91c1c;">Invalid JSON: ${String(e)}</div>`;
+        return;
+      }
+      const payload = {
+        company: elCompany.value.trim() || null,
+        lookback_days: parseInt(elLook.value, 10) || 90,
+        events
+      };
+      elOut.style.display = 'block';
+      document.getElementById('grid').classList.add('two-col');
+      elOut.innerHTML = '<div class="muted">(analyzing...)</div>';
+      try {
+        const res = await fetch('/saas/analyze', { method: 'POST', headers: {'Content-Type':'application/json'}, body: JSON.stringify(payload) });
+        if (!res.ok) throw new Error(await res.text());
+        const data = await res.json();
+        const risks = (data.at_risk || []).map(r => {
+          const sig = (r.signals||[]).map(s=>`<li>${s}</li>`).join('');
+          const acts = (r.recommended_actions||[]).map(a=>`<li>${a}</li>`).join('');
+          return `<div class="card" style="margin-top:12px;">
+            <div><strong>User:</strong> ${r.user_id} <span class="muted">(risk ${(r.risk_score??0).toFixed(2)})</span></div>
+            <div style="margin-top:6px;"><strong>Signals</strong><ul>${sig || '<li class="muted">None</li>'}</ul></div>
+            <div style="margin-top:6px;"><strong>Recommended actions</strong><ul>${acts || '<li class="muted">None</li>'}</ul></div>
+          </div>`;
+        }).join('');
+        const cohort = (data.cohort||[]).map(c=>`<code class="mono">${c}</code>`).join(' ');
+        elOut.innerHTML = `
+          <div><strong>Summary</strong></div>
+          <div style="white-space:pre-wrap;margin-top:6px;">${(data.summary||'').replace(/</g,'&lt;').replace(/>/g,'&gt;')}</div>
+          <div style="margin-top:12px;"><strong>At-risk customers</strong></div>
+          ${risks || '<div class="muted">None identified</div>'}
+          <div style="margin-top:12px;"><strong>Global recommendations</strong></div>
+          <ul>${(data.global_recommendations||[]).map(g=>`<li>${g}</li>`).join('') || '<li class="muted">None</li>'}</ul>
+          <div style="margin-top:12px;"><strong>Cohort</strong> ${cohort || '<span class="muted">N/A</span>'}</div>
+        `;
+      } catch (e) {
+        elOut.innerHTML = `<div style="color:#b91c1c;">Error: ${String(e)}</div>`;
+      }
+    });
+  </script>
+</body>
+</html>
+
+

AIStrategy/app/main.py

@@ -0,0 +1,148 @@
+from fastapi import FastAPI, APIRouter, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from pydantic import BaseModel, Field
+from typing import List, Literal, Optional
+import os
+import sys
+import json
+from dotenv import load_dotenv, find_dotenv
+
+ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+if ROOT_DIR not in sys.path:
+    sys.path.append(ROOT_DIR)
+
+load_dotenv(find_dotenv(), override=True)
+
+
+class StrategyRequest(BaseModel):
+    product_idea: str = Field(..., description="Describe the product idea and target users")
+    context: Optional[str] = Field(None, description="Optional business constraints, competitors, goals")
+
+
+class StrategyAdvice(BaseModel):
+    verdict: Literal["feature", "product", "unclear"]
+    rationale: List[str]
+    differentiation: List[str]
+    scope_mvp: List[str]
+    risks: List[str]
+    next_steps: List[str]
+
+
+from openai import OpenAI
+
+
+SYSTEM = (
+    "You are an executive product strategy coach. Given a product idea, advise whether AI should be a FEATURE inside a wider "
+    "product or whether AI IS THE PRODUCT. Your advice must be practical, defensible, and immediately useful.\n\n"
+    "Decision policy (apply all):\n"
+    "- Data advantage: Is there proprietary/high‑quality data and a learning loop?\n"
+    "- Workflow dependence: Does the core user outcome hinge on model output vs. orchestration/UI/integrations?\n"
+    "- Defensibility: Is there a moat (feedback, evals, infra, distribution) beyond prompt engineering?\n"
+    "- ROI and constraints: Clear business lift vs. simpler heuristics; latency/cost fit SLAs; safety/compliance manageable.\n"
+    "- Operability: Can the org monitor, evaluate, and retrain reliably?\n\n"
+    "Verdict rules:\n"
+    "- product: Core value is the model’s decisions/creations and strengthens with data network effects; non‑AI alternatives are weak.\n"
+    "- feature: AI augments a workflow; primary value is product/UX/system; heuristics could deliver most value.\n"
+    "- unclear: Information is insufficient or highly contingent on GTM/constraints. Prefer 'unclear' over guessing.\n\n"
+    "Output requirements (JSON schema enforced):\n"
+    "- rationale: 4–7 terse bullets mapping evidence to the verdict (no fluff, no restating the prompt).\n"
+    "- differentiation: 3–6 bullets on moats (data, evals, distribution, UX), not vendor names.\n"
+    "- scope_mvp: 3–6 concrete MVP items with success metrics (e.g., +X% reply rate, <Y ms latency).\n"
+    "- risks: 3–6 specific risks (data gaps, drift, eval difficulty, privacy/regulatory, hallucination impact).\n"
+    "- next_steps: 3–6 actions with a 30/60/90‑day shape (data plan, evals, baseline, pilot scope).\n\n"
+    "Rules: Be vendor‑agnostic, no hand‑waving, no hallucinated internal policies. If info is missing, set verdict='unclear' and include
+    clarifying questions in next_steps."
+)
+
+
+class StrategyCoachService:
+    def __init__(self) -> None:
+        key = (os.getenv("OPENAI_API_KEY") or "").strip().strip('"').strip("'")
+        if not key:
+            raise RuntimeError("OPENAI_API_KEY is not set")
+        base_url = (os.getenv("OPENAI_BASE_URL") or "").strip().strip('"').strip("'") or None
+        kwargs = {"api_key": key}
+        if base_url:
+            kwargs["base_url"] = base_url
+        self.client = OpenAI(**kwargs)
+        self.model = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+
+    def advise(self, req: StrategyRequest) -> StrategyAdvice:
+        user = (
+            "Product idea:\n" + req.product_idea.strip() + "\n\n" +
+            ("Context:\n" + req.context.strip() if (req.context and req.context.strip()) else "")
+        )
+        resp = self.client.chat.completions.create(
+            model=self.model,
+            messages=[
+                {"role": "system", "content": SYSTEM},
+                {"role": "user", "content": user},
+            ],
+            temperature=0.1,
+            response_format={
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "StrategyAdvice",
+                    "schema": {
+                        "type": "object",
+                        "additionalProperties": False,
+                        "required": ["verdict", "rationale", "differentiation", "scope_mvp", "risks", "next_steps"],
+                        "properties": {
+                            "verdict": {"type": "string", "enum": ["feature", "product", "unclear"]},
+                            "rationale": {"type": "array", "items": {"type": "string"}},
+                            "differentiation": {"type": "array", "items": {"type": "string"}},
+                            "scope_mvp": {"type": "array", "items": {"type": "string"}},
+                            "risks": {"type": "array", "items": {"type": "string"}},
+                            "next_steps": {"type": "array", "items": {"type": "string"}}
+                        }
+                    }
+                }
+            },
+        )
+        content = resp.choices[0].message.content
+        try:
+            data = json.loads(content)
+        except Exception:
+            start = content.find('{'); end = content.rfind('}')
+            if start != -1 and end != -1 and end > start:
+                data = json.loads(content[start:end+1])
+            else:
+                raise RuntimeError("Invalid JSON from model")
+        return StrategyAdvice.model_validate(data)
+
+
+app = FastAPI(title="Strategy Coach Bot", version="0.1.0")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+router = APIRouter(prefix="/strategy", tags=["strategy"])
+
+
+@router.get("/health")
+def health() -> dict:
+    return {"status":"ok","openai_key": bool(os.getenv("OPENAI_API_KEY")), "model": os.getenv("OPENAI_MODEL","gpt-4o-mini")}
+
+
+@router.post("/advise", response_model=StrategyAdvice)
+def advise(payload: StrategyRequest) -> StrategyAdvice:
+    try:
+        return StrategyCoachService().advise(payload)
+    except Exception as exc:
+        raise HTTPException(status_code=502, detail=f"Strategy coach error: {exc}")
+
+
+app.include_router(router)
+
+
+@app.get("/", response_class=FileResponse)
+def index() -> FileResponse:
+    base = os.path.dirname(__file__)
+    return FileResponse(os.path.join(base, "static", "index.html"))
+
+

AIStrategy/app/static/index.html

@@ -0,0 +1,54 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8"/>
+  <meta name="viewport" content="width=device-width, initial-scale=1"/>
+  <title>Strategy Coach Bot</title>
+  <link rel="stylesheet" href="/static/suite.css"/>
+  <style>
+    .actions{display:flex;gap:12px;flex-wrap:wrap;margin-top:12px}
+  </style>
+</head>
+<body>
+  <div id="suite-shared-header"></div>
+  <div class="container">
+    <h1>Strategy Coach Bot</h1>
+    <p class="muted">Input a product idea — get a verdict: AI as a feature vs AI as the product.</p>
+    <div class="grid two-col">
+      <div class="card">
+        <label for="idea">Product idea</label>
+        <textarea id="idea" rows="8" placeholder="Describe the user, problem, workflow, and where AI could help"></textarea>
+        <label for="ctx">Optional business context</label>
+        <textarea id="ctx" rows="6" placeholder="Constraints, competitors, goals"></textarea>
+        <div class="actions"><button id="go" class="btn">Advise</button></div>
+      </div>
+      <div class="card" id="out" style="display:none"></div>
+    </div>
+  </div>
+  <script src="/static/header.js"></script>
+  <script>
+    const out=document.getElementById('out');
+    document.getElementById('go').addEventListener('click', async ()=>{
+      const payload={product_idea:(document.getElementById('idea').value||''), context:(document.getElementById('ctx').value||null)};
+      out.style.display='block'; out.innerHTML='<div class="muted">(thinking...)</div>';
+      try{
+        const res=await fetch('/strategy/advise',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(payload)});
+        if(!res.ok) throw new Error(await res.text());
+        const d=await res.json();
+        const vlabel={feature:'AI should be a feature', product:'AI is the product', unclear:'Unclear'}[d.verdict]||d.verdict;
+        const list=(a)=> (a||[]).map(x=>`<li>${(x||'').replace(/</g,'&lt;').replace(/>/g,'&gt;')}</li>`).join('')||'<li class="muted">None</li>';
+        out.innerHTML=`
+          <h2>${vlabel}</h2>
+          <h3>Rationale</h3><ul>${list(d.rationale)}</ul>
+          <h3>Differentiation & Moat</h3><ul>${list(d.differentiation)}</ul>
+          <h3>MVP Scope</h3><ul>${list(d.scope_mvp)}</ul>
+          <h3>Risks</h3><ul>${list(d.risks)}</ul>
+          <h3>Next steps</h3><ul>${list(d.next_steps)}</ul>
+        `;
+      }catch(e){ out.innerHTML=`<div style="color:#b91c1c;">Error: ${String(e)}</div>`; }
+    });
+  </script>
+</body>
+</html>
+
+