Merge pull request #56 from sohank-17/girish-response-fixes

.gitignore

@@ -4,6 +4,7 @@
 # backend
 multi_llm_chatbot_backend/.env
 multi_llm_chatbot_backend/chroma_db/
+multi_llm_chatbot_backend/chromadb_storage/
 
 # frontend
 

README.md

@@ -4,7 +4,7 @@ An AI-powered academic guidance system that provides personalized advice through
 
 ## Features
 
-- **Multiple AI Advisor Personas**: Chat with specialized advisors including Methodist (methodology expert), Theorist (conceptual frameworks), and Pragmatist (action-focused guidance)
+- **Multiple AI Advisor Personas**: Chat with specialized advisors including Methodologist (methodology expert), Theorist (conceptual frameworks), and Pragmatist (action-focused guidance)
 - **Document Upload Support**: Upload PDFs, Word documents, and text files to provide context for your questions
 - **Multi-LLM Backend**: Supports both Gemini API and Ollama models with seamless provider switching
 - **Real-time Chat Interface**: Modern, responsive chat interface with advisor-specific styling
@@ -83,7 +83,7 @@ The application will open at `http://localhost:3000`
 
 ## Advisor Personas
 
-### Methodist - Research Methodology Expert
+### Methodologist - Research Methodology Expert
 - **Focus**: Research design, validity, sampling, methodological rigor
 - **Style**: Precise, analytical, methodology-focused
 - **Best for**: Research design questions, data collection methods, validity concerns

multi_llm_chatbot_backend/app/api/routes.py

@@ -133,7 +133,7 @@ def _is_valid_response(response: str, persona_id: str) -> bool:
 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?",
+        "methodologist": "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?"
     }
@@ -188,42 +188,64 @@ async def switch_provider(provider_data: ProviderSwitch):
 
 # Main chat endpoint (SAME INTERFACE, improved backend)
 @router.post("/chat-sequential")
-async def chat_sequential(message: ChatMessage, request: Request):
-    """Generate advisor responses - ENHANCED with RAG"""
+async def chat_sequential_enhanced(message: ChatMessage, request: Request):
+    """
+    Enhanced sequential chat with improved document awareness and response quality
+    """
     try:
+        # Get or create session
         session_id = get_or_create_session_for_request(request, message.session_id)
         
-        # Process message through improved orchestrator (now with RAG)
-        result = await chat_orchestrator.process_message(
+        # Process message with enhanced orchestrator
+        orchestrator_result = await chat_orchestrator.process_message_with_enhanced_context(
             user_input=message.user_input,
             session_id=session_id,
             response_length=message.response_length or "medium"
         )
-        
-        # Add RAG information to response
-        if result["type"] == "persona_responses":
-            # Count how many personas used documents
-            personas_with_docs = sum(1 for r in result["responses"] if r.get("used_documents", False))
-            total_chunks_used = sum(r.get("document_chunks_used", 0) for r in result["responses"])
+
+        if orchestrator_result["status"] == "success":
+            responses = orchestrator_result["responses"]
             
-            result["rag_info"] = {
-                "personas_using_documents": personas_with_docs,
-                "total_document_chunks_used": total_chunks_used,
-                "rag_enabled": True
+            # Enhanced RAG information for debugging and user feedback
+            rag_info = {
+                "total_personas": len(responses),
+                "personas_using_documents": sum(1 for r in responses if r.get("used_documents", False)),
+                "total_document_chunks_used": sum(r.get("document_chunks_used", 0) for r in responses),
+                "document_aware_query": orchestrator_result.get("document_references_detected", False),
+                "available_documents": orchestrator_result.get("available_documents", [])
             }
-        
-        return result
-        
+            
+            return {
+                "type": "persona_responses",
+                "responses": responses,
+                "rag_info": rag_info,
+                "session_id": session_id,
+                "query_analysis": {
+                    "document_references_found": orchestrator_result.get("document_references_detected", False),
+                    "personas_with_high_quality_context": [
+                        r["persona_id"] for r in responses 
+                        if r.get("context_quality") == "high"
+                    ]
+                }
+            }
+        else:
+            # Fallback response with helpful guidance
+            return {
+                "type": "clarification_needed",
+                "message": orchestrator_result.get("message", "I need more information to help you effectively."),
+                "suggestions": orchestrator_result.get("suggestions", [
+                    "Could you provide more details about your specific question?",
+                    "Consider uploading relevant documents to get more targeted advice.",
+                    "Try asking about a specific aspect of your research."
+                ]),
+                "session_id": session_id,
+                "rag_info": {"total_personas": 0, "personas_using_documents": 0}
+            }
+
     except Exception as e:
-        logger.error(f"Error in chat-sequential: {str(e)}")
-        return {
-            "type": "error",
-            "message": "I encountered an error processing your request. Please try again.",
-            "error": str(e),
-            "rag_enabled": False
-        }
+        logger.error(f"Error in enhanced sequential chat: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error processing request: {str(e)}")
 
-# Individual advisor endpoint (SAME INTERFACE)
 @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"""
@@ -241,17 +263,33 @@ async def chat_with_specific_advisor(persona_id: str, input: UserInput, request:
             session_id=session_id
         )
         
-        if result["type"] == "single_persona_response":
+        # 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": result.get("message", "I'm having trouble generating a response right now. Please try again.")
+                "response": "I'm having trouble generating a response right now. Please try again."
             }
             
     except HTTPException:
@@ -310,51 +348,37 @@ async def reply_to_advisor(reply: ReplyToAdvisor, request: Request):
 @router.post("/upload-document")
 async def upload_document(file: UploadFile = File(...), request: Request = None):
     """
-    Upload document with RAG integration - ENHANCED VERSION
-    
-    Now documents are:
-    1. Chunked intelligently 
-    2. Embedded and stored in ChromaDB
-    3. Available for semantic retrieval
-    4. NOT stored in session context (saves memory)
+    Enhanced document upload with better metadata tracking and user feedback
     """
-    # 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:
-        # Get session using compatibility layer
+        # Get or create session
         session_id = get_or_create_session_for_request(request)
         session = session_manager.get_session(session_id)
         
-        file_bytes = await file.read()
-
-        # Simple size check
+        # Validate file
         MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
-        if len(file_bytes) > MAX_FILE_SIZE:
-            raise HTTPException(status_code=400, detail="Upload exceeds file size limit (10 MB).")
+        if file.size and file.size > MAX_FILE_SIZE:
+            raise HTTPException(status_code=413, detail="File size exceeds 10MB limit")
 
-        # Extract text content
+        
+        # Read and validate file content
+        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.")
 
-        # Get RAG manager
+        # Get enhanced RAG manager
         rag_manager = get_rag_manager()
         
         # Determine file type for metadata
         file_type_map = {
             "application/pdf": "pdf",
-            "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+            "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx", 
             "text/plain": "txt"
         }
         file_type = file_type_map.get(file.content_type, "unknown")
         
-        # Add document to vector database instead of session context
+        # Add document to enhanced vector database
         rag_result = rag_manager.add_document(
             content=content,
             filename=file.filename,
@@ -363,27 +387,46 @@ async def upload_document(file: UploadFile = File(...), request: Request = None)
         )
         
         if not rag_result["success"]:
-            raise HTTPException(status_code=500, detail=f"Failed to process document: {rag_result.get('error', 'Unknown error')}")
+            raise HTTPException(
+                status_code=500, 
+                detail=f"Failed to process document: {rag_result.get('error', 'Unknown error')}"
+            )
         
-        # Add just the filename to session for tracking (not the full content)
+        # Update session tracking
         session.uploaded_files.append(file.filename)
         session.total_upload_size += len(file_bytes)
         
-        # Add a brief document reference to session messages (not full content)
-        session.append_message("system", f"Document uploaded: {file.filename} ({rag_result['chunks_created']} chunks, {rag_result['total_tokens']} tokens)")
+        # Add enhanced document reference to session messages
+        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}) - "
+            f"{rag_result['chunks_created']} sections processed, "
+            f"~{rag_result['total_tokens']} tokens analyzed. "
+            f"You can now ask questions about this document by referencing it by name."
+        )
 
         return {
-            "message": "Document uploaded and processed successfully.",
+            "message": f"Document '{file.filename}' uploaded and processed successfully.",
             "filename": file.filename,
-            "chunks_created": rag_result["chunks_created"],
-            "total_tokens": rag_result["total_tokens"],
-            "processing_method": "RAG_vector_storage"
+            "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,
+            "suggestions": [
+                f"Try asking: 'What methodology does my {file.filename} propose?'",
+                f"Or: 'What are the key findings in {doc_title}?'",
+                f"Or: 'Compare the approach in my document with current best practices'"
+            ]
         }
 
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Error uploading document: {str(e)}")
+        logger.error(f"Error processing document upload: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Error processing document: {str(e)}")
 
 
@@ -512,7 +555,7 @@ async def search_documents(request: Request, query: str = Body(..., embed=True),
         
         # Get persona context for search enhancement
         persona_contexts = {
-            "methodist": "methodology research design analysis",
+            "methodologist": "methodology research design analysis",
             "theorist": "theory theoretical framework conceptual",
             "pragmatist": "practical application implementation"
         }
@@ -663,6 +706,137 @@ async def chat_with_specific_persona(persona_id: str, message: ChatMessage, requ
             "message": f"Error chatting with {persona_id}: {str(e)}",
             "persona_id": persona_id
         }
+    
+@router.get("/debug/enhanced-personas")
+async def debug_enhanced_personas(request: Request):
+    """
+    Enhanced debug endpoint with document context information
+    """
+    try:
+        session_id = get_or_create_session_for_request(request)
+        session = session_manager.get_session(session_id)
+        
+        # Get enhanced RAG statistics
+        rag_manager = get_rag_manager()
+        rag_stats = rag_manager.get_document_stats(session_id)
+        
+        # Analyze document awareness capabilities
+        document_analysis = {}
+        if rag_stats.get("documents"):
+            for doc in rag_stats["documents"]:
+                document_analysis[doc["filename"]] = {
+                    "chunks_available": doc["chunks"],
+                    "estimated_tokens": doc["estimated_tokens"],
+                    "sections_identified": doc["sections"],
+                    "content_types_detected": {
+                        "has_methodology": doc.get("has_methodology", False),
+                        "has_theory": doc.get("has_theory", False),
+                        "has_references": doc.get("has_references", False)
+                    }
+                }
+        
+        return {
+            "personas": {
+                pid: {
+                    "name": persona.name,
+                    "expertise_area": persona.name.split(" - ")[1] if " - " in persona.name else "General",
+                    "prompt_quality": "enhanced" if len(persona.system_prompt) > 500 else "basic",
+                    "document_handling_enabled": "document awareness" in persona.system_prompt.lower(),
+                    "retrieval_keywords": chat_orchestrator._get_enhanced_persona_context_keywords(pid)[:100] + "...",
+                    "temperature": getattr(persona, 'temperature', 5)
+                } for pid, persona in chat_orchestrator.personas.items()
+            },
+            "session_info": {
+                "context_length": len(session.messages),
+                "uploaded_files": session.uploaded_files,
+                "rag_stats": rag_stats,
+                "document_analysis": document_analysis
+            },
+            "system_capabilities": {
+                "document_name_recognition": True,
+                "cross_document_analysis": True,
+                "persona_specialized_retrieval": True,
+                "enhanced_attribution": True,
+                "query_document_detection": True
+            },
+            "current_provider": current_provider,
+            "rag_enabled": True,
+            "enhancement_level": "advanced"
+        }
+    except Exception as e:
+        logger.error(f"Error in enhanced debug endpoint: {str(e)}")
+        return {
+            "error": str(e),
+            "enhancement_level": "error",
+            "rag_enabled": False
+        }
+
+@router.get("/document-insights/{filename}")
+async def get_document_insights(filename: str, request: Request):
+    """
+    NEW ENDPOINT: Get insights about a specific uploaded document
+    """
+    try:
+        session_id = get_or_create_session_for_request(request)
+        rag_manager = get_rag_manager()
+        
+        # Get document statistics
+        stats = rag_manager.get_document_stats(session_id)
+        
+        # Find the specific document
+        document_info = None
+        for doc in stats.get("documents", []):
+            if doc["filename"] == filename:
+                document_info = doc
+                break
+        
+        if not document_info:
+            raise HTTPException(status_code=404, detail=f"Document {filename} not found")
+        
+        # Get a sample of content from this document
+        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,
+            "suggested_queries": [
+                f"What methodology does my {filename} propose?",
+                f"What are the key theoretical concepts in {filename}?",
+                f"What are the main findings in my {document_info.get('title', filename)}?",
+                f"How can I improve the approach described in {filename}?"
+            ]
+        }
+        
+    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)}")
 
 # Also add a debug endpoint to check RAG status:
 

multi_llm_chatbot_backend/app/api/routes_old.py

@@ -95,7 +95,7 @@ def _is_valid_response(response: str, persona_id: str) -> bool:
 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?",
+        "methodologist": "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?"
     }

multi_llm_chatbot_backend/app/core/context_manager.py

@@ -167,7 +167,7 @@ class ContextManager:
                     "role": "user",
                     "parts": [{"text": content}]
                 })
-            elif role in ['assistant', 'methodist', 'theorist', 'pragmatist']:
+            elif role in ['assistant', 'methodologist', 'theorist', 'pragmatist']:
                 formatted.append({
                     "role": "model",
                     "parts": [{"text": content}]

multi_llm_chatbot_backend/app/core/improved_orchestrator.py

@@ -14,7 +14,7 @@ logger = logging.getLogger(__name__)
 
 class ImprovedChatOrchestrator:
     """
-    Improved orchestrator with proper session management and context handling
+    Enhanced orchestrator with document awareness and improved context handling
     """
     
     def __init__(self):
@@ -55,159 +55,155 @@ class ImprovedChatOrchestrator:
             if needs_clarification:
                 # Generate clarification question
                 clarification = await self._generate_clarification_question(session)
-                session.append_message("orchestrator", clarification)
+                session.append_message("system", f"Clarification request: {clarification}")
                 
                 return {
-                    "type": "clarification",
-                    "session_id": session.session_id,
+                    "status": "clarification_needed",
                     "message": clarification,
-                    "context_summary": self.context_manager.get_context_summary(session.messages)
+                    "suggestions": self._get_clarification_suggestions(),
+                    "session_id": session.session_id
                 }
             
             # Generate responses from all personas
             responses = await self._generate_persona_responses(session, response_length)
             
             return {
-                "type": "persona_responses",
-                "session_id": session.session_id,
+                "status": "success",
                 "responses": responses,
-                "context_summary": self.context_manager.get_context_summary(session.messages)
+                "session_id": session.session_id
             }
             
         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.",
+                "status": "error",
+                "message": "I'm having technical difficulties. 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]:
+
+    async def process_message_with_enhanced_context(self, user_input: str, session_id: str, response_length: str = "medium"):
         """
-        Chat with a specific persona - ENHANCED WITH RAG
+        Enhanced message processing with document awareness and better context management
         """
         try:
-            if persona_id not in self.personas:
-                return {
-                    "type": "error",
-                    "message": f"Persona '{persona_id}' not found"
-                }
-            
-            # Get or create session
+            # Get session
             session = self.session_manager.get_session(session_id)
             
-            # Add user message
+            # Add user message to session
             session.append_message("user", user_input)
             
-            # Generate response from specific persona with RAG
-            persona = self.personas[persona_id]
-            response = await self._generate_single_persona_response(session, persona, response_length)
+            # Detect document references in the query
+            document_references = self._extract_document_references_from_query(user_input)
             
-            # Add persona response to session
-            session.append_message(persona_id, response['response'])
+            # Get available documents for this session
+            rag_manager = get_rag_manager()
+            doc_stats = rag_manager.get_document_stats(session_id)
+            available_documents = [doc["filename"] for doc in doc_stats.get("documents", [])]
+            
+            # Generate enhanced persona responses
+            responses = await self._generate_persona_responses(session, response_length)
             
             return {
-                "type": "single_persona_response",
-                "session_id": session.session_id,
-                "persona": response,
-                "context_summary": self.context_manager.get_context_summary(session.messages),
-                "rag_info": {
-                    "used_documents": response.get("used_documents", False),
-                    "document_chunks_used": response.get("document_chunks_used", 0)
-                }
+                "status": "success",
+                "responses": responses,
+                "document_references_detected": bool(document_references),
+                "available_documents": available_documents,
+                "session_id": session_id
             }
             
         except Exception as e:
-            logger.error(f"Error in chat_with_persona: {str(e)}")
+            logger.error(f"Error in enhanced message processing: {str(e)}")
             return {
-                "type": "error",
-                "session_id": session_id,
-                "message": "I encountered an error generating a response. Please try again.",
-                "error": str(e)
+                "status": "error", 
+                "message": "I'm having technical difficulties processing your request.",
+                "suggestions": ["Please try rephrasing your question.", "Check if your documents uploaded successfully."]
             }
+
+    def _extract_document_references_from_query(self, query: str) -> List[str]:
+        """Extract document references from user query"""
+        query_lower = query.lower()
+        references = []
+        
+        # Common document reference patterns
+        patterns = [
+            r"(?:my|the|in)\s+([a-zA-Z_\-]+\.(?:pdf|docx|txt))",  # specific files
+            r"(?:my|the)\s+(dissertation|thesis|proposal|chapter|manuscript)",  # document types
+            r"(?:in|from)\s+(?:my\s+)?([a-zA-Z_\-\s]+(?:chapter|section))",  # sections
+        ]
+        
+        for pattern in patterns:
+            matches = re.findall(pattern, query_lower)
+            references.extend(matches)
+        
+        return references[:3]  # Limit to first 3 references
     
-    def _needs_clarification(self, session, user_input: str) -> bool:
+    def _needs_clarification(self, session: ConversationContext, user_input: str) -> bool:
         """
-        Determine if we need clarification - SIMPLIFIED VERSION
+        Determine if the user input needs clarification
         """
-        try:
-            # Simple heuristics for clarification
-            if len(user_input.strip()) < 10:
-                return True
-            
-            # Check if it's a greeting or very general question
-            greeting_words = ['hi', 'hello', 'hey', 'good morning', 'good afternoon']
-            if any(word in user_input.lower() for word in greeting_words):
-                return True
-            
-            # Very vague questions
-            vague_words = ['help', 'advice', 'what should i do', 'i need help']
-            if len([word for word in vague_words if word in user_input.lower()]) > 0 and len(user_input.split()) < 8:
-                return True
-            
+        # If this is not the first message, probably don't need clarification
+        user_messages = [msg for msg in session.messages if msg.get('role') == 'user']
+        if len(user_messages) > 1:
             return False
-            
-        except Exception as e:
-            logger.error(f"Error in clarification check: {str(e)}")
-            return False  # Default to no clarification needed
+        
+        # Check for vague patterns
+        vague_patterns = [
+            r"^(help|advice|guidance|assistance)$",
+            r"i'?m (stuck|lost|confused|not sure)",
+            r"(what should i|how do i|where do i start)",
+            r"i need (help|advice|guidance)",
+            r"(any|some) (advice|suggestions|ideas)"
+        ]
+        
+        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 and vague
+        if len(user_input.split()) < 6 and not any(
+            keyword in user_lower for keyword in 
+            ['methodology', 'theory', 'data', 'analysis', 'research', 'thesis', 'dissertation']
+        ):
+            return True
+        
+        return False
     
     async def _generate_clarification_question(self, session: ConversationContext) -> str:
         """
-        Generate a clarification question based on context
+        Generate a clarification question based on the conversation 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?"
+        # Simple clarification questions based on common PhD needs
+        clarification_options = [
+            "What specific aspect of your PhD research would you like guidance on?",
+            "Are you looking for help with methodology, theory, writing, or something else?",
+            "What stage of your PhD program are you currently in?",
+            "What's the main challenge you're facing with your research right now?"
+        ]
+        
+        # Return the first option for now (could be made smarter with AI)
+        return clarification_options[0]
+    
+    def _get_clarification_suggestions(self) -> List[str]:
+        """Get suggestions for clarification"""
+        return [
+            "Ask about research methodology or design",
+            "Get help with theoretical frameworks",
+            "Request guidance on practical next steps",
+            "Upload a document for specific feedback"
+        ]
     
-    async def _generate_persona_responses(self, session, response_length: str = "medium"):
+    async def _generate_persona_responses(self, session: ConversationContext, response_length: str = "medium"):
         """
-        Generate responses from all personas with RAG integration
-        
-        Each persona gets persona-specific document retrieval for more targeted responses
+        Generate responses from all personas with enhanced RAG integration
         """
         responses = []
         
         for persona_id, persona in self.personas.items():
-            logger.info(f"Generating response for {persona_id} with RAG")
+            logger.info(f"Generating response for {persona_id} with enhanced RAG")
             
-            # Generate persona response with RAG
+            # Generate persona response with enhanced RAG
             response_data = await self._generate_single_persona_response(session, persona, response_length)
             
             # Add persona response to session context
@@ -219,25 +215,21 @@ class ImprovedChatOrchestrator:
     
     async def _generate_single_persona_response(self, session, persona, response_length: str = "medium"):
         """
-        Generate response from a single persona with RAG-enhanced context - FIXED VERSION
+        Enhanced version - Generate response from a single persona with enhanced RAG integration
         """
         try:
-            # Get conversation context (recent messages only for efficiency)
-            recent_messages = session.messages[-5:] if len(session.messages) > 5 else session.messages
-            
             # Get the user's latest message for document retrieval
             user_message = ""
             try:
-                # Use the new method to get latest user message
                 user_message = session.get_latest_user_message() or ""
             except AttributeError:
                 # Fallback: manually find latest user message
-                for msg in reversed(recent_messages):
+                for msg in reversed(session.messages):
                     if msg.get('role') == 'user':
                         user_message = msg.get('content', '')
                         break
             
-            # Retrieve relevant document context using RAG
+            # Retrieve relevant document context using enhanced RAG
             document_context = ""
             if user_message:
                 document_context = await self._retrieve_relevant_documents(
@@ -247,68 +239,298 @@ class ImprovedChatOrchestrator:
                 )
             
             # Build enhanced context for the LLM
-            enhanced_context = []
-            
-            # Add document context at the beginning if available
-            if document_context:
-                enhanced_context.append({
-                    "role": "system",
-                    "content": f"{document_context}Based on the above document context and conversation history, please respond as {persona.name}."
-                })
-            
-            # Add recent conversation messages
-            enhanced_context.extend(recent_messages)
+            enhanced_context = await self._build_enhanced_context_for_persona(
+                session, persona, user_message, document_context
+            )
             
             # Generate response with enhanced context
             response = await persona.respond(enhanced_context, response_length)
             
-            # Validate response
+            # Validate and improve response quality
             if not self._is_valid_response(response, persona.id):
                 logger.warning(f"Invalid response from {persona.id}, using fallback")
-                response = self._get_fallback_response(persona.id)
+                response = self._get_persona_fallback(persona.id)
+            
+            # Track document usage for debugging
+            used_documents = bool(document_context and len(document_context.strip()) > 100)
+            document_chunks_used = document_context.count("[Source:") if document_context else 0
             
             return {
                 "persona_id": persona.id,
                 "persona_name": persona.name,
                 "response": response,
-                "error": False,
-                "used_documents": bool(document_context),
-                "document_chunks_used": document_context.count("[Document") if document_context else 0
+                "used_documents": used_documents,
+                "document_chunks_used": document_chunks_used,
+                "response_length": response_length,
+                "context_quality": "high" if document_context else "conversation_only"
             }
             
         except Exception as e:
-            logger.error(f"Error in _generate_single_persona_response for {persona.id}: {str(e)}")
+            logger.error(f"Error generating response for {persona.id}: {str(e)}")
             return {
                 "persona_id": persona.id,
                 "persona_name": persona.name,
-                "response": self._get_fallback_response(persona.id),
-                "error": True,
+                "response": f"I apologize, but I'm having technical difficulties. {self._get_persona_fallback(persona.id)}",
                 "used_documents": False,
-                "document_chunks_used": 0
+                "document_chunks_used": 0,
+                "response_length": response_length,
+                "context_quality": "error"
             }
+
+    async def _retrieve_relevant_documents(self, user_input: str, session_id: str, persona_id: str = "") -> str:
+        """
+        Enhanced document retrieval with document awareness and better attribution
+        """
+        try:
+            rag_manager = get_rag_manager()
+            
+            # Extract document hints from user query
+            document_hint = self._extract_document_hint_from_query(user_input)
+            
+            # Get persona-specific context for better retrieval
+            persona_context = self._get_enhanced_persona_context_keywords(persona_id)
+            
+            # Search for relevant chunks with document awareness
+            relevant_chunks = rag_manager.search_documents_with_context(
+                query=user_input,
+                session_id=session_id,
+                persona_context=persona_context,
+                n_results=6,  # Increased for better context
+                document_hint=document_hint
+            )
+            
+            logger.info(f"Retrieved {len(relevant_chunks)} chunks for {persona_id}")
+            
+            if not relevant_chunks:
+                logger.info(f"No relevant documents found for query: {user_input[:50]}...")
+                return ""
+            
+            # Format retrieved content with enhanced attribution
+            return self._format_document_context_with_attribution(relevant_chunks, persona_id)
+            
+        except Exception as e:
+            logger.error(f"Error retrieving documents for {persona_id}: {str(e)}")
+            return ""
+
+    def _extract_document_hint_from_query(self, query: str) -> Optional[str]:
+        """
+        Extract document name hints from user queries
+        """
+        query_lower = query.lower()
+        
+        # Common patterns for document references
+        document_indicators = [
+            r"(?:my|the|in|from)\s+([a-zA-Z_\-]+\.(?:pdf|docx|txt|doc))",  # specific files
+            r"(?:my|the)\s+(dissertation|thesis|proposal|chapter|manuscript|paper)",  # document types
+            r"(?:in|from)\s+(?:my\s+)?([a-zA-Z_\-\s]+(?:chapter|section|proposal))",  # sections
+            r"(?:the|my)\s+([a-zA-Z_\-\s]+(?:document|file))",  # generic documents
+        ]
+        
+        for pattern in document_indicators:
+            matches = re.findall(pattern, query_lower)
+            if matches:
+                return matches[0].strip().replace(" ", "_")
+        
+        return None
+
+    def _get_enhanced_persona_context_keywords(self, persona_id: str) -> str:
+        """
+        Enhanced persona-specific keywords for better document retrieval
+        """
+        enhanced_keywords = {
+            "methodologist": "methodology research design experimental approach data collection sampling validity reliability statistical analysis quantitative qualitative mixed-methods procedures protocol IRB ethics",
+            "theorist": "theory theoretical framework conceptual model literature review philosophy epistemology ontology paradigm abstract concepts hypothesis proposition postulate axiom",
+            "pragmatist": "practical application implementation action steps next steps recommendation solution strategy timeline concrete advice roadmap execution deliverables milestones"
+        }
+        return enhanced_keywords.get(persona_id, "")
+
+    def _format_document_context_with_attribution(self, chunks: List[Dict], persona_id: str) -> str:
+        """
+        Format document context with clear attribution and source information
+        """
+        if not chunks:
+            return ""
+        
+        # Filter chunks by relevance (increased threshold for quality)
+        high_quality_chunks = [
+            chunk for chunk in chunks 
+            if chunk.get("relevance_score", 0) > 0.4  # Increased from 0.3
+        ]
+        
+        if not high_quality_chunks:
+            # If no high-quality chunks, take top 2 anyway but with lower confidence
+            high_quality_chunks = chunks[:2]
+        
+        formatted_sections = []
+        
+        # Group chunks by document for better organization
+        documents = {}
+        for chunk in high_quality_chunks:
+            doc_source = chunk.get("document_source", {})
+            filename = doc_source.get("filename", "unknown")
+            
+            if filename not in documents:
+                documents[filename] = {
+                    "title": doc_source.get("document_title", filename),
+                    "chunks": []
+                }
+            documents[filename]["chunks"].append(chunk)
+        
+        # Format each document's content
+        for filename, doc_data in documents.items():
+            doc_title = doc_data["title"]
+            doc_chunks = doc_data["chunks"]
+            
+            formatted_sections.append(f"=== FROM DOCUMENT: {doc_title} ===")
+            
+            for i, chunk in enumerate(doc_chunks):
+                doc_source = chunk.get("document_source", {})
+                section = doc_source.get("section", "unknown section")
+                position = doc_source.get("chunk_position", "unknown position")
+                relevance = chunk.get("relevance_score", 0)
+                
+                chunk_intro = f"[Source: {section}, Part {position}, Relevance: {relevance:.2f}]"
+                formatted_sections.append(f"{chunk_intro}\n{chunk['text']}\n")
+        
+        # Add context summary
+        total_docs = len(documents)
+        total_chunks = len(high_quality_chunks)
+        
+        context_header = f"""
+DOCUMENT CONTEXT FOR {persona_id.upper()} ANALYSIS:
+Found {total_chunks} relevant passages from {total_docs} document(s).
+Use this context to inform your response, and cite specific documents when referencing information.
+
+"""
+        
+        formatted_context = context_header + "\n".join(formatted_sections)
+        
+        # Add instructions specific to persona
+        persona_instructions = self._get_persona_document_instructions(persona_id)
+        formatted_context += f"\n\nSPECIAL INSTRUCTIONS FOR {persona_id.upper()}:\n{persona_instructions}"
+        
+        return formatted_context
+
+    def _get_persona_document_instructions(self, persona_id: str) -> str:
+        """
+        Get persona-specific instructions for handling document context
+        """
+        instructions = {
+            "methodologist": """
+When analyzing the document context:
+- Focus on methodological rigor and research design elements
+- Identify potential validity threats or methodological gaps
+- Suggest specific improvements to research procedures
+- Reference exact methodological frameworks mentioned in their documents
+- Connect their approach to established research standards""",
+            
+            "theorist": """
+When analyzing the document context:
+- Examine theoretical positioning and conceptual clarity
+- Identify theoretical gaps or inconsistencies
+- Suggest theoretical frameworks that align with their work
+- Evaluate the coherence between theory and research questions
+- Reference specific theoretical concepts mentioned in their documents""",
+            
+            "pragmatist": """
+When analyzing the document context:
+- Extract actionable next steps from their current progress
+- Identify immediate bottlenecks or decision points
+- Prioritize tasks based on their timeline and constraints
+- Translate theoretical concepts into practical implementation steps
+- Reference specific deadlines or milestones mentioned in their documents"""
+        }
+        
+        return instructions.get(persona_id, "Provide helpful guidance based on the document context.")
+
+    async def _build_enhanced_context_for_persona(self, session, persona, user_message: str, document_context: str) -> List[Dict[str, str]]:
+        """
+        Build enhanced context that properly integrates document information with conversation history
+        FIXED VERSION - No document hallucination when no documents exist
+        """
+        enhanced_context = []
+    
+        # Get recent conversation history (last 6 messages for efficiency)
+        recent_messages = session.messages[-6:] if len(session.messages) > 6 else session.messages
+        
+        # Check if we actually have meaningful document content
+        has_documents = bool(document_context and document_context.strip() and len(document_context.strip()) > 50)
+        
+        # Build the system message with proper document awareness
+        if has_documents:
+            # Get list of uploaded documents
+            uploaded_docs = session.uploaded_files if hasattr(session, 'uploaded_files') else []
+            doc_list = ", ".join(uploaded_docs) if uploaded_docs else "uploaded documents"
+            
+            system_message = f"""{persona.system_prompt}
+
+    CURRENT SESSION CONTEXT:
+    The student has uploaded the following documents: {doc_list}
+
+    {document_context}
+
+    IMPORTANT: When the student refers to "my document," "my dissertation," "my proposal," etc., they are referring to one of their uploaded documents. Use the document context above to understand which specific document they mean and reference it by name in your response.
+
+    Always cite your sources when referencing information from their documents using the format: "According to your [document_name]..." or "In your [section_name] from [document_name]..."
+    """
+            
+            enhanced_context.append({
+                "role": "system",
+                "content": system_message
+            })
+        else:
+            # NO DOCUMENTS - Explicitly tell persona not to reference documents
+            system_message = f"""{persona.system_prompt}
+
+    IMPORTANT: The student has NOT uploaded any documents yet. Do not reference any specific documents, files, or assume you have access to their research materials.
+
+    If they mention "my document," "my dissertation," "my proposal," etc., you should:
+    1. Acknowledge that you don't have access to their specific documents
+    2. Ask them to upload the relevant files for more targeted advice
+    3. Provide general guidance based on best practices in your area of expertise
+
+    Do NOT make up document names or pretend to have access to files that don't exist."""
+            
+            enhanced_context.append({
+                "role": "system", 
+                "content": system_message
+            })
+        
+        # Add recent conversation history
+        for message in recent_messages:
+            if message.get('role') in ['user', 'assistant']:
+                enhanced_context.append({
+                    "role": message['role'],
+                    "content": message['content']
+                })
+        
+        # Add current user message
+        enhanced_context.append({
+            "role": "user",
+            "content": user_message
+        })
+        
+        return enhanced_context
     
     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
+        if len(response) < 10 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()}:",
+            f"Dr. {persona_id.title()} Advisor:",
             "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"""
+    def _get_persona_fallback(self, persona_id: str) -> str:
+        """Get persona-specific fallback responses"""
         fallbacks = {
-            "methodist": "Let's focus on your research methodology. What specific methodological approach are you considering?",
+            "methodologist": "I'd be happy to help with 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?"
         }
@@ -340,74 +562,42 @@ class ImprovedChatOrchestrator:
         """Delete a session completely"""
         return self.session_manager.delete_session(session_id)
     
+    # Legacy method for backward compatibility
     def _get_persona_context_keywords(self, persona_id: str) -> str:
         """
-        Get persona-specific keywords for enhanced document retrieval
-        
-        This ensures each advisor gets the most relevant document chunks
-        based on their specialization
+        Legacy method - use _get_enhanced_persona_context_keywords instead
         """
-        persona_keywords = {
-            "methodist": "methodology research design analysis methods data collection sampling validity reliability statistical approach quantitative qualitative",
-            "theorist": "theory theoretical framework conceptual model literature review philosophy epistemology ontology paradigm abstract concepts",
-            "pragmatist": "practical application implementation action steps next steps recommendation solution strategy timeline concrete advice"
-        }
-        return persona_keywords.get(persona_id, "")
+        return self._get_enhanced_persona_context_keywords(persona_id)
     
-    async def _retrieve_relevant_documents(self, user_input: str, session_id: str, persona_id: str = "") -> str:
+    async def chat_with_persona(self, persona_id: str, user_input: str, session_id: str, response_length: str = "medium") -> Dict[str, Any]:
         """
-        Retrieve relevant document chunks using RAG - FIXED VERSION
+        Chat with a specific persona directly
         """
         try:
-            rag_manager = get_rag_manager()
-            
-            # Get persona-specific context for better retrieval
-            persona_context = self._get_persona_context_keywords(persona_id)
+            persona = self.get_persona(persona_id)
+            if not persona:
+                return {
+                    "error": f"Persona {persona_id} not found",
+                    "available_personas": list(self.personas.keys())
+                }
             
-            # Search for relevant chunks
-            relevant_chunks = rag_manager.search_documents(
-                query=user_input,
-                session_id=session_id,
-                persona_context=persona_context,
-                n_results=3  # Limit to top 3 most relevant chunks
-            )
+            session = self.session_manager.get_session(session_id)
+            session.append_message("user", user_input)
             
-            logger.info(f"Retrieved {len(relevant_chunks)} total chunks for {persona_id}")
+            # Generate response from single persona
+            response_data = await self._generate_single_persona_response(session, persona, response_length)
             
-            if not relevant_chunks:
-                logger.info(f"No relevant documents found for query: {user_input[:50]}...")
-                return ""
+            # Add response to session
+            session.append_message(persona_id, response_data["response"])
             
-            # Format retrieved content - LOWERED THRESHOLD
-            context_parts = []
-            for i, chunk in enumerate(relevant_chunks, 1):
-                filename = chunk["metadata"].get("filename", "Unknown")
-                relevance = chunk["relevance_score"]
-                distance = chunk.get("distance", "unknown")
-                text = chunk["text"]
-                
-                logger.info(f"Chunk {i} for {persona_id}: relevance={relevance:.3f}, distance={distance}")
-                
-                # LOWERED threshold from 0.3 to 0.1 to allow more chunks through
-                if relevance > 0.1:
-                    context_parts.append(
-                        f"[Document {i}: {filename} (relevance: {relevance:.3f})]\n{text[:500]}..."  # Limit text length
-                    )
-                    logger.info(f"Including chunk {i} for {persona_id} (relevance: {relevance:.3f})")
-                else:
-                    logger.info(f"Excluding chunk {i} for {persona_id} (relevance too low: {relevance:.3f})")
-            
-            if context_parts:
-                retrieved_context = "\n\n".join(context_parts)
-                logger.info(f"Using {len(context_parts)} relevant chunks for {persona_id}")
-                return f"RELEVANT DOCUMENT CONTEXT:\n{retrieved_context}\n\n"
-            
-            logger.info(f"No chunks met relevance threshold for {persona_id}")
-            return ""
+            return response_data
             
         except Exception as e:
-            logger.error(f"Error retrieving documents for {persona_id}: {str(e)}")
-            return ""
+            logger.error(f"Error in chat_with_persona: {str(e)}")
+            return {
+                "error": f"Error processing request: {str(e)}",
+                "persona_id": persona_id
+            }
         
 
     async def get_top_personas(self, session_id: str, k: int = 3) -> List[str]:

multi_llm_chatbot_backend/app/core/rag_manager.py

@@ -453,17 +453,501 @@ class RAGManager:
         except Exception as e:
             return {"status": "error", "message": str(e)}
 
+
+class EnhancedRAGManager:
+    def __init__(self, persist_directory: str = "./chromadb_storage"):
+        """Initialize enhanced RAG manager with improved document handling"""
+        self.persist_directory = persist_directory
+        Path(persist_directory).mkdir(exist_ok=True)
+        
+        # Initialize ChromaDB client
+        self.client = chromadb.PersistentClient(
+            path=persist_directory,
+            settings=Settings(anonymized_telemetry=False)
+        )
+        
+        # Create or get collection
+        self.collection = self.client.get_or_create_collection(
+            name="phd_advisor_documents",
+            metadata={"hnsw:space": "cosine"}
+        )
+        
+        logger.info(f"Enhanced RAG Manager initialized with collection: {self.collection.name}")
+    
+    def add_document(self, content: str, filename: str, session_id: str, 
+                    file_type: str = "unknown") -> Dict[str, Any]:
+        """
+        Enhanced document addition with better metadata and document awareness
+        """
+        try:
+            # Preprocess the content
+            cleaned_content = self._preprocess_content(content)
+            if not cleaned_content.strip():
+                return {
+                    "success": False,
+                    "error": "Document content is empty after preprocessing",
+                    "filename": filename
+                }
+            
+            # Extract document metadata
+            doc_metadata = self._extract_document_metadata(cleaned_content, filename, file_type)
+            
+            # Create intelligent chunks with overlap and context preservation
+            chunks = self._create_enhanced_chunks(cleaned_content, filename, doc_metadata)
+            
+            # Prepare data for ChromaDB
+            chunk_texts = []
+            chunk_metadatas = []
+            chunk_ids = []
+            
+            for i, chunk_data in enumerate(chunks):
+                chunk_id = f"{session_id}_{filename}_{i}_{uuid.uuid4().hex[:8]}"
+                
+                # Enhanced metadata with document awareness
+                metadata = {
+                    "session_id": session_id,
+                    "filename": filename,
+                    "file_type": file_type,
+                    "chunk_index": i,
+                    "total_chunks": len(chunks),
+                    "document_section": chunk_data.get("section", "unknown"),
+                    "keywords": chunk_data.get("keywords", ""),
+                    "chunk_type": chunk_data.get("type", "content"),
+                    "document_title": doc_metadata.get("title", filename),
+                    "estimated_tokens": len(chunk_data["text"].split()) * 1.3,
+                    "has_references": "references" in chunk_data["text"].lower(),
+                    "has_methodology": "method" in chunk_data["text"].lower(),
+                    "has_theory": any(word in chunk_data["text"].lower() 
+                                    for word in ["theory", "theoretical", "framework", "concept"])
+                }
+                
+                chunk_texts.append(chunk_data["text"])
+                chunk_metadatas.append(metadata)
+                chunk_ids.append(chunk_id)
+            
+            # Add to ChromaDB
+            self.collection.add(
+                documents=chunk_texts,
+                metadatas=chunk_metadatas,
+                ids=chunk_ids
+            )
+            
+            total_tokens = sum(metadata["estimated_tokens"] for metadata in chunk_metadatas)
+            
+            logger.info(f"Successfully added document {filename}: {len(chunks)} chunks, ~{total_tokens:.0f} tokens")
+            
+            return {
+                "success": True,
+                "filename": filename,
+                "chunks_created": len(chunks),
+                "total_tokens": int(total_tokens),
+                "document_metadata": doc_metadata
+            }
+            
+        except Exception as e:
+            logger.error(f"Error adding document {filename}: {str(e)}")
+            return {
+                "success": False,
+                "filename": filename,
+                "error": str(e)
+            }
+    
+    def search_documents_with_context(self, query: str, session_id: str, 
+                                    persona_context: str = "", n_results: int = 5,
+                                    document_hint: str = None) -> List[Dict[str, Any]]:
+        """
+        Enhanced search with document awareness and context
+        """
+        try:
+            # Extract potential document references from query
+            document_references = self._extract_document_references(query)
+            
+            # Build enhanced query
+            enhanced_query = self._build_enhanced_query(query, persona_context, document_references)
+            
+            # Base search filters
+            search_filters = {"session_id": session_id}
+            
+            # If specific document mentioned, prioritize it
+            if document_hint or document_references:
+                priority_filename = document_hint or document_references[0] if document_references else None
+                if priority_filename:
+                    # First search: prioritize specific document
+                    priority_results = self._search_with_filters(
+                        enhanced_query, 
+                        {**search_filters, "filename": {"$contains": priority_filename}},
+                        n_results=min(3, n_results)
+                    )
+                    
+                    # Second search: get additional context from other documents
+                    remaining_results = max(0, n_results - len(priority_results))
+                    if remaining_results > 0:
+                        general_results = self._search_with_filters(
+                            enhanced_query,
+                            search_filters,
+                            n_results=remaining_results + 2  # Get extras to filter out duplicates
+                        )
+                        
+                        # Combine results, avoiding duplicates
+                        all_results = priority_results + [
+                            r for r in general_results 
+                            if r["metadata"]["filename"] != priority_filename
+                        ][:remaining_results]
+                    else:
+                        all_results = priority_results
+                else:
+                    all_results = self._search_with_filters(enhanced_query, search_filters, n_results)
+            else:
+                all_results = self._search_with_filters(enhanced_query, search_filters, n_results)
+            
+            # Enhance results with context and attribution
+            enhanced_results = self._enhance_search_results(all_results, query)
+            
+            logger.info(f"Enhanced search returned {len(enhanced_results)} results for query: {query[:50]}...")
+            return enhanced_results
+            
+        except Exception as e:
+            logger.error(f"Error in enhanced document search: {str(e)}")
+            return []
+    
+    def _search_with_filters(self, query: str, filters: Dict, n_results: int) -> List[Dict[str, Any]]:
+        """Helper method for filtered search"""
+        results = self.collection.query(
+            query_texts=[query],
+            n_results=n_results,
+            where=filters
+        )
+        
+        formatted_results = []
+        if results['documents'] and results['documents'][0]:
+            for i, (doc, metadata, distance) in enumerate(zip(
+                results['documents'][0],
+                results['metadatas'][0],
+                results['distances'][0]
+            )):
+                similarity_score = 1 / (1 + abs(distance)) if distance is not None else 0.5
+                
+                formatted_results.append({
+                    "text": doc,
+                    "metadata": metadata,
+                    "relevance_score": similarity_score,
+                    "distance": distance,
+                    "rank": i + 1
+                })
+        
+        return formatted_results
+    
+    def _extract_document_references(self, query: str) -> List[str]:
+        """Extract potential document name references from user query"""
+        # Common patterns for document references
+        patterns = [
+            r"(?:my|the|in)\s+([a-zA-Z_\-]+\.(?:pdf|docx|txt|doc))",  # my document.pdf
+            r"(?:my|the)\s+(dissertation|thesis|proposal|chapter|paper|manuscript)",  # my dissertation
+            r"(?:in|from)\s+(?:my\s+)?([a-zA-Z_\-\s]+(?:chapter|section|proposal))",  # in my methodology chapter
+            r"(?:the|my)\s+([a-zA-Z_\-\s]+(?:document|file))",  # the research document
+        ]
+        
+        references = []
+        query_lower = query.lower()
+        
+        for pattern in patterns:
+            matches = re.findall(pattern, query_lower)
+            references.extend(matches)
+        
+        # Clean up references
+        cleaned_references = []
+        for ref in references:
+            cleaned = ref.strip().replace(" ", "_")
+            if len(cleaned) > 2:  # Avoid single characters
+                cleaned_references.append(cleaned)
+        
+        return cleaned_references[:3]  # Limit to first 3 references
+    
+    def _build_enhanced_query(self, original_query: str, persona_context: str, 
+                            document_refs: List[str]) -> str:
+        """Build enhanced query with context and document awareness"""
+        query_parts = [original_query]
+        
+        if persona_context:
+            query_parts.append(persona_context)
+        
+        if document_refs:
+            query_parts.extend(document_refs)
+        
+        return " ".join(query_parts)
+    
+    def _enhance_search_results(self, results: List[Dict], original_query: str) -> List[Dict[str, Any]]:
+        """Enhance search results with better attribution and context"""
+        enhanced = []
+        
+        for result in results:
+            metadata = result["metadata"]
+            
+            # Create enhanced result with clear attribution
+            enhanced_result = {
+                **result,
+                "document_source": {
+                    "filename": metadata.get("filename", "unknown"),
+                    "document_title": metadata.get("document_title", metadata.get("filename", "unknown")),
+                    "section": metadata.get("document_section", "unknown"),
+                    "chunk_position": f"{metadata.get('chunk_index', 0) + 1} of {metadata.get('total_chunks', 1)}"
+                },
+                "content_type": metadata.get("chunk_type", "content"),
+                "context_indicators": {
+                    "has_methodology": metadata.get("has_methodology", False),
+                    "has_theory": metadata.get("has_theory", False),
+                    "has_references": metadata.get("has_references", False)
+                }
+            }
+            
+            enhanced.append(enhanced_result)
+        
+        # Sort by relevance score, but boost results from explicitly mentioned documents
+        enhanced.sort(key=lambda x: (
+            1.0 if any(ref in x["document_source"]["filename"].lower() 
+                      for ref in self._extract_document_references(original_query)) else 0.0,
+            x["relevance_score"]
+        ), reverse=True)
+        
+        return enhanced
+    
+    def _extract_document_metadata(self, content: str, filename: str, file_type: str) -> Dict[str, Any]:
+        """Extract metadata from document content"""
+        lines = content.split('\n')
+        
+        # Try to find title (usually first significant line)
+        title = filename
+        for line in lines[:10]:
+            if line.strip() and len(line.strip()) > 10 and len(line.strip()) < 100:
+                if not line.strip().startswith(('Abstract', 'Introduction', '1.', 'Chapter')):
+                    title = line.strip()
+                    break
+        
+        # Extract other metadata
+        word_count = len(content.split())
+        has_sections = bool(re.search(r'(?:Chapter|Section|\d+\.)', content))
+        
+        return {
+            "title": title,
+            "word_count": word_count,
+            "has_sections": has_sections,
+            "file_type": file_type,
+            "estimated_pages": word_count // 250  # Rough estimate
+        }
+    
+    def _create_enhanced_chunks(self, content: str, filename: str, doc_metadata: Dict) -> List[Dict[str, Any]]:
+        """Create intelligent chunks with context preservation"""
+        # Split into logical sections first
+        sections = self._split_into_sections(content)
+        
+        chunks = []
+        for section_data in sections:
+            section_text = section_data["text"]
+            section_type = section_data["type"]
+            
+            # Create overlapping chunks within each section
+            if len(section_text.split()) > 300:  # Large section, needs chunking
+                section_chunks = self._create_overlapping_chunks(section_text, chunk_size=250, overlap=50)
+                for chunk_text in section_chunks:
+                    chunks.append({
+                        "text": chunk_text,
+                        "section": section_type,
+                        "type": "content",
+                        "keywords": self._extract_keywords(chunk_text)
+                    })
+            else:
+                # Small section, keep as single chunk
+                chunks.append({
+                    "text": section_text,
+                    "section": section_type,
+                    "type": section_type,
+                    "keywords": self._extract_keywords(section_text)
+                })
+        
+        return chunks
+    
+    def _split_into_sections(self, content: str) -> List[Dict[str, Any]]:
+        """Split content into logical sections"""
+        lines = content.split('\n')
+        sections = []
+        current_section = []
+        current_type = "introduction"
+        
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            
+            # Check if this line starts a new section
+            section_match = re.match(r'(?:Chapter|Section|\d+\.?\s+)(.+)', line, re.IGNORECASE)
+            if section_match:
+                # Save previous section
+                if current_section:
+                    sections.append({
+                        "text": '\n'.join(current_section),
+                        "type": current_type
+                    })
+                
+                # Start new section
+                current_section = [line]
+                section_title = section_match.group(1).lower()
+                current_type = self._classify_section_type(section_title)
+            else:
+                current_section.append(line)
+        
+        # Add final section
+        if current_section:
+            sections.append({
+                "text": '\n'.join(current_section),
+                "type": current_type
+            })
+        
+        return sections if sections else [{"text": content, "type": "content"}]
+    
+    def _classify_section_type(self, section_title: str) -> str:
+        """Classify section type based on title"""
+        title_lower = section_title.lower()
+        
+        if any(word in title_lower for word in ['method', 'approach', 'design', 'procedure']):
+            return "methodology"
+        elif any(word in title_lower for word in ['theory', 'framework', 'literature', 'review']):
+            return "theory"
+        elif any(word in title_lower for word in ['result', 'finding', 'analysis', 'data']):
+            return "results"
+        elif any(word in title_lower for word in ['conclusion', 'discussion', 'implication']):
+            return "conclusion"
+        elif any(word in title_lower for word in ['introduction', 'background', 'abstract']):
+            return "introduction"
+        else:
+            return "content"
+    
+    def _create_overlapping_chunks(self, text: str, chunk_size: int = 250, overlap: int = 50) -> List[str]:
+        """Create overlapping chunks from text"""
+        words = text.split()
+        chunks = []
+        
+        start = 0
+        while start < len(words):
+            end = min(start + chunk_size, len(words))
+            chunk = ' '.join(words[start:end])
+            chunks.append(chunk)
+            
+            if end >= len(words):
+                break
+            
+            start += chunk_size - overlap
+        
+        return chunks
+    
+    def _extract_keywords(self, text: str) -> str:
+        """Extract key terms from text chunk"""
+        # Simple keyword extraction - could be enhanced with NLP
+        words = text.lower().split()
+        
+        # Academic keywords to prioritize
+        academic_terms = set([
+            'methodology', 'theory', 'analysis', 'research', 'study', 'data',
+            'framework', 'approach', 'method', 'findings', 'results', 'literature',
+            'hypothesis', 'experiment', 'survey', 'interview', 'observation',
+            'qualitative', 'quantitative', 'mixed-methods', 'case study'
+        ])
+        
+        found_keywords = [word for word in words if word in academic_terms]
+        return ' '.join(found_keywords[:5])  # Top 5 keywords
+    
+    def _preprocess_content(self, content: str) -> str:
+        """Clean and preprocess document content"""
+        # Remove excessive whitespace
+        content = re.sub(r'\s+', ' ', content)
+        
+        # Remove page numbers and headers/footers
+        content = re.sub(r'\n\s*\d+\s*\n', '\n', content)
+        
+        # Clean up encoding issues
+        content = content.replace('\ufffd', ' ')
+        
+        return content.strip()
+    
+    def get_document_stats(self, session_id: str) -> Dict[str, Any]:
+        """Get enhanced statistics about documents in a session"""
+        try:
+            # Get all chunks for this session
+            results = self.collection.get(
+                where={"session_id": session_id},
+                include=["metadatas"]
+            )
+            
+            if not results['metadatas']:
+                return {"total_chunks": 0, "total_documents": 0, "documents": []}
+            
+            # Analyze documents
+            documents = {}
+            total_tokens = 0
+            
+            for metadata in results['metadatas']:
+                filename = metadata.get('filename', 'unknown')
+                
+                if filename not in documents:
+                    documents[filename] = {
+                        "filename": filename,
+                        "title": metadata.get('document_title', filename),
+                        "file_type": metadata.get('file_type', 'unknown'),
+                        "chunks": 0,
+                        "estimated_tokens": 0,
+                        "sections": set(),
+                        "has_methodology": False,
+                        "has_theory": False,
+                        "has_references": False
+                    }
+                
+                doc_info = documents[filename]
+                doc_info["chunks"] += 1
+                doc_info["estimated_tokens"] += metadata.get('estimated_tokens', 0)
+                doc_info["sections"].add(metadata.get('document_section', 'unknown'))
+                
+                if metadata.get('has_methodology'):
+                    doc_info["has_methodology"] = True
+                if metadata.get('has_theory'):
+                    doc_info["has_theory"] = True
+                if metadata.get('has_references'):
+                    doc_info["has_references"] = True
+                
+                total_tokens += metadata.get('estimated_tokens', 0)
+            
+            # Convert sets to lists for JSON serialization
+            for doc_info in documents.values():
+                doc_info["sections"] = list(doc_info["sections"])
+            
+            return {
+                "total_chunks": len(results['metadatas']),
+                "total_documents": len(documents),
+                "total_estimated_tokens": int(total_tokens),
+                "documents": list(documents.values())
+            }
+            
+        except Exception as e:
+            logger.error(f"Error getting document stats: {str(e)}")
+            return {"error": str(e), "total_chunks": 0, "total_documents": 0}
+
+
 # Global RAG manager instance
 _rag_manager = None
 
-def get_rag_manager() -> RAGManager:
-    """Get the global RAG manager instance"""
+# def get_rag_manager() -> RAGManager:
+#     """Get the global RAG manager instance"""
+#     global _rag_manager
+#     if _rag_manager is None:
+#         try:
+#             _rag_manager = RAGManager()
+#             logger.info("RAG Manager initialized successfully")
+#         except Exception as e:
+#             logger.error(f"Failed to initialize RAG Manager: {e}")
+#             raise
+#     return _rag_manager
+
+def get_rag_manager() -> EnhancedRAGManager:
+    """Get or create the global RAG manager instance"""
     global _rag_manager
     if _rag_manager is None:
-        try:
-            _rag_manager = RAGManager()
-            logger.info("RAG Manager initialized successfully")
-        except Exception as e:
-            logger.error(f"Failed to initialize RAG Manager: {e}")
-            raise
+        _rag_manager = EnhancedRAGManager()
     return _rag_manager

multi_llm_chatbot_backend/app/llm/gemini_client.py

@@ -113,8 +113,8 @@ class GeminiClient(LLMClient):
         """Clean up Gemini responses"""
         # Remove common prefixes that indicate AI confusion
         prefixes_to_remove = [
-            "Dr. Methodist:", "Dr. Theorist:", "Dr. Pragmatist:",
-            "Methodist Advisor:", "Theorist Advisor:", "Pragmatist Advisor:",
+            "Dr. Methodologist:", "Dr. Theorist:", "Dr. Pragmatist:",
+            "Methodologist Advisor:", "Theorist Advisor:", "Pragmatist Advisor:",
             "As Dr.", "Here's my response:", "Response:", "Assistant:",
             "Here are 2-3 sentence", "Here's an expansion of the advice:",
         ]

multi_llm_chatbot_backend/app/llm/improved_ollama_client.py

@@ -71,8 +71,8 @@ class ImprovedOllamaClient(LLMClient):
         # 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:",
+            "Dr. Methodologist:", "Dr. Theorist:", "Dr. Pragmatist:",
+            "Methodologist Advisor:", "Theorist Advisor:", "Pragmatist Advisor:",
         ]
         
         for prefix in prefixes_to_remove:

multi_llm_chatbot_backend/app/llm/short_ollama_client.py

@@ -62,8 +62,8 @@ class ShortResponseOllamaClient(LLMClient):
         # Remove common prefixes
         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:",
+            "Dr. Methodologist:", "Dr. Theorist:", "Dr. Pragmatist:",
+            "Methodologist Advisor:", "Theorist Advisor:", "Pragmatist Advisor:",
         ]
         
         for prefix in prefixes_to_remove:

multi_llm_chatbot_backend/app/models/default_personas.py

@@ -2,20 +2,117 @@ from app.models.persona import Persona
 
 # Registry of default personas
 DEFAULT_PERSONAS = {
-    "methodist": {
-        "name": "Methodical Advisor",
-        "system_prompt": "You are a highly methodical PhD advisor. Provide organized, step-by-step guidance with strong structure and clarity.",
-        "default_temperature": 5
+    "methodologist": {
+        "name": "Methodologist",
+        "system_prompt": """You are a distinguished PhD advisor and Research Methodology Expert with 15+ years of experience guiding doctoral students across multiple disciplines. You hold a PhD in Research Methods and Statistics from Stanford University.
+
+**YOUR EXPERTISE:**
+- Quantitative and qualitative research design
+- Mixed-methods approaches and triangulation
+- Statistical analysis and data validation
+- Research ethics and IRB protocols
+- Sampling strategies and validity frameworks
+- Systematic reviews and meta-analyses
+
+**YOUR RESPONSE STYLE:**
+- Be precise and analytical, with clear methodological reasoning
+- Always ground advice in established research principles
+- Provide step-by-step guidance for complex methodological decisions
+- Include specific examples and cite relevant methodological frameworks
+- Ask clarifying questions about research design when needed
+
+**DOCUMENT HANDLING (when documents are available):**
+- Reference uploaded documents by name when discussing their work
+- Extract and analyze methodological approaches from their documents
+- Compare their current methodology against best practices
+- Identify gaps or weaknesses in their research design
+- Provide clear citations: "Based on your [document_name], I notice..."
+
+**INTERACTION GUIDELINES:**
+- Address methodological rigor without being overwhelming
+- Balance theoretical frameworks with practical implementation
+- Help them understand WHY certain methods are appropriate
+- Connect methodology to their specific research questions and field
+- Emphasize validity, reliability, and ethical considerations""",
+        "default_temperature": 4
     },
     "theorist": {
-        "name": "Theorist Advisor",
-        "system_prompt": "You are a philosophical PhD advisor who focuses on abstract theories and big-picture thinking.",
-        "default_temperature": 8
+        "name": "Theorist - Theoretical Frameworks Specialist",
+        "system_prompt": """You are a renowned PhD advisor and Theoretical Frameworks Specialist with deep expertise in epistemology, conceptual development, and philosophical foundations of research. You hold a PhD in Philosophy of Science from Oxford University.
+
+**YOUR EXPERTISE:**
+- Epistemological and ontological foundations
+- Theoretical framework development and selection
+- Literature synthesis and conceptual mapping
+- Paradigmatic positioning (positivist, interpretivist, critical, pragmatic)
+- Theory building and model development
+- Philosophical underpinnings of research approaches
+- Conceptual clarity and definitional precision
+
+**YOUR RESPONSE STYLE:**
+- Engage with deep intellectual rigor and philosophical depth
+- Help students think critically about underlying assumptions
+- Guide theoretical exploration without being overly abstract
+- Connect theoretical concepts to practical research implications
+- Encourage reflection on epistemological positioning
+- Build conceptual bridges between different theoretical traditions
+
+**DOCUMENT HANDLING (when documents are available):**
+- Analyze theoretical positioning in their literature reviews
+- Identify conceptual gaps and theoretical contributions
+- Evaluate philosophical consistency across their work
+- Suggest theoretical frameworks that align with their research questions
+- Reference their work: "Your theoretical framework in [document_name] draws from..."
+
+**INTERACTION GUIDELINES:**
+- Foster deep thinking about theoretical foundations
+- Help students articulate their epistemological stance
+- Guide them through complex theoretical landscapes
+- Encourage synthesis of multiple theoretical perspectives
+- Emphasize the importance of theoretical coherence
+- Make abstract concepts accessible and actionable
+- Challenge assumptions constructively""",
+        "default_temperature": 7
     },
     "pragmatist": {
-        "name": "Pragmatist Advisor",
-        "system_prompt": "You are a practical PhD advisor who gives real-world, actionable advice focused on utility and outcomes.",
-        "default_temperature": 4
+        "name": "Pragmatist - Action-Focused Research Coach",
+        "system_prompt": """You are an energetic and results-oriented PhD advisor specializing in turning research plans into actionable progress. With a PhD in Applied Psychology from UC Berkeley and 12+ years of mentoring experience, you're known for helping students overcome analysis paralysis and make consistent progress.
+
+**YOUR EXPERTISE:**
+- Project management and timeline development
+- Breaking complex research into manageable tasks
+- Overcoming research roadblocks and motivation challenges
+- Practical implementation of research plans
+- Resource management and efficiency optimization
+- Writing strategies and productivity systems
+- Career development and professional networking
+
+**YOUR RESPONSE STYLE:**
+- Warm, encouraging, and motivational tone
+- Focus on practical, immediately implementable advice
+- Break down overwhelming tasks into smaller, manageable steps
+- Emphasize progress over perfection
+- Provide specific deadlines and accountability markers
+- Celebrate small wins and maintain momentum
+- Ask about practical constraints and real-world limitations
+
+**DOCUMENT HANDLING (when documents are available):**
+- Transform document analysis into actionable next steps
+- Create concrete timelines based on their current progress
+- Find immediate action items in their research materials
+- Convert theoretical frameworks into practical research steps
+- Reference their work: "Looking at your [document_name], I suggest..."
+
+**INTERACTION GUIDELINES:**
+- Always end with specific, actionable next steps
+- Help them prioritize when facing multiple options
+- Address emotional and motivational aspects of research
+- Provide realistic timelines and expectations
+- Focus on sustainable progress strategies
+- Encourage them to start with what they can control
+- Offer practical solutions to common PhD challenges
+- Maintain optimism while being realistic about challenges""",
+        "default_temperature": 5
     }
 }
 

multi_llm_chatbot_backend/app/tests/debug_rag.py

@@ -16,7 +16,7 @@ def test_direct_search():
     print("🔍 Testing direct document search...")
     
     test_queries = [
-        {"query": "research methodology approach", "persona": "methodist"},
+        {"query": "research methodology approach", "persona": "methodologist"},
         {"query": "theoretical framework theory", "persona": "theorist"},
         {"query": "practical steps implementation", "persona": "pragmatist"}
     ]
@@ -55,7 +55,7 @@ def test_single_persona_chat():
     """Test individual persona chat to isolate issues"""
     print("\n💬 Testing individual persona chat...")
     
-    personas = ["methodist", "theorist", "pragmatist"]
+    personas = ["methodologist", "theorist", "pragmatist"]
     query = "What research methodology should I use based on the uploaded document?"
     
     for persona in personas:

multi_llm_chatbot_backend/app/tests/test_rag_system.py

@@ -65,7 +65,7 @@ def test_rag_system():
     print("🔍 Test 3: Testing direct document search...")
     
     search_queries = [
-        {"query": "What methodology should I use?", "persona": "methodist"},
+        {"query": "What methodology should I use?", "persona": "methodologist"},
         {"query": "What is the theoretical framework?", "persona": "theorist"},
         {"query": "What are the next steps?", "persona": "pragmatist"}
     ]

phd-advisor-frontend/src/data/advisors.js

@@ -1,9 +1,10 @@
 import { BookOpen, Target, Brain } from 'lucide-react';
 
 export const advisors = {
-  methodist: {
-    name: 'Methodist',
-    role: 'Methodical Advisor',
+  methodologist: {
+    // Original structure preserved
+    name: 'Methodologist',
+    role: 'Research Methodology Expert',
     // Light theme colors
     color: '#3B82F6',
     bgColor: '#EFF6FF',
@@ -12,11 +13,58 @@ export const advisors = {
     darkBgColor: '#1E3A8A',
     // Icon and description
     icon: BookOpen,
-    description: 'Structured & Planning-focused'
+    description: 'Structured & Planning-focused',
+    
+    // Enhanced information added
+    fullTitle: 'Methodologist - Research Methodology Expert',
+    credentials: 'PhD in Research Methods and Statistics from Stanford University',
+    experience: '15+ years of experience guiding doctoral students',
+    
+    specialties: [
+      'Quantitative & Qualitative Research Design',
+      'Statistical Analysis & Data Validation', 
+      'Research Ethics & IRB Protocols',
+      'Mixed-Methods Approaches',
+      'Systematic Reviews & Meta-Analyses'
+    ],
+    
+    expertise: {
+      primary: 'Research Methodology',
+      secondary: ['Statistical Analysis', 'Research Design', 'Data Collection'],
+      documentTypes: ['methodology chapters', 'research proposals', 'data analysis plans'],
+      strengths: [
+        'Methodological rigor assessment',
+        'Validity and reliability guidance', 
+        'Statistical approach optimization',
+        'Research ethics consultation'
+      ]
+    },
+    
+    personality: {
+      tone: 'Precise and analytical',
+      approach: 'Systematic, evidence-based guidance',
+      communicationStyle: 'Clear, structured, methodically reasoned',
+      documentHandling: 'Analyzes methodological approaches and identifies design improvements'
+    },
+    
+    sampleQuestions: [
+      "What methodology does my research proposal suggest?",
+      "How can I improve the validity of my study design?", 
+      "What sampling strategy would work best for my research?",
+      "Are there any methodological gaps in my approach?"
+    ],
+    
+    responseStyle: {
+      length: 'Detailed with step-by-step guidance',
+      structure: 'Organized with clear methodological reasoning',
+      citations: 'References established research principles and frameworks'
+    }
   },
+
   theorist: {
+    // Original structure preserved
     name: 'Theorist',
-    role: 'Theoretical Advisor',
+    role: 'Theoretical Frameworks Specialist',
     // Light theme colors
     color: '#8B5CF6',
     bgColor: '#F3E8FF',
@@ -25,11 +73,58 @@ export const advisors = {
     darkBgColor: '#581C87',
     // Icon and description
     icon: Brain,
-    description: 'Abstract & Conceptual'
+    description: 'Abstract & Conceptual',
+    
+    // Enhanced information added
+    fullTitle: 'Theorist - Theoretical Frameworks Specialist',
+    credentials: 'PhD in Philosophy of Science from Oxford University',
+    experience: 'Deep expertise in epistemology and conceptual development',
+    
+    specialties: [
+      'Epistemological & Ontological Foundations',
+      'Theoretical Framework Development',
+      'Literature Synthesis & Conceptual Mapping',
+      'Philosophy of Science',
+      'Theory Building & Model Development'
+    ],
+    
+    expertise: {
+      primary: 'Theoretical Frameworks',
+      secondary: ['Conceptual Development', 'Literature Synthesis', 'Philosophical Foundations'],
+      documentTypes: ['literature reviews', 'theoretical chapters', 'conceptual frameworks'],
+      strengths: [
+        'Theoretical positioning guidance',
+        'Conceptual clarity development',
+        'Epistemological stance articulation',
+        'Literature synthesis strategy'
+      ]
+    },
+    
+    personality: {
+      tone: 'Intellectually rigorous and philosophically deep',
+      approach: 'Explores theoretical foundations and conceptual relationships',
+      communicationStyle: 'Thoughtful, reflective, theoretically grounded',
+      documentHandling: 'Analyzes theoretical positioning and identifies conceptual gaps'
+    },
+    
+    sampleQuestions: [
+      "What theoretical framework best fits my research?",
+      "How do I position my work within existing literature?",
+      "What are the philosophical assumptions in my approach?",
+      "How can I strengthen my conceptual foundation?"
+    ],
+    
+    responseStyle: {
+      length: 'Comprehensive with deep theoretical exploration',
+      structure: 'Builds from foundational concepts to specific applications',
+      citations: 'References major theoretical traditions and philosophers'
+    }
   },
+
   pragmatist: {
+    // Original structure preserved
     name: 'Pragmatist',
-    role: 'Practical Advisor',
+    role: 'Action-Focused Research Coach',
     // Light theme colors
     color: '#10B981',
     bgColor: '#ECFDF5',
@@ -38,11 +133,56 @@ export const advisors = {
     darkBgColor: '#065F46',
     // Icon and description
     icon: Target,
-    description: 'Real-world & Outcome-focused'
+    description: 'Real-world & Outcome-focused',
+    
+    // Enhanced information added
+    fullTitle: 'Pragmatist - Action-Focused Research Coach',
+    credentials: 'PhD in Applied Psychology from UC Berkeley',
+    experience: '12+ years of mentoring experience specializing in practical progress',
+    
+    specialties: [
+      'Project Management & Timeline Development',
+      'Research Implementation Strategies',
+      'Productivity & Workflow Optimization',
+      'Academic Career Development',
+      'Overcoming Research Roadblocks'
+    ],
+    
+    expertise: {
+      primary: 'Practical Implementation',
+      secondary: ['Project Management', 'Productivity Systems', 'Career Development'],
+      documentTypes: ['research timelines', 'progress reports', 'implementation plans'],
+      strengths: [
+        'Task prioritization and planning',
+        'Productivity system design',
+        'Motivation and momentum building',
+        'Real-world constraint navigation'
+      ]
+    },
+    
+    personality: {
+      tone: 'Warm, encouraging, and motivational',
+      approach: 'Focuses on practical, immediately implementable advice',
+      communicationStyle: 'Energetic, supportive, action-oriented',
+      documentHandling: 'Transforms analysis into concrete next steps and timelines'
+    },
+    
+    sampleQuestions: [
+      "What should be my next immediate steps?",
+      "How can I prioritize my research tasks?",
+      "What's a realistic timeline for my project?",
+      "How do I overcome analysis paralysis?"
+    ],
+    
+    responseStyle: {
+      length: 'Concise with clear action items',
+      structure: 'Always ends with specific, actionable next steps',
+      citations: 'References practical examples and success strategies'
+    }
   }
 };
 
-// Helper function to get theme-appropriate colors
+// Helper function to get theme-appropriate colors (preserved exactly)
 export const getAdvisorColors = (advisorId, isDark = false) => {
   const advisor = advisors[advisorId];
   if (!advisor) return { color: '#6B7280', bgColor: '#F3F4F6' };
@@ -51,10 +191,53 @@ export const getAdvisorColors = (advisorId, isDark = false) => {
     color: isDark ? advisor.darkColor : advisor.color,
     bgColor: isDark ? advisor.darkBgColor : advisor.bgColor,
     // For text that needs to be readable on colored backgrounds
-    textColor: isDark ? '#F9FAFB' : 
-                advisor.color === '#10B981' ? '#047857' : // Darker green for pragmatist
-                advisor.color === '#3B82F6' ? '#1D4ED8' : // Darker blue for methodist  
-                advisor.color === '#8B5CF6' ? '#7C3AED' : // Darker purple for theorist
-                '#374151' // fallback
+    textColor: isDark ? '#F9FAFB' :
+      advisor.color === '#10B981' ? '#047857' : // Darker green for pragmatist
+      advisor.color === '#3B82F6' ? '#1D4ED8' : // Darker blue for methodologist
+      advisor.color === '#8B5CF6' ? '#7C3AED' : // Darker purple for theorist
+      '#374151' // fallback
   };
+};
+
+// Additional helper functions for enhanced functionality
+export const getAdvisorById = (id) => {
+  return advisors[id];
+};
+
+export const getAdvisorSpecialties = (id) => {
+  const advisor = getAdvisorById(id);
+  return advisor ? advisor.specialties : [];
+};
+
+export const getAdvisorExpertise = (id) => {
+  const advisor = getAdvisorById(id);
+  return advisor ? advisor.expertise : {};
+};
+
+export const getDocumentHandlingInfo = (id) => {
+  const advisor = getAdvisorById(id);
+  return advisor?.personality?.documentHandling || 'Provides general guidance based on uploaded documents';
+};
+
+export const getSampleQuestionsForDocuments = (id) => {
+  const advisor = getAdvisorById(id);
+  return advisor?.sampleQuestions || [];
+};
+
+export const getAdvisorDocumentTypes = (id) => {
+  const advisor = getAdvisorById(id);
+  return advisor?.expertise?.documentTypes || [];
+};
+
+// Backward compatibility: get advisor list as array (if needed elsewhere)
+export const getAdvisorsList = () => {
+  return Object.entries(advisors).map(([id, advisor]) => ({
+    id,
+    ...advisor
+  }));
+};
+
+// Get advisor IDs for iteration
+export const getAdvisorIds = () => {
+  return Object.keys(advisors);
 };