Update api/server.py

api/server.py

@@ -1,8 +1,8 @@
 # api/server.py
 import os
 import time
-import threading
-from typing import Dict, List, Optional, Any
+import json
+from typing import Dict, List, Optional
 
 from fastapi import FastAPI, UploadFile, File, Form, Request
 from fastapi.responses import FileResponse, JSONResponse
@@ -23,15 +23,12 @@ from api.clare_core import (
     summarize_conversation,
 )
 
-# ✅ LangSmith
 try:
     from langsmith import Client
 except Exception:
     Client = None
 
-# ----------------------------
-# Paths / Constants
-# ----------------------------
+
 API_DIR = os.path.dirname(__file__)
 
 MODULE10_PATH = os.path.join(API_DIR, "module10_responsible_ai.pdf")
@@ -44,13 +41,6 @@ WEB_ASSETS = os.path.join(WEB_DIST, "assets")
 LS_DATASET_NAME = os.getenv("LS_DATASET_NAME", "clare_user_events").strip()
 LS_PROJECT = os.getenv("LANGSMITH_PROJECT", os.getenv("LANGCHAIN_PROJECT", "")).strip()
 
-# ✅ Profiling / Debug controls
-RETURN_LATENCY_BREAKDOWN = os.getenv("RETURN_LATENCY_BREAKDOWN", "1").strip() == "1"
-ASYNC_LANGSMITH_LOGGING = os.getenv("ASYNC_LANGSMITH_LOGGING", "1").strip() == "1"
-
-# ----------------------------
-# App
-# ----------------------------
 app = FastAPI(title="Clare API")
 
 app.add_middleware(
@@ -61,9 +51,6 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# ----------------------------
-# Static hosting (Vite build)
-# ----------------------------
 if os.path.isdir(WEB_ASSETS):
     app.mount("/assets", StaticFiles(directory=WEB_ASSETS), name="assets")
 
@@ -81,9 +68,6 @@ def index():
     )
 
 
-# ----------------------------
-# In-memory session store (MVP)
-# ----------------------------
 SESSIONS: Dict[str, Dict] = {}
 
 
@@ -115,34 +99,6 @@ def _get_session(user_id: str) -> Dict:
     return SESSIONS[user_id]
 
 
-# ----------------------------
-# Profiling helpers
-# ----------------------------
-def _now_ms() -> float:
-    return time.perf_counter() * 1000.0
-
-
-class _Perf:
-    def __init__(self):
-        self.t0 = _now_ms()
-        self.marks: Dict[str, float] = {}
-
-    def mark(self, name: str):
-        self.marks[name] = _now_ms() - self.t0
-
-    def summary(self) -> Dict[str, Any]:
-        keys = list(self.marks.keys())
-        prev = 0.0
-        seg = {}
-        for k in keys:
-            seg[k] = self.marks[k] - prev
-            prev = self.marks[k]
-        return {"marks_ms": dict(self.marks), "segments_ms": seg, "total_ms": prev}
-
-
-# ----------------------------
-# LangSmith helpers
-# ----------------------------
 _ls_client = None
 if Client is not None:
     try:
@@ -152,12 +108,7 @@ if Client is not None:
         _ls_client = None
 
 
-def _log_event_to_langsmith_sync(data: Dict):
-    """
-    Create an Example in LangSmith Dataset.
-    Inputs/Outputs show up as "Inputs" / "Reference Outputs".
-    Everything else goes into metadata columns.
-    """
+def _log_event_to_langsmith(data: Dict):
     if _ls_client is None:
         return
 
@@ -183,25 +134,6 @@ def _log_event_to_langsmith_sync(data: Dict):
         print("[langsmith] log failed:", repr(e))
 
 
-def _log_event_to_langsmith(data: Dict):
-    # ✅ Async mode: do not block API latency on network I/O
-    if not ASYNC_LANGSMITH_LOGGING:
-        _log_event_to_langsmith_sync(data)
-        return
-
-    if _ls_client is None:
-        return
-
-    def _runner():
-        _log_event_to_langsmith_sync(data)
-
-    t = threading.Thread(target=_runner, daemon=True)
-    t.start()
-
-
-# ----------------------------
-# Schemas
-# ----------------------------
 class LoginReq(BaseModel):
     name: str
     user_id: str
@@ -228,23 +160,17 @@ class SummaryReq(BaseModel):
 
 class FeedbackReq(BaseModel):
     user_id: str
-    rating: str  # "helpful" | "not_helpful"
+    rating: str
     assistant_message_id: Optional[str] = None
-
     assistant_text: str
     user_text: Optional[str] = ""
-
     comment: Optional[str] = ""
-
     refs: Optional[List[str]] = []
     learning_mode: Optional[str] = None
     doc_type: Optional[str] = None
     timestamp_ms: Optional[int] = None
 
 
-# ----------------------------
-# API Routes
-# ----------------------------
 @app.post("/api/login")
 def login(req: LoginReq):
     user_id = (req.user_id or "").strip()
@@ -259,8 +185,8 @@ def login(req: LoginReq):
 
 @app.post("/api/chat")
 def chat(req: ChatReq):
-    perf = _Perf()
-    perf.mark("start")
+    t0 = time.time()
+    marks = {"start": 0.0}
 
     user_id = (req.user_id or "").strip()
     msg = (req.message or "").strip()
@@ -277,24 +203,25 @@ def chat(req: ChatReq):
             ),
             "refs": [],
             "latency_ms": 0.0,
+            "latency_breakdown": {"total_ms": 0.0, "marks_ms": {}, "segments_ms": {}},
         }
 
-    # 1) language detect
     resolved_lang = detect_language(msg, req.language_preference)
-    perf.mark("language_detect_done")
+    marks["language_detect_done"] = (time.time() - t0) * 1000.0
 
-    # 2) state updates (cheap)
     sess["weaknesses"] = update_weaknesses_from_message(msg, sess["weaknesses"])
-    perf.mark("weakness_update_done")
+    marks["weakness_update_done"] = (time.time() - t0) * 1000.0
 
     sess["cognitive_state"] = update_cognitive_state_from_message(msg, sess["cognitive_state"])
-    perf.mark("cognitive_update_done")
+    marks["cognitive_update_done"] = (time.time() - t0) * 1000.0
 
-    # 3) RAG retrieval (can be heavy if chunks huge)
     rag_context_text, rag_used_chunks = retrieve_relevant_chunks(msg, sess["rag_chunks"])
-    perf.mark("rag_retrieve_done")
+    marks["rag_retrieve_done"] = (time.time() - t0) * 1000.0
+
+    rag_context_chars = len(rag_context_text or "")
+    used_chunks_count = len(rag_used_chunks or [])
+    history_len = len(sess.get("history") or [])
 
-    # 4) LLM
     try:
         answer, new_history = chat_with_clare(
             message=msg,
@@ -312,8 +239,9 @@ def chat(req: ChatReq):
         print(f"[chat] error: {repr(e)}")
         return JSONResponse({"error": f"chat failed: {repr(e)}"}, status_code=500)
 
-    perf.mark("llm_done")
+    marks["llm_done"] = (time.time() - t0) * 1000.0
 
+    total_ms = (time.time() - t0) * 1000.0
     sess["history"] = new_history
 
     refs = [
@@ -321,10 +249,22 @@ def chat(req: ChatReq):
         for c in (rag_used_chunks or [])
     ]
 
-    breakdown = perf.summary()
-    latency_ms_total = float(breakdown["total_ms"])
+    # segments_ms：给你一眼看“每段耗时”
+    marks_ms = dict(marks)
+    segments_ms = {}
+    order = ["start", "language_detect_done", "weakness_update_done", "cognitive_update_done", "rag_retrieve_done", "llm_done"]
+    prev = 0.0
+    for k in order[1:]:
+        cur = marks_ms.get(k, prev)
+        segments_ms[k] = max(0.0, cur - prev)
+        prev = cur
+
+    latency_breakdown = {
+        "marks_ms": marks_ms,
+        "segments_ms": segments_ms,
+        "total_ms": total_ms,
+    }
 
-    # 5) LangSmith log (async by default)
     _log_event_to_langsmith(
         {
             "experiment_id": "RESP_AI_W10",
@@ -332,9 +272,8 @@ def chat(req: ChatReq):
             "student_name": sess.get("name", ""),
             "event_type": "chat_turn",
             "timestamp": time.time(),
-            "latency_ms": latency_ms_total,
-            "latency_breakdown": breakdown,  # ✅ now visible in metadata
-
+            "latency_ms": total_ms,
+            "latency_breakdown": json.dumps(latency_breakdown, ensure_ascii=False),
             "question": msg,
             "answer": answer,
             "model_name": sess["model_name"],
@@ -342,26 +281,24 @@ def chat(req: ChatReq):
             "learning_mode": req.learning_mode,
             "doc_type": req.doc_type,
             "refs": refs,
-
-            # ✅ helpful debug dimensions
-            "rag_used_chunks_count": len(rag_used_chunks or []),
-            "rag_context_chars": len(rag_context_text or ""),
-            "history_len": len(sess.get("history") or []),
+            "history_len": history_len,
+            "rag_context_chars": rag_context_chars,
+            "rag_used_chunks_count": used_chunks_count,
         }
     )
-    perf.mark("langsmith_log_scheduled")
 
-    resp = {
+    return {
         "reply": answer,
         "session_status_md": render_session_status(
             req.learning_mode, sess["weaknesses"], sess["cognitive_state"]
         ),
         "refs": refs,
-        "latency_ms": latency_ms_total,
+        "latency_ms": total_ms,
+        "latency_breakdown": latency_breakdown,
+        "rag_context_chars": rag_context_chars,
+        "rag_used_chunks_count": used_chunks_count,
+        "history_len": history_len,
     }
-    if RETURN_LATENCY_BREAKDOWN:
-        resp["latency_breakdown"] = breakdown
-    return resp
 
 
 @app.post("/api/upload")
@@ -500,9 +437,6 @@ def memoryline(user_id: str):
     return {"next_review_label": "T+7", "progress_pct": 0.4}
 
 
-# ----------------------------
-# SPA Fallback
-# ----------------------------
 @app.get("/{full_path:path}")
 def spa_fallback(full_path: str, request: Request):
     if (