added fastapi backend server

backend/main.py

@@ -0,0 +1,117 @@
+"""
+FastAPI backend for Math Agentic RAG system.
+"""
+import sys
+import os
+from pathlib import Path
+
+# Add the parent directory to Python path to import database module
+parent_dir = Path(__file__).parent.parent
+sys.path.append(str(parent_dir))
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+import logging
+import structlog
+from dotenv import load_dotenv
+
+# Import routes
+from routes.search import router as search_router
+from routes.feedback import router as feedback_router
+
+# Load environment variables
+load_dotenv()
+
+# Configure structured logging
+structlog.configure(
+    processors=[
+        structlog.stdlib.filter_by_level,
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.PositionalArgumentsFormatter(),
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.processors.StackInfoRenderer(),
+        structlog.processors.format_exc_info,
+        structlog.processors.UnicodeDecoder(),
+        structlog.processors.JSONRenderer()
+    ],
+    context_class=dict,
+    logger_factory=structlog.stdlib.LoggerFactory(),
+    cache_logger_on_first_use=True,
+)
+
+logger = structlog.get_logger()
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan manager."""
+    logger.info("Starting Math Agentic RAG Backend...")
+    
+    # Startup
+    try:
+        # Initialize services here if needed
+        logger.info("Backend services initialized successfully")
+        yield
+    except Exception as e:
+        logger.error("Failed to initialize backend services", error=str(e))
+        raise
+    finally:
+        # Cleanup
+        logger.info("Shutting down Math Agentic RAG Backend...")
+
+# Create FastAPI application
+app = FastAPI(
+    title="Math Agentic RAG API",
+    description="Backend API for Math-focused Agentic RAG system with knowledge base and web search capabilities",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc",
+    lifespan=lifespan
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure this properly for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(search_router, prefix="/api", tags=["search"])
+app.include_router(feedback_router, prefix="/api", tags=["feedback"])
+
+@app.get("/")
+async def root():
+    """Root endpoint for health check."""
+    return {
+        "message": "Math Agentic RAG Backend API",
+        "status": "running",
+        "version": "1.0.0",
+        "docs": "/docs"
+    }
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint."""
+    return {
+        "status": "healthy",
+        "timestamp": structlog.processors.TimeStamper(fmt="iso")._stamper(),
+        "services": {
+            "api": "running",
+            "database": "connected",  # Will be updated with actual checks
+            "mcp": "available"        # Will be updated with actual checks
+        }
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,
+        log_level="info"
+    )

backend/models/__init__.py

@@ -0,0 +1 @@
+# Empty __init__.py file to make this a Python package

backend/models/schemas.py

@@ -0,0 +1,61 @@
+"""
+Pydantic models for API request/response schemas.
+"""
+from pydantic import BaseModel, Field
+from typing import List, Optional, Literal
+from datetime import datetime
+import uuid
+
+# Request Models
+class SearchRequest(BaseModel):
+    """Request model for search endpoint."""
+    question: str = Field(..., description="Math question to search for", max_length=200)
+
+class FeedbackRequest(BaseModel):
+    """Request model for feedback endpoint."""
+    question: str = Field(..., description="Original question")
+    response_id: str = Field(..., description="UUID of the response")
+    correctness_rating: int = Field(..., ge=1, le=5, description="Rating from 1-5")
+    comment: str = Field("", description="Optional feedback comment")
+
+# Response Models
+class SearchResult(BaseModel):
+    """Individual search result."""
+    problem: str = Field(..., description="Math problem statement")
+    solution: str = Field(..., description="Solution to the problem")
+    score: float = Field(..., description="Similarity score")
+
+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")
+    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")
+    response_time_ms: Optional[float] = Field(None, description="Response time in milliseconds")
+
+class FeedbackResponse(BaseModel):
+    """Response model for feedback endpoint."""
+    message: str = Field(..., description="Confirmation message")
+    feedback_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+
+# Internal Models
+class APILogEntry(BaseModel):
+    """Model for logging API requests and responses."""
+    request_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+    endpoint: str = Field(..., description="API endpoint called")
+    method: str = Field(..., description="HTTP method")
+    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")
+    feedback_received: bool = Field(default=False, description="Whether feedback was received")
+    status_code: int = Field(..., description="HTTP status code")
+
+class ErrorResponse(BaseModel):
+    """Standard error response model."""
+    error: str = Field(..., description="Error message")
+    detail: Optional[str] = Field(None, description="Detailed error information")
+    request_id: Optional[str] = Field(None, description="Request ID for tracking")

backend/requirements.txt

@@ -0,0 +1,41 @@
+# FastAPI and web server
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+
+# HTTP client for MCP calls
+httpx==0.25.2
+
+# Qdrant vector database
+qdrant-client==1.8.0
+
+# AI Guardrails
+guardrails-ai==0.4.5
+
+# Environment management
+python-dotenv==1.0.0
+
+# Structured logging
+structlog==23.2.0
+
+# Data processing and embeddings (reusing from database module)
+sentence-transformers==2.2.2
+datasets==2.18.0
+pandas==2.1.4
+
+# MCP client (for web search integration)
+fastmcp==0.3.0
+
+# Logging and monitoring
+structlog==23.2.0
+
+# Data validation
+pydantic==2.5.0
+
+# Async support
+asyncio==3.4.3
+
+# UUID generation (built-in, but listed for clarity)
+# uuid (built-in)
+
+# JSON handling
+orjson==3.9.10

backend/routes/__init__.py

@@ -0,0 +1 @@
+# Empty __init__.py file to make this a Python package

backend/routes/feedback.py

@@ -0,0 +1,91 @@
+"""
+Feedback endpoint for the Math Agentic RAG system.
+"""
+from fastapi import APIRouter, HTTPException, BackgroundTasks
+import structlog
+import time
+from typing import Dict, Any
+
+from models.schemas import FeedbackRequest, FeedbackResponse, ErrorResponse
+
+router = APIRouter()
+logger = structlog.get_logger()
+
+@router.post("/feedback", response_model=FeedbackResponse)
+async def submit_feedback(
+    feedback: FeedbackRequest,
+    background_tasks: BackgroundTasks
+) -> FeedbackResponse:
+    """
+    Submit user feedback for search results.
+    
+    Args:
+        feedback: Feedback data including response_id, rating, and comments
+        background_tasks: Background tasks for processing
+        
+    Returns:
+        FeedbackResponse confirming feedback receipt
+    """
+    start_time = time.time()
+    
+    try:
+        logger.info("Processing feedback submission",
+                   response_id=feedback.response_id,
+                   rating=feedback.rating,
+                   has_comments=bool(feedback.comments))
+        
+        # Process feedback in background
+        background_tasks.add_task(
+            process_feedback,
+            feedback.dict()
+        )
+        
+        response_time_ms = (time.time() - start_time) * 1000
+        
+        response = FeedbackResponse(
+            message="Feedback received successfully",
+            feedback_id=feedback.response_id,  # Using response_id as feedback_id for traceability
+            status="received"
+        )
+        
+        logger.info("Feedback submission completed",
+                   response_id=feedback.response_id,
+                   response_time_ms=response_time_ms)
+        
+        return response
+        
+    except Exception as e:
+        logger.error("Feedback submission failed",
+                    response_id=feedback.response_id,
+                    error=str(e))
+        
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to process feedback: {str(e)}"
+        )
+
+async def process_feedback(feedback_data: Dict[str, Any]):
+    """
+    Process feedback data in the background.
+    
+    This function will:
+    1. Store feedback in Qdrant for analysis
+    2. Update system metrics
+    3. Trigger retraining if needed (future enhancement)
+    """
+    try:
+        logger.info("Processing feedback in background",
+                   response_id=feedback_data.get("response_id"))
+        
+        # TODO: Implement feedback storage in Qdrant
+        # TODO: Update system performance metrics
+        # TODO: Implement feedback-based model improvements
+        
+        # For now, just log the feedback
+        logger.info("Feedback processed successfully",
+                   feedback_data=feedback_data)
+                   
+    except Exception as e:
+        logger.error("Background feedback processing failed",
+                    error=str(e),
+                    feedback_data=feedback_data)

backend/routes/search.py

@@ -0,0 +1,170 @@
+"""
+Search endpoint for the Math Agentic RAG system.
+"""
+from fastapi import APIRouter, HTTPException, BackgroundTasks
+import sys
+from pathlib import Path
+import structlog
+import time
+import uuid
+
+# Add parent directory to import database module
+parent_dir = Path(__file__).parent.parent.parent
+sys.path.append(str(parent_dir))
+
+from models.schemas import SearchRequest, SearchResponse, ErrorResponse, SearchResult
+from services.qdrant_service import QdrantService
+from services.mcp_service import MCPService
+from services.guardrails_service import GuardrailsService
+
+router = APIRouter()
+logger = structlog.get_logger()
+
+# Initialize services (will be properly initialized when packages are installed)
+qdrant_service = None
+mcp_service = None
+guardrails_service = None
+
+def initialize_services():
+    """Initialize services on first request."""
+    global qdrant_service, mcp_service, guardrails_service
+    
+    if qdrant_service is None:
+        qdrant_service = QdrantService()
+        mcp_service = MCPService()
+        guardrails_service = GuardrailsService()
+
+@router.post("/search", response_model=SearchResponse)
+async def search_math_problems(
+    request: SearchRequest,
+    background_tasks: BackgroundTasks
+) -> SearchResponse:
+    """
+    Search for math problems in knowledge base or web.
+    
+    Args:
+        request: Search request containing the math question
+        background_tasks: Background tasks for logging
+        
+    Returns:
+        SearchResponse with results and metadata
+    """
+    start_time = time.time()
+    response_id = str(uuid.uuid4())
+    
+    try:
+        # Initialize services if not already done
+        initialize_services()
+        
+        logger.info("Processing search request", 
+                   request_id=response_id, 
+                   question=request.question)
+        
+        # Step 1: Validate input with guardrails
+        validated_question = guardrails_service.validate_input(request.question)
+        
+        # Step 2: Search knowledge base (Qdrant)
+        kb_results = await qdrant_service.search_similar(validated_question)
+        
+        # Step 3: Determine if we need web search fallback
+        confidence_threshold = 0.5
+        best_score = kb_results[0].score if kb_results else 0.0
+        
+        if best_score >= confidence_threshold:
+            # Use knowledge base results
+            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}"
+            results = kb_results[:3]  # Return top 3 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)
+            
+            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"
+                
+                # Convert web results to SearchResult format
+                results = [SearchResult(
+                    problem=validated_question,
+                    solution=final_answer,
+                    score=0.8  # Default score for web results
+                )]
+                
+            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 []
+        
+        # Step 4: Validate output with guardrails
+        validated_response = guardrails_service.validate_output(final_answer)
+        
+        # Calculate response time
+        response_time_ms = (time.time() - start_time) * 1000
+        
+        # Create response
+        response = SearchResponse(
+            response_id=response_id,
+            final_answer=validated_response,
+            source=source,
+            explanation=explanation,
+            results=results,
+            metadata={
+                "confidence_score": best_score,
+                "threshold_used": confidence_threshold,
+                "kb_results_count": len(kb_results) if kb_results else 0
+            },
+            response_time_ms=response_time_ms
+        )
+        
+        # Log API call in background
+        background_tasks.add_task(
+            log_api_call,
+            request=request.dict(),
+            response=response.dict(),
+            response_time_ms=response_time_ms,
+            source=source
+        )
+        
+        logger.info("Search request completed successfully",
+                   request_id=response_id,
+                   source=source,
+                   response_time_ms=response_time_ms)
+        
+        return response
+        
+    except Exception as e:
+        logger.error("Search request failed", 
+                    request_id=response_id, 
+                    error=str(e))
+        
+        raise HTTPException(
+            status_code=500,
+            detail=f"Internal server error: {str(e)}"
+        )
+
+async def log_api_call(
+    request: dict,
+    response: dict,
+    response_time_ms: float,
+    source: str
+):
+    """Log API call to Qdrant for analytics."""
+    try:
+        if qdrant_service:
+            await qdrant_service.log_api_call(
+                endpoint="/search",
+                method="POST",
+                request_data=request,
+                response_data=response,
+                response_time_ms=response_time_ms,
+                source=source
+            )
+    except Exception as e:
+        logger.warning("Failed to log API call", error=str(e))

backend/services/__init__.py

@@ -0,0 +1 @@
+# Empty __init__.py file to make this a Python package

backend/services/guardrails_service.py

@@ -0,0 +1,155 @@
+"""
+Guardrails service for input/output validation and safety.
+"""
+import re
+import structlog
+from typing import Dict, List, Any, Optional
+
+logger = structlog.get_logger()
+
+class GuardrailsService:
+    """Service for input/output validation using guardrails-ai."""
+    
+    def __init__(self):
+        """Initialize Guardrails service."""
+        self.initialized = False
+        self._setup_validation_rules()
+        logger.info("Guardrails service initialized")
+    
+    def _setup_validation_rules(self):
+        """Setup validation rules for math content."""
+        # TODO: Implement actual guardrails-ai integration
+        # For now, implement basic validation rules
+        
+        # Prohibited content patterns
+        self.prohibited_patterns = [
+            r'(?i)\b(hack|exploit|malicious|virus|attack)\b',
+            r'(?i)\b(personal|private|confidential|secret)\b',
+            r'(?i)\b(password|credit|social.*security)\b'
+        ]
+        
+        # Math-related positive patterns
+        self.math_patterns = [
+            r'\b\d+\b',  # Numbers
+            r'[+\-*/=()]',  # Math operators
+            r'(?i)\b(solve|equation|function|derivative|integral|limit|sum|product)\b',
+            r'(?i)\b(algebra|geometry|calculus|trigonometry|statistics|probability)\b',
+            r'(?i)\b(theorem|proof|formula|solution|answer)\b'
+        ]
+        
+        self.initialized = True
+    
+    def validate_input(self, question: str) -> str:
+        """
+        Validate and sanitize input question.
+        
+        Args:
+            question: Input question to validate
+            
+        Returns:
+            Validated and sanitized question
+            
+        Raises:
+            ValueError: If input is invalid or unsafe
+        """
+        try:
+            if not question or not question.strip():
+                raise ValueError("Question cannot be empty")
+            
+            # Check length limits
+            if len(question) > 2000:
+                raise ValueError("Question too long (max 2000 characters)")
+            
+            if len(question) < 5:
+                raise ValueError("Question too short (min 5 characters)")
+            
+            # Check for prohibited content
+            for pattern in self.prohibited_patterns:
+                if re.search(pattern, question):
+                    logger.warning("Prohibited content detected in input",
+                                 pattern=pattern)
+                    raise ValueError("Input contains prohibited content")
+            
+            # Basic sanitization
+            sanitized = question.strip()
+            
+            # Remove potential script injections
+            sanitized = re.sub(r'<script.*?</script>', '', sanitized, flags=re.IGNORECASE | re.DOTALL)
+            sanitized = re.sub(r'javascript:', '', sanitized, flags=re.IGNORECASE)
+            
+            # Check if it looks like a math question
+            has_math_content = any(re.search(pattern, sanitized) for pattern in self.math_patterns)
+            
+            if not has_math_content:
+                logger.info("Non-math content detected, proceeding with caution")
+            
+            logger.info("Input validation successful",
+                       original_length=len(question),
+                       sanitized_length=len(sanitized),
+                       has_math_content=has_math_content)
+            
+            return sanitized
+            
+        except ValueError:
+            raise
+        except Exception as e:
+            logger.error("Input validation failed", error=str(e))
+            raise ValueError(f"Input validation error: {str(e)}")
+    
+    def validate_output(self, response: str) -> str:
+        """
+        Validate and sanitize output response.
+        
+        Args:
+            response: Output response to validate
+            
+        Returns:
+            Validated and sanitized response
+            
+        Raises:
+            ValueError: If output is invalid or unsafe
+        """
+        try:
+            if not response or not response.strip():
+                return "No response generated"
+            
+            # Check length limits
+            if len(response) > 10000:
+                logger.warning("Response too long, truncating")
+                response = response[:10000] + "... [truncated]"
+            
+            # Basic sanitization
+            sanitized = response.strip()
+            
+            # Remove potential harmful content
+            sanitized = re.sub(r'<script.*?</script>', '', sanitized, flags=re.IGNORECASE | re.DOTALL)
+            sanitized = re.sub(r'javascript:', '', sanitized, flags=re.IGNORECASE)
+            
+            # Check for prohibited content in output
+            for pattern in self.prohibited_patterns:
+                if re.search(pattern, sanitized):
+                    logger.warning("Prohibited content detected in output",
+                                 pattern=pattern)
+                    sanitized = re.sub(pattern, '[FILTERED]', sanitized, flags=re.IGNORECASE)
+            
+            logger.info("Output validation successful",
+                       original_length=len(response),
+                       sanitized_length=len(sanitized))
+            
+            return sanitized
+            
+        except Exception as e:
+            logger.error("Output validation failed", error=str(e))
+            return "Response validation failed - please try again"
+    
+    def is_math_related(self, text: str) -> bool:
+        """
+        Check if text is math-related.
+        
+        Args:
+            text: Text to analyze
+            
+        Returns:
+            True if text appears to be math-related
+        """
+        return any(re.search(pattern, text) for pattern in self.math_patterns)

backend/services/mcp_service.py

@@ -0,0 +1,85 @@
+"""
+MCP (Model Context Protocol) service for web search fallback.
+"""
+import asyncio
+import structlog
+from typing import Dict, Any, Optional
+import json
+
+logger = structlog.get_logger()
+
+class MCPService:
+    """Service for MCP web search integration."""
+    
+    def __init__(self):
+        """Initialize MCP service."""
+        self.mcp_server_path = "pranavms13/web-search-mcp"
+        self.initialized = False
+        logger.info("MCP service initialized")
+    
+    async def search_web(self, question: str) -> Dict[str, Any]:
+        """
+        Search the web for math-related information using MCP.
+        
+        Args:
+            question: The math question to search for
+            
+        Returns:
+            Dictionary containing web search results
+        """
+        try:
+            logger.info("Starting web search via MCP", question_length=len(question))
+            
+            # TODO: Implement actual MCP integration
+            # For now, return a placeholder response
+            
+            # Simulate web search delay
+            await asyncio.sleep(0.5)
+            
+            # Mock response based on question type
+            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."
+            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."
+            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."
+            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."
+            
+            result = {
+                "answer": answer,
+                "source": "web_search",
+                "confidence": 0.7,
+                "search_query": question,
+                "results_count": 1
+            }
+            
+            logger.info("Web search completed via MCP",
+                       answer_length=len(answer),
+                       confidence=result["confidence"])
+            
+            return result
+            
+        except Exception as e:
+            logger.error("Web search via MCP failed", error=str(e))
+            raise Exception(f"MCP web search failed: {str(e)}")
+    
+    async def initialize_mcp_connection(self):
+        """Initialize connection to MCP server."""
+        try:
+            # TODO: Implement actual MCP server connection
+            # This would involve:
+            # 1. Spawning the MCP server process
+            # 2. Establishing JSON-RPC communication
+            # 3. Calling available tools like web_search
+            
+            self.initialized = True
+            logger.info("MCP connection initialized successfully")
+            
+        except Exception as e:
+            logger.error("Failed to initialize MCP connection", error=str(e))
+            raise
+    
+    def is_available(self) -> bool:
+        """Check if MCP service is available."""
+        return self.initialized

backend/services/qdrant_service.py

@@ -0,0 +1,147 @@
+"""
+Qdrant service for vector database operations.
+"""
+import sys
+from pathlib import Path
+import structlog
+from typing import List, Dict, Any, Optional
+
+# Add parent directory to import database module
+parent_dir = Path(__file__).parent.parent.parent
+sys.path.append(str(parent_dir))
+
+try:
+    from database.qdrant_manager import QdrantManager
+    from database.utils import EmbeddingGenerator
+    from models.schemas import SearchResult, APILogEntry
+except ImportError as e:
+    # Services will be initialized when packages are available
+    pass
+
+logger = structlog.get_logger()
+
+class QdrantService:
+    """Service layer for Qdrant vector database operations."""
+    
+    def __init__(self):
+        """Initialize Qdrant service."""
+        self.qdrant_manager = None
+        self.embedding_generator = None
+        self._initialize()
+    
+    def _initialize(self):
+        """Initialize Qdrant manager and embedding generator."""
+        try:
+            # Qdrant configuration (matching database/ingest.py)
+            qdrant_config = {
+                'url': 'https://7c49e9a8-f84b-4cc8-9e14-bbffdc2e68ad.us-east4-0.gcp.cloud.qdrant.io:6333',
+                'api_key': 'aFrfsC3xnXVgMEjClC3VNgY2Hgp0f6A5Zd30UM5yQJx4SkEPgn4xSw',
+                'collection_name': 'math_problems'
+            }
+            
+            self.qdrant_manager = QdrantManager(
+                url=qdrant_config['url'],
+                api_key=qdrant_config['api_key']
+            )
+            
+            self.embedding_generator = EmbeddingGenerator()
+            
+            logger.info("Qdrant service initialized successfully")
+            
+        except Exception as e:
+            logger.error("Failed to initialize Qdrant service", error=str(e))
+            # Service will work in degraded mode
+    
+    async def search_similar(self, question: str, limit: int = 5) -> List[SearchResult]:
+        """
+        Search for similar math problems in the knowledge base.
+        
+        Args:
+            question: The math question to search for
+            limit: Maximum number of results to return
+            
+        Returns:
+            List of SearchResult objects
+        """
+        if not self.qdrant_manager or not self.embedding_generator:
+            logger.warning("Qdrant service not properly initialized")
+            return []
+        
+        try:
+            # Generate embedding for the question
+            query_embedding = self.embedding_generator.embed_text(question)
+            
+            # Search in Qdrant
+            results = self.qdrant_manager.search_similar(
+                collection_name='math_problems',
+                query_vector=query_embedding,
+                limit=limit
+            )
+            
+            # Convert to SearchResult objects
+            search_results = []
+            for result in results:
+                payload = result.payload
+                search_result = SearchResult(
+                    problem=payload.get('problem', ''),
+                    solution=payload.get('solution', ''),
+                    score=result.score
+                )
+                search_results.append(search_result)
+            
+            logger.info("Knowledge base search completed",
+                       question_length=len(question),
+                       results_count=len(search_results),
+                       best_score=search_results[0].score if search_results else 0)
+            
+            return search_results
+            
+        except Exception as e:
+            logger.error("Knowledge base search failed", error=str(e))
+            return []
+    
+    async def log_api_call(
+        self,
+        endpoint: str,
+        method: str,
+        request_data: Dict[str, Any],
+        response_data: Dict[str, Any],
+        response_time_ms: float,
+        source: str
+    ):
+        """
+        Log API call to Qdrant for analytics.
+        
+        Args:
+            endpoint: API endpoint called
+            method: HTTP method
+            request_data: Request payload
+            response_data: Response payload
+            response_time_ms: Response time in milliseconds
+            source: Source of the response (KB/MCP)
+        """
+        if not self.qdrant_manager or not self.embedding_generator:
+            logger.warning("Cannot log API call - Qdrant service not initialized")
+            return
+        
+        try:
+            # Create log entry
+            log_entry = APILogEntry(
+                endpoint=endpoint,
+                method=method,
+                request_data=request_data,
+                response_data=response_data,
+                response_time_ms=response_time_ms,
+                source=source
+            )
+            
+            # TODO: Store log entry in Qdrant analytics collection
+            # For now, just log to stdout
+            logger.info("API call logged",
+                       endpoint=endpoint,
+                       method=method,
+                       response_time_ms=response_time_ms,
+                       source=source)
+            
+        except Exception as e:
+            logger.warning("Failed to log API call", error=str(e))