Update services/quiz_service.py

services/quiz_service.py

@@ -7,16 +7,14 @@ import re
 import uuid
 from datetime import datetime
 
-from huggingface_hub import InferenceClient
+import anthropic
 
 from state import Artifact, Notebook
 
 logger = logging.getLogger(__name__)
 
-GEN_MODEL = "mistralai/Mistral-7B-Instruct-v0.2"
-MAX_NEW_TOKENS = 2048
-TEMPERATURE = 0.3
-TIMEOUT_SEC = 60
+MODEL = "claude-haiku-4-5-20251001"
+MAX_TOKENS = 2048
 
 
 def _build_source_text(notebook: Notebook, max_chars: int = 8000) -> str:
@@ -25,7 +23,6 @@ def _build_source_text(notebook: Notebook, max_chars: int = 8000) -> str:
         from persistence.vector_store import VectorStore
         from ingestion_engine.embedding_generator import generate_query
 
-        # Use a broad query to retrieve a wide sample of content
         query_vector = generate_query("key concepts main ideas summary")
         matches = VectorStore().query(
             query_vector=query_vector,
@@ -34,12 +31,10 @@ def _build_source_text(notebook: Notebook, max_chars: int = 8000) -> str:
         )
         chunks = [m.get("text", "") for m in matches if m.get("text")]
         if chunks:
-            combined = "\n\n".join(chunks)
-            return combined[:max_chars]
+            return "\n\n".join(chunks)[:max_chars]
     except Exception as e:
         logger.warning("Could not retrieve chunks from vector store: %s", e)
 
-    # Fallback: just list source filenames
     parts = [src.filename for src in notebook.sources if src.status == "ready"]
     return "Sources: " + ", ".join(parts) if parts else "No sources available."
 
@@ -75,7 +70,6 @@ Now generate {num_questions} questions. Return ONLY the JSON array:"""
 
 
 def _parse_quiz_json(raw: str) -> list[dict]:
-    """Robustly extract and parse JSON array from LLM output."""
     cleaned = re.sub(r"```(?:json)?", "", raw).strip()
     start = cleaned.find("[")
     end = cleaned.rfind("]")
@@ -187,40 +181,30 @@ def _render_quiz_html(questions: list[dict], title: str) -> str:
 
 
 def generate_quiz(notebook: Notebook, num_questions: int) -> Artifact:
-    """Generate a quiz artifact from notebook sources using HF InferenceClient."""
-    token = os.environ.get("HF_TOKEN")
-    client = InferenceClient(token=token, timeout=TIMEOUT_SEC)
+    """Generate a quiz artifact from notebook sources using Anthropic Claude."""
+    client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
 
     source_text = _build_source_text(notebook)
     logger.info("Quiz source text length: %d chars", len(source_text))
 
-    prompt = _build_quiz_prompt(source_text, num_questions)
-
     try:
-        response = client.chat_completion(
-            model=GEN_MODEL,
-            messages=[
-                {
-                    "role": "system",
-                    "content": (
-                        "You are an expert quiz generator. Always respond with ONLY valid JSON arrays. "
-                        "Never include markdown formatting, code fences, or any text outside the JSON array."
-                    ),
-                },
-                {"role": "user", "content": prompt},
-            ],
-            max_tokens=MAX_NEW_TOKENS,
-            temperature=TEMPERATURE,
+        response = client.messages.create(
+            model=MODEL,
+            max_tokens=MAX_TOKENS,
+            system=(
+                "You are an expert quiz generator. Always respond with ONLY valid JSON arrays. "
+                "Never include markdown formatting, code fences, or any text outside the JSON array."
+            ),
+            messages=[{"role": "user", "content": _build_quiz_prompt(source_text, num_questions)}],
         )
-        raw = response.choices[0].message.content or ""
-        logger.info("Raw LLM response length: %d chars, preview: %s", len(raw), raw[:200])
+        raw = response.content[0].text
+        logger.info("Raw response preview: %s", raw[:200])
 
         questions = _parse_quiz_json(raw)
         questions = _validate_questions(questions)
 
         if not questions:
-            raise ValueError(f"No valid questions parsed. Raw response: {raw[:300]}")
-
+            raise ValueError(f"No valid questions parsed. Raw: {raw[:300]}")
         if len(questions) > num_questions:
             questions = questions[:num_questions]
 
@@ -228,21 +212,19 @@ def generate_quiz(notebook: Notebook, num_questions: int) -> Artifact:
         logger.error("Quiz generation failed: %s", e)
         questions = [
             {
-                "question": f"Quiz generation encountered an error. Please try again.",
-                "options": ["A) Try again", "B) Check logs", "C) Verify HF_TOKEN is set", "D) Check model availability"],
+                "question": "Quiz generation encountered an error. Please try again.",
+                "options": ["A) Try again", "B) Check logs", "C) Verify ANTHROPIC_API_KEY", "D) Check model"],
                 "answer": "A",
                 "explanation": f"Error: {str(e)[:200]}",
             }
         ]
 
     title = f"Practice Quiz ({len(questions)} Questions)"
-    html_content = _render_quiz_html(questions, title)
-
     return Artifact(
         id=str(uuid.uuid4()),
         type="quiz",
         title=title,
-        content=html_content,
+        content=_render_quiz_html(questions, title),
         audio_path=None,
         created_at=datetime.now().isoformat(),
     )