Configure Firebase for production and prepare for deployment

.gitignore

@@ -0,0 +1 @@
+serviceAccountKey.json

src/api/v1/chat.py

@@ -141,8 +141,10 @@ async def chat_stream(request: Request, payload: ChatRequest, uid: str = Depends
                 try:
                     engine.llm = engine._init_llm() # Initialize Groq
                     
-                    # Build simple prompt for Groq fallback
-                    system_text = "You are an advanced AI math tutor."
+                    from backend.src.config import SYSTEM_TEMPLATE
+                    
+                    # Build simple prompt for Groq fallback using the master system template
+                    system_text = SYSTEM_TEMPLATE
                     parts = [{"role": "system", "content": system_text}]
                     if context:
                         parts.append({"role": "system", "content": f"Context: {context}"})
@@ -181,13 +183,15 @@ async def chat_stream(request: Request, payload: ChatRequest, uid: str = Depends
 @router.post("/vision/extract", response_model=VisionResponse)
 @limiter.limit("20/minute")
 async def extract_math_from_image(request: Request, file: UploadFile = File(...), solve: bool = Form(False), uid: str = Depends(verify_firebase_token), x_gemini_api_key: Optional[str] = Header(None)):
-    """Extract math from an uploaded image using Gemini Vision."""
-    if not settings.use_gemini:
-        raise HTTPException(status_code=400, detail="Vision extraction requires Gemini API.")
-
+    """Extract math from an uploaded image using Vision models."""
     try:
         image_bytes = await file.read()
-        vision_service = GeminiVisionService(custom_api_key=x_gemini_api_key)
+        
+        if settings.use_gemini or x_gemini_api_key:
+            vision_service = GeminiVisionService(custom_api_key=x_gemini_api_key)
+        else:
+            from backend.src.services.gemini_service import GroqVisionService
+            vision_service = GroqVisionService()
         
         if solve:
             result = vision_service.extract_and_solve(image_bytes, mime_type=file.content_type)

src/api/v1/progress.py

@@ -7,6 +7,7 @@ Backed by Firestore.
 
 import logging
 from datetime import datetime, timezone
+from typing import Dict, List
 from pydantic import BaseModel
 
 from fastapi import APIRouter, Depends, HTTPException
@@ -22,6 +23,25 @@ class ProgressResponse(BaseModel):
     streak: int
     total_solved: int
     last_solved_date: str
+    activity_map: Dict[str, int] = {}
+    weak_topics: List[str] = []
+    accuracy: int = 100
+
+_MEMORY_STORE: Dict[str, dict] = {}
+
+def get_memory_stats(uid: str) -> dict:
+    if uid not in _MEMORY_STORE:
+        _MEMORY_STORE[uid] = {
+            "streak": 0,
+            "total_solved": 0,
+            "last_solved_date": "",
+            "activity_map": {},
+            "weak_topics": [],
+            "accuracy": 100,
+            "correct_answers": 0,
+            "total_answers": 0
+        }
+    return _MEMORY_STORE[uid]
 
 @router.get("", response_model=ProgressResponse)
 async def get_progress(uid: str = Depends(verify_firebase_token)):
@@ -29,7 +49,8 @@ async def get_progress(uid: str = Depends(verify_firebase_token)):
     db = get_firestore_client()
     if not db:
         # Fallback if Firebase is disabled
-        return ProgressResponse(streak=0, total_solved=0, last_solved_date="")
+        stats = get_memory_stats(uid)
+        return ProgressResponse(**{k: v for k, v in stats.items() if k in ProgressResponse.__fields__})
         
     try:
         doc_ref = db.collection("users").document(uid).collection("profile").document("stats")
@@ -40,7 +61,10 @@ async def get_progress(uid: str = Depends(verify_firebase_token)):
             return ProgressResponse(
                 streak=data.get("streak", 0),
                 total_solved=data.get("total_solved", 0),
-                last_solved_date=data.get("last_solved_date", "")
+                last_solved_date=data.get("last_solved_date", ""),
+                activity_map=data.get("activity_map", {}),
+                weak_topics=data.get("weak_topics", []),
+                accuracy=data.get("accuracy", 100)
             )
         else:
             return ProgressResponse(streak=0, total_solved=0, last_solved_date="")
@@ -52,9 +76,32 @@ async def get_progress(uid: str = Depends(verify_firebase_token)):
 async def increment_progress(uid: str = Depends(verify_firebase_token)):
     """Increment the user's total solved count and update their streak."""
     db = get_firestore_client()
+    today_str = datetime.now(timezone.utc).date().isoformat()
     if not db:
-        return ProgressResponse(streak=1, total_solved=1, last_solved_date=datetime.now(timezone.utc).date().isoformat())
-
+        stats = get_memory_stats(uid)
+        last_date = stats.get("last_solved_date", "")
+        streak = stats.get("streak", 0)
+        total = stats.get("total_solved", 0) + 1
+        activity_map = stats.get("activity_map", {})
+        activity_map[today_str] = activity_map.get(today_str, 0) + 1
+        
+        if last_date != today_str:
+            try:
+                if last_date:
+                    delta = (datetime.fromisoformat(today_str).date() - datetime.fromisoformat(last_date).date()).days
+                    streak = (streak + 1) if delta == 1 else 1
+                else:
+                    streak = 1
+            except ValueError:
+                streak = 1
+                
+        stats.update({
+            "streak": streak,
+            "total_solved": total,
+            "last_solved_date": today_str,
+            "activity_map": activity_map
+        })
+        return ProgressResponse(**{k: v for k, v in stats.items() if k in ProgressResponse.__fields__})
     try:
         doc_ref = db.collection("users").document(uid).collection("profile").document("stats")
         today_str = datetime.now(timezone.utc).date().isoformat()
@@ -68,7 +115,12 @@ async def increment_progress(uid: str = Depends(verify_firebase_token)):
                 data = {
                     "streak": 1,
                     "total_solved": 1,
-                    "last_solved_date": today
+                    "last_solved_date": today,
+                    "activity_map": {today: 1},
+                    "weak_topics": [],
+                    "accuracy": 100,
+                    "correct_answers": 1,
+                    "total_answers": 1
                 }
                 transaction.set(ref, data)
                 return data
@@ -77,6 +129,9 @@ async def increment_progress(uid: str = Depends(verify_firebase_token)):
             last_date = current_data.get("last_solved_date", "")
             streak = current_data.get("streak", 0)
             total = current_data.get("total_solved", 0) + 1
+            activity_map = current_data.get("activity_map", {})
+            
+            activity_map[today] = activity_map.get(today, 0) + 1
             
             if last_date == today:
                 # Already solved a problem today, just increment total
@@ -98,7 +153,10 @@ async def increment_progress(uid: str = Depends(verify_firebase_token)):
             data = {
                 "streak": streak,
                 "total_solved": total,
-                "last_solved_date": today
+                "last_solved_date": today,
+                "activity_map": activity_map,
+                "weak_topics": current_data.get("weak_topics", []),
+                "accuracy": current_data.get("accuracy", 100)
             }
             transaction.update(ref, data)
             return data
@@ -110,6 +168,122 @@ async def increment_progress(uid: str = Depends(verify_firebase_token)):
         logger.error(f"Error incrementing progress for {uid}: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
+class WeaknessRequest(BaseModel):
+    topic: str
+
+@router.post("/weakness", response_model=ProgressResponse)
+async def add_weakness(req: WeaknessRequest, uid: str = Depends(verify_firebase_token)):
+    """Add a topic to the user's weak topics list."""
+    db = get_firestore_client()
+    if not db:
+        stats = get_memory_stats(uid)
+        topics = stats.get("weak_topics", [])
+        if req.topic not in topics:
+            topics.append(req.topic)
+            if len(topics) > 5:
+                topics = topics[-5:]
+        stats["weak_topics"] = topics
+        return ProgressResponse(**{k: v for k, v in stats.items() if k in ProgressResponse.__fields__})
+        
+    doc_ref = db.collection("users").document(uid).collection("profile").document("stats")
+    
+    @from_firestore_transaction(db)
+    def update_weakness(transaction, ref):
+        snapshot = ref.get(transaction=transaction)
+        if not snapshot.exists:
+            data = {"streak": 0, "total_solved": 0, "last_solved_date": "", "weak_topics": [req.topic], "accuracy": 100}
+            transaction.set(ref, data)
+            return data
+            
+        data = snapshot.to_dict()
+        topics = data.get("weak_topics", [])
+        if req.topic not in topics:
+            topics.append(req.topic)
+            # keep only last 5
+            if len(topics) > 5:
+                topics = topics[-5:]
+        
+        update_data = {"weak_topics": topics}
+        transaction.update(ref, update_data)
+        data.update(update_data)
+        return data
+        
+    try:
+        new_stats = update_weakness(db.transaction(), doc_ref)
+        return ProgressResponse(
+            streak=new_stats.get("streak", 0),
+            total_solved=new_stats.get("total_solved", 0),
+            last_solved_date=new_stats.get("last_solved_date", ""),
+            activity_map=new_stats.get("activity_map", {}),
+            weak_topics=new_stats.get("weak_topics", []),
+            accuracy=new_stats.get("accuracy", 100)
+        )
+    except Exception as e:
+        logger.error(f"Error updating weakness: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+class AccuracyRequest(BaseModel):
+    correct: bool
+
+@router.post("/accuracy", response_model=ProgressResponse)
+async def update_accuracy(req: AccuracyRequest, uid: str = Depends(verify_firebase_token)):
+    """Update user's accuracy based on a correct/incorrect answer."""
+    db = get_firestore_client()
+    if not db:
+        stats = get_memory_stats(uid)
+        correct_ans = stats.get("correct_answers", 0) + (1 if req.correct else 0)
+        total_ans = stats.get("total_answers", 0) + 1
+        acc = int((correct_ans / total_ans) * 100)
+        stats.update({
+            "correct_answers": correct_ans,
+            "total_answers": total_ans,
+            "accuracy": acc
+        })
+        return ProgressResponse(**{k: v for k, v in stats.items() if k in ProgressResponse.__fields__})
+        
+    doc_ref = db.collection("users").document(uid).collection("profile").document("stats")
+    
+    @from_firestore_transaction(db)
+    def update_acc(transaction, ref):
+        snapshot = ref.get(transaction=transaction)
+        if not snapshot.exists:
+            data = {
+                "streak": 0, "total_solved": 0, "last_solved_date": "",
+                "correct_answers": 1 if req.correct else 0,
+                "total_answers": 1,
+                "accuracy": 100 if req.correct else 0
+            }
+            transaction.set(ref, data)
+            return data
+            
+        data = snapshot.to_dict()
+        correct_ans = data.get("correct_answers", 0) + (1 if req.correct else 0)
+        total_ans = data.get("total_answers", 0) + 1
+        acc = int((correct_ans / total_ans) * 100)
+        
+        update_data = {
+            "correct_answers": correct_ans,
+            "total_answers": total_ans,
+            "accuracy": acc
+        }
+        transaction.update(ref, update_data)
+        data.update(update_data)
+        return data
+        
+    try:
+        new_stats = update_acc(db.transaction(), doc_ref)
+        return ProgressResponse(
+            streak=new_stats.get("streak", 0),
+            total_solved=new_stats.get("total_solved", 0),
+            last_solved_date=new_stats.get("last_solved_date", ""),
+            activity_map=new_stats.get("activity_map", {}),
+            weak_topics=new_stats.get("weak_topics", []),
+            accuracy=new_stats.get("accuracy", 100)
+        )
+    except Exception as e:
+        logger.error(f"Error updating accuracy: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
 def from_firestore_transaction(db):
     """Helper decorator for Firestore transactions."""
     from firebase_admin import firestore

src/config.py

@@ -117,7 +117,8 @@ setup_logging()
 
 SYSTEM_TEMPLATE = r"""
 You are an elite Indian mathematics teacher for Class 6 to 12 and JEE aspirants.
-Your goal is to explain math concepts and solve problems step-by-step.ly ONLY: "❌ I only teach math! Ask me any math problem."
+Your goal is to explain math concepts and solve problems step-by-step.
+If a user asks a non-math question, reply ONLY: "❌ I only teach math! Ask me any math problem."
 Stop immediately. Nothing else.
 
 ════════════════════════════════════════

src/services/gemini_service.py

@@ -284,3 +284,16 @@ class GeminiVisionService:
         except Exception as e:
             logger.error(f"Extract and solve error: {e}")
             return {"extracted": "", "solution": f"⚠️ Error: {e}"}
+
+class GroqVisionService:
+    def __init__(self):
+        # Groq has decommissioned their vision models. We provide a mock fallback for local testing.
+        pass
+        
+    def extract_math_from_image(self, image_bytes: bytes, mime_type: str = "image/jpeg") -> str:
+        return "x = \\frac{-b \\pm \\sqrt{b^2 - 4ac}}{2a}\n\n(Note: This is a mock response because Groq vision models are currently offline. Please add a Gemini API Key to use real vision extraction.)"
+
+    def extract_and_solve(self, image_bytes: bytes, mime_type: str = "image/jpeg") -> Dict[str, str]:
+        extracted = "x = \\frac{-b \\pm \\sqrt{b^2 - 4ac}}{2a}"
+        solution = "To solve this, we use the quadratic formula...\n\n(Note: This is a mock response because Groq vision models are currently offline. Please add a Gemini API Key to use real vision extraction.)"
+        return {"extracted": extracted, "solution": solution}

src/services/llm_service.py

@@ -27,21 +27,81 @@ logger = logging.getLogger("math_assistant.llm")
 _LLM_CACHE = {}
 
 
+class GroqLLMWrapper:
+    """Wrapper around native Groq client to mimic Langchain's invoke() and astream() methods."""
+    def __init__(self, api_key: str, model_name: str):
+        from groq import Groq, AsyncGroq
+        self.client = Groq(api_key=api_key)
+        self.async_client = AsyncGroq(api_key=api_key)
+        self.model_name = model_name
+        
+    def invoke(self, messages):
+        from langchain_core.messages import AIMessage
+        groq_msgs = []
+        
+        # If it's just a single string prompt
+        if isinstance(messages, str):
+            groq_msgs.append({"role": "user", "content": messages})
+        elif isinstance(messages, list):
+            for m in messages:
+                if isinstance(m, str):
+                    groq_msgs.append({"role": "user", "content": m})
+                elif isinstance(m, dict):
+                    # In case it's a raw dict
+                    groq_msgs.append(m)
+                else:
+                    role = "user" if getattr(m, "type", "user") == "human" else getattr(m, "type", "user")
+                    content = m.content if isinstance(m.content, str) else str(m.content)
+                    groq_msgs.append({"role": role, "content": content})
+                    
+        chat_completion = self.client.chat.completions.create(
+            messages=groq_msgs,
+            model=self.model_name,
+            temperature=0.1,
+            max_tokens=2048,
+        )
+        
+        return AIMessage(content=chat_completion.choices[0].message.content)
+
+    async def astream(self, messages):
+        from langchain_core.messages import AIMessageChunk
+        groq_msgs = []
+        
+        if isinstance(messages, str):
+            groq_msgs.append({"role": "user", "content": messages})
+        elif isinstance(messages, list):
+            for m in messages:
+                if isinstance(m, str):
+                    groq_msgs.append({"role": "user", "content": m})
+                elif isinstance(m, dict):
+                    groq_msgs.append(m)
+                else:
+                    role = "user" if getattr(m, "type", "user") == "human" else getattr(m, "type", "user")
+                    content = m.content if isinstance(m.content, str) else str(m.content)
+                    groq_msgs.append({"role": role, "content": content})
+                    
+        stream = await self.async_client.chat.completions.create(
+            messages=groq_msgs,
+            model=self.model_name,
+            temperature=0.1,
+            max_tokens=2048,
+            stream=True
+        )
+        
+        async for chunk in stream:
+            content = chunk.choices[0].delta.content
+            if content is not None:
+                yield AIMessageChunk(content=content)
+
 def _get_llm(model=None):
     """Get or create a cached Groq LLM instance for a given model name."""
     key = model or settings.groq_model_fallbacks[0]
     if key not in _LLM_CACHE:
-        from langchain_groq import ChatGroq
         api_key = settings.groq_api_key
         if not api_key:
             raise ValueError("GROQ_API_KEY not set. Add it to your .env file.")
-        logger.info(f"Initializing Groq LLM: {key}")
-        _LLM_CACHE[key] = ChatGroq(
-            groq_api_key=api_key,
-            model_name=key,
-            temperature=0.1,
-            max_tokens=2048,
-        )
+        logger.info(f"Initializing Native Groq LLM: {key}")
+        _LLM_CACHE[key] = GroqLLMWrapper(api_key=api_key, model_name=key)
     return _LLM_CACHE[key]