Update api/clare_core.py

api/clare_core.py

@@ -2,8 +2,6 @@
 import os
 import re
 import math
-import time
-import json
 from typing import List, Dict, Tuple, Optional
 
 from docx import Document
@@ -21,91 +19,11 @@ from langsmith import traceable
 from langsmith.run_helpers import set_run_metadata
 
 
-# ============================
-# Token helpers (optional tiktoken)
-# ============================
-def _safe_import_tiktoken():
-    try:
-        import tiktoken  # type: ignore
-        return tiktoken
-    except Exception:
-        return None
-
-
-def _approx_tokens(text: str) -> int:
-    if not text:
-        return 0
-    return max(1, int(len(text) / 4))
-
-
-def _count_text_tokens(text: str, model: str = "") -> int:
-    tk = _safe_import_tiktoken()
-    if tk is None:
-        return _approx_tokens(text)
-
-    try:
-        enc = tk.encoding_for_model(model) if model else tk.get_encoding("cl100k_base")
-    except Exception:
-        enc = tk.get_encoding("cl100k_base")
-
-    return len(enc.encode(text or ""))
-
-
-def _count_messages_tokens(messages: List[Dict[str, str]], model: str = "") -> int:
-    """
-    Approximation for chat messages overhead.
-    """
-    total = 0
-    for m in messages or []:
-        total += 4  # role/content wrappers
-        total += _count_text_tokens(str(m.get("role", "")), model=model)
-        total += _count_text_tokens(str(m.get("content", "")), model=model)
-    total += 2
-    return total
-
-
-def _truncate_to_tokens(text: str, max_tokens: int, model: str = "") -> str:
-    if not text:
-        return text
-
-    tk = _safe_import_tiktoken()
-    if tk is None:
-        total = _approx_tokens(text)
-        if total <= max_tokens:
-            return text
-        ratio = max_tokens / max(1, total)
-        cut = max(50, min(len(text), int(len(text) * ratio)))
-        s = text[:cut]
-        while _approx_tokens(s) > max_tokens and len(s) > 50:
-            s = s[: int(len(s) * 0.9)]
-        return s
-
-    try:
-        enc = tk.encoding_for_model(model) if model else tk.get_encoding("cl100k_base")
-    except Exception:
-        enc = tk.get_encoding("cl100k_base")
-
-    ids = enc.encode(text or "")
-    if len(ids) <= max_tokens:
-        return text
-    return enc.decode(ids[:max_tokens])
-
-
-def model_name_or_default(x: str) -> str:
-    return (x or "").strip() or DEFAULT_MODEL
-
-
 # ----------------------------
-# Speed knobs (HARD LIMITS)
+# Speed knobs (simple + stable)
 # ----------------------------
-# 1) history 最近 10 轮
 MAX_HISTORY_TURNS = int(os.getenv("CLARE_MAX_HISTORY_TURNS", "10"))
-
-# 2) rag 最多 4 条每条 500 tokens 已在 rag_engine.py 实现
-# 这里仅控制“注入到 LLM prompt 的总 tokens”，避免 prompt 爆炸
-MAX_RAG_TOKENS_IN_PROMPT = int(os.getenv("CLARE_MAX_RAG_TOKENS", "2000"))
-
-# 3) max_new_tokens 默认 384
+MAX_RAG_CHARS_IN_PROMPT = int(os.getenv("CLARE_MAX_RAG_CHARS", "2000"))
 DEFAULT_MAX_OUTPUT_TOKENS = int(os.getenv("CLARE_MAX_OUTPUT_TOKENS", "384"))
 
 
@@ -234,9 +152,7 @@ def build_session_memory_summary(
         parts.append("Cognitive state: " + describe_cognitive_state(cognitive_state))
 
     if not parts:
-        return (
-            "No prior session memory. Start with a short explanation and ask a quick check-up question."
-        )
+        return "No prior session memory. Start with a short explanation and ask a quick check-up question."
 
     return " | ".join(parts)
 
@@ -250,11 +166,7 @@ def detect_language(message: str, preference: str) -> str:
     return "English"
 
 
-def build_error_message(
-    e: Exception,
-    lang: str,
-    op: str = "chat",
-) -> str:
+def build_error_message(e: Exception, lang: str, op: str = "chat") -> str:
     if lang == "中文":
         prefix = {
             "chat": "抱歉，刚刚在和模型对话时出现了一点问题。",
@@ -398,142 +310,39 @@ def find_similar_past_question(
     return None
 
 
-def _log_prompt_token_breakdown(
-    messages: List[Dict[str, str]],
-    system_prompt: str,
-    rag_context: str,
-    trimmed_history: List[Tuple[str, str]],
-    user_message: str,
-    model_name: str,
-):
-    stats = {
-        "system_tokens": _count_text_tokens(system_prompt, model=model_name),
-        "rag_tokens": _count_text_tokens(rag_context or "", model=model_name),
-        "history_tokens": sum(
-            _count_text_tokens(u or "", model=model_name)
-            + _count_text_tokens(a or "", model=model_name)
-            for u, a in (trimmed_history or [])
-        ),
-        "user_tokens": _count_text_tokens(user_message or "", model=model_name),
-        "prompt_tokens_total_est": _count_messages_tokens(messages, model=model_name),
-        "history_turns_kept": len(trimmed_history or []),
-        "max_rag_tokens_in_prompt": MAX_RAG_TOKENS_IN_PROMPT,
-        "max_output_tokens": DEFAULT_MAX_OUTPUT_TOKENS,
-        "model": model_name,
-    }
-    print("[LLM_PROMPT_TOKENS] " + json.dumps(stats, ensure_ascii=False))
-    return stats
-
-
-@traceable(run_type="llm", name="safe_chat_completion_profiled")
-def safe_chat_completion_profiled(
+@traceable(run_type="llm", name="safe_chat_completion")
+def safe_chat_completion(
     model_name: str,
     messages: List[Dict[str, str]],
     lang: str,
     op: str = "chat",
     temperature: float = 0.5,
     max_tokens: Optional[int] = None,
-    timeout: int = 20,
-) -> Tuple[str, Dict]:
-    """
-    Streaming-based call to measure TTFT and tokens/sec (estimated).
-    Returns: (text, prof)
-    prof includes:
-      model, llm_total_ms, ttft_ms, gen_ms, output_tokens_est, tokens_per_sec_est, streaming_used, max_tokens
-    """
-    t0 = time.perf_counter()
-
+) -> str:
     preferred_model = model_name_or_default(model_name)
-    max_tokens = int(max_tokens or DEFAULT_MAX_OUTPUT_TOKENS)
-
-    used_model = preferred_model
     last_error: Optional[Exception] = None
+    max_tokens = int(max_tokens or DEFAULT_MAX_OUTPUT_TOKENS)
 
     for attempt in range(2):
-        used_model = preferred_model if attempt == 0 else DEFAULT_MODEL
+        current_model = preferred_model if attempt == 0 else DEFAULT_MODEL
         try:
-            first_token_ms: Optional[float] = None
-            text_parts: List[str] = []
-            output_chars = 0
-
-            stream = client.chat.completions.create(
-                model=used_model,
+            resp = client.chat.completions.create(
+                model=current_model,
                 messages=messages,
                 temperature=temperature,
                 max_tokens=max_tokens,
-                stream=True,
-                timeout=timeout,
+                timeout=20,
             )
-
-            for chunk in stream:
-                if first_token_ms is None:
-                    first_token_ms = (time.perf_counter() - t0) * 1000.0
-
-                delta = None
-                try:
-                    delta = chunk.choices[0].delta
-                except Exception:
-                    delta = None
-
-                piece = ""
-                if delta is not None:
-                    piece = getattr(delta, "content", "") or ""
-                else:
-                    try:
-                        piece = chunk.choices[0].message.content or ""
-                    except Exception:
-                        piece = ""
-
-                if piece:
-                    text_parts.append(piece)
-                    output_chars += len(piece)
-
-            full_text = "".join(text_parts)
-            llm_total_ms = (time.perf_counter() - t0) * 1000.0
-            ttft_ms = float(first_token_ms or llm_total_ms)
-            gen_ms = max(0.0, llm_total_ms - ttft_ms)
-
-            # output tokens est (rough)
-            if re.search(r"[\u4e00-\u9fff]", full_text or ""):
-                output_tokens_est = int(output_chars / 2.0) if output_chars else 0
-            else:
-                output_tokens_est = int(output_chars / 4.0) if output_chars else 0
-
-            tokens_per_sec_est = (
-                (output_tokens_est / (gen_ms / 1000.0)) if gen_ms > 1 else None
-            )
-
-            prof = {
-                "model": used_model,
-                "streaming_used": True,
-                "max_tokens": max_tokens,
-                "output_tokens_est": output_tokens_est,
-                "tokens_per_sec_est": tokens_per_sec_est,
-                "ttft_ms": ttft_ms,
-                "gen_ms": gen_ms,
-                "llm_total_ms": llm_total_ms,
-            }
-            return full_text, prof
-
+            return resp.choices[0].message.content or ""
         except Exception as e:
-            last_error = e
             print(
-                f"[safe_chat_completion_profiled][{op}] attempt {attempt+1} failed: {repr(e)}"
+                f"[safe_chat_completion][{op}] attempt {attempt+1} failed with model={current_model}: {repr(e)}"
             )
-            if attempt == 1:
+            last_error = e
+            if current_model == DEFAULT_MODEL or attempt == 1:
                 break
 
-    return build_error_message(last_error or Exception("unknown"), lang, op), {
-        "model": used_model,
-        "streaming_used": True,
-        "max_tokens": max_tokens,
-        "output_tokens_est": 0,
-        "tokens_per_sec_est": None,
-        "ttft_ms": None,
-        "gen_ms": None,
-        "llm_total_ms": (time.perf_counter() - t0) * 1000.0,
-        "error": repr(last_error) if last_error else "unknown",
-    }
+    return build_error_message(last_error or Exception("unknown error"), lang, op)
 
 
 def build_messages(
@@ -546,13 +355,8 @@ def build_messages(
     weaknesses: Optional[List[str]],
     cognitive_state: Optional[Dict[str, int]],
     rag_context: Optional[str] = None,
-    model_name: str = "",
 ) -> List[Dict[str, str]]:
-    model_for_count = model_name_or_default(model_name)
-
-    messages: List[Dict[str, str]] = [
-        {"role": "system", "content": CLARE_SYSTEM_PROMPT}
-    ]
+    messages: List[Dict[str, str]] = [{"role": "system", "content": CLARE_SYSTEM_PROMPT}]
 
     if learning_mode in LEARNING_MODE_INSTRUCTIONS:
         mode_instruction = LEARNING_MODE_INSTRUCTIONS[learning_mode]
@@ -579,9 +383,7 @@ def build_messages(
         messages.append(
             {
                 "role": "system",
-                "content": (
-                    f"The student also uploaded a {doc_type} document as supporting material."
-                ),
+                "content": f"The student also uploaded a {doc_type} document as supporting material.",
             }
         )
 
@@ -624,22 +426,15 @@ def build_messages(
     )
     messages.append({"role": "system", "content": "Session memory: " + session_memory_text})
 
-    # RAG context: enforce token cap here
-    rag_text_for_prompt = ""
     if rag_context:
-        rag_text_for_prompt = _truncate_to_tokens(
-            rag_context,
-            max_tokens=MAX_RAG_TOKENS_IN_PROMPT,
-            model=model_for_count,
-        )
+        rc = (rag_context or "")[:MAX_RAG_CHARS_IN_PROMPT]
         messages.append(
             {
                 "role": "system",
-                "content": "Relevant excerpts (use as primary grounding):\n\n" + rag_text_for_prompt,
+                "content": "Relevant excerpts (use as primary grounding):\n\n" + rc,
             }
         )
 
-    # Only keep the last N turns for speed (HARD LIMIT)
     trimmed_history = history[-MAX_HISTORY_TURNS:] if history else []
     for user, assistant in trimmed_history:
         messages.append({"role": "user", "content": user})
@@ -647,18 +442,11 @@ def build_messages(
             messages.append({"role": "assistant", "content": assistant})
 
     messages.append({"role": "user", "content": user_message})
+    return messages
 
-    # prompt token breakdown log
-    _log_prompt_token_breakdown(
-        messages=messages,
-        system_prompt=CLARE_SYSTEM_PROMPT,
-        rag_context=rag_text_for_prompt,
-        trimmed_history=trimmed_history,
-        user_message=user_message,
-        model_name=model_for_count,
-    )
 
-    return messages
+def model_name_or_default(x: str) -> str:
+    return (x or "").strip() or DEFAULT_MODEL
 
 
 @traceable(run_type="chain", name="chat_with_clare")
@@ -673,13 +461,7 @@ def chat_with_clare(
     weaknesses: Optional[List[str]],
     cognitive_state: Optional[Dict[str, int]],
     rag_context: Optional[str] = None,
-) -> Tuple[str, List[Tuple[str, str]], Dict]:
-    """
-    Returns:
-      answer: str
-      history: List[(user, assistant)]
-      llm_stats: Dict (TTFT + tokens/sec est + prompt token breakdown printed in logs)
-    """
+) -> Tuple[str, List[Tuple[str, str]]]:
     try:
         set_run_metadata(
             learning_mode=learning_mode,
@@ -699,42 +481,19 @@ def chat_with_clare(
         weaknesses=weaknesses,
         cognitive_state=cognitive_state,
         rag_context=rag_context,
-        model_name=model_name,
     )
 
-    # IMPORTANT: pass messages + lang (fixes your HTTP 500)
-    answer, prof = safe_chat_completion_profiled(
+    answer = safe_chat_completion(
         model_name=model_name,
         messages=messages,
         lang=language_preference,
         op="chat",
         temperature=0.5,
         max_tokens=DEFAULT_MAX_OUTPUT_TOKENS,
-        timeout=20,
     )
 
     history = history + [(message, answer)]
-
-    llm_stats = {
-        "llm_profile": {
-            "model": prof.get("model"),
-            "streaming_used": prof.get("streaming_used"),
-            "max_tokens": prof.get("max_tokens"),
-            "output_tokens_est": prof.get("output_tokens_est"),
-            "tokens_per_sec_est": prof.get("tokens_per_sec_est"),
-        },
-        "marks_ms": {
-            "llm_first_token": prof.get("ttft_ms"),
-            "llm_done": prof.get("llm_total_ms"),
-        },
-        "segments_ms": {
-            "llm_ttft_ms": prof.get("ttft_ms"),
-            "llm_gen_ms": prof.get("gen_ms"),
-            "llm_done": prof.get("llm_total_ms"),
-        },
-    }
-
-    return answer, history, llm_stats
+    return answer, history
 
 
 def export_conversation(
@@ -783,10 +542,7 @@ def summarize_conversation(
 
     messages = [
         {"role": "system", "content": CLARE_SYSTEM_PROMPT},
-        {
-            "role": "system",
-            "content": "Produce a concept-only summary. Use bullet points. No off-topic text.",
-        },
+        {"role": "system", "content": "Produce a concept-only summary. Use bullet points. No off-topic text."},
         {"role": "system", "content": f"Course topics: {topics_text}"},
         {"role": "system", "content": f"Student difficulties: {weakness_text}"},
         {"role": "system", "content": f"Cognitive state: {cog_text}"},
@@ -796,13 +552,12 @@ def summarize_conversation(
     if language_preference == "中文":
         messages.append({"role": "system", "content": "请用中文输出要点总结（bullet points）。"})
 
-    summary_text, _prof = safe_chat_completion_profiled(
+    summary_text = safe_chat_completion(
         model_name=model_name,
         messages=messages,
         lang=language_preference,
         op="summary",
         temperature=0.4,
         max_tokens=DEFAULT_MAX_OUTPUT_TOKENS,
-        timeout=20,
     )
     return summary_text