feat: implement profile caching and optimize database client initialization.

auth/routes.py

@@ -28,50 +28,68 @@ async def get_profile(
     current_user=Depends(get_current_user)
 ):
     user = get_user_by_id(user_id)
-    
-    # Identify if the email is a temporary placeholder
+
+    # Fast-path: profile row exists and has a real email — return immediately
     email = user.get("email", "") if user else ""
-    is_placeholder = not user or "@placeholder.ai" in email or "@studymate.ai" in email or "user" in email
-    
+    is_placeholder = (
+        not user
+        or not email
+        or "@placeholder.ai" in email
+        or "@studymate.ai" in email
+    )
+
     if is_placeholder:
-        # Try to get DEFINITELY REAL data from Supabase Auth using the service role client
+        # First-ever login: pull real data from Supabase Auth admin API and persist it
         from src.database import get_supabase
         supabase = get_supabase()
         if supabase:
             try:
-                # Use admin API to get real user data
                 res = supabase.auth.admin.get_user_by_id(user_id)
                 if res.user and res.user.email and "@" in res.user.email:
                     real_email = res.user.email
                     real_name = res.user.user_metadata.get("name")
-                    
-                    # Use upsert to create or update the profile with real data
+
                     from src.store import _table_supabase, _map_profile
                     data = {"id": user_id, "email": real_email}
                     if real_name:
                         data["display_name"] = real_name
-                        
+
                     try:
-                        res_upd = _table_supabase("profiles").upsert(data).execute()
+                        res_upd = _table_supabase("profiles").insert(data).execute()
                         if res_upd.data:
                             user = _map_profile(res_upd.data[0])
                     except Exception:
-                        pass
+                        # Profile row probably already exists — do a targeted update instead
+                        try:
+                            res_upd = (
+                                _table_supabase("profiles")
+                                .update(data)
+                                .eq("id", user_id)
+                                .execute()
+                            )
+                            if res_upd.data:
+                                user = _map_profile(res_upd.data[0])
+                        except Exception:
+                            pass
             except Exception:
                 pass
-                
-    if not user and isinstance(current_user, dict) and current_user.get("id"):
-        # Last resort: return data from headers if DB/Supabase both failed
-        # This keeps the UI working even if there's a temporary DB issue
-        from src.store import _map_profile
-        user = _map_profile({
-            "id": current_user["id"],
-            "display_name": current_user.get("name") or "User",
-            "email": current_user.get("email") or "",
-            "avatar_url": "",
-            "daily_requests": 0,
-            "last_request_date": ""
-        })
+
+    if not user:
+        # Last resort: synthetic profile from the JWT claims so the UI doesn't break
+        user_obj = current_user
+        uid = getattr(user_obj, "id", None) or (user_obj.get("id") if isinstance(user_obj, dict) else None)
+        if uid:
+            from src.store import _map_profile
+            meta = getattr(user_obj, "user_metadata", {}) or {}
+            user = _map_profile({
+                "id": uid,
+                "display_name": meta.get("full_name") or meta.get("name") or "User",
+                "email": getattr(user_obj, "email", "") or "",
+                "avatar_url": "",
+                "daily_requests": 0,
+                "last_request_date": "",
+                "_is_fallback": True,
+            })
 
     if not user:
         raise HTTPException(404, "Profile not found")
@@ -82,8 +100,8 @@ async def get_profile(
 async def update_profile(body: ProfileUpdateRequest, user_id: str = Depends(get_current_user_id)):
     try:
         updated_user = update_user_profile(
-            user_id, 
-            name=body.name, 
+            user_id,
+            name=body.name,
             avatar_url=body.avatar_url,
             theme=body.theme
         )

database.py

@@ -2,14 +2,24 @@ from typing import Optional
 from supabase import Client, create_client
 from src.config import settings
 
+# Singletons — created once, reused on every request
+_supabase_client: Optional[Client] = None
+_auth_supabase_client: Optional[Client] = None
+
 
 def get_supabase() -> Optional[Client]:
-    if not settings.supabase_url or not settings.supabase_key:
-        return None
-    return create_client(settings.supabase_url, settings.supabase_key)
+    global _supabase_client
+    if _supabase_client is None:
+        if not settings.supabase_url or not settings.supabase_key:
+            return None
+        _supabase_client = create_client(settings.supabase_url, settings.supabase_key)
+    return _supabase_client
 
 
 def get_auth_supabase() -> Optional[Client]:
-    if not settings.supabase_url or not settings.supabase_anon_key:
-        return None
-    return create_client(settings.supabase_url, settings.supabase_anon_key)
+    global _auth_supabase_client
+    if _auth_supabase_client is None:
+        if not settings.supabase_url or not settings.supabase_anon_key:
+            return None
+        _auth_supabase_client = create_client(settings.supabase_url, settings.supabase_anon_key)
+    return _auth_supabase_client

dependencies.py

@@ -1,3 +1,4 @@
+import time
 from fastapi import Depends, HTTPException, Header, status, Request
 from fastapi.security import OAuth2PasswordBearer
 from typing import Any, Optional
@@ -9,6 +10,34 @@ DEV_USER = {"id": DEV_USER_ID, "email": "dev@studymate.ai", "name": "Dev User"}
 
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token", auto_error=False)
 
+_TOKEN_CACHE: dict = {}
+_TOKEN_CACHE_TTL = 300  # 5 minutes
+
+
+def _verify_token_cached(client, token: str) -> Any:
+    now = time.time()
+
+    # Simple cleanup to prevent unbounded growth
+    if len(_TOKEN_CACHE) > 1000:
+        expired = [k for k, v in _TOKEN_CACHE.items() if now - v[1] > _TOKEN_CACHE_TTL]
+        for k in expired:
+            del _TOKEN_CACHE[k]
+
+    # Return cached user if valid
+    if token in _TOKEN_CACHE:
+        user, timestamp = _TOKEN_CACHE[token]
+        if now - timestamp < _TOKEN_CACHE_TTL:
+            return user
+
+    # Not cached or expired — fetch from Supabase
+    response = client.auth.get_user(token)
+    user = getattr(response, "user", None) or response
+    if user:
+        _TOKEN_CACHE[token] = (user, now)
+        return user
+
+    raise ValueError("Invalid token response")
+
 
 def _extract_token(request: Request) -> Optional[str]:
     """
@@ -35,7 +64,8 @@ def _extract_token(request: Request) -> Optional[str]:
 
 
 async def get_current_user_id(request: Request) -> str:
-    client = get_supabase()
+    # Use a single cached client — prefer the auth client, fall back to service client
+    client = get_auth_supabase() or get_supabase()
 
     # Dev mode
     if client is None:
@@ -47,18 +77,15 @@ async def get_current_user_id(request: Request) -> str:
         raise HTTPException(status.HTTP_401_UNAUTHORIZED, "Not authenticated")
 
     try:
-        auth_client = get_auth_supabase()
-        supabase = auth_client if auth_client is not None else client
-        user = supabase.auth.get_user(token)
-        user_obj = getattr(user, "user", None) or user
-        return str(user_obj.id)
-    except Exception as e:
+        user = _verify_token_cached(client, token)
+        return str(user.id)
+    except Exception:
         raise HTTPException(status.HTTP_401_UNAUTHORIZED, "Invalid or expired token")
 
 
 async def get_current_user(request: Request) -> Any:
-    auth_client = get_auth_supabase()
-    client = get_supabase()
+    # Use a single cached client — prefer the auth client, fall back to service client
+    client = get_auth_supabase() or get_supabase()
 
     # Dev mode
     if client is None:
@@ -68,9 +95,7 @@ async def get_current_user(request: Request) -> Any:
 
     if token:
         try:
-            verify_client = auth_client if auth_client is not None else client
-            response = verify_client.auth.get_user(token)
-            user = getattr(response, "user", None) or response
+            user = _verify_token_cached(client, token)
             if user:
                 return user
         except Exception:

quiz_generator/quiz.py

@@ -56,6 +56,12 @@ Include exactly:
     ]
 }}
 
+**CRITICAL RULES:**
+1. Your final output MUST be exactly the JSON structure above.
+2. DO NOT include any conversational text, prefixes, or markdown blocks (like ```json).
+3. Even if you cannot find enough context or tools fail, YOU MUST STILL output a valid JSON containing questions based on your general knowledge.
+4. ANY deviation from the valid JSON format will break the system.
+
 **AVAILABLE CONTEXT:**
 {context}
 

store.py

@@ -1,4 +1,6 @@
 import os
+import time
+from httpx import RemoteProtocolError
 from typing import Optional
 import logging
 from datetime import datetime, timezone, date
@@ -125,13 +127,12 @@ def _table_supabase(table: str):
     return _FakeTable(table)
 
 def _robust_execute(query):
-    import time
-    from httpx import RemoteProtocolError
     for attempt in range(3):
         try:
             return query.execute()
-        except (RemoteProtocolError, Exception) as e:
-            if attempt == 2: raise e
+        except RemoteProtocolError as e:
+            if attempt == 2:
+                raise e
             time.sleep(0.5 * (attempt + 1))
     return query.execute()
 

summary_generator/summary.py

@@ -124,7 +124,8 @@ def web_summarizer(topic: str) -> str:
         logger.warning(f"Arxiv search for '{topic}' failed: {e}")
 
     if not all_content:
-        raise ValueError(f"No content found for topic: {topic}")
+        logger.warning(f"No content found for topic: {topic}. Falling back to general knowledge.")
+        all_content.append(f"Topic: {topic}\n\nPlease provide a comprehensive educational summary of this topic based on your general knowledge.")
 
     combined = "\n\n".join(all_content)
     logger.info(f"Web search combined text length for topic '{topic}': {len(combined)}")