Routes refactoring

multi_llm_chatbot_backend/app/api/routes/__init__.py

@@ -0,0 +1,15 @@
+from fastapi import APIRouter
+from .chat import router as chat_router
+from .documents import router as document_router
+from .sessions import router as session_router
+from .provider import router as provider_router
+from .debug import router as debug_router
+from .root import router as root_router
+
+router = APIRouter()
+router.include_router(chat_router)
+router.include_router(document_router)
+router.include_router(session_router)
+router.include_router(provider_router)
+router.include_router(debug_router)
+router.include_router(root_router)

multi_llm_chatbot_backend/app/api/routes/chat.py

@@ -0,0 +1,289 @@
+from fastapi import APIRouter, Request, HTTPException, Body
+from app.models.persona import Persona
+from app.core.session_manager import get_session_manager
+from app.api.utils import get_or_create_session_for_request
+from app.core.bootstrap import chat_orchestrator
+from pydantic import BaseModel
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+session_manager = get_session_manager()
+
+# Keep all the same data models as before
+class UserInput(BaseModel):
+    user_input: str
+
+class ChatMessage(BaseModel):
+    user_input: str
+    session_id: str = None
+    response_length: str = "medium"
+
+class ReplyToAdvisor(BaseModel):
+    user_input: str
+    advisor_id: str
+    original_message_id: str = None
+
+class PersonaQuery(BaseModel):
+    question: str
+    persona: str
+
+
+@router.post("/chat-sequential")
+async def chat_sequential_enhanced(message: ChatMessage, request: Request):
+    """
+    Enhanced sequential chat with intelligent persona ordering.
+    Returns responses in the order determined by LLM-based relevance ranking.
+    """
+    try:
+        # Get or create session
+        session_id = get_or_create_session_for_request(request, message.session_id)
+        
+        # Add user message to session first (needed for persona ranking)
+        session = session_manager.get_session(session_id)
+        session.append_message("user", message.user_input)
+        
+        # Get intelligently ordered personas based on context
+        top_personas = await chat_orchestrator.get_top_personas(
+            session_id=session_id, 
+            k=3  # Get top 3 most relevant personas
+        )
+        
+        logger.info(f"Intelligent persona order for session {session_id}: {top_personas}")
+        
+        # Generate responses from personas in the intelligent order
+        responses = []
+        
+        for persona_id in top_personas:
+            try:
+                # Generate response from this persona
+                persona_result = await chat_orchestrator.chat_with_persona(
+                    user_input=message.user_input,
+                    persona_id=persona_id,
+                    session_id=session_id,
+                    response_length=message.response_length or "medium"
+                )
+                
+                
+                if "persona_name" in persona_result and "response" in persona_result:
+                    responses.append({
+                        "persona": persona_result["persona_name"],
+                        "persona_id": persona_result["persona_id"],
+                        "response": persona_result["response"]
+                    })
+                elif persona_result.get("type") == "single_persona_response" and "persona" in persona_result:
+                    persona_data = persona_result["persona"]
+                    responses.append({
+                        "persona": persona_data["persona_name"],
+                        "persona_id": persona_data["persona_id"],
+                        "response": persona_data["response"]
+                    })
+                else:
+                    # Fallback response
+                    responses.append({
+                        "persona": chat_orchestrator.personas[persona_id].name,
+                        "persona_id": persona_id,
+                        "response": "I'm having trouble processing your question right now. Please try again."
+                    })
+                    
+            except Exception as e:
+                logger.error(f"Error generating response for persona {persona_id}: {str(e)}")
+                # Error fallback
+                responses.append({
+                    "persona": chat_orchestrator.personas[persona_id].name,
+                    "persona_id": persona_id,
+                    "response": "I encountered an error while processing your question. Please try again."
+                })
+        
+        #  response format
+        return {
+            "type": "sequential_responses",
+            "responses": responses
+        }
+
+    except Exception as e:
+        logger.error(f"Error in enhanced sequential chat: {str(e)}")
+        return {
+            "type": "error", 
+            "responses": [{
+                "persona": "System",
+                "response": "I'm having trouble processing your request. Could you please try again?"
+            }]
+        }
+    
+@router.post("/chat/{persona_id}")
+async def chat_with_specific_advisor(persona_id: str, input: UserInput, request: Request):
+    """Chat with a specific advisor - SAME INTERFACE"""
+    try:
+        if persona_id not in chat_orchestrator.personas:
+            raise HTTPException(status_code=404, detail=f"Persona '{persona_id}' not found")
+
+        # Get session using compatibility layer
+        session_id = get_or_create_session_for_request(request)
+        
+        # Use new orchestrator
+        result = await chat_orchestrator.chat_with_persona(
+            user_input=input.user_input,
+            persona_id=persona_id,
+            session_id=session_id
+        )
+        
+        # FIX: Handle the actual response structure from orchestrator
+        if result.get("type") == "single_persona_response" and "persona" in result:
+            # New expected structure
+            persona_data = result["persona"]
+            return {
+                "persona": persona_data["persona_name"],
+                "persona_id": persona_data["persona_id"],
+                "response": persona_data["response"]
+            }
+        elif "persona_id" in result and "response" in result:
+            # Current actual structure from orchestrator
+            return {
+                "persona": result["persona_name"],
+                "persona_id": result["persona_id"],
+                "response": result["response"]
+            }
+        elif result.get("type") == "error" or "error" in result:
+            # Error handling
+            return {
+                "persona": "System",
+                "response": result.get("error", "I'm having trouble generating a response right now. Please try again.")
+            }
+        else:
+            # Fallback
+            return {
+                "persona": "System",
+                "response": "I'm having trouble generating a response right now. Please try again."
+            }
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error in chat_with_specific_advisor: {e}")
+        return {
+            "persona": "System",
+            "response": "I'm having trouble generating a response right now. Please try again."
+        }
+
+# Reply to advisor endpoint (SAME INTERFACE)
+@router.post("/reply-to-advisor")
+async def reply_to_advisor(reply: ReplyToAdvisor, request: Request):
+    """Reply to a specific advisor - SAME INTERFACE"""
+    try:
+        if reply.advisor_id not in chat_orchestrator.personas:
+            raise HTTPException(status_code=404, detail=f"Advisor '{reply.advisor_id}' not found")
+
+        # Get session using compatibility layer
+        session_id = get_or_create_session_for_request(request)
+        
+        # Use new orchestrator
+        result = await chat_orchestrator.chat_with_persona(
+            user_input=reply.user_input,
+            persona_id=reply.advisor_id,
+            session_id=session_id
+        )
+        
+        if result["type"] == "single_persona_response":
+            persona_data = result["persona"]
+            return {
+                "type": "advisor_reply",
+                "persona": persona_data["persona_name"],
+                "persona_id": persona_data["persona_id"],
+                "response": persona_data["response"],
+                "original_message_id": reply.original_message_id
+            }
+        else:
+            return {
+                "type": "error",
+                "persona": "System",
+                "response": result.get("message", "I'm having trouble generating a reply right now. Please try again.")
+            }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error in reply_to_advisor: {e}")
+        return {
+            "type": "error",
+            "persona": "System",
+            "response": "I'm having trouble generating a reply right now. Please try again."
+        }
+    
+@router.post("/chat/{persona_id}")
+async def chat_with_specific_persona(persona_id: str, message: ChatMessage, request: Request):
+    """
+    Chat with a specific persona - Enhanced with RAG debugging
+    
+    This endpoint helps debug RAG integration by testing individual personas
+    """
+    try:
+        session_id = get_or_create_session_for_request(request, message.session_id)
+        
+        # Validate persona exists
+        if persona_id not in chat_orchestrator.personas:
+            available_personas = list(chat_orchestrator.personas.keys())
+            raise HTTPException(
+                status_code=400, 
+                detail=f"Persona '{persona_id}' not found. Available: {available_personas}"
+            )
+        
+        # Use the enhanced orchestrator method
+        result = await chat_orchestrator.chat_with_persona(
+            user_input=message.user_input,
+            persona_id=persona_id,
+            session_id=session_id,
+            response_length=message.response_length or "medium"
+        )
+        
+        # Fix: Handle the response structure properly
+        if result.get("type") == "single_persona_response" and "persona" in result:
+            persona_data = result["persona"]
+            
+            # Add debugging information
+            result["debug_info"] = {
+                "persona_id": persona_id,
+                "session_id": session_id,
+                "query_length": len(message.user_input),
+                "rag_manager_available": True,
+                "used_documents": persona_data.get("used_documents", False),
+                "chunks_used": persona_data.get("document_chunks_used", 0)
+            }
+        
+        return result
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error in individual persona chat: {str(e)}")
+        return {
+            "type": "error",
+            "message": f"Error chatting with {persona_id}: {str(e)}",
+            "persona_id": persona_id
+        }
+    
+@router.post("/ask/")
+async def ask_question(query: PersonaQuery, request: Request):
+    """Ask question - SAME INTERFACE"""
+    try:
+        session_id = get_or_create_session_for_request(request)
+        
+        # Use the new orchestrator
+        result = await chat_orchestrator.chat_with_persona(
+            user_input=query.question,
+            persona_id=query.persona,
+            session_id=session_id
+        )
+        
+        if result["type"] == "single_persona_response":
+            response_text = result["persona"]["response"]
+        else:
+            response_text = result.get("message", "I'm having trouble responding right now.")
+        
+        return {"response": response_text}
+        
+    except Exception as e:
+        logger.error(f"Error in ask endpoint: {str(e)}")
+        return {"response": "I encountered an error. Please try again."}

multi_llm_chatbot_backend/app/api/routes/debug.py

@@ -0,0 +1,101 @@
+from fastapi import APIRouter, Request, Query
+from app.core.session_manager import get_session_manager
+from app.core.rag_manager import get_rag_manager
+from app.api.utils import get_or_create_session_for_request
+from app.core.bootstrap import chat_orchestrator
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+session_manager = get_session_manager()
+
+@router.get("/debug/personas")
+async def debug_personas(request: Request):
+    try:
+        session_id = get_or_create_session_for_request(request)
+        session = session_manager.get_session(session_id)
+        rag_manager = get_rag_manager()
+        rag_stats = rag_manager.get_document_stats(session_id)
+
+        return {
+            "personas": {
+                pid: {
+                    "name": persona.name,
+                    "prompt": persona.system_prompt[:100] + "...",
+                    "retrieval_keywords": chat_orchestrator._get_persona_context_keywords(pid)
+                } for pid, persona in chat_orchestrator.personas.items()
+            },
+            "session_info": {
+                "context_length": len(session.messages),
+                "uploaded_files": session.uploaded_files,
+                "rag_stats": rag_stats
+            }
+        }
+    except Exception as e:
+        logger.error(f"Error in debug endpoint: {str(e)}")
+        return {
+            "personas": {},
+            "session_info": {"context_length": 0},
+            "error": str(e)
+        }
+
+@router.get("/debug/ranked-personas")
+async def get_ranked_personas(request: Request, k: int = Query(3, ge=1, le=10)):
+    try:
+        session_id = get_or_create_session_for_request(request)
+        top_personas = await chat_orchestrator.get_top_personas(session_id=session_id, k=k)
+        return {
+            "ranked_personas": top_personas,
+            "available_personas": list(chat_orchestrator.personas.keys()),
+            "session_id": session_id
+        }
+    except Exception as e:
+        logger.error(f"Error in /debug/ranked-personas: {e}")
+        return {
+            "ranked_personas": [],
+            "error": str(e)
+        }
+
+@router.get("/debug/rag-status")
+async def debug_rag_status(request: Request):
+    try:
+        session_id = get_or_create_session_for_request(request)
+        rag_manager = get_rag_manager()
+        session_stats = session_manager.get_session_stats(session_id)
+
+        test_search = rag_manager.search_documents(
+            query="test methodology research",
+            session_id=session_id,
+            persona_context="",
+            n_results=3
+        )
+
+        return {
+            "rag_manager_healthy": True,
+            "session_id": session_id,
+            "session_stats": session_stats.get("rag_stats", {}),
+            "test_search_results": len(test_search),
+            "test_search_details": [
+                {
+                    "relevance": chunk.get("relevance_score", 0),
+                    "distance": chunk.get("distance", "unknown"),
+                    "text_length": len(chunk.get("text", "")),
+                    "filename": chunk.get("metadata", {}).get("filename", "unknown")
+                }
+                for chunk in test_search[:3]
+            ],
+            "persona_keywords": {
+                pid: chat_orchestrator._get_persona_context_keywords(pid)
+                for pid in chat_orchestrator.personas.keys()
+            }
+        }
+
+    except Exception as e:
+        logger.error(f"Error in RAG debug: {str(e)}")
+        return {
+            "rag_manager_healthy": False,
+            "error": str(e),
+            "session_id": session_id if 'session_id' in locals() else "unknown"
+        }

multi_llm_chatbot_backend/app/api/routes/documents.py

@@ -0,0 +1,236 @@
+from fastapi import APIRouter, Request, HTTPException, UploadFile, File, Body
+from fastapi import Query
+from app.utils.document_extractor import extract_text_from_file
+from app.core.session_manager import get_session_manager
+from app.core.rag_manager import get_rag_manager
+from app.api.utils import get_or_create_session_for_request
+from fastapi.responses import StreamingResponse
+from app.utils.chat_summary import generate_summary_from_messages, parse_summary_to_blocks
+from app.utils.file_export import prepare_export_response
+from app.core.session_manager import get_session_manager
+from app.api.utils import get_or_create_session_for_request
+from app.core.bootstrap import chat_orchestrator
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+session_manager = get_session_manager()
+get_rag_manager = get_rag_manager  # avoid circular import issues
+
+
+@router.post("/upload-document")
+async def upload_document(file: UploadFile = File(...), request: Request = None):
+    try:
+        session_id = get_or_create_session_for_request(request)
+        session = session_manager.get_session(session_id)
+
+        MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
+        if file.size and file.size > MAX_FILE_SIZE:
+            raise HTTPException(status_code=413, detail="File size exceeds 10MB limit")
+
+        file_bytes = await file.read()
+        content = extract_text_from_file(file_bytes, file.content_type)
+        if not content.strip():
+            raise HTTPException(status_code=400, detail="Document is empty or unreadable.")
+
+        rag_manager = get_rag_manager()
+        file_type_map = {
+            "application/pdf": "pdf",
+            "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx", 
+            "text/plain": "txt"
+        }
+        file_type = file_type_map.get(file.content_type, "unknown")
+
+        rag_result = rag_manager.add_document(
+            content=content,
+            filename=file.filename,
+            session_id=session_id,
+            file_type=file_type
+        )
+
+        if not rag_result["success"]:
+            raise HTTPException(status_code=500, detail=f"Failed to process document: {rag_result.get('error', 'Unknown error')}")
+
+        session.uploaded_files.append(file.filename)
+        session.total_upload_size += len(file_bytes)
+
+        doc_metadata = rag_result.get("document_metadata", {})
+        doc_title = doc_metadata.get("title", file.filename)
+
+        session.append_message(
+            "system", 
+            f"Document uploaded: '{doc_title}' ({file.filename}) - {rag_result['chunks_created']} sections processed, ~{rag_result['total_tokens']} tokens analyzed. You can now ask questions about this document by referencing it by name."
+        )
+
+        return {
+            "message": f"Document '{file.filename}' uploaded and processed successfully.",
+            "filename": file.filename,
+            "document_title": doc_title,
+            "chunks_created": rag_result['chunks_created'],
+            "total_tokens": rag_result['total_tokens'],
+            "file_type": file_type,
+            "can_reference_by_name": True
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error processing document upload: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error processing document: {str(e)}")
+
+
+@router.post("/search-documents")
+async def search_documents(request: Request, query: str = Body(..., embed=True), persona: str = Body("", embed=True)):
+    try:
+        session_id = get_or_create_session_for_request(request)
+        rag_manager = get_rag_manager()
+
+        persona_contexts = {
+            "methodologist": "methodology research design analysis",
+            "theorist": "theory theoretical framework conceptual",
+            "pragmatist": "practical application implementation"
+        }
+        persona_context = persona_contexts.get(persona, "")
+
+        results = rag_manager.search_documents(
+            query=query,
+            session_id=session_id,
+            persona_context=persona_context,
+            n_results=5
+        )
+
+        return {
+            "query": query,
+            "persona_filter": persona,
+            "results_count": len(results),
+            "results": results
+        }
+
+    except Exception as e:
+        logger.error(f"Error searching documents: {str(e)}")
+        return {"query": query, "results_count": 0, "results": [], "error": str(e)}
+
+
+@router.get("/document-stats")
+async def get_document_stats(request: Request):
+    try:
+        session_id = get_or_create_session_for_request(request)
+        rag_manager = get_rag_manager()
+        return rag_manager.get_document_stats(session_id)
+    except Exception as e:
+        logger.error(f"Error getting document stats: {str(e)}")
+        return {"total_chunks": 0, "total_documents": 0, "documents": []}
+
+
+@router.get("/uploaded-files")
+async def get_uploaded_filenames(request: Request):
+    try:
+        session_id = get_or_create_session_for_request(request)
+        session = session_manager.get_session(session_id)
+        return {"files": session.uploaded_files}
+    except Exception as e:
+        logger.error(f"Error getting uploaded files: {str(e)}")
+        return {"files": []}
+
+
+@router.get("/document-insights/{filename}")
+async def get_document_insights(filename: str, request: Request):
+    try:
+        session_id = get_or_create_session_for_request(request)
+        rag_manager = get_rag_manager()
+        stats = rag_manager.get_document_stats(session_id)
+        document_info = next((doc for doc in stats.get("documents", []) if doc["filename"] == filename), None)
+
+        if not document_info:
+            raise HTTPException(status_code=404, detail=f"Document {filename} not found")
+
+        results = rag_manager.collection.get(
+            where={"session_id": session_id, "filename": filename},
+            limit=3,
+            include=["documents", "metadatas"]
+        )
+
+        sample_sections = []
+        if results["documents"]:
+            for doc, metadata in zip(results["documents"], results["metadatas"]):
+                sample_sections.append({
+                    "section": metadata.get("document_section", "unknown"),
+                    "content_preview": doc[:200] + "..." if len(doc) > 200 else doc,
+                    "keywords": metadata.get("keywords", "")
+                })
+
+        return {
+            "filename": filename,
+            "document_title": document_info.get("title", filename),
+            "file_type": document_info.get("file_type", "unknown"),
+            "statistics": {
+                "total_chunks": document_info["chunks"],
+                "estimated_tokens": document_info["estimated_tokens"],
+                "sections_identified": document_info["sections"]
+            },
+            "content_analysis": {
+                "has_methodology": document_info.get("has_methodology", False),
+                "has_theory": document_info.get("has_theory", False),
+                "has_references": document_info.get("has_references", False)
+            },
+            "sample_sections": sample_sections
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting document insights: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error analyzing document: {str(e)}")
+    
+@router.get("/export-chat")
+async def export_chat(request: Request, format: str = Query(..., regex="^(txt|pdf|docx)$")):
+    try:
+        session_id = get_or_create_session_for_request(request)
+        session = session_manager.get_session(session_id)
+
+        if not session.messages:
+            return {"error": "No messages in this session."}
+
+        return prepare_export_response(session.messages, format)
+
+    except Exception as e:
+        logger.error(f"Error exporting chat: {str(e)}")
+        return {"error": "Failed to export chat.", "detail": str(e)}
+
+@router.get("/chat-summary")
+async def chat_summary(request: Request, format: str = Query("text", regex="^(txt|pdf|docx)$")):
+    try:
+        session_id = get_or_create_session_for_request(request)
+        session = session_manager.get_session(session_id)
+
+        if not session.messages:
+            return {"error": "No messages in this session."}
+
+        llm = next(iter(session_manager.get_session(session_id).messages), {}).get("llm")
+        if not llm:
+            llm = next(iter(session_manager.sessions.values())).messages[0].get("llm")
+
+        llm = next(iter(chat_orchestrator.personas.values())).llm
+        summary_text = await generate_summary_from_messages(session.messages, llm)
+
+        if format == "txt":
+            return prepare_export_response(summary_text, "txt", filename_prefix="chat_summary")
+
+        elif format == "docx":
+            return prepare_export_response(summary_text, "docx", filename_prefix="chat_summary")
+
+        elif format == "pdf":
+            blocks = [{"type": "heading", "text": "Chat Summary"}] + parse_summary_to_blocks(summary_text)
+            file_stream = prepare_export_response(summary_text, "pdf", filename_prefix="chat_summary").body_iterator
+            return StreamingResponse(
+                file_stream,
+                media_type="application/pdf",
+                headers={"Content-Disposition": "attachment; filename=chat_summary.pdf"}
+            )
+
+    except Exception as e:
+        logger.error(f"Error in chat-summary endpoint: {str(e)}")
+        return {"error": "Summary generation failed", "detail": str(e)}
+

multi_llm_chatbot_backend/app/api/routes/provider.py

@@ -0,0 +1,92 @@
+from fastapi import APIRouter, Body, HTTPException
+from app.llm.improved_gemini_client import ImprovedGeminiClient
+from app.llm.improved_ollama_client import ImprovedOllamaClient
+from app.models.default_personas import get_default_personas
+from app.core.bootstrap import chat_orchestrator, llm, current_provider, available_providers
+from pydantic import BaseModel
+import os
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+def create_llm_client(provider: str = None):
+    global current_provider
+    if provider is None:
+        provider = current_provider
+
+    if provider == "gemini":
+        try:
+            return ImprovedGeminiClient(model_name=os.getenv("GEMINI_MODEL"))
+        except ValueError as e:
+            logger.warning(f"Gemini API key not found, falling back to Ollama: {e}")
+            return ImprovedOllamaClient(model_name="llama3.2:1b")
+    elif provider == "ollama":
+        return ImprovedOllamaClient(model_name="llama3.2:1b")
+    else:
+        raise ValueError(f"Unknown provider: {provider}")
+
+# Initialize LLM and personas
+llm = create_llm_client(current_provider)
+DEFAULT_PERSONAS = get_default_personas(llm)
+for persona in DEFAULT_PERSONAS:
+    chat_orchestrator.register_persona(persona)
+
+class ProviderSwitch(BaseModel):
+    provider: str
+
+@router.get("/current-provider")
+async def get_current_provider():
+    return {
+        "current_provider": current_provider,
+        "available_providers": available_providers,
+        "model_info": {
+            "name": llm.model_name if hasattr(llm, 'model_name') else "gemini-2.0-flash",
+            "provider": current_provider
+        }
+    }
+
+@router.post("/switch-provider")
+async def switch_provider(provider_data: ProviderSwitch):
+    global current_provider, llm
+
+    if provider_data.provider not in available_providers:
+        raise HTTPException(status_code=400, detail=f"Unknown provider: {provider_data.provider}. Available: {available_providers}")
+
+    try:
+        current_provider = provider_data.provider
+        new_llm = create_llm_client(current_provider)
+        llm = new_llm
+
+        new_personas = get_default_personas(new_llm)
+        chat_orchestrator.personas.clear()
+        for persona in new_personas:
+            chat_orchestrator.register_persona(persona)
+
+        return {
+            "message": f"Successfully switched to {current_provider}",
+            "current_provider": current_provider,
+            "model_info": {
+                "name": new_llm.model_name if hasattr(new_llm, 'model_name') else "gemini-2.0-flash",
+                "provider": current_provider
+            }
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to switch to {provider_data.provider}: {str(e)}")
+
+@router.post("/switch-model")
+async def switch_model(model_name: str = Body(...)):
+    if "gemini" in model_name.lower():
+        return await switch_provider(ProviderSwitch(provider="gemini"))
+    else:
+        return await switch_provider(ProviderSwitch(provider="ollama"))
+
+@router.get("/current-model")
+async def get_current_model():
+    model_name = llm.model_name if hasattr(llm, 'model_name') else "gemini-2.0-flash"
+    return {
+        "model": model_name,
+        "provider": current_provider
+    }

multi_llm_chatbot_backend/app/api/routes/root.py

@@ -0,0 +1,22 @@
+from fastapi import APIRouter
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+@router.get("/")
+def root():
+    return {
+        "message": "Multi-LLM PhD Advisor Backend is up and running",
+        "version": "1.0.0",
+        "features": [
+            "Improved Session Management",
+            "Unified Context Handling",
+            "Ollama Support",
+            "Gemini API Support",
+            "Provider Switching"
+        ]
+    }
+

multi_llm_chatbot_backend/app/api/routes/sessions.py

@@ -0,0 +1,54 @@
+from fastapi import APIRouter, Request, HTTPException
+from app.core.session_manager import get_session_manager
+from app.api.utils import get_or_create_session_for_request
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+session_manager = get_session_manager()
+
+@router.get("/context")
+async def get_context(request: Request):
+    try:
+        session_id = get_or_create_session_for_request(request)
+        session = session_manager.get_session(session_id)
+        rag_stats = session.get_rag_stats()
+        return {
+            "messages": session.messages,
+            "rag_info": {
+                "total_documents": rag_stats.get("total_documents", 0),
+                "total_chunks": rag_stats.get("total_chunks", 0),
+                "documents": rag_stats.get("documents", [])
+            }
+        }
+    except Exception as e:
+        logger.error(f"Error getting context: {str(e)}")
+        return {"messages": [], "rag_info": {"total_documents": 0, "total_chunks": 0}}
+
+
+@router.post("/reset-session")
+async def reset_session(request: Request):
+    try:
+        session_id = get_or_create_session_for_request(request)
+        success = session_manager.reset_session_completely(session_id)
+
+        if success:
+            return {"status": "reset", "message": "Session and all documents reset successfully"}
+        else:
+            return {"status": "error", "message": "Failed to reset session"}
+    except Exception as e:
+        logger.error(f"Error resetting session: {e}")
+        return {"status": "error", "message": "Failed to reset session"}
+
+
+@router.get("/session-stats")
+async def get_session_stats(request: Request):
+    try:
+        session_id = get_or_create_session_for_request(request)
+        stats = session_manager.get_session_stats(session_id)
+        return stats
+    except Exception as e:
+        logger.error(f"Error getting session stats: {str(e)}")
+        return {"error": str(e)}

multi_llm_chatbot_backend/app/api/utils.py

@@ -0,0 +1,24 @@
+from typing import Optional
+from fastapi import Request
+from app.core.session_manager import get_session_manager
+
+session_manager = get_session_manager()
+
+def get_or_create_session_for_request(request: Request, session_id_override: Optional[str] = None) -> str:
+    """
+    Get or create session for request using multiple strategies:
+    1. Explicit session ID
+    2. X-Session-ID header
+    3. Client IP fallback
+    """
+    if session_id_override:
+        return session_id_override
+
+    session_header = request.headers.get("X-Session-ID")
+    if session_header:
+        return session_header
+
+    client_ip = request.client.host if request.client else "unknown"
+    ip_session_id = f"ip_{client_ip}"
+    session = session_manager.get_session(ip_session_id)
+    return session.session_id

multi_llm_chatbot_backend/app/core/bootstrap.py

@@ -0,0 +1,24 @@
+# app/core/bootstrap.py
+import os
+from app.llm.improved_gemini_client import ImprovedGeminiClient
+from app.llm.improved_ollama_client import ImprovedOllamaClient
+from app.core.improved_orchestrator import ImprovedChatOrchestrator
+from app.models.default_personas import get_default_personas
+
+current_provider = "gemini"
+available_providers = ["ollama", "gemini"]
+
+def create_llm_client(provider=None):
+    if provider is None:
+        provider = current_provider
+    if provider == "gemini":
+        return ImprovedGeminiClient(model_name=os.getenv("GEMINI_MODEL"))
+    else:
+        return ImprovedOllamaClient(model_name="llama3.2:1b")
+
+llm = create_llm_client()
+chat_orchestrator = ImprovedChatOrchestrator()
+
+DEFAULT_PERSONAS = get_default_personas(llm)
+for persona in DEFAULT_PERSONAS:
+    chat_orchestrator.register_persona(persona)