Merge pull request #47 from sohank-17/girish-feature

multi_llm_chatbot_backend/app/api/routes.py

@@ -1,26 +1,25 @@
 import os
-from fastapi import APIRouter, Body, HTTPException
+from fastapi import APIRouter, Body, HTTPException, Header, UploadFile, File, Request
+from typing import Optional, List
 import httpx
 from app.llm.llm_client import LLMClient
-from app.llm.gemini_client import GeminiClient
-from app.llm.short_ollama_client import ShortResponseOllamaClient
+from app.llm.improved_gemini_client import ImprovedGeminiClient
+from app.llm.improved_ollama_client import ImprovedOllamaClient
 from app.models.persona import Persona
-from app.core.orchestrator import ChatOrchestrator
-from app.core.seamless_orchestrator import SeamlessOrchestrator
-from app.core.context import GlobalSessionContext
+from app.core.improved_orchestrator import ImprovedChatOrchestrator
+from app.core.session_manager import get_session_manager
 from app.models.default_personas import get_default_personas
-from pydantic import BaseModel
-from typing import Optional, List
-from fastapi import UploadFile, File
 from app.utils.document_extractor import extract_text_from_file
-from app.core.orchestrator import answer_with_persona_context
-from app.utils.chroma_client import add_persona_doc
-import hashlib
 from app.utils.file_limits import is_within_upload_limit
+from pydantic import BaseModel
+import hashlib
+import logging
+
+logger = logging.getLogger(__name__)
 
 router = APIRouter()
 
-# Provider management
+# Provider management (same as before)
 current_provider = "gemini"
 available_providers = ["ollama", "gemini"]
 
@@ -31,30 +30,26 @@ def create_llm_client(provider: str = None) -> LLMClient:
         
     if provider == "gemini":
         try:
-            return GeminiClient(model_name=os.getenv("GEMINI_MODEL"))
+            return ImprovedGeminiClient(model_name=os.getenv("GEMINI_MODEL"))
         except ValueError as e:
-            # Fallback to Ollama if Gemini API key is not available
-            print(f"Gemini API key not found, falling back to Ollama: {e}")
-            return ShortResponseOllamaClient(model_name="llama3.2:1b")
+            logger.warning(f"Gemini API key not found, falling back to Ollama: {e}")
+            return ImprovedOllamaClient(model_name="llama3.2:1b")
     elif provider == "ollama":
-        return ShortResponseOllamaClient(model_name="llama3.2:1b")
+        return ImprovedOllamaClient(model_name="llama3.2:1b")
     else:
         raise ValueError(f"Unknown provider: {provider}")
 
 # Initialize with default provider
 llm = create_llm_client()
-chat_orchestrator = ChatOrchestrator()
-seamless_orchestrator = SeamlessOrchestrator(llm=llm)
-
-session_context = GlobalSessionContext()
+chat_orchestrator = ImprovedChatOrchestrator()
+session_manager = get_session_manager()
 
 # Initialize personas
 DEFAULT_PERSONAS = get_default_personas(llm)
-
 for persona in DEFAULT_PERSONAS:
     chat_orchestrator.register_persona(persona)
 
-# Data models
+# Keep all the same data models as before
 class UserInput(BaseModel):
     user_input: str
 
@@ -76,16 +71,52 @@ class ReplyToAdvisor(BaseModel):
 class ProviderSwitch(BaseModel):
     provider: str
 
-# Helper functions for response validation
+# ==============================================================
+# SESSION MANAGEMENT COMPATIBILITY LAYER
+# ==============================================================
+
+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. Use provided session_id if given
+    2. Use X-Session-ID header if present  
+    3. Use client IP as fallback for backward compatibility
+    4. Create new session if nothing available
+    
+    This allows the old stateless API to work with session management
+    """
+    # Strategy 1: Explicit session ID (for new clients)
+    if session_id_override:
+        return session_id_override
+    
+    # Strategy 2: Check for session header (optional for frontend)
+    session_header = request.headers.get("X-Session-ID")
+    if session_header:
+        return session_header
+    
+    # Strategy 3: Use client IP for backward compatibility
+    # This gives each client IP their own persistent session
+    client_ip = request.client.host if request.client else "unknown"
+    ip_session_id = f"ip_{client_ip}"
+    
+    # Get or create session for this IP
+    session = session_manager.get_session(ip_session_id)
+    return session.session_id
+
+
+
+# Helper functions (same as before)
 def _is_valid_response(response: str, persona_id: str) -> bool:
     """Validate response quality"""
     if len(response) < 2 or len(response) > 5000:
         return False
     
-    # Check for AI confusion indicators
     confusion_indicators = [
         f"Thank you, Dr. {persona_id.title()}",
         "Assistant:",
+        f"Dr. {persona_id.title()}",
+        "Assistant:",
         f"Dr. {persona_id.title()} Advisor:",
         "excellent discussion, Assistant"
     ]
@@ -101,7 +132,7 @@ def _get_persona_fallback(persona_id: str) -> str:
     }
     return fallbacks.get(persona_id, "I'd be happy to help. Could you provide more details?")
 
-# Provider management endpoints
+# Provider management endpoints (EXACTLY THE SAME)
 @router.get("/current-provider")
 async def get_current_provider():
     return {
@@ -124,22 +155,15 @@ async def switch_provider(provider_data: ProviderSwitch):
         )
     
     try:
-        # Update current provider
         current_provider = provider_data.provider
-        
-        # Create new LLM client
         new_llm = create_llm_client(current_provider)
         llm = new_llm
         
-        # Update all personas with new LLM
         new_personas = get_default_personas(new_llm)
         chat_orchestrator.personas.clear()
         for persona in new_personas:
             chat_orchestrator.register_persona(persona)
         
-        # Update seamless orchestrator
-        seamless_orchestrator.llm = new_llm
-        
         return {
             "message": f"Successfully switched to {current_provider}",
             "current_provider": current_provider,
@@ -155,79 +179,61 @@ async def switch_provider(provider_data: ProviderSwitch):
             detail=f"Failed to switch to {provider_data.provider}: {str(e)}"
         )
 
-# Sequential advisor responses endpoint
+# Main chat endpoint (SAME INTERFACE, improved backend)
 @router.post("/chat-sequential")
-async def chat_sequential(message: ChatMessage):
-    """Generate advisor responses with improved quality controls"""
-    
+async def chat_sequential(message: ChatMessage, request: Request):
+    """
+    SAME INTERFACE AS BEFORE - Generate advisor responses 
+    Now with improved session management behind the scenes
+    """
     try:
-        orchestrator_result = await seamless_orchestrator.process_message(message.user_input)
-
-        if orchestrator_result["status"] == "orchestrator_asking":
+        # Get session using compatibility layer
+        session_id = get_or_create_session_for_request(request, message.session_id)
+        
+        # Use the new orchestrator with session management
+        result = await chat_orchestrator.process_message(
+            user_input=message.user_input,
+            session_id=session_id,
+            response_length=message.response_length
+        )
+        
+        # Convert new format back to old format for backward compatibility
+        if result["type"] == "clarification":
             return {
                 "type": "orchestrator_question",
                 "responses": [{
                     "persona": "PhD Advisor Assistant",
-                    "response": orchestrator_result["orchestrator_question"]
+                    "response": result["message"]
                 }],
-                "collected_info": orchestrator_result["collected_info"]
+                "collected_info": {}
             }
-
-        elif orchestrator_result["status"] == "ready_for_advisors":
-            enhanced_context = orchestrator_result["enhanced_context"]
-            
-            # Clear previous advisor responses to avoid confusion
-            session_context.clear()
-            session_context.append("user", message.user_input)
-            session_context.append("orchestrator", enhanced_context)
-
-            advisor_order = chat_orchestrator.get_response_order()
-            print("Advisor Order:")
-            print(advisor_order)
-            responses = []
-            
-            for persona_id in advisor_order:
-                try:
-                    persona = chat_orchestrator.personas[persona_id]                    
-                    reply = await persona.respond(session_context.full_log, response_length="medium")
-                    print("Replies:")
-                    print(reply)
-                    
-                    # Validate response before adding
-                    if _is_valid_response(reply, persona_id):
-                        responses.append({
-                            "persona": persona.name,
-                            "persona_id": persona_id,
-                            "response": reply,
-                        })
-                    else:
-                        # Fallback response for invalid responses
-                        responses.append({
-                            "persona": persona.name,
-                            "persona_id": persona_id,
-                            "response": _get_persona_fallback(persona_id),
-                        })
-
-                    session_context.append(persona_id, reply)
-                    
-                except Exception as e:
-                    print(f"Error generating response for {persona_id}: {e}")
-                    responses.append({
-                        "persona": chat_orchestrator.personas[persona_id].name,
-                        "persona_id": persona_id,
-                        "response": _get_persona_fallback(persona_id),
-                    })
-
-            print("Response Block: " )
-            print(responses)
+        
+        elif result["type"] == "persona_responses":
+            # Convert new response format to old format
             return {
-                "type": "sequential_responses",
-                "responses": responses,
-                "collected_info": orchestrator_result["collected_info"]
+                "type": "sequential_responses", 
+                "responses": [
+                    {
+                        "persona": resp["persona_name"],
+                        "persona_id": resp["persona_id"],
+                        "response": resp["response"]
+                    }
+                    for resp in result["responses"]
+                ],
+                "collected_info": {}
+            }
+        
+        else:
+            return {
+                "type": "error",
+                "responses": [{
+                    "persona": "System",
+                    "response": result.get("message", "Please try again.")
+                }]
             }
             
     except Exception as e:
-        print(f"Error in chat_sequential: {e}")
+        logger.error(f"Error in chat_sequential: {e}")
         return {
             "type": "error",
             "responses": [{
@@ -236,109 +242,94 @@ async def chat_sequential(message: ChatMessage):
             }]
         }
 
-
-# Individual advisor endpoint with context
+# Individual advisor endpoint (SAME INTERFACE)
 @router.post("/chat/{persona_id}")
-async def chat_with_specific_advisor(persona_id: str, input: UserInput):
-    """Chat with a specific advisor"""
+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")
 
-        session_context.append("user", input.user_input)
-        persona = chat_orchestrator.personas[persona_id]
-        context = session_context.full_log.copy()
-        reply = await persona.respond(context, response_length="medium")
-        session_context.append(persona_id, reply)
-
-        return {
-            "persona": persona.name,
-            "persona_id": persona_id,
-            "response": reply
-        }
+        # 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
+        )
+        
+        if result["type"] == "single_persona_response":
+            persona_data = result["persona"]
+            return {
+                "persona": persona_data["persona_name"],
+                "persona_id": persona_data["persona_id"],
+                "response": persona_data["response"]
+            }
+        else:
+            return {
+                "persona": "System",
+                "response": result.get("message", "I'm having trouble generating a response right now. Please try again.")
+            }
+            
     except HTTPException:
         raise
     except Exception as e:
-        print(f"Error in chat_with_specific_advisor: {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 specific advisor endpoint
+# Reply to advisor endpoint (SAME INTERFACE)
 @router.post("/reply-to-advisor")
-async def reply_to_advisor(reply: ReplyToAdvisor):
-    """Reply to a specific advisor and get response only from that 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")
 
-        # Add user reply to context
-        session_context.append("user", reply.user_input)
-
-        # Get response from specific advisor
-        persona = chat_orchestrator.personas[reply.advisor_id]
+        # Get session using compatibility layer
+        session_id = get_or_create_session_for_request(request)
         
-        # Generate response
-        reply_response = await persona.respond(session_context.full_log, response_length="medium")
-        session_context.append(reply.advisor_id, reply_response)
+        # Use new orchestrator
+        result = await chat_orchestrator.chat_with_persona(
+            user_input=reply.user_input,
+            persona_id=reply.advisor_id,
+            session_id=session_id
+        )
         
-        return {
-            "type": "advisor_reply",
-            "persona": persona.name,
-            "persona_id": reply.advisor_id,
-            "response": reply_response,
-            "original_message_id": reply.original_message_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:
-        print(f"Error in reply_to_advisor: {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."
         }
 
-# Reset session
-@router.post("/reset-session")
-async def reset_session():
-    try:
-        seamless_orchestrator.reset()
-        session_context.clear()
-        return {"status": "reset", "message": "Session reset successfully"}
-    except Exception as e:
-        print(f"Error resetting session: {e}")
-        return {"status": "error", "message": "Failed to reset session"}
-
-# Context inspection
-@router.get("/context")
-def get_context():
-    return session_context.full_log
-
-# Legacy model switching endpoint (now redirects to provider switching)
-@router.post("/switch-model")
-async def switch_model(model_name: str = Body(...)):
-    # For backward compatibility, try to map model names to providers
-    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():
-    # For backward compatibility
-    model_name = llm.model_name if hasattr(llm, 'model_name') else "gemini-2.0-flash"
-    return {
-        "model": model_name,
-        "provider": current_provider
-    }
-
+# Document upload (SAME INTERFACE)
 @router.post("/upload-document")
-async def upload_document(file: UploadFile = File(...)):
-    # Validate file type
+async def upload_document(file: UploadFile = File(...), request: Request = None):
+    """Upload document - SAME INTERFACE"""
     if file.content_type not in [
         "application/pdf",
         "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
@@ -347,58 +338,157 @@ async def upload_document(file: UploadFile = File(...)):
         raise HTTPException(status_code=400, detail="Unsupported file type.")
 
     try:
-        # Read file bytes
+        # Get session using compatibility layer
+        session_id = get_or_create_session_for_request(request)
+        session = session_manager.get_session(session_id)
+        
         file_bytes = await file.read()
 
-        # Check file size limit
-        if not is_within_upload_limit("default", file_bytes, session_context):
+        # Simple size check
+        MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
+        if len(file_bytes) > MAX_FILE_SIZE:
             raise HTTPException(status_code=400, detail="Upload exceeds session document size limit (10 MB).")
 
-        # Extract and validate text
         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.")
 
-        # Track file size and name
-        session_context.append("Document", f"[Uploaded Document Content]\n{content.strip()}")
-        session_context.uploaded_files.append(file.filename)
-        session_context.total_upload_size += len(file_bytes)
+        # Add to session context using new system
+        session.add_uploaded_file(file.filename, content, len(file_bytes))
 
         return {"message": "Document uploaded and added to context successfully."}
 
+    except HTTPException:
+        raise
     except Exception as e:
+        logger.error(f"Error uploading document: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Error processing document: {str(e)}")
 
-# Debug endpoint
-@router.get("/debug/personas")
-async def debug_personas():
+# Get uploaded files (SAME INTERFACE)
+@router.get("/uploaded-files")
+async def get_uploaded_filenames(request: Request):
+    """Get uploaded files - SAME INTERFACE"""
+    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": []}
+
+# Context endpoint (SAME INTERFACE)
+@router.get("/context")
+async def get_context(request: Request):
+    """Get context - SAME INTERFACE"""
+    try:
+        session_id = get_or_create_session_for_request(request)
+        session = session_manager.get_session(session_id)
+        return session.messages  # Return messages in same format as before
+    except Exception as e:
+        logger.error(f"Error getting context: {str(e)}")
+        return []
+
+# Reset session (SAME INTERFACE) 
+@router.post("/reset-session")
+async def reset_session(request: Request):
+    """Reset session - SAME INTERFACE"""
+    try:
+        session_id = get_or_create_session_for_request(request)
+        success = chat_orchestrator.reset_session(session_id)
+        
+        if success:
+            return {"status": "reset", "message": "Session 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"}
+
+# Legacy model endpoints (SAME INTERFACE)
+@router.post("/switch-model")
+async def switch_model(model_name: str = Body(...)):
+    """Legacy model switching - SAME INTERFACE"""
+    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():
+    """Legacy model info - SAME INTERFACE"""
+    model_name = llm.model_name if hasattr(llm, 'model_name') else "gemini-2.0-flash"
     return {
-        "personas": {
-            pid: {
-                "name": persona.name,
-                "prompt": persona.system_prompt[:100] + "..."
-            } for pid, persona in chat_orchestrator.personas.items()
-        },
-        "context_length": len(session_context.full_log),
-        "current_provider": current_provider
+        "model": model_name,
+        "provider": current_provider
     }
 
+# Debug endpoint (SAME INTERFACE)
+@router.get("/debug/personas")
+async def debug_personas(request: Request):
+    """Debug personas - SAME INTERFACE"""
+    try:
+        session_id = get_or_create_session_for_request(request)
+        session = session_manager.get_session(session_id)
+        
+        return {
+            "personas": {
+                pid: {
+                    "name": persona.name,
+                    "prompt": persona.system_prompt[:100] + "..."
+                } for pid, persona in chat_orchestrator.personas.items()
+            },
+            "context_length": len(session.messages),
+            "current_provider": current_provider
+        }
+    except Exception as e:
+        logger.error(f"Error in debug endpoint: {str(e)}")
+        return {
+            "personas": {},
+            "context_length": 0,
+            "current_provider": current_provider
+        }
+
+# Ask endpoint (SAME INTERFACE)
 class PersonaQuery(BaseModel):
     question: str
     persona: str
 
 @router.post("/ask/")
-async def ask_question(query: PersonaQuery):
-    response = await answer_with_persona_context(query.question, query.persona)
-    
-    # Store Q&A in vector DB
-    combined_text = f"Q: {query.question}\nA: {response}"
-    doc_id = hashlib.md5(combined_text.encode()).hexdigest()  # Create a unique doc ID
-    
-    add_persona_doc(combined_text, query.persona, doc_id)
-
-    return {"response": response}
+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."}
 
-@router.get("/uploaded-files")
-def get_uploaded_filenames():
-    return {"files": session_context.uploaded_files}
+# Root endpoint (SAME INTERFACE)
+@router.get("/")
+def root():
+    """Root endpoint - SAME INTERFACE with updated info"""
+    return {
+        "message": "Multi-LLM PhD Advisor Backend is up and running",
+        "version": "1.0.0",  # Updated version 
+        "features": [
+            "Improved Session Management",
+            "Unified Context Handling", 
+            "Ollama Support", 
+            "Gemini API Support", 
+            "Provider Switching"
+        ]
+    }

multi_llm_chatbot_backend/app/api/routes_old.py

@@ -0,0 +1,404 @@
+import os
+from fastapi import APIRouter, Body, HTTPException
+import httpx
+from app.llm.llm_client import LLMClient
+from app.llm.gemini_client import GeminiClient
+from app.llm.short_ollama_client import ShortResponseOllamaClient
+from app.models.persona import Persona
+from app.core.orchestrator import ChatOrchestrator
+from app.core.seamless_orchestrator import SeamlessOrchestrator
+from app.core.context import GlobalSessionContext
+from app.models.default_personas import get_default_personas
+from pydantic import BaseModel
+from typing import Optional, List
+from fastapi import UploadFile, File
+from app.utils.document_extractor import extract_text_from_file
+from app.core.orchestrator import answer_with_persona_context
+from app.utils.chroma_client import add_persona_doc
+import hashlib
+from app.utils.file_limits import is_within_upload_limit
+
+router = APIRouter()
+
+# Provider management
+current_provider = "gemini"
+available_providers = ["ollama", "gemini"]
+
+def create_llm_client(provider: str = None) -> LLMClient:
+    """Create LLM client based on provider"""
+    if provider is None:
+        provider = current_provider
+        
+    if provider == "gemini":
+        try:
+            return GeminiClient(model_name=os.getenv("GEMINI_MODEL"))
+        except ValueError as e:
+            # Fallback to Ollama if Gemini API key is not available
+            print(f"Gemini API key not found, falling back to Ollama: {e}")
+            return ShortResponseOllamaClient(model_name="llama3.2:1b")
+    elif provider == "ollama":
+        return ShortResponseOllamaClient(model_name="llama3.2:1b")
+    else:
+        raise ValueError(f"Unknown provider: {provider}")
+
+# Initialize with default provider
+llm = create_llm_client()
+chat_orchestrator = ChatOrchestrator()
+seamless_orchestrator = SeamlessOrchestrator(llm=llm)
+
+session_context = GlobalSessionContext()
+
+# Initialize personas
+DEFAULT_PERSONAS = get_default_personas(llm)
+
+for persona in DEFAULT_PERSONAS:
+    chat_orchestrator.register_persona(persona)
+
+# Data models
+class UserInput(BaseModel):
+    user_input: str
+
+class PersonaInput(BaseModel):
+    id: str
+    name: str
+    system_prompt: str
+
+class ChatMessage(BaseModel):
+    user_input: str
+    session_id: Optional[str] = None
+    response_length: Optional[str] = "medium"
+
+class ReplyToAdvisor(BaseModel):
+    user_input: str
+    advisor_id: str
+    original_message_id: Optional[str] = None
+
+class ProviderSwitch(BaseModel):
+    provider: str
+
+# Helper functions for response validation
+def _is_valid_response(response: str, persona_id: str) -> bool:
+    """Validate response quality"""
+    if len(response) < 2 or len(response) > 5000:
+        return False
+    
+    # Check for AI confusion indicators
+    confusion_indicators = [
+        f"Thank you, Dr. {persona_id.title()}",
+        "Assistant:",
+        f"Dr. {persona_id.title()} Advisor:",
+        "excellent discussion, Assistant"
+    ]
+    
+    return not any(indicator in response for indicator in confusion_indicators)
+
+def _get_persona_fallback(persona_id: str) -> str:
+    """Get persona-specific fallback responses"""
+    fallbacks = {
+        "methodist": "Focus on ensuring your methodology aligns with your research question. What specific method are you considering?",
+        "theorist": "Consider the theoretical framework underlying your approach. What assumptions guide your thinking?",
+        "pragmatist": "Let's break this down into actionable steps. What's the most important thing you need to decide today?"
+    }
+    return fallbacks.get(persona_id, "I'd be happy to help. Could you provide more details?")
+
+# Provider management endpoints
+@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:
+        # Update current provider
+        current_provider = provider_data.provider
+        
+        # Create new LLM client
+        new_llm = create_llm_client(current_provider)
+        llm = new_llm
+        
+        # Update all personas with new LLM
+        new_personas = get_default_personas(new_llm)
+        chat_orchestrator.personas.clear()
+        for persona in new_personas:
+            chat_orchestrator.register_persona(persona)
+        
+        # Update seamless orchestrator
+        seamless_orchestrator.llm = new_llm
+        
+        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)}"
+        )
+
+# Sequential advisor responses endpoint
+@router.post("/chat-sequential")
+async def chat_sequential(message: ChatMessage):
+    """Generate advisor responses with improved quality controls"""
+    
+    try:
+        orchestrator_result = await seamless_orchestrator.process_message(message.user_input)
+
+        if orchestrator_result["status"] == "orchestrator_asking":
+            return {
+                "type": "orchestrator_question",
+                "responses": [{
+                    "persona": "PhD Advisor Assistant",
+                    "response": orchestrator_result["orchestrator_question"]
+                }],
+                "collected_info": orchestrator_result["collected_info"]
+            }
+
+        elif orchestrator_result["status"] == "ready_for_advisors":
+            enhanced_context = orchestrator_result["enhanced_context"]
+            
+            # Clear previous advisor responses to avoid confusion
+            session_context.clear()
+            session_context.append("user", message.user_input)
+            session_context.append("orchestrator", enhanced_context)
+
+            advisor_order = chat_orchestrator.get_response_order()
+            print("Advisor Order:")
+            print(advisor_order)
+            responses = []
+            
+            for persona_id in advisor_order:
+                try:
+                    persona = chat_orchestrator.personas[persona_id]                    
+                    reply = await persona.respond(session_context.full_log, response_length="medium")
+                    print("Replies:")
+                    print(reply)
+                    
+                    # Validate response before adding
+                    if _is_valid_response(reply, persona_id):
+                        responses.append({
+                            "persona": persona.name,
+                            "persona_id": persona_id,
+                            "response": reply,
+                        })
+                    else:
+                        # Fallback response for invalid responses
+                        responses.append({
+                            "persona": persona.name,
+                            "persona_id": persona_id,
+                            "response": _get_persona_fallback(persona_id),
+                        })
+
+                    session_context.append(persona_id, reply)
+                    
+                except Exception as e:
+                    print(f"Error generating response for {persona_id}: {e}")
+                    responses.append({
+                        "persona": chat_orchestrator.personas[persona_id].name,
+                        "persona_id": persona_id,
+                        "response": _get_persona_fallback(persona_id),
+                    })
+
+            print("Response Block: " )
+            print(responses)
+            return {
+                "type": "sequential_responses",
+                "responses": responses,
+                "collected_info": orchestrator_result["collected_info"]
+            }
+            
+    except Exception as e:
+        print(f"Error in chat_sequential: {e}")
+        return {
+            "type": "error",
+            "responses": [{
+                "persona": "System",
+                "response": "I'm having trouble processing your request. Could you please try again?"
+            }]
+        }
+
+
+# Individual advisor endpoint with context
+@router.post("/chat/{persona_id}")
+async def chat_with_specific_advisor(persona_id: str, input: UserInput):
+    """Chat with a specific advisor"""
+    try:
+        if persona_id not in chat_orchestrator.personas:
+            raise HTTPException(status_code=404, detail=f"Persona '{persona_id}' not found")
+
+        session_context.append("user", input.user_input)
+        persona = chat_orchestrator.personas[persona_id]
+        context = session_context.full_log.copy()
+        reply = await persona.respond(context, response_length="medium")
+        session_context.append(persona_id, reply)
+
+        return {
+            "persona": persona.name,
+            "persona_id": persona_id,
+            "response": reply
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(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 specific advisor endpoint
+@router.post("/reply-to-advisor")
+async def reply_to_advisor(reply: ReplyToAdvisor):
+    """Reply to a specific advisor and get response only from that advisor"""
+    
+    try:
+        if reply.advisor_id not in chat_orchestrator.personas:
+            raise HTTPException(status_code=404, detail=f"Advisor '{reply.advisor_id}' not found")
+
+        # Add user reply to context
+        session_context.append("user", reply.user_input)
+
+        # Get response from specific advisor
+        persona = chat_orchestrator.personas[reply.advisor_id]
+        
+        # Generate response
+        reply_response = await persona.respond(session_context.full_log, response_length="medium")
+        session_context.append(reply.advisor_id, reply_response)
+        
+        return {
+            "type": "advisor_reply",
+            "persona": persona.name,
+            "persona_id": reply.advisor_id,
+            "response": reply_response,
+            "original_message_id": reply.original_message_id
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(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."
+        }
+
+# Reset session
+@router.post("/reset-session")
+async def reset_session():
+    try:
+        seamless_orchestrator.reset()
+        session_context.clear()
+        return {"status": "reset", "message": "Session reset successfully"}
+    except Exception as e:
+        print(f"Error resetting session: {e}")
+        return {"status": "error", "message": "Failed to reset session"}
+
+# Context inspection
+@router.get("/context")
+def get_context():
+    return session_context.full_log
+
+# Legacy model switching endpoint (now redirects to provider switching)
+@router.post("/switch-model")
+async def switch_model(model_name: str = Body(...)):
+    # For backward compatibility, try to map model names to providers
+    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():
+    # For backward compatibility
+    model_name = llm.model_name if hasattr(llm, 'model_name') else "gemini-2.0-flash"
+    return {
+        "model": model_name,
+        "provider": current_provider
+    }
+
+@router.post("/upload-document")
+async def upload_document(file: UploadFile = File(...)):
+    # Validate file type
+    if file.content_type not in [
+        "application/pdf",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        "text/plain"
+    ]:
+        raise HTTPException(status_code=400, detail="Unsupported file type.")
+
+    try:
+        # Read file bytes
+        file_bytes = await file.read()
+
+        # Check file size limit
+        if not is_within_upload_limit("default", file_bytes, session_context):
+            raise HTTPException(status_code=400, detail="Upload exceeds session document size limit (10 MB).")
+
+        # Extract and validate text
+        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.")
+
+        # Track file size and name
+        session_context.append("Document", f"[Uploaded Document Content]\n{content.strip()}")
+        session_context.uploaded_files.append(file.filename)
+        session_context.total_upload_size += len(file_bytes)
+
+        return {"message": "Document uploaded and added to context successfully."}
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error processing document: {str(e)}")
+
+# Debug endpoint
+@router.get("/debug/personas")
+async def debug_personas():
+    return {
+        "personas": {
+            pid: {
+                "name": persona.name,
+                "prompt": persona.system_prompt[:100] + "..."
+            } for pid, persona in chat_orchestrator.personas.items()
+        },
+        "context_length": len(session_context.full_log),
+        "current_provider": current_provider
+    }
+
+class PersonaQuery(BaseModel):
+    question: str
+    persona: str
+
+@router.post("/ask/")
+async def ask_question(query: PersonaQuery):
+    response = await answer_with_persona_context(query.question, query.persona)
+    
+    # Store Q&A in vector DB
+    combined_text = f"Q: {query.question}\nA: {response}"
+    doc_id = hashlib.md5(combined_text.encode()).hexdigest()  # Create a unique doc ID
+    
+    add_persona_doc(combined_text, query.persona, doc_id)
+
+    return {"response": response}
+
+@router.get("/uploaded-files")
+def get_uploaded_filenames():
+    return {"files": session_context.uploaded_files}

multi_llm_chatbot_backend/app/core/context_manager.py

@@ -0,0 +1,255 @@
+from typing import List, Dict, Optional, Tuple
+from dataclasses import dataclass
+import re
+from datetime import datetime
+
+@dataclass
+class ContextWindow:
+    """Represents a context window for LLM processing"""
+    messages: List[dict]
+    total_tokens: int
+    truncated: bool = False
+    
+class ContextManager:
+    """Unified context management for consistent LLM behavior"""
+    
+    def __init__(self, 
+                 max_context_tokens: int = 8000,
+                 preserve_recent_messages: int = 5,
+                 chars_per_token: float = 4.0):
+        self.max_context_tokens = max_context_tokens
+        self.preserve_recent_messages = preserve_recent_messages
+        self.chars_per_token = chars_per_token
+    
+    def prepare_context_for_llm(self, 
+                               messages: List[dict], 
+                               system_prompt: str,
+                               llm_provider: str = "gemini") -> ContextWindow:
+        """
+        Prepare context for LLM with intelligent windowing and formatting
+        """
+        # Calculate token budget
+        system_tokens = self._estimate_tokens(system_prompt)
+        available_tokens = self.max_context_tokens - system_tokens - 500  # Reserve for response
+        
+        # Get relevant context window
+        context_messages = self._get_optimal_context_window(messages, available_tokens)
+        
+        # Format for specific LLM provider
+        formatted_messages = self._format_for_provider(context_messages, system_prompt, llm_provider)
+        
+        return ContextWindow(
+            messages=formatted_messages,
+            total_tokens=self._estimate_tokens_for_messages(formatted_messages),
+            truncated=len(context_messages) < len(messages)
+        )
+    
+    def _get_optimal_context_window(self, messages: List[dict], token_budget: int) -> List[dict]:
+        """
+        Select optimal messages for context window using recency + relevance
+        """
+        if not messages:
+            return []
+        
+        # Always preserve the most recent messages
+        recent_messages = messages[-self.preserve_recent_messages:]
+        recent_tokens = self._estimate_tokens_for_messages(recent_messages)
+        
+        if recent_tokens >= token_budget:
+            # If recent messages exceed budget, truncate to fit
+            return self._truncate_to_fit(recent_messages, token_budget)
+        
+        # Add older messages if we have token budget remaining
+        remaining_budget = token_budget - recent_tokens
+        older_messages = messages[:-self.preserve_recent_messages] if len(messages) > self.preserve_recent_messages else []
+        
+        # Score older messages by relevance and recency
+        scored_messages = self._score_messages_for_relevance(older_messages, messages[-1]['content'] if messages else "")
+        
+        # Add highest scoring messages that fit in budget
+        selected_older = []
+        for message, score in scored_messages:
+            message_tokens = self._estimate_tokens(message['content'])
+            if message_tokens <= remaining_budget:
+                selected_older.append(message)
+                remaining_budget -= message_tokens
+            else:
+                break
+        
+        # Combine in chronological order
+        return selected_older + recent_messages
+    
+    def _score_messages_for_relevance(self, messages: List[dict], current_query: str) -> List[Tuple[dict, float]]:
+        """
+        Score messages by relevance to current query and recency
+        """
+        scored = []
+        current_query_lower = current_query.lower()
+        
+        for i, message in enumerate(messages):
+            score = 0.0
+            content_lower = message['content'].lower()
+            
+            # Recency score (more recent = higher score)
+            recency_score = (i + 1) / len(messages) * 0.3
+            
+            # Keyword overlap score
+            current_words = set(current_query_lower.split())
+            message_words = set(content_lower.split())
+            overlap = len(current_words.intersection(message_words))
+            keyword_score = min(overlap / max(len(current_words), 1) * 0.4, 0.4)
+            
+            # Role importance (user questions and document content more important)
+            role_score = 0.3 if message['role'] in ['user', 'document'] else 0.1
+            
+            score = recency_score + keyword_score + role_score
+            scored.append((message, score))
+        
+        # Sort by score descending
+        return sorted(scored, key=lambda x: x[1], reverse=True)
+    
+    def _truncate_to_fit(self, messages: List[dict], token_budget: int) -> List[dict]:
+        """
+        Truncate messages to fit within token budget, preserving most recent
+        """
+        result = []
+        current_tokens = 0
+        
+        # Add messages from most recent backward
+        for message in reversed(messages):
+            message_tokens = self._estimate_tokens(message['content'])
+            if current_tokens + message_tokens <= token_budget:
+                result.insert(0, message)
+                current_tokens += message_tokens
+            else:
+                break
+        
+        return result
+    
+    def _format_for_provider(self, messages: List[dict], system_prompt: str, provider: str) -> List[dict]:
+        """
+        Format messages for specific LLM provider
+        """
+        if provider.lower() == "gemini":
+            return self._format_for_gemini(messages, system_prompt)
+        elif provider.lower() in ["ollama", "mistral"]:
+            return self._format_for_ollama(messages, system_prompt)
+        else:
+            # Default format
+            return [{"role": "system", "content": system_prompt}] + messages
+    
+    def _format_for_gemini(self, messages: List[dict], system_prompt: str) -> List[dict]:
+        """
+        Format messages for Gemini API (uses user/model roles with parts structure)
+        """
+        formatted = []
+        
+        # Add system prompt as initial exchange
+        if system_prompt:
+            formatted.extend([
+                {
+                    "role": "user",
+                    "parts": [{"text": system_prompt}]
+                },
+                {
+                    "role": "model",
+                    "parts": [{"text": "I understand. I'll follow these instructions."}]
+                }
+            ])
+        
+        # Convert messages to Gemini format
+        for message in messages:
+            role = message['role']
+            content = message['content']
+            
+            if role == 'user':
+                formatted.append({
+                    "role": "user",
+                    "parts": [{"text": content}]
+                })
+            elif role in ['assistant', 'methodist', 'theorist', 'pragmatist']:
+                formatted.append({
+                    "role": "model",
+                    "parts": [{"text": content}]
+                })
+            elif role == 'document':
+                # Add document as user context
+                formatted.append({
+                    "role": "user",
+                    "parts": [{"text": f"[Context Document] {content}"}]
+                })
+        
+        return formatted
+    
+    def _format_for_ollama(self, messages: List[dict], system_prompt: str) -> str:
+        """
+        Format messages for Ollama (returns formatted prompt string)
+        """
+        parts = [system_prompt] if system_prompt else []
+        
+        for message in messages:
+            role = message['role'].capitalize()
+            content = message['content']
+            
+            if role == 'Document':
+                parts.append(f"Context: {content}")
+            else:
+                parts.append(f"{role}: {content}")
+        
+        parts.append("Assistant:")
+        return "\n\n".join(parts)
+    
+    def _estimate_tokens(self, text: str) -> int:
+        """
+        Estimate token count for text
+        """
+        return int(len(text) / self.chars_per_token)
+    
+    def _estimate_tokens_for_messages(self, messages: List[dict]) -> int:
+        """
+        Estimate total tokens for list of messages
+        """
+        if isinstance(messages, str):
+            return self._estimate_tokens(messages)
+        
+        total = 0
+        for message in messages:
+            if isinstance(message, dict):
+                if 'content' in message:
+                    total += self._estimate_tokens(message['content'])
+                elif 'parts' in message:
+                    # Gemini format
+                    for part in message['parts']:
+                        if 'text' in part:
+                            total += self._estimate_tokens(part['text'])
+            else:
+                total += self._estimate_tokens(str(message))
+        
+        return total
+    
+    def get_context_summary(self, messages: List[dict]) -> Dict[str, any]:
+        """
+        Get summary information about context
+        """
+        if not messages:
+            return {"total_messages": 0, "estimated_tokens": 0, "roles": {}}
+        
+        role_counts = {}
+        for message in messages:
+            role = message.get('role', 'unknown')
+            role_counts[role] = role_counts.get(role, 0) + 1
+        
+        return {
+            "total_messages": len(messages),
+            "estimated_tokens": self._estimate_tokens_for_messages(messages),
+            "roles": role_counts,
+            "oldest_message": messages[0].get('timestamp', 'unknown') if messages else None,
+            "newest_message": messages[-1].get('timestamp', 'unknown') if messages else None
+        }
+
+# Global context manager instance
+context_manager = ContextManager()
+
+def get_context_manager() -> ContextManager:
+    """Get the global context manager instance"""
+    return context_manager

multi_llm_chatbot_backend/app/core/improved_orchestrator.py

@@ -0,0 +1,317 @@
+from typing import Dict, List, Optional, Any
+from app.models.persona import Persona
+from app.core.session_manager import ConversationContext, get_session_manager
+from app.core.context_manager import get_context_manager
+from app.llm.llm_client import LLMClient
+import logging
+import re
+
+logger = logging.getLogger(__name__)
+
+class ImprovedChatOrchestrator:
+    """
+    Improved orchestrator with proper session management and context handling
+    """
+    
+    def __init__(self):
+        self.personas: Dict[str, Persona] = {}
+        self.session_manager = get_session_manager()
+        self.context_manager = get_context_manager()
+    
+    def register_persona(self, persona: Persona):
+        """Register a persona with the orchestrator"""
+        self.personas[persona.id] = persona
+        logger.info(f"Registered persona: {persona.id} ({persona.name})")
+    
+    def get_persona(self, persona_id: str) -> Optional[Persona]:
+        """Get a specific persona"""
+        return self.personas.get(persona_id)
+    
+    def list_personas(self) -> List[str]:
+        """List all available persona IDs"""
+        return list(self.personas.keys())
+    
+    async def process_message(self, 
+                            user_input: str, 
+                            session_id: Optional[str] = None,
+                            response_length: str = "medium") -> Dict[str, Any]:
+        """
+        Process a user message through the orchestration pipeline
+        """
+        try:
+            # Get or create session
+            session = self.session_manager.get_session(session_id)
+            
+            # Add user message to session
+            session.append_message("user", user_input)
+            
+            # Determine if we need clarification
+            needs_clarification = self._needs_clarification(session, user_input)
+            
+            if needs_clarification:
+                # Generate clarification question
+                clarification = await self._generate_clarification_question(session)
+                session.append_message("orchestrator", clarification)
+                
+                return {
+                    "type": "clarification",
+                    "session_id": session.session_id,
+                    "message": clarification,
+                    "context_summary": self.context_manager.get_context_summary(session.messages)
+                }
+            
+            # Generate responses from all personas
+            responses = await self._generate_persona_responses(session, response_length)
+            
+            return {
+                "type": "persona_responses",
+                "session_id": session.session_id,
+                "responses": responses,
+                "context_summary": self.context_manager.get_context_summary(session.messages)
+            }
+            
+        except Exception as e:
+            logger.error(f"Error in process_message: {str(e)}")
+            return {
+                "type": "error",
+                "session_id": session_id,
+                "message": "I encountered an error processing your request. Please try again.",
+                "error": str(e)
+            }
+    
+    async def chat_with_persona(self, 
+                               user_input: str, 
+                               persona_id: str,
+                               session_id: Optional[str] = None,
+                               response_length: str = "medium") -> Dict[str, Any]:
+        """
+        Chat with a specific persona
+        """
+        try:
+            if persona_id not in self.personas:
+                return {
+                    "type": "error",
+                    "message": f"Persona '{persona_id}' not found"
+                }
+            
+            # Get or create session
+            session = self.session_manager.get_session(session_id)
+            
+            # Add user message
+            session.append_message("user", user_input)
+            
+            # Generate response from specific persona
+            persona = self.personas[persona_id]
+            response = await self._generate_single_persona_response(session, persona, response_length)
+            
+            # Add persona response to session
+            session.append_message(persona_id, response['response'])
+            
+            return {
+                "type": "single_persona_response",
+                "session_id": session.session_id,
+                "persona": response,
+                "context_summary": self.context_manager.get_context_summary(session.messages)
+            }
+            
+        except Exception as e:
+            logger.error(f"Error in chat_with_persona: {str(e)}")
+            return {
+                "type": "error",
+                "session_id": session_id,
+                "message": "I encountered an error generating a response. Please try again.",
+                "error": str(e)
+            }
+    
+    def _needs_clarification(self, session: ConversationContext, user_input: str) -> bool:
+        """
+        Determine if user input needs clarification
+        """
+        # Don't ask for clarification if this is a follow-up message
+        user_messages = session.get_messages_by_role("user")
+        if len(user_messages) > 1:
+            return False
+        
+        # Check if input is vague
+        vague_patterns = [
+            r"i'm (not sure|unsure|confused|lost)",
+            r"i (don't know|dunno) (what|how|where)",
+            r"help me with (my|the|a) (thesis|research|phd)",
+            r"(what should i|how do i|where do i start)",
+            r"i need (help|advice|guidance)$",
+            r"(stuck|struggling) with",
+            r"(any|some) (advice|suggestions|ideas)$",
+            r"^(help|advice|guidance)$",
+        ]
+        
+        user_lower = user_input.lower().strip()
+        
+        for pattern in vague_patterns:
+            if re.search(pattern, user_lower):
+                return True
+        
+        # Check if input is too short (likely vague)
+        if len(user_input.split()) < 8:
+            return True
+        
+        return False
+    
+    async def _generate_clarification_question(self, session: ConversationContext) -> str:
+        """
+        Generate a clarification question based on context
+        """
+        user_messages = session.get_messages_by_role("user")
+        if not user_messages:
+            return "What specific aspect of your PhD journey would you like guidance on?"
+        
+        latest_message = user_messages[-1]['content']
+        
+        # Extract what information we might be missing
+        missing_info = []
+        
+        # Check for research area
+        research_keywords = ["computer science", "biology", "psychology", "physics", "chemistry", 
+                           "engineering", "literature", "history", "mathematics", "sociology"]
+        if not any(keyword in latest_message.lower() for keyword in research_keywords):
+            missing_info.append("research area")
+        
+        # Check for specific question type
+        question_keywords = ["methodology", "theory", "writing", "analysis", "data", "literature review"]
+        if not any(keyword in latest_message.lower() for keyword in question_keywords):
+            missing_info.append("specific aspect")
+        
+        # Check for academic stage
+        stage_keywords = ["first year", "second year", "third year", "qualifying", "dissertation", 
+                         "defense", "proposal", "coursework"]
+        if not any(keyword in latest_message.lower() for keyword in stage_keywords):
+            missing_info.append("PhD stage")
+        
+        # Generate appropriate clarification question
+        if "research area" in missing_info:
+            return "What field or discipline are you studying in?"
+        elif "specific aspect" in missing_info:
+            return "What specific aspect of your research would you like guidance on?"
+        elif "PhD stage" in missing_info:
+            return "What stage of your PhD program are you currently in?"
+        else:
+            return "Could you provide more details about your specific situation or question?"
+    
+    async def _generate_persona_responses(self, 
+                                        session: ConversationContext, 
+                                        response_length: str) -> List[Dict[str, Any]]:
+        """
+        Generate responses from all personas
+        """
+        responses = []
+        
+        # Get the conversation context for personas
+        context_messages = session.get_recent_messages(limit=20)
+        
+        for persona_id, persona in self.personas.items():
+            try:
+                response_data = await self._generate_single_persona_response(
+                    session, persona, response_length
+                )
+                responses.append(response_data)
+                
+                # Add persona response to session
+                session.append_message(persona_id, response_data['response'])
+                
+            except Exception as e:
+                logger.error(f"Error generating response for persona {persona_id}: {str(e)}")
+                # Add fallback response
+                responses.append({
+                    "persona_id": persona_id,
+                    "persona_name": persona.name,
+                    "response": self._get_fallback_response(persona_id),
+                    "error": True
+                })
+        
+        return responses
+    
+    async def _generate_single_persona_response(self, 
+                                              session: ConversationContext,
+                                              persona: Persona, 
+                                              response_length: str) -> Dict[str, Any]:
+        """
+        Generate response from a single persona
+        """
+        try:
+            # Get conversation context
+            context_messages = session.get_recent_messages(limit=20)
+            
+            # Generate response using persona
+            response = await persona.respond(context_messages, response_length)
+            
+            # Validate response
+            if not self._is_valid_response(response, persona.id):
+                response = self._get_fallback_response(persona.id)
+            
+            return {
+                "persona_id": persona.id,
+                "persona_name": persona.name,
+                "response": response,
+                "error": False
+            }
+            
+        except Exception as e:
+            logger.error(f"Error in _generate_single_persona_response for {persona.id}: {str(e)}")
+            return {
+                "persona_id": persona.id,
+                "persona_name": persona.name,
+                "response": self._get_fallback_response(persona.id),
+                "error": True
+            }
+    
+    def _is_valid_response(self, response: str, persona_id: str) -> bool:
+        """Validate response quality"""
+        if not response or len(response.strip()) < 10:
+            return False
+        
+        if len(response) > 2000:  # Too long
+            return False
+        
+        # Check for AI confusion indicators
+        confusion_indicators = [
+            f"Thank you, Dr. {persona_id.title()}",
+            "Assistant:",
+            f"Dr. {persona_id.title()}:",
+            "excellent discussion, Assistant"
+        ]
+        
+        return not any(indicator in response for indicator in confusion_indicators)
+    
+    def _get_fallback_response(self, persona_id: str) -> str:
+        """Get persona-specific fallback response"""
+        fallbacks = {
+            "methodist": "Let's focus on your research methodology. What specific methodological approach are you considering?",
+            "theorist": "I'd like to explore the theoretical foundation of your work. What conceptual framework guides your research?",
+            "pragmatist": "Let's take a practical approach. What's the most pressing decision you need to make about your research right now?"
+        }
+        return fallbacks.get(persona_id, "I'd be happy to help. Could you provide more specific details about your question?")
+    
+    def get_session_info(self, session_id: str) -> Optional[Dict[str, Any]]:
+        """Get information about a session"""
+        session = self.session_manager.get_session(session_id)
+        if session:
+            return {
+                "session_id": session.session_id,
+                "message_count": len(session.messages),
+                "uploaded_files": session.uploaded_files,
+                "created_at": session.created_at.isoformat(),
+                "last_accessed": session.last_accessed.isoformat(),
+                "context_summary": self.context_manager.get_context_summary(session.messages)
+            }
+        return None
+    
+    def reset_session(self, session_id: str) -> bool:
+        """Reset a session (clear messages but keep metadata)"""
+        session = self.session_manager.get_session(session_id)
+        if session:
+            session.clear_messages()
+            return True
+        return False
+    
+    def delete_session(self, session_id: str) -> bool:
+        """Delete a session completely"""
+        return self.session_manager.delete_session(session_id)

multi_llm_chatbot_backend/app/core/session_manager.py

@@ -0,0 +1,124 @@
+from typing import Dict, List, Optional, Any
+from datetime import datetime, timedelta
+import uuid
+from dataclasses import dataclass, field
+import asyncio
+from threading import Lock
+
+@dataclass
+class ConversationContext:
+    """Individual conversation context for a session"""
+    session_id: str
+    messages: List[dict] = field(default_factory=list)
+    uploaded_files: List[str] = field(default_factory=list)
+    total_upload_size: int = 0
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    created_at: datetime = field(default_factory=datetime.now)
+    last_accessed: datetime = field(default_factory=datetime.now)
+    
+    def append_message(self, role: str, content: str):
+        """Add a message to the conversation"""
+        self.messages.append({
+            "role": role,
+            "content": content,
+            "timestamp": datetime.now().isoformat()
+        })
+        self.last_accessed = datetime.now()
+    
+    def get_recent_messages(self, limit: int = 20) -> List[dict]:
+        """Get recent messages with limit"""
+        return self.messages[-limit:] if len(self.messages) > limit else self.messages
+    
+    def get_messages_by_role(self, role: str) -> List[dict]:
+        """Get all messages from a specific role"""
+        return [msg for msg in self.messages if msg['role'] == role]
+    
+    def clear_messages(self):
+        """Clear all messages but preserve metadata"""
+        self.messages = []
+        self.last_accessed = datetime.now()
+    
+    def add_uploaded_file(self, filename: str, content: str, file_size: int):
+        """Add uploaded file content to context"""
+        self.uploaded_files.append(filename)
+        self.total_upload_size += file_size
+        self.append_message("document", f"[Uploaded: {filename}]\n{content}")
+    
+    def get_context_size(self) -> int:
+        """Calculate total context size in characters"""
+        return sum(len(msg['content']) for msg in self.messages)
+
+class SessionManager:
+    """Thread-safe session manager for handling multiple user conversations"""
+    
+    def __init__(self, session_timeout_hours: int = 24, cleanup_interval_minutes: int = 60):
+        self.sessions: Dict[str, ConversationContext] = {}
+        self.session_timeout = timedelta(hours=session_timeout_hours)
+        self.cleanup_interval = timedelta(minutes=cleanup_interval_minutes)
+        self.lock = Lock()
+        self.last_cleanup = datetime.now()
+    
+    def create_session(self) -> str:
+        """Create a new session and return session ID"""
+        session_id = str(uuid.uuid4())
+        with self.lock:
+            self.sessions[session_id] = ConversationContext(session_id=session_id)
+        return session_id
+    
+    def get_session(self, session_id: Optional[str] = None) -> ConversationContext:
+        """Get existing session or create new one"""
+        if not session_id:
+            session_id = self.create_session()
+        
+        with self.lock:
+            if session_id not in self.sessions:
+                self.sessions[session_id] = ConversationContext(session_id=session_id)
+            
+            session = self.sessions[session_id]
+            session.last_accessed = datetime.now()
+            
+            # Trigger cleanup if needed
+            self._cleanup_expired_sessions()
+            
+            return session
+    
+    def delete_session(self, session_id: str) -> bool:
+        """Delete a specific session"""
+        with self.lock:
+            if session_id in self.sessions:
+                del self.sessions[session_id]
+                return True
+            return False
+    
+    def get_active_session_count(self) -> int:
+        """Get number of active sessions"""
+        with self.lock:
+            return len(self.sessions)
+    
+    def _cleanup_expired_sessions(self):
+        """Remove expired sessions (called periodically)"""
+        now = datetime.now()
+        
+        # Only run cleanup periodically to avoid overhead
+        if now - self.last_cleanup < self.cleanup_interval:
+            return
+        
+        expired_sessions = []
+        for session_id, session in self.sessions.items():
+            if now - session.last_accessed > self.session_timeout:
+                expired_sessions.append(session_id)
+        
+        for session_id in expired_sessions:
+            del self.sessions[session_id]
+        
+        self.last_cleanup = now
+        
+        if expired_sessions:
+            print(f"Cleaned up {len(expired_sessions)} expired sessions")
+
+# Global session manager instance
+session_manager = SessionManager()
+
+def get_session_manager() -> SessionManager:
+    """Get the global session manager instance"""
+    return session_manager

multi_llm_chatbot_backend/app/llm/improved_gemini_client.py

@@ -0,0 +1,106 @@
+import httpx
+import os
+from typing import List
+from app.llm.llm_client import LLMClient
+from app.core.context_manager import get_context_manager
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ImprovedGeminiClient(LLMClient):
+    def __init__(self, model_name: str = None):
+        if model_name is None:
+            model_name = os.getenv("GEMINI_MODEL", "gemini-2.0-flash-exp")
+        
+        self.model_name = model_name
+        self.api_key = os.getenv("GEMINI_API_KEY")
+        if not self.api_key:
+            raise ValueError("GEMINI_API_KEY environment variable is required")
+        
+        self.base_url = "https://generativelanguage.googleapis.com/v1beta/models"
+        self.context_manager = get_context_manager()
+    
+    async def generate(self, system_prompt: str, context: List[dict], temperature: float, max_tokens: int) -> str:
+        """
+        Generate response using improved context management
+        """
+        try:
+            # Use context manager to prepare optimal context window
+            context_window = self.context_manager.prepare_context_for_llm(
+                messages=context,
+                system_prompt=system_prompt,
+                llm_provider="gemini"
+            )
+            
+            logger.debug(f"Context prepared: {len(context_window.messages)} messages, "
+                        f"~{context_window.total_tokens} tokens, truncated={context_window.truncated}")
+            
+            payload = {
+                "contents": context_window.messages,
+                "generationConfig": {
+                    "temperature": temperature,
+                    "topK": 40,
+                    "topP": 0.9,
+                    "maxOutputTokens": max_tokens,
+                    "stopSequences": ["Student:", "Question:", "\n\nStudent:", "\n\nQuestion:"]
+                },
+                "safetySettings": [
+                    {
+                        "category": "HARM_CATEGORY_HARASSMENT",
+                        "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+                    },
+                    {
+                        "category": "HARM_CATEGORY_HATE_SPEECH",
+                        "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+                    },
+                    {
+                        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+                        "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+                    },
+                    {
+                        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+                        "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+                    }
+                ]
+            }
+            
+            url = f"{self.base_url}/{self.model_name}:generateContent?key={self.api_key}"
+            
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response = await client.post(url, json=payload)
+                response.raise_for_status()
+                
+                result = response.json()
+                
+                if "candidates" in result and result["candidates"]:
+                    candidate = result["candidates"][0]
+                    if "content" in candidate and "parts" in candidate["content"]:
+                        text = candidate["content"]["parts"][0].get("text", "")
+                        return self._clean_response(text)
+                
+                # Handle safety filter or other issues
+                if "promptFeedback" in result:
+                    feedback = result["promptFeedback"]
+                    logger.warning(f"Gemini prompt feedback: {feedback}")
+                
+                return "I apologize, but I'm unable to provide a response to that query."
+                
+        except httpx.TimeoutException:
+            logger.error("Gemini API timeout")
+            return "I'm experiencing a delay in processing. Please try again."
+        except httpx.HTTPStatusError as e:
+            logger.error(f"Gemini API HTTP error: {e.response.status_code} - {e.response.text}")
+            return "I'm having trouble accessing the AI service. Please try again."
+        except Exception as e:
+            logger.error(f"Unexpected error in Gemini client: {str(e)}")
+            return "I encountered an unexpected error. Please try again."
+    
+    def _clean_response(self, response: str) -> str:
+        """Clean up response text"""
+        # Remove common issues
+        response = response.strip()
+        
+        # Remove duplicate spaces and normalize
+        response = ' '.join(response.split())
+        
+        return response

multi_llm_chatbot_backend/app/llm/improved_ollama_client.py

@@ -0,0 +1,109 @@
+import httpx
+from typing import List
+from app.llm.llm_client import LLMClient
+from app.core.context_manager import get_context_manager
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ImprovedOllamaClient(LLMClient):
+    def __init__(self, model_name: str = "llama3.2:1b", base_url: str = "http://localhost:11434"):
+        self.model_name = model_name
+        self.base_url = base_url
+        self.context_manager = get_context_manager()
+    
+    async def generate(self, system_prompt: str, context: List[dict], temperature: float, max_tokens: int) -> str:
+        """
+        Generate response using improved context management
+        """
+        try:
+            # Use context manager to prepare optimal context
+            context_window = self.context_manager.prepare_context_for_llm(
+                messages=context,
+                system_prompt=system_prompt,
+                llm_provider="ollama"
+            )
+            
+            logger.debug(f"Context prepared: ~{context_window.total_tokens} tokens, "
+                        f"truncated={context_window.truncated}")
+            
+            # For Ollama, context_window.messages is a formatted prompt string
+            formatted_prompt = context_window.messages
+            
+            payload = {
+                "model": self.model_name,
+                "prompt": formatted_prompt,
+                "stream": False,
+                "options": {
+                    "temperature": temperature,
+                    "top_p": 0.9,
+                    "top_k": 40,
+                    "num_predict": max_tokens,
+                    "repeat_penalty": 1.1,
+                    "stop": ["\n\nStudent:", "\n\nUser:", "Question:", "Student:"]
+                }
+            }
+            
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response = await client.post(f"{self.base_url}/api/generate", json=payload)
+                response.raise_for_status()
+                
+                result = response.json()
+                text = result.get("response", "").strip()
+                
+                return self._clean_response(text)
+                
+        except httpx.ConnectError:
+            logger.error(f"Cannot connect to Ollama at {self.base_url}")
+            return "I'm unable to connect to the local AI service. Please ensure Ollama is running."
+        except httpx.TimeoutException:
+            logger.error("Ollama request timeout")
+            return "The AI service is taking too long to respond. Please try again."
+        except httpx.HTTPStatusError as e:
+            logger.error(f"Ollama HTTP error: {e.response.status_code}")
+            return "The AI service encountered an error. Please try again."
+        except Exception as e:
+            logger.error(f"Unexpected error in Ollama client: {str(e)}")
+            return "I encountered an unexpected error. Please try again."
+    
+    def _clean_response(self, response: str) -> str:
+        """Clean up common response issues"""
+        # Remove common prefixes that indicate AI confusion
+        prefixes_to_remove = [
+            "Here are 2-3 sentence", "Here's an expansion", "Assistant:",
+            "Dr. Methodist:", "Dr. Theorist:", "Dr. Pragmatist:",
+            "Methodist Advisor:", "Theorist Advisor:", "Pragmatist Advisor:",
+        ]
+        
+        for prefix in prefixes_to_remove:
+            if response.startswith(prefix):
+                response = response[len(prefix):].strip()
+        
+        # Remove trailing incomplete sentences
+        sentences = response.split('.')
+        if len(sentences) > 1 and len(sentences[-1].strip()) < 10:
+            response = '.'.join(sentences[:-1]) + '.'
+        
+        # Remove excessive academic fluff
+        fluff_patterns = [
+            "conceptual insights:", "actionable advice:", "my inquisitive student",
+            "excellent question", "thank you for", "assistant!"
+        ]
+        
+        for pattern in fluff_patterns:
+            response = response.replace(pattern, "").strip()
+        
+        # Normalize whitespace
+        response = ' '.join(response.split())
+        
+        return response
+
+    def _is_poor_quality(self, response: str) -> bool:
+        """Check if response quality is poor"""
+        poor_indicators = [
+            "Thank you, Dr." in response,
+            "Assistant:" in response,
+            len(response.split()) > 150,  # Too verbose
+            response.count("?") > 3,  # Too many questions
+        ]
+        return any(poor_indicators)

multi_llm_chatbot_backend/app/main.py

@@ -1,34 +1,42 @@
-# app/main.py
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from app.api.routes import router
+from app.api.routes import router  # This line stays the same!
 from dotenv import load_dotenv
+import logging
 import os
 
-# Load environment variables
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+
 load_dotenv()
 
 app = FastAPI(
     title="Multi-LLM Chatbot Backend",
-    version="0.2"
+    version="1.0.0"  # Updated version
 )
 
-# Add CORS middleware
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["http://localhost:3000"],  # React dev server
+    allow_origins=["http://localhost:3000"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-# Include route definitions
 app.include_router(router)
 
 @app.get("/")
 def root():
     return {
         "message": "Multi-LLM PhD Advisor Backend is up and running",
-        "version": "0.2",
-        "features": ["Ollama Support", "Gemini API Support", "Provider Switching"]
+        "version": "1.0.0",
+        "features": [
+            "Improved Session Management", 
+            "Unified Context Handling",
+            "Ollama Support", 
+            "Gemini API Support", 
+            "Provider Switching"
+        ]
     }