feat: implement lazy chunk caching for topic-based materials to reduce quiz and summary generation time

quiz_generator/routes.py

@@ -3,7 +3,7 @@ import logging
 from fastapi import APIRouter, HTTPException, Depends
 from typing import Optional
 from src.quiz_generator.quiz import smart_quiz_generator
-from src.store import get_material, get_chunks, get_summary, save_quiz, get_quizzes, save_quiz_result, get_quiz_results, check_daily_limit, increment_daily_usage, ADMIN_EMAILS
+from src.store import get_material, get_chunks, save_chunks, get_summary, save_quiz, get_quizzes, save_quiz_result, get_quiz_results, check_daily_limit, increment_daily_usage, ADMIN_EMAILS
 from src.dependencies import get_current_user_id, get_current_user
 from src.config import settings
 from .schemas import QuizRequest, QuizResponse, SaveQuizResultRequest
@@ -56,20 +56,71 @@ async def generate_quiz(
                     if mat.get("user_id") != user_id:
                         raise HTTPException(403, "Access denied")
                     topic_title = mat.get("title")
-            
+
             if not topic_title:
                 raise HTTPException(400, "Topic title or valid material_id is required for web-based quiz")
 
             loop = asyncio.get_event_loop()
-            quiz = await loop.run_in_executor(
-                None,
-                lambda: smart_quiz_generator(
-                    difficulty=body.difficulty,
-                    mcq_count=body.mcq_count,
-                    tf_count=body.tf_count,
-                    topic_title=topic_title,
+
+            # ── Lazy cache check ──────────────────────────────────────────────
+            # If this topic material already has cached chunks (from a prior
+            # summary/quiz), use the contextual path (vector retriever).
+            # Otherwise fetch web content now, cache it, then generate.
+            existing_chunks = []
+            if body.material_id:
+                existing_chunks = await loop.run_in_executor(None, get_chunks, body.material_id)
+
+            if existing_chunks:
+                # Fast path — use cached embeddings via SupabaseRetriever
+                logger.info(
+                    f"Topic '{topic_title}' has {len(existing_chunks)} cached chunks — "
+                    "using contextual quiz path."
+                )
+                chunks_texts = [c["content"] for c in existing_chunks]
+                quiz = await loop.run_in_executor(
+                    None,
+                    lambda: smart_quiz_generator(
+                        difficulty=body.difficulty,
+                        mcq_count=body.mcq_count,
+                        tf_count=body.tf_count,
+                        material_id=body.material_id,  # triggers SupabaseRetriever
+                        chunks=chunks_texts,
+                    )
+                )
+
+            else:
+                # First-time path — fetch web content, cache it, then quiz
+                logger.info(
+                    f"Topic '{topic_title}' has no cached chunks — fetching web content for quiz."
+                )
+                from src.summary_generator.summary import fetch_web_content
+                from src.materials.text_utils import chunk_text
+                from src.rag.rag import store_embeddings_async
+
+                raw_content = await loop.run_in_executor(None, fetch_web_content, topic_title)
+
+                chunks_texts = await loop.run_in_executor(
+                    None, lambda: chunk_text(raw_content, chunk_size=600, chunk_overlap=100)
+                )
+                if chunks_texts and body.material_id:
+                    chunk_ids = await loop.run_in_executor(
+                        None, save_chunks, body.material_id, chunks_texts
+                    )
+                    await store_embeddings_async(body.material_id, chunk_ids, chunks_texts)
+                    logger.info(
+                        f"Cached {len(chunks_texts)} chunks for topic '{topic_title}'."
+                    )
+
+                quiz = await loop.run_in_executor(
+                    None,
+                    lambda: smart_quiz_generator(
+                        difficulty=body.difficulty,
+                        mcq_count=body.mcq_count,
+                        tf_count=body.tf_count,
+                        topic_title=topic_title,
+                        chunks=chunks_texts if chunks_texts else None,
+                    )
                 )
-            )
 
         elif body.source_type in ("pdf", "url"):
             mat = get_material(body.material_id) if body.material_id else None

summary_generator/routes.py

@@ -3,8 +3,14 @@ import time
 import logging 
 from fastapi import APIRouter, HTTPException, Depends
 
-from src.summary_generator.summary import summarizer, web_summarizer
-from src.store import get_material, get_chunks, save_summary, get_summary as get_stored_summary, check_daily_limit, increment_daily_usage
+from src.summary_generator.summary import summarizer, web_summarizer, fetch_web_content
+from src.materials.text_utils import chunk_text
+from src.rag.rag import store_embeddings_async
+from src.store import (
+    get_material, get_chunks, save_chunks, save_summary,
+    get_summary as get_stored_summary, update_material_status,
+    check_daily_limit, increment_daily_usage,
+)
 from src.dependencies import get_current_user_id, get_current_user
 from src.config import settings
 from .schemas import SummarizeRequest, SummarizeResponse
@@ -37,7 +43,50 @@ async def generate_summary(
 
         if mat.get("source_type") == "topic":
             topic_title = mat.get("title", "topic")
-            summary = await loop.run_in_executor(None, web_summarizer, topic_title)
+
+            # ── Lazy cache check ───────────────────────────────────────────────
+            # Check whether we already have stored chunks for this topic.
+            # If yes: use them directly (no web fetching).
+            # If no: fetch web content, chunk + embed it, then summarize.
+            existing_chunks = await loop.run_in_executor(None, get_chunks, body.material_id)
+
+            if existing_chunks:
+                # Fast path — use cached chunks
+                logger.info(
+                    f"Topic '{topic_title}' has {len(existing_chunks)} cached chunks — "
+                    "skipping web fetch for summarization."
+                )
+                combined = "\n".join(c["content"] for c in existing_chunks)
+                if len(combined) > MAX_COMBINED_TEXT_LEN:
+                    half = MAX_COMBINED_TEXT_LEN // 2
+                    combined = combined[:half] + combined[-half:]
+                summary = await loop.run_in_executor(None, summarizer, combined)
+
+            else:
+                # First-time path — fetch, cache, then summarize
+                logger.info(
+                    f"Topic '{topic_title}' has no cached chunks — fetching web content."
+                )
+                raw_content = await loop.run_in_executor(None, fetch_web_content, topic_title)
+
+                # Chunk + store + embed (mirrors the URL pipeline)
+                chunks_texts = await loop.run_in_executor(
+                    None, lambda: chunk_text(raw_content, chunk_size=600, chunk_overlap=100)
+                )
+                if chunks_texts:
+                    chunk_ids = await loop.run_in_executor(
+                        None, save_chunks, body.material_id, chunks_texts
+                    )
+                    await store_embeddings_async(body.material_id, chunk_ids, chunks_texts)
+                    logger.info(
+                        f"Cached {len(chunks_texts)} chunks for topic '{topic_title}'."
+                    )
+
+                # Generate summary from the raw fetched content
+                summary = await loop.run_in_executor(
+                    None, web_summarizer, topic_title, raw_content
+                )
+
         else:
             chunks_list = get_chunks(body.material_id)
             if not chunks_list:

summary_generator/summary.py

@@ -68,12 +68,18 @@ def summarizer(text: str) -> str:
         raise
 
 
-def web_summarizer(topic: str) -> str:
-    logger.info(f"Web summarizer started for topic: {topic}")
-
-    all_content = []
-
-    def fetch_wikipedia():
+def fetch_web_content(topic: str) -> str:
+    """
+    Fetch raw Wikipedia + DuckDuckGo content for *topic* and return the combined
+    text string.  This is a pure data-fetching helper — no LLM is called.
+
+    The returned text can be:
+    - Chunked and stored in the DB for future reuse.
+    - Passed directly to an LLM prompt as context.
+    """
+    logger.info(f"fetch_web_content started for topic: {topic}")
+
+    def _fetch_wikipedia():
         try:
             wiki_api = WikipediaAPIWrapper(
                 top_k_results=WIKI_TOP_K_RESULTS,
@@ -84,7 +90,7 @@ def web_summarizer(topic: str) -> str:
             logger.warning(f"Wikipedia search for '{topic}' failed: {e}")
             return ""
 
-    def fetch_duckduckgo():
+    def _fetch_duckduckgo():
         try:
             duck_api = DuckDuckGoSearchAPIWrapper()
             return duck_api.run(topic)
@@ -92,34 +98,47 @@ def web_summarizer(topic: str) -> str:
             logger.warning(f"DuckDuckGo search for '{topic}' failed: {e}")
             return ""
 
-    # Execute searches in parallel to minimize latency
     with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
-        wiki_future = executor.submit(fetch_wikipedia)
-        duck_future = executor.submit(fetch_duckduckgo)
-
+        wiki_future = executor.submit(_fetch_wikipedia)
+        duck_future = executor.submit(_fetch_duckduckgo)
         wiki_content = wiki_future.result()
         duck_content = duck_future.result()
 
+    all_content = []
     if wiki_content and wiki_content.strip():
         all_content.append(f"--- Wikipedia ---\n{wiki_content}")
     if duck_content and duck_content.strip():
         all_content.append(f"--- Web Search ---\n{duck_content}")
 
     if not all_content:
-        logger.warning(f"No content found for topic: {topic}. Falling back to general knowledge.")
-        all_content.append(f"No web content found for: {topic}")
+        logger.warning(f"No content found for topic: {topic}. Returning placeholder.")
+        return f"No web content found for: {topic}"
 
     combined = "\n\n".join(all_content)
-    logger.info(f"Web search combined text length for topic '{topic}': {len(combined)}")
+    logger.info(f"fetch_web_content combined length for '{topic}': {len(combined)}")
+    return combined
+
 
+def web_summarizer(topic: str, raw_content: str | None = None) -> str:
+    """
+    Generate an LLM summary for *topic*.
+
+    If *raw_content* is provided (pre-fetched web text) it is used directly,
+    skipping the Wiki/DDG network calls.  Otherwise fetch_web_content() is
+    called internally so this function stays usable standalone.
+    """
+    logger.info(f"Web summarizer started for topic: {topic}")
+
+    combined = raw_content if raw_content is not None else fetch_web_content(topic)
     combined = _truncate_text(combined)
+
     try:
         llm = get_llm()
         chain = WEB_SUMMARIZER_PROMPT_TEMPLATE | llm
         response = chain.invoke({"topic": topic, "input": combined})
-        raw_content = response.content
-        logger.info(f"Web summarizer received response of length {len(raw_content)}")
-        return clean_summary(raw_content)
+        raw_resp = response.content
+        logger.info(f"Web summarizer received response of length {len(raw_resp)}")
+        return clean_summary(raw_resp)
     except Exception as e:
         logger.error(f"Web summarizer failed: {str(e)}", exc_info=True)
         raise