feat: implement LLM fallback for quiz generation and enhance OAuth error handling

config.py

@@ -11,6 +11,7 @@ load_dotenv(ENV_PATH)
 
 class Settings:
     gemini_api_key: str = os.getenv("GEMINI_API_KEY", "")
+    groq_api_key: str = os.getenv("GROQ_API_KEY", "")
     # Accept both plain and NEXT_PUBLIC_ prefixed names (config.env uses NEXT_PUBLIC_)
     supabase_url: str = (
         os.getenv("SUPABASE_URL")
@@ -60,6 +61,8 @@ def get_settings() -> Settings:
     s = Settings()
     if s.gemini_api_key:
         os.environ["GEMINI_API_KEY"] = s.gemini_api_key
+    if s.groq_api_key:
+        os.environ["GROQ_API_KEY"] = s.groq_api_key
     if "TRANSFORMERS_NO_TF" not in os.environ and s.transformers_no_tf:
         os.environ["TRANSFORMERS_NO_TF"] = s.transformers_no_tf
     return s

main.py

@@ -47,6 +47,10 @@ root_logger.setLevel(logging.INFO)
 root_logger.addHandler(file_handler)
 root_logger.addHandler(console_handler)
 
+# Suppress noisy watchfiles reload logs
+logging.getLogger("watchfiles").setLevel(logging.WARNING)
+logging.getLogger("watchfiles.main").setLevel(logging.WARNING)
+
 logger = logging.getLogger(__name__)
 
 
@@ -85,7 +89,7 @@ app = FastAPI(
     title="AI Tutor API",
     description="Backend API for the AI Tutor for Students application",
     version="1.0.0",
-    # lifespan=lifespan,
+    lifespan=lifespan,
 )
 
 @app.middleware("http")

materials/text_utils.py

@@ -3,22 +3,34 @@ from langchain_text_splitters import RecursiveCharacterTextSplitter
 from langchain_community.document_loaders import UnstructuredURLLoader
 
 
+def _clean_text(text: str) -> str:
+    if not text:
+        return ""
+    # Remove NULL bytes (\x00 / \u0000) which PostgreSQL text format cannot accept
+    return text.replace("\x00", "").replace("\u0000", "")
+
+
 def text_from_pdf(pdf_file) -> str:
     reader = PyPDF2.PdfReader(pdf_file)
     text = ""
     for page in reader.pages:
-        text += page.extract_text()
-    return text
+        extracted = page.extract_text()
+        if extracted:
+            text += extracted
+    return _clean_text(text)
 
 
 def chunk_text(text: str, chunk_size: int = 800, chunk_overlap: int = 150):
+    cleaned = _clean_text(text)
     splitter = RecursiveCharacterTextSplitter(
         chunk_size=chunk_size, chunk_overlap=chunk_overlap
     )
-    return splitter.split_text(text)
+    chunks = splitter.split_text(cleaned)
+    return [_clean_text(c) for c in chunks if _clean_text(c).strip()]
 
 
 def scrap_website(url: str) -> str:
     loader = UnstructuredURLLoader(urls=[url], ssl_verify=True)
     data = loader.load()
-    return data[0].page_content
+    raw = data[0].page_content if data else ""
+    return _clean_text(raw)

quiz_generator/quiz.py

@@ -6,7 +6,7 @@ from typing import Optional
 from langchain.agents import create_tool_calling_agent, AgentExecutor
 from langchain_core.tools import create_retriever_tool
 
-from src.rag.rag import get_quiz_llm, SupabaseRetriever
+from src.rag.rag import get_quiz_llm, get_quiz_fallback_llm, SupabaseRetriever
 from .constants import (
     QUIZ_PROMPT_TEMPLATE,
     WEB_QUIZ_PROMPT_TEMPLATE,
@@ -58,11 +58,11 @@ def smart_quiz_generator(
 
 def _summary_quiz(difficulty, mcq_count, tf_count, context_text):
     logger.info(f"Summary Quiz started (diff={difficulty}, mcq={mcq_count}, tf={tf_count})")
+    prompt = _quiz_prompt()
+    safe_context = context_text
+
     try:
-        prompt = _quiz_prompt()
         llm = get_quiz_llm()
-        safe_context = context_text
-        
         chain = prompt | llm
         response = chain.invoke({
             "difficulty": difficulty,
@@ -72,30 +72,39 @@ def _summary_quiz(difficulty, mcq_count, tf_count, context_text):
             "context": safe_context,
             "agent_scratchpad": "",
         })
-        
-        raw_content = response.content
-        logger.info(f"Summary Quiz received response of length {len(raw_content)}")
-        
-        # response is a message object, content is the text
-        return _parse_quiz({"output": raw_content})
+        return _parse_quiz({"output": response.content})
     except Exception as e:
-        logger.error(f"Summary Quiz failed: {str(e)}", exc_info=True)
-        raise
+        logger.warning(f"Primary Quiz LLM (gemini-3.5-flash-lite) failed: {e}. Falling back to gemini-3.1-flash-lite.")
+        try:
+            fallback_llm = get_quiz_fallback_llm()
+            chain = prompt | fallback_llm
+            response = chain.invoke({
+                "difficulty": difficulty,
+                "mcq_count": mcq_count,
+                "tf_count": tf_count,
+                "source_type": "summary",
+                "context": safe_context,
+                "agent_scratchpad": "",
+            })
+            return _parse_quiz({"output": response.content})
+        except Exception as fallback_err:
+            logger.error(f"Fallback Quiz generation failed: {fallback_err}", exc_info=True)
+            raise fallback_err
 
 
 def _contextual_quiz(difficulty, mcq_count, tf_count, context, material_id):
     logger.info(f"Contextual Quiz started (material_id={material_id}, diff={difficulty})")
+    prompt = _quiz_prompt()
+    retriever = SupabaseRetriever(material_id=material_id, k=RETRIEVER_K)
+    retriever_tool = create_retriever_tool(
+        retriever,
+        name="quiz_material_retriever",
+        description="Retrieves relevant content from uploaded materials for quiz generation.",
+    )
+    safe_context = context or ""
+
     try:
-        prompt = _quiz_prompt()
         llm = get_quiz_llm()
-
-        retriever = SupabaseRetriever(material_id=material_id, k=RETRIEVER_K)
-        retriever_tool = create_retriever_tool(
-            retriever,
-            name="quiz_material_retriever",
-            description="Retrieves relevant content from uploaded materials for quiz generation.",
-        )
-
         agent = create_tool_calling_agent(llm, [retriever_tool], prompt)
         executor = AgentExecutor(
             agent=agent,
@@ -106,8 +115,6 @@ def _contextual_quiz(difficulty, mcq_count, tf_count, context, material_id):
             max_iterations=80,
             max_execution_time=300,
         )
-
-        safe_context = context or ""
         response = executor.invoke({
             "difficulty": difficulty,
             "source_type": "Document Embeddings",
@@ -116,57 +123,78 @@ def _contextual_quiz(difficulty, mcq_count, tf_count, context, material_id):
             "agent_scratchpad": "",
             "context": safe_context,
         })
-        logger.info("Contextual Quiz agent finished successfully")
         return _parse_quiz(response)
     except Exception as e:
-        logger.error(f"Contextual Quiz failed: {str(e)}", exc_info=True)
-        raise
+        logger.warning(f"Primary Contextual Quiz agent failed: {e}. Falling back to gemini-3.1-flash-lite.")
+        try:
+            fallback_llm = get_quiz_fallback_llm()
+            agent = create_tool_calling_agent(fallback_llm, [retriever_tool], prompt)
+            executor = AgentExecutor(
+                agent=agent,
+                tools=[retriever_tool],
+                verbose=False,
+                return_intermediate_steps=False,
+                handle_parsing_errors=True,
+                max_iterations=80,
+                max_execution_time=300,
+            )
+            response = executor.invoke({
+                "difficulty": difficulty,
+                "source_type": "Document Embeddings",
+                "mcq_count": mcq_count,
+                "tf_count": tf_count,
+                "agent_scratchpad": "",
+                "context": safe_context,
+            })
+            return _parse_quiz(response)
+        except Exception as fallback_err:
+            logger.error(f"Fallback Contextual Quiz failed: {fallback_err}", exc_info=True)
+            raise fallback_err
 
 
 def _web_quiz(difficulty, mcq_count, tf_count, topic_title):
     logger.info(f"Web Quiz started (topic={topic_title}, diff={difficulty})")
+    import concurrent.futures
+    from langchain_community.utilities import WikipediaAPIWrapper, DuckDuckGoSearchAPIWrapper
+
+    def fetch_wikipedia():
+        try:
+            wiki_api = WikipediaAPIWrapper(
+                top_k_results=WIKI_TOP_K_RESULTS,
+                doc_content_chars_max=WIKI_DOC_CONTENT_CHARS_MAX,
+            )
+            return wiki_api.run(topic_title)
+        except Exception as e:
+            logger.warning(f"Wikipedia search for '{topic_title}' failed: {e}")
+            return ""
+
+    def fetch_duckduckgo():
+        try:
+            duck_api = DuckDuckGoSearchAPIWrapper()
+            return duck_api.run(topic_title)
+        except Exception as e:
+            logger.warning(f"DuckDuckGo search for '{topic_title}' failed: {e}")
+            return ""
+
+    # Fetch in parallel
+    with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
+        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}")
+
+    combined_context = "\n\n".join(all_content) if all_content else f"No web content found for: {topic_title}"
+    prompt = WEB_QUIZ_PROMPT_TEMPLATE
+
     try:
-        import concurrent.futures
-        from langchain_community.utilities import WikipediaAPIWrapper, DuckDuckGoSearchAPIWrapper
-
-        def fetch_wikipedia():
-            try:
-                wiki_api = WikipediaAPIWrapper(
-                    top_k_results=WIKI_TOP_K_RESULTS,
-                    doc_content_chars_max=WIKI_DOC_CONTENT_CHARS_MAX,
-                )
-                return wiki_api.run(topic_title)
-            except Exception as e:
-                logger.warning(f"Wikipedia search for '{topic_title}' failed: {e}")
-                return ""
-
-        def fetch_duckduckgo():
-            try:
-                duck_api = DuckDuckGoSearchAPIWrapper()
-                return duck_api.run(topic_title)
-            except Exception as e:
-                logger.warning(f"DuckDuckGo search for '{topic_title}' failed: {e}")
-                return ""
-
-        # Fetch in parallel
-        with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
-            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}")
-
-        combined_context = "\n\n".join(all_content) if all_content else f"No web content found for: {topic_title}"
-
-        prompt = WEB_QUIZ_PROMPT_TEMPLATE
         llm = get_quiz_llm()
-
         chain = prompt | llm
         response = chain.invoke({
             "topic": topic_title,
@@ -177,13 +205,25 @@ def _web_quiz(difficulty, mcq_count, tf_count, topic_title):
             "source_type": "Web Search",
             "agent_scratchpad": "",
         })
-
-        raw_content = response.content
-        logger.info("Web Quiz chain finished successfully")
-        return _parse_quiz({"output": raw_content})
+        return _parse_quiz({"output": response.content})
     except Exception as e:
-        logger.error(f"Web Quiz failed: {str(e)}", exc_info=True)
-        raise
+        logger.warning(f"Primary Web Quiz model failed: {e}. Falling back to gemini-3.1-flash-lite.")
+        try:
+            fallback_llm = get_quiz_fallback_llm()
+            chain = prompt | fallback_llm
+            response = chain.invoke({
+                "topic": topic_title,
+                "context": combined_context,
+                "difficulty": difficulty,
+                "mcq_count": mcq_count,
+                "tf_count": tf_count,
+                "source_type": "Web Search",
+                "agent_scratchpad": "",
+            })
+            return _parse_quiz({"output": response.content})
+        except Exception as fallback_err:
+            logger.error(f"Fallback Web Quiz failed: {fallback_err}", exc_info=True)
+            raise fallback_err
 
 
 def _parse_quiz(response):

rag/constants.py

@@ -6,15 +6,15 @@ WARMUP_INTERVAL_S = 300
 
 # Web search configuration — Wiki + DDG for topics, DDG only for PDF/URL materials.
 WIKI_TOP_K_RESULTS = 1                   # Number of top Wikipedia articles retrieved
-WIKI_DOC_CONTENT_CHARS_MAX = 1000         # Max chars from Wikipedia result
+WIKI_DOC_CONTENT_CHARS_MAX = 1200        # Max chars from Wikipedia result
 
 # DuckDuckGO Search
 DUCKDUCKGO_NUM_RESULTS = 3               # Number of DDG snippet results returned per search
-DUCKDUCKGO_DOC_CONTENT_CHARS_MAX = 1500  # Max chars kept from combined DDG result block
+DUCKDUCKGO_DOC_CONTENT_CHARS_MAX = 1200  # Max chars kept from combined DDG result block
 
 # RAG & Memory Configuration
-MEMORY_WINDOW_SIZE = 8                   # Number of previous conversation turns preserved in memory window
-TOP_K_CHUNKS = 3                         # Number of top relevant material chunks retrieved for context
+MEMORY_WINDOW_SIZE = 5                   # Number of previous conversation turns preserved in memory window
+TOP_K_CHUNKS = 4                         # Number of top relevant material chunks retrieved for context
 
 RAG_PROMPT_TEMPLATE_BASE = """\
 <role>

rag/rag.py

@@ -13,6 +13,7 @@ from langchain.memory import ConversationBufferMemory, ConversationBufferWindowM
 from langchain_core.retrievers import BaseRetriever
 from langchain_core.documents import Document
 from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_groq import ChatGroq
 
 from src.config import settings
 from src.database import get_supabase
@@ -136,35 +137,85 @@ def similarity_search(query: str, material_id: str, k: int = 5) -> list[dict]:
 # ── LLM ────────────────────────────────────────────────
 
 def get_llm():
-    if not os.environ.get("GEMINI_API_KEY"):
-        raise ValueError("GEMINI_API_KEY not found. Please set it in config.env.")
-    logger.info(f"Initializing LLM with model: {settings.model_name}")
-    return ChatGoogleGenerativeAI(
-        model=settings.model_name,
-        api_key=settings.gemini_api_key,
+    """RAG Chatbot LLM — strictly uses Groq llama-3.1-8b-instant."""
+    groq_key = os.environ.get("GROQ_API_KEY")
+    if not groq_key:
+        raise ValueError("GROQ_API_KEY is not configured in config.env. Required for Llama 3.1 RAG chatbot.")
+    logger.info("Initializing RAG Chatbot LLM with Groq model: llama-3.1-8b-instant")
+    return ChatGroq(
+        model="llama-3.1-8b-instant",
+        api_key=groq_key,
         temperature=0.3,
-        max_output_tokens=2500,
+        max_tokens=2500,
         timeout=120,
     )
 
 
+def get_summary_llm():
+    """Primary Summary Generator LLM using gemini-3.5-flash-lite."""
+    gemini_key = os.environ.get("GEMINI_API_KEY")
+    if not gemini_key:
+        raise ValueError("GEMINI_API_KEY not found in config.env.")
+    logger.info("Initializing Summary LLM with model: gemini-3.5-flash-lite")
+    return ChatGoogleGenerativeAI(
+        model="gemini-3.5-flash-lite",
+        api_key=gemini_key,
+        temperature=0.3,
+        max_output_tokens=4000,
+        timeout=180,
+    )
+
+
+def get_summary_fallback_llm():
+    """Fallback Summary Generator LLM using gemini-3.1-flash-lite."""
+    gemini_key = os.environ.get("GEMINI_API_KEY")
+    if not gemini_key:
+        raise ValueError("GEMINI_API_KEY not found in config.env.")
+    logger.info("Initializing Fallback Summary LLM with model: gemini-3.1-flash-lite")
+    return ChatGoogleGenerativeAI(
+        model="gemini-3.1-flash-lite",
+        api_key=gemini_key,
+        temperature=0.3,
+        max_output_tokens=4000,
+        timeout=180,
+    )
+
+
 def get_quiz_llm():
-    """Dedicated LLM instance for quiz generation with a high output token budget.
-    Large quizzes (40 MCQs + 20 T/F) can produce 8000-12000 tokens of JSON,
-    so we cannot reuse the chat LLM which is capped at 2000 tokens.
-    """
-    if not os.environ.get("GEMINI_API_KEY"):
-        raise ValueError("GEMINI_API_KEY not found. Please set it in config.env.")
-    logger.info(f"Initializing Quiz LLM with model: {settings.model_name}")
+    """Primary Quiz Generator LLM using gemini-3.5-flash-lite."""
+    gemini_key = os.environ.get("GEMINI_API_KEY")
+    if not gemini_key:
+        raise ValueError("GEMINI_API_KEY not found in config.env.")
+    logger.info("Initializing Quiz LLM with model: gemini-3.5-flash-lite")
     return ChatGoogleGenerativeAI(
-        model=settings.model_name,
-        api_key=settings.gemini_api_key,
+        model="gemini-3.5-flash-lite",
+        api_key=gemini_key,
         temperature=0.3,
         max_output_tokens=12000,
         timeout=300,
     )
 
 
+def get_quiz_fallback_llm():
+    """Fallback Quiz Generator LLM using gemini-3.1-flash-lite."""
+    gemini_key = os.environ.get("GEMINI_API_KEY")
+    if not gemini_key:
+        raise ValueError("GEMINI_API_KEY not found in config.env.")
+    logger.info("Initializing Fallback Quiz LLM with model: gemini-3.1-flash-lite")
+    return ChatGoogleGenerativeAI(
+        model="gemini-3.1-flash-lite",
+        api_key=gemini_key,
+        temperature=0.3,
+        max_output_tokens=12000,
+        timeout=300,
+    )
+
+
+def get_fallback_llm():
+    """Fallback LLM using Gemini 3.1 Flash Lite."""
+    return get_summary_fallback_llm()
+
+
 def _clean_llm_response(content) -> str:
     if isinstance(content, str):
         return content
@@ -182,32 +233,6 @@ def _clean_llm_response(content) -> str:
     return str(content)
 
 
-def get_gemma_31b_llm():
-    if not os.environ.get("GEMINI_API_KEY"):
-        raise ValueError("GEMINI_API_KEY not found. Please set it in config.env.")
-    logger.info("Initializing primary LLM with model: gemma-4-31b-it")
-    return ChatGoogleGenerativeAI(
-        model="gemma-4-31b-it",
-        api_key=settings.gemini_api_key,
-        temperature=0.3,
-        max_output_tokens=2500,
-        timeout=120,
-    )
-
-
-def get_gemma_26b_llm():
-    if not os.environ.get("GEMINI_API_KEY"):
-        raise ValueError("GEMINI_API_KEY not found. Please set it in config.env.")
-    logger.info("Initializing fallback LLM with model: gemma-4-26b-a4b-it")
-    return ChatGoogleGenerativeAI(
-        model="gemma-4-26b-a4b-it",
-        api_key=settings.gemini_api_key,
-        temperature=0.3,
-        max_output_tokens=2500,
-        timeout=120,
-    )
-
-
 # ── Web Search Helpers ────────────────────────────────
 
 def direct_ddg_search(query: str) -> str:
@@ -386,7 +411,7 @@ def rag_answer(
         return any(t.startswith(p) for p in _REFUSAL_PREFIXES)
 
     try:
-        primary_llm = get_gemma_26b_llm()
+        primary_llm = get_llm()
         chain = prompt | primary_llm
 
         memory_vars = memory.load_memory_variables({"input": query})
@@ -405,9 +430,9 @@ def rag_answer(
             memory.save_context({"input": query}, {"output": answer})
         return answer, memory
     except Exception as e:
-        logger.warning(f"Gemma 4 26B API call failed or rate-limited: {e}. Falling back to gemma-4-31b-it immediately.")
+        logger.warning(f"Primary LLM call failed or rate-limited: {e}. Falling back to secondary LLM.")
         try:
-            fallback_llm = get_gemma_31b_llm()
+            fallback_llm = get_fallback_llm()
             chain = prompt | fallback_llm
             memory_vars = memory.load_memory_variables({"input": query})
             chat_history = memory_vars.get("chat_history", [])
@@ -424,7 +449,7 @@ def rag_answer(
                 memory.save_context({"input": query}, {"output": answer})
             return answer, memory
         except Exception as fallback_err:
-            logger.error(f"Fallback Gemma 4 31B LLM call also failed: {fallback_err}")
+            logger.error(f"Fallback LLM call also failed: {fallback_err}")
             raise fallback_err
 
 def extract_chat_title(query: str, material_title: Optional[str] = None) -> str:
@@ -440,17 +465,17 @@ def extract_chat_title(query: str, material_title: Optional[str] = None) -> str:
     )
     
     try:
-        primary_llm = get_gemma_26b_llm()
+        primary_llm = get_llm()
         chain = prompt | primary_llm
         response = chain.invoke({"query": query})
     except Exception as e:
-        logger.warning(f"Gemma 4 26B API call failed or rate-limited in extract_chat_title: {e}. Falling back to gemma-4-31b-it immediately.")
+        logger.warning(f"Primary LLM call failed in extract_chat_title: {e}. Falling back to secondary LLM.")
         try:
-            fallback_llm = get_gemma_31b_llm()
+            fallback_llm = get_fallback_llm()
             chain = prompt | fallback_llm
             response = chain.invoke({"query": query})
         except Exception as fallback_err:
-            logger.error(f"Fallback Gemma 4 31B LLM call also failed in extract_chat_title: {fallback_err}")
+            logger.error(f"Fallback LLM call also failed in extract_chat_title: {fallback_err}")
             raise fallback_err
 
     title = _clean_llm_response(response.content).strip().strip('"').strip("'")

requirements.txt

@@ -11,6 +11,8 @@ streamlit==1.45.0
 langchain==0.3.25
 langchain-community==0.3.4
 langchain-google-genai
+langchain-groq
+groq
 langchain-openai
 langchain-huggingface
 langchain-text-splitters

store.py

@@ -294,9 +294,10 @@ def delete_material(material_id: str):
 # ── Material Chunks ────────────────────────────────────
 
 def save_chunks(material_id: str, chunks: list[str]) -> list[str]:
+    cleaned_chunks = [c.replace("\x00", "").replace("\u0000", "") for c in chunks if c]
     records = [
         {"material_id": material_id, "chunk_index": i, "content": c}
-        for i, c in enumerate(chunks)
+        for i, c in enumerate(cleaned_chunks)
     ]
     result = _robust_execute(_table_supabase("material_chunks").insert(records))
     return [r["id"] for r in result.data]

summary_generator/summary.py

@@ -2,7 +2,7 @@ import re
 import logging
 import concurrent.futures
 from langchain_community.utilities import WikipediaAPIWrapper, DuckDuckGoSearchAPIWrapper
-from src.rag.rag import get_llm
+from src.rag.rag import get_summary_llm, get_summary_fallback_llm
 from .constants import (
     SUMMARIZER_PROMPT_TEMPLATE,
     WEB_SUMMARIZER_PROMPT_TEMPLATE,
@@ -51,21 +51,23 @@ def _truncate_text(text: str, max_chars: int = MAX_INPUT_CHARS) -> str:
 def summarizer(text: str) -> str:
     logger.info(f"Summarizer started for text of length {len(text)}")
     text = _truncate_text(text)
+    prompt = summarizer_prompt()
+
     try:
-        prompt = summarizer_prompt()
-        llm = get_llm()
-        # Modern LCEL syntax
+        llm = get_summary_llm()
         chain = prompt | llm
         response = chain.invoke({"input": text})
-        
-        raw_content = response.content
-        logger.info(f"Summarizer received response of length {len(raw_content)}")
-        logger.debug(f"Raw summary response: {raw_content[:500]}...")
-        
-        return clean_summary(raw_content)
+        return clean_summary(response.content)
     except Exception as e:
-        logger.error(f"Summarizer failed: {str(e)}", exc_info=True)
-        raise
+        logger.warning(f"Primary summary model (gemini-3.5-flash-lite) failed: {e}. Falling back to gemini-3.1-flash-lite.")
+        try:
+            fallback_llm = get_summary_fallback_llm()
+            chain = prompt | fallback_llm
+            response = chain.invoke({"input": text})
+            return clean_summary(response.content)
+        except Exception as fallback_err:
+            logger.error(f"Fallback summary generation failed: {fallback_err}", exc_info=True)
+            raise fallback_err
 
 
 def fetch_web_content(topic: str) -> str:
@@ -133,12 +135,17 @@ def web_summarizer(topic: str, raw_content: str | None = None) -> str:
     combined = _truncate_text(combined)
 
     try:
-        llm = get_llm()
+        llm = get_summary_llm()
         chain = WEB_SUMMARIZER_PROMPT_TEMPLATE | llm
         response = chain.invoke({"topic": topic, "input": combined})
-        raw_resp = response.content
-        logger.info(f"Web summarizer received response of length {len(raw_resp)}")
-        return clean_summary(raw_resp)
+        return clean_summary(response.content)
     except Exception as e:
-        logger.error(f"Web summarizer failed: {str(e)}", exc_info=True)
-        raise
+        logger.warning(f"Primary web summarizer model (gemini-3.5-flash-lite) failed: {e}. Falling back to gemini-3.1-flash-lite.")
+        try:
+            fallback_llm = get_summary_fallback_llm()
+            chain = WEB_SUMMARIZER_PROMPT_TEMPLATE | fallback_llm
+            response = chain.invoke({"topic": topic, "input": combined})
+            return clean_summary(response.content)
+        except Exception as fallback_err:
+            logger.error(f"Fallback web summarizer failed: {fallback_err}", exc_info=True)
+            raise fallback_err