added frontend and gemini fallback

backend/models/schemas.py

@@ -29,7 +29,7 @@ class SearchResponse(BaseModel):
     """Response model for search endpoint."""
     response_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
     final_answer: str = Field(..., description="The main answer to the question")
-    source: Literal["KB", "MCP"] = Field(..., description="Source of the answer")
+    source: Literal["KB", "MCP", "Gemini"] = Field(..., description="Source of the answer")
     explanation: Optional[str] = Field(None, description="Optional explanation")
     results: List[SearchResult] = Field(default_factory=list, description="Detailed search results")
     metadata: dict = Field(default_factory=dict, description="Additional metadata")
@@ -50,7 +50,7 @@ class APILogEntry(BaseModel):
     request_data: dict = Field(..., description="Request payload")
     response_data: dict = Field(..., description="Response payload")
     response_time_ms: float = Field(..., description="Response time in milliseconds")
-    source: Literal["KB", "MCP"] = Field(..., description="Source of the answer")
+    source: Literal["KB", "MCP", "Gemini"] = Field(..., description="Source of the answer")
     feedback_received: bool = Field(default=False, description="Whether feedback was received")
     status_code: int = Field(..., description="HTTP status code")
 

backend/requirements.txt

@@ -11,6 +11,9 @@ qdrant-client==1.8.0
 # AI Guardrails
 guardrails-ai==0.4.5
 
+# Google Generative AI (Gemini)
+google-generativeai==0.8.3
+
 # Environment management
 python-dotenv==1.0.0
 

backend/routes/search.py

@@ -16,6 +16,7 @@ from models.schemas import SearchRequest, SearchResponse, ErrorResponse, SearchR
 from services.qdrant_service import QdrantService
 from services.mcp_service import MCPService
 from services.guardrails_service import GuardrailsService
+from services.gemini_service import GeminiService
 
 router = APIRouter()
 logger = structlog.get_logger()
@@ -24,15 +25,17 @@ logger = structlog.get_logger()
 qdrant_service = None
 mcp_service = None
 guardrails_service = None
+gemini_service = None
 
 def initialize_services():
     """Initialize services on first request."""
-    global qdrant_service, mcp_service, guardrails_service
+    global qdrant_service, mcp_service, guardrails_service, gemini_service
     
     if qdrant_service is None:
         qdrant_service = QdrantService()
         mcp_service = MCPService()
         guardrails_service = GuardrailsService()
+        gemini_service = GeminiService()
 
 @router.post("/search", response_model=SearchResponse)
 async def search_math_problems(
@@ -66,49 +69,165 @@ async def search_math_problems(
         # Step 2: Search knowledge base (Qdrant)
         kb_results = await qdrant_service.search_similar(validated_question)
         
-        # Step 3: Determine if we need web search fallback
+        # Step 3: Determine if we need web search fallback with enhanced logic
         confidence_threshold = 0.8  # Increased from 0.5 to 0.8 for higher confidence requirement
         best_score = kb_results[0].score if kb_results else 0.0
         
+        logger.info("Evaluating search results",
+                   kb_results_found=len(kb_results) if kb_results else 0,
+                   best_score=best_score,
+                   threshold=confidence_threshold)
+        
         if best_score >= confidence_threshold:
-            # Use knowledge base results
+            # Use knowledge base results - high confidence match found
             source = "KB"
             final_answer = kb_results[0].solution if kb_results else "No solution found"
-            explanation = f"Found similar problem with confidence score: {best_score:.3f}"
+            explanation = f"High confidence match found (score: {best_score:.3f} ≥ {confidence_threshold})"
             results = kb_results[:3]  # Return top 3 results
             
+            logger.info("Using knowledge base results",
+                       confidence_score=best_score,
+                       results_returned=len(results))
+            
         else:
-            # Fallback to web search via MCP
-            logger.info("Low confidence KB results, using web search fallback",
-                       best_score=best_score, threshold=confidence_threshold)
+            # First fallback: Web search via MCP
+            logger.info("Low confidence KB results, trying web search fallback",
+                       best_score=best_score, 
+                       threshold=confidence_threshold)
             
             try:
                 web_results = await mcp_service.search_web(validated_question)
-                source = "MCP"
-                final_answer = web_results.get("answer", "No web results found")
-                explanation = f"Knowledge base confidence too low ({best_score:.3f}), used web search"
+                mcp_answer = web_results.get("answer", "")
+                mcp_confidence = web_results.get("confidence", 0.6)  # Default MCP confidence
+                
+                logger.info("MCP web search completed",
+                           answer_length=len(mcp_answer),
+                           mcp_confidence=mcp_confidence)
+                
+                # Check if MCP results meet confidence threshold
+                if mcp_confidence >= confidence_threshold and mcp_answer:
+                    # Use MCP results - sufficient confidence
+                    source = "MCP"
+                    final_answer = mcp_answer
+                    explanation = f"KB confidence too low ({best_score:.3f} < {confidence_threshold}), used web search (confidence: {mcp_confidence:.3f})"
+                    
+                    results = [SearchResult(
+                        problem=validated_question,
+                        solution=final_answer,
+                        score=mcp_confidence
+                    )]
+                    
+                    logger.info("Using MCP web search results",
+                               mcp_confidence=mcp_confidence)
                 
-                # Convert web results to SearchResult format
-                results = [SearchResult(
-                    problem=validated_question,
-                    solution=final_answer,
-                    score=0.8  # Default score for web results
-                )]
+                else:
+                    # Second fallback: Gemini LLM when both KB and MCP have low confidence
+                    logger.info("Both KB and MCP have low confidence, falling back to Gemini LLM",
+                               kb_score=best_score,
+                               mcp_confidence=mcp_confidence,
+                               threshold=confidence_threshold)
+                    
+                    try:
+                        if gemini_service and gemini_service.is_available():
+                            gemini_result = await gemini_service.solve_math_problem(validated_question)
+                            
+                            source = "Gemini"
+                            final_answer = gemini_result.get("answer", "No solution generated")
+                            gemini_confidence = gemini_result.get("confidence", 0.75)
+                            explanation = f"Both KB ({best_score:.3f}) and MCP ({mcp_confidence:.3f}) below threshold ({confidence_threshold}), used Gemini LLM"
+                            
+                            results = [SearchResult(
+                                problem=validated_question,
+                                solution=final_answer,
+                                score=gemini_confidence
+                            )]
+                            
+                            logger.info("Gemini LLM response generated successfully",
+                                       answer_length=len(final_answer),
+                                       gemini_confidence=gemini_confidence)
+                        
+                        else:
+                            # Ultimate fallback: Use best available result
+                            logger.warning("Gemini service unavailable, using best available result")
+                            
+                            if mcp_answer and len(mcp_answer) > 20:  # Prefer MCP if it has substantial content
+                                source = "MCP"
+                                final_answer = mcp_answer
+                                explanation = f"All services below threshold, using MCP result (confidence: {mcp_confidence:.3f})"
+                                results = [SearchResult(problem=validated_question, solution=final_answer, score=mcp_confidence)]
+                            else:
+                                source = "KB"
+                                final_answer = kb_results[0].solution if kb_results else "No solution available"
+                                explanation = f"All services below threshold, using best KB result (score: {best_score:.3f})"
+                                results = kb_results[:1] if kb_results else []
+                    
+                    except Exception as gemini_error:
+                        logger.error("Gemini LLM failed, using MCP results", error=str(gemini_error))
+                        source = "MCP"
+                        final_answer = mcp_answer if mcp_answer else "No solution available"
+                        explanation = f"Gemini failed, used MCP result (confidence: {mcp_confidence:.3f})"
+                        results = [SearchResult(problem=validated_question, solution=final_answer, score=mcp_confidence)] if mcp_answer else []
                 
-            except Exception as e:
-                logger.error("Web search failed, falling back to KB results", error=str(e))
-                source = "KB"
-                final_answer = kb_results[0].solution if kb_results else "No solution available"
-                explanation = f"Web search failed, using best KB result (score: {best_score:.3f})"
-                results = kb_results[:1] if kb_results else []
+            except Exception as mcp_error:
+                logger.error("MCP web search failed, trying Gemini fallback", error=str(mcp_error))
+                
+                # If MCP fails, try Gemini directly
+                try:
+                    if gemini_service and gemini_service.is_available():
+                        gemini_result = await gemini_service.solve_math_problem(validated_question)
+                        
+                        source = "Gemini"
+                        final_answer = gemini_result.get("answer", "No solution generated")
+                        gemini_confidence = gemini_result.get("confidence", 0.75)
+                        explanation = f"KB confidence low ({best_score:.3f}), MCP failed, used Gemini LLM"
+                        
+                        results = [SearchResult(
+                            problem=validated_question,
+                            solution=final_answer,
+                            score=gemini_confidence
+                        )]
+                        
+                        logger.info("Gemini LLM used after MCP failure",
+                                   answer_length=len(final_answer))
+                    
+                    else:
+                        # Final fallback to KB results
+                        logger.warning("Both MCP and Gemini failed, using KB results")
+                        source = "KB"
+                        final_answer = kb_results[0].solution if kb_results else "No solution available"
+                        explanation = f"MCP and Gemini failed, using best KB result (score: {best_score:.3f})"
+                        results = kb_results[:1] if kb_results else []
+                
+                except Exception as final_error:
+                    logger.error("All fallbacks failed, using KB results", error=str(final_error))
+                    source = "KB"
+                    final_answer = kb_results[0].solution if kb_results else "No solution available"
+                    explanation = f"All services failed, using best KB result (score: {best_score:.3f})"
+                    results = kb_results[:1] if kb_results else []
+        
         
-        # Step 4: Validate output with guardrails
-        validated_response = guardrails_service.validate_output(final_answer)
+        # Step 4: Validate output with guardrails and create comprehensive response
+        logger.info("Validating final answer with guardrails",
+                   answer_length=len(final_answer),
+                   source=source)
+        
+        try:
+            validated_response = guardrails_service.validate_output(final_answer)
+            
+            # Check if validation changed the response
+            if validated_response != final_answer:
+                logger.warning("Guardrails modified the response",
+                             original_length=len(final_answer),
+                             validated_length=len(validated_response))
+            
+        except Exception as e:
+            logger.error("Guardrails validation failed, using original response", error=str(e))
+            validated_response = final_answer
         
         # Calculate response time
         response_time_ms = (time.time() - start_time) * 1000
         
-        # Create response
+        # Create comprehensive response with enhanced metadata
         response = SearchResponse(
             response_id=response_id,
             final_answer=validated_response,
@@ -118,12 +237,74 @@ async def search_math_problems(
             metadata={
                 "confidence_score": best_score,
                 "threshold_used": confidence_threshold,
-                "kb_results_count": len(kb_results) if kb_results else 0
+                "kb_results_count": len(kb_results) if kb_results else 0,
+                "search_strategy": "semantic_similarity" if source == "KB" else "web_search",
+                "guardrails_applied": validated_response != final_answer,
+                "processing_time_ms": response_time_ms
             },
             response_time_ms=response_time_ms
         )
         
-        # Log API call in background
+        logger.info("Response created successfully",
+                   response_id=response_id,
+                   final_answer_length=len(validated_response),
+                   results_count=len(results),
+                   metadata_fields=len(response.metadata))
+        
+        # Step 5: Post-processing, analytics, and optimization
+        logger.info("Starting post-processing and analytics",
+                   response_id=response_id,
+                   source=source)
+        
+        try:
+            # 5.1: Performance optimization - cache high-confidence results
+            if source == "KB" and best_score >= 0.9:
+                logger.info("High confidence result detected for potential caching",
+                           confidence_score=best_score,
+                           question_hash=hash(validated_question))
+            
+            # 5.2: Quality assessment
+            response_quality = assess_response_quality(
+                question=validated_question,
+                answer=validated_response,
+                source=source,
+                confidence=best_score
+            )
+            
+            # 5.3: Add quality metrics to metadata
+            response.metadata.update({
+                "response_quality": response_quality,
+                "optimization_applied": best_score >= 0.9,
+                "search_efficiency": calculate_search_efficiency(
+                    kb_results_count=len(kb_results) if kb_results else 0,
+                    source=source,
+                    response_time_ms=response_time_ms
+                )
+            })
+            
+            # 5.4: Trigger analytics and learning
+            background_tasks.add_task(
+                update_analytics,
+                question=validated_question,
+                response_data=response.dict(),
+                performance_metrics={
+                    "kb_hit": source == "KB",
+                    "confidence_score": best_score,
+                    "response_time_ms": response_time_ms,
+                    "quality_score": response_quality
+                }
+            )
+            
+            logger.info("Post-processing completed successfully",
+                       response_id=response_id,
+                       quality_score=response_quality,
+                       total_metadata_fields=len(response.metadata))
+            
+        except Exception as e:
+            logger.warning("Post-processing failed, but response is still valid", 
+                          error=str(e), response_id=response_id)
+        
+        # Log API call in background for analytics
         background_tasks.add_task(
             log_api_call,
             request=request.dict(),
@@ -132,10 +313,16 @@ async def search_math_problems(
             source=source
         )
         
+        # Final completion log with comprehensive metrics
         logger.info("Search request completed successfully",
                    request_id=response_id,
                    source=source,
-                   response_time_ms=response_time_ms)
+                   confidence_score=best_score,
+                   threshold_used=confidence_threshold,
+                   kb_results_count=len(kb_results) if kb_results else 0,
+                   final_results_count=len(results),
+                   response_time_ms=response_time_ms,
+                   guardrails_applied=response.metadata.get("guardrails_applied", False))
         
         return response
         
@@ -168,3 +355,98 @@ async def log_api_call(
             )
     except Exception as e:
         logger.warning("Failed to log API call", error=str(e))
+
+def assess_response_quality(question: str, answer: str, source: str, confidence: float) -> float:
+    """
+    Assess the quality of the response based on multiple factors.
+    
+    Returns:
+        Quality score between 0.0 and 1.0
+    """
+    try:
+        quality_score = 0.0
+        
+        # Factor 1: Answer length (not too short, not too long)
+        answer_length = len(answer.strip())
+        if 50 <= answer_length <= 2000:
+            quality_score += 0.3
+        elif answer_length > 20:
+            quality_score += 0.1
+        
+        # Factor 2: Source reliability
+        if source == "KB":
+            quality_score += 0.4 * confidence  # Scale by confidence
+        else:
+            quality_score += 0.3  # Web search baseline
+        
+        # Factor 3: Mathematical content indicators
+        math_indicators = ['=', '+', '-', '*', '/', '^', '√', '∫', '∑', 'x', 'y', 'equation']
+        math_content = sum(1 for indicator in math_indicators if indicator in answer.lower())
+        quality_score += min(0.3, math_content * 0.05)
+        
+        return min(1.0, quality_score)
+        
+    except Exception as e:
+        logger.warning("Quality assessment failed", error=str(e))
+        return 0.5  # Default neutral score
+
+def calculate_search_efficiency(kb_results_count: int, source: str, response_time_ms: float) -> float:
+    """
+    Calculate search efficiency based on results and performance.
+    
+    Returns:
+        Efficiency score between 0.0 and 1.0
+    """
+    try:
+        efficiency = 0.0
+        
+        # Factor 1: Speed (faster is better)
+        if response_time_ms < 1000:
+            efficiency += 0.5
+        elif response_time_ms < 3000:
+            efficiency += 0.3
+        else:
+            efficiency += 0.1
+        
+        # Factor 2: Result availability
+        if kb_results_count > 0:
+            efficiency += 0.3
+        
+        # Factor 3: Source efficiency (KB is more efficient)
+        if source == "KB":
+            efficiency += 0.2
+        
+        return min(1.0, efficiency)
+        
+    except Exception as e:
+        logger.warning("Efficiency calculation failed", error=str(e))
+        return 0.5
+
+async def update_analytics(question: str, response_data: dict, performance_metrics: dict):
+    """
+    Update analytics and learning systems with search data.
+    """
+    try:
+        logger.info("Updating analytics",
+                   kb_hit=performance_metrics.get("kb_hit", False),
+                   confidence=performance_metrics.get("confidence_score", 0),
+                   quality=performance_metrics.get("quality_score", 0))
+        
+        # Future: Could integrate with ML systems for:
+        # - Query pattern analysis
+        # - Response quality improvement
+        # - Automatic threshold adjustment
+        # - Usage pattern detection
+        
+        # For now, just comprehensive logging
+        analytics_data = {
+            "question_length": len(question),
+            "question_hash": hash(question),
+            "timestamp": time.time(),
+            **performance_metrics
+        }
+        
+        logger.info("Analytics updated", **analytics_data)
+        
+    except Exception as e:
+        logger.warning("Analytics update failed", error=str(e))

backend/services/gemini_service.py

@@ -0,0 +1,219 @@
+"""
+Gemini LLM service for final fallback when both KB and MCP have low confidence.
+"""
+import os
+import re
+import structlog
+import google.generativeai as genai
+from typing import Dict, Optional
+
+logger = structlog.get_logger()
+
+
+class GeminiService:
+    """Service for interacting with Google Gemini 2.5 Pro."""
+    
+    def __init__(self):
+        """Initialize Gemini service."""
+        self.api_key = os.getenv("GEMINI_API_KEY")
+        if not self.api_key:
+            logger.warning("GEMINI_API_KEY not found in environment variables")
+            self.client = None
+            return
+            
+        try:
+            genai.configure(api_key=self.api_key)
+            self.model = genai.GenerativeModel('gemini-2.0-flash-exp')
+            logger.info("Gemini service initialized successfully")
+        except Exception as e:
+            logger.error("Failed to initialize Gemini service", error=str(e))
+            self.client = None
+    
+    async def solve_math_problem(self, question: str) -> Dict[str, any]:
+        """
+        Solve a math problem using Gemini 2.5 Pro.
+        
+        Args:
+            question: The math question to solve
+            
+        Returns:
+            Dict containing the solution and metadata
+        """
+        if not self.model:
+            raise Exception("Gemini service not properly initialized")
+        
+        try:
+            # Create a comprehensive prompt for math problem solving
+            prompt = self._create_math_prompt(question)
+            
+            logger.info("Sending request to Gemini", question_length=len(question))
+            
+            # Generate response
+            response = await self._generate_response(prompt)
+            
+            # Parse and validate the response
+            result = self._parse_response(response, question)
+            
+            logger.info("Gemini response generated successfully", 
+                       answer_length=len(result.get("answer", "")))
+            
+            return result
+            
+        except Exception as e:
+            logger.error("Error in Gemini math problem solving", error=str(e))
+            raise
+    
+    def _create_math_prompt(self, question: str) -> str:
+        """Create a comprehensive prompt for math problem solving."""
+        return f"""You are an expert mathematics tutor. Solve this math problem with precision and clarity.
+
+QUESTION: {question}
+
+CRITICAL FORMATTING REQUIREMENT - THIS IS MANDATORY:
+You MUST wrap every single mathematical expression in dollar signs ($). No exceptions.
+
+RESPONSE FORMAT:
+Solution Steps:
+[Provide numbered steps with clear explanations]
+
+Final Answer:
+[State the final answer clearly and concisely]
+
+Verification (if applicable):
+[Show verification using an alternative method or substitution]
+
+MANDATORY MATH FORMATTING EXAMPLES - COPY THIS STYLE EXACTLY:
+- Write: "For the term $3x^2$, we have $a = 3$ and $n = 2$"
+- Write: "The function $f(x) = 3x^2 + 2x - 1$"
+- Write: "The derivative is $f'(x) = 6x + 2$"
+- Write: "Apply the power rule: if $f(x) = ax^n$, then $f'(x) = nax^{{n-1}}$"
+
+NEVER WRITE MATH WITHOUT DOLLAR SIGNS:
+- WRONG: "For the term 3x^2, we have a = 3 and n = 2"
+- WRONG: "The function f(x) = 3x^2 + 2x - 1"
+- WRONG: "The derivative is f'(x) = 6x + 2"
+
+EVERYTHING mathematical must have $ around it: variables, numbers in math context, equations, expressions.
+
+Begin your solution now, remembering to wrap ALL math in $ signs:"""
+    
+    async def _generate_response(self, prompt: str) -> str:
+        """Generate response from Gemini."""
+        try:
+            # Generate content using the configured model
+            response = self.model.generate_content(prompt)
+            
+            if not response.text:
+                raise Exception("Empty response from Gemini")
+            
+            return response.text
+            
+        except Exception as e:
+            logger.error("Error generating Gemini response", error=str(e))
+            raise
+    
+    def _parse_response(self, response: str, original_question: str) -> Dict[str, any]:
+        """Parse Gemini response into structured format."""
+        try:
+            # Clean up the response
+            cleaned_response = self._clean_response(response)
+            
+            return {
+                "answer": cleaned_response,
+                "confidence": 0.85,  # Increased confidence for better structured responses
+                "source": "Gemini",
+                "original_question": original_question,
+                "response_length": len(cleaned_response),
+                "model": "gemini-2.0-flash-exp"
+            }
+            
+        except Exception as e:
+            logger.error("Error parsing Gemini response", error=str(e))
+            return {
+                "answer": response.strip(),
+                "confidence": 0.6,
+                "source": "Gemini",
+                "original_question": original_question,
+                "error": "Failed to parse response properly"
+            }
+    
+    def _clean_response(self, response: str) -> str:
+        """Clean and format the Gemini response."""
+        try:
+            # Remove excessive introductory phrases
+            response = response.strip()
+            
+            # Remove common verbose openings
+            verbose_openings = [
+                "Okay, let's",
+                "Alright, let's", 
+                "Sure, let's",
+                "Let's solve",
+                "I'll solve",
+                "Here's how to"
+            ]
+            
+            for opening in verbose_openings:
+                if response.lower().startswith(opening.lower()):
+                    # Find the first period or newline and start from there
+                    first_break = min(
+                        response.find('.') + 1 if response.find('.') != -1 else len(response),
+                        response.find('\n') if response.find('\n') != -1 else len(response)
+                    )
+                    response = response[first_break:].strip()
+                    break
+            
+            # Convert LaTeX delimiters to standard format for frontend
+            response = response.replace('\\(', '$').replace('\\)', '$')
+            response = response.replace('\\[', '$$').replace('\\]', '$$')
+            
+            # Remove markdown formatting
+            response = response.replace("**Final Answer:**", "Final Answer:")
+            response = response.replace("**Final Answer**", "Final Answer:")
+            response = response.replace("## Final Answer", "Final Answer:")
+            response = response.replace("## Solution Steps", "Solution Steps:")
+            response = response.replace("## Verification", "Verification:")
+            
+            # Clean up excessive asterisks and markdown formatting
+            response = re.sub(r'\*{2,}', '', response)  # Remove all ** formatting
+            response = re.sub(r'#{2,}\s*', '', response)  # Remove ## headers
+            
+            # Improve section formatting
+            response = re.sub(r'^(\d+\.\s)', r'\n\1', response, flags=re.MULTILINE)  # Add newlines before numbered steps
+            response = re.sub(r'\n\s*\n\s*\n', '\n\n', response)  # Remove excessive line breaks
+            
+            return response.strip()
+            
+        except Exception as e:
+            logger.warning("Failed to clean response, returning original", error=str(e))
+            return response.strip()
+    
+    def is_available(self) -> bool:
+        """Check if Gemini service is available."""
+        return self.model is not None
+    
+    async def health_check(self) -> Dict[str, any]:
+        """Perform a health check on the Gemini service."""
+        if not self.model:
+            return {
+                "status": "unhealthy",
+                "error": "Gemini service not initialized"
+            }
+        
+        try:
+            # Test with a simple math problem
+            test_response = await self.solve_math_problem("What is 2 + 2?")
+            
+            return {
+                "status": "healthy",
+                "model": "gemini-2.0-flash-exp",
+                "test_response_length": len(test_response.get("answer", "")),
+                "api_key_configured": bool(self.api_key)
+            }
+            
+        except Exception as e:
+            return {
+                "status": "unhealthy",
+                "error": str(e),
+                "api_key_configured": bool(self.api_key)
+            }

backend/services/mcp_service.py

@@ -36,20 +36,38 @@ class MCPService:
             # Simulate web search delay
             await asyncio.sleep(0.5)
             
-            # Mock response based on question type
+            # Mock response based on question type with realistic confidence scoring
+            confidence_score = 0.6  # Default confidence
+            
             if any(keyword in question.lower() for keyword in ['derivative', 'integral', 'calculus']):
                 answer = f"Based on web search: This appears to be a calculus problem. {question} involves applying standard calculus techniques. Consider using the fundamental theorem of calculus or integration by parts."
+                confidence_score = 0.75  # Higher confidence for calculus
             elif any(keyword in question.lower() for keyword in ['algebra', 'equation', 'solve']):
                 answer = f"Based on web search: This is an algebraic problem. {question} can be solved using algebraic manipulation and equation solving techniques."
+                confidence_score = 0.7  # Good confidence for algebra
             elif any(keyword in question.lower() for keyword in ['geometry', 'triangle', 'circle']):
                 answer = f"Based on web search: This is a geometry problem. {question} involves geometric principles and may require knowledge of shapes, areas, or angles."
+                confidence_score = 0.65  # Moderate confidence for geometry
+            elif any(keyword in question.lower() for keyword in ['statistics', 'probability', 'mean', 'standard deviation']):
+                answer = f"Based on web search: This is a statistics/probability problem. {question} requires understanding of statistical concepts and may involve data analysis."
+                confidence_score = 0.72  # Good confidence for stats
             else:
                 answer = f"Based on web search: {question} is a mathematical problem that may require breaking down into smaller steps and applying relevant mathematical concepts."
+                confidence_score = 0.55  # Lower confidence for unknown types
+            
+            # Adjust confidence based on question length and complexity
+            if len(question) > 100:
+                confidence_score += 0.05  # Slightly higher for detailed questions
+            if '=' in question and any(op in question for op in ['+', '-', '*', '/', '^']):
+                confidence_score += 0.1   # Higher for equations with operators
+            
+            # Cap confidence to ensure it's below KB threshold for testing fallback
+            confidence_score = min(confidence_score, 0.79)  # Always below 0.8 threshold
             
             result = {
                 "answer": answer,
                 "source": "web_search",
-                "confidence": 0.7,
+                "confidence": confidence_score,
                 "search_query": question,
                 "results_count": 1
             }

backend/services/qdrant_service.py

@@ -34,7 +34,10 @@ class QdrantService:
         try:
             import os
             from dotenv import load_dotenv
-            load_dotenv()
+            
+            # Load .env from project root (3 levels up from services)
+            env_path = Path(__file__).parent.parent.parent / '.env'
+            load_dotenv(env_path)
             
             # Qdrant configuration from environment variables
             qdrant_config = {