cite-agent 1.3.6__py3-none-any.whl → 1.3.7__py3-none-any.whl

src/services/research_service/chatbot.py

@@ -1,2056 +0,0 @@
-import asyncio
-import logging
-from typing import List, Dict, Optional
-from datetime import datetime, timezone
-import os
-from src.services.llm_service.api_clients.llm_chat_client import LLMChatClient
-from src.services.llm_service.api_clients.llm_doc_client import LLMDcClient
-from src.services.llm_service.llm_manager import LLMManager
-from src.services.research_service.context_manager import ResearchContextManager
-from src.services.research_service.synthesizer import ResearchSynthesizer
-from src.services.graph.knowledge_graph import KnowledgeGraph
-from src.storage.db.operations import DatabaseOperations
-from dotenv import load_dotenv
-load_dotenv(".env.local")
-import random
-import re
-import sys
-import time
-
-# Configure logging
-logger = logging.getLogger(__name__)
-
-class TypingEffect:
-    """Simulate human-like typing effect for chatbot responses."""
-    
-    def __init__(self, speed=0.03, pause_chars=['.', '!', '?', ',', ';', ':']):
-        self.speed = speed
-        self.pause_chars = pause_chars
-    
-    async def type_message(self, message: str, stream=True):
-        """Type out a message with realistic timing."""
-        if not stream:
-            return message
-        
-        typed_message = ""
-        for char in message:
-            typed_message += char
-            print(char, end='', flush=True)
-            
-            # Add longer pauses for punctuation
-            if char in self.pause_chars:
-                await asyncio.sleep(self.speed * 3)
-            else:
-                await asyncio.sleep(self.speed)
-        
-        print()  # New line at the end
-        return typed_message
-    
-    def type_message_simple(self, message: str, stream=True):
-        """Simpler typing effect for when async isn't available."""
-        if not stream:
-            print(message)
-            return message
-        
-        for char in message:
-            print(char, end='', flush=True)
-            time.sleep(self.speed)
-        print()
-        return message
-
-class ConversationContext:
-    """Track conversation context for better responses."""
-    
-    def __init__(self):
-        self.topics_discussed = []
-        self.user_interests = set()
-        self.conversation_style = "neutral"
-        self.depth_preference = "balanced"
-        self.questions_asked = []
-        self.research_readiness = 0.0
-    
-    def update(self, user_message: str, bot_response: str):
-        """Update context based on conversation."""
-        # Extract and track topics
-        new_topics = self._extract_topics(user_message)
-        self.topics_discussed.extend(new_topics)
-        
-        # Detect user's preferred style
-        if "?" in user_message:
-            self.questions_asked.append(user_message)
-        
-        # Adjust conversation style based on patterns
-        if len(user_message.split()) > 50:
-            self.depth_preference = "detailed"
-        elif len(user_message.split()) < 10:
-            self.depth_preference = "concise"
-        
-        # Update research readiness
-        self._update_research_readiness(user_message)
-    
-    def get_style_guidelines(self) -> str:
-        """Get style guidelines based on context."""
-        guidelines = []
-        
-        if self.depth_preference == "detailed":
-            guidelines.append("Provide thorough, detailed responses")
-        elif self.depth_preference == "concise":
-            guidelines.append("Keep responses focused and concise")
-        
-        if len(self.questions_asked) > 3:
-            guidelines.append("User is curious - encourage exploration")
-        
-        if self.research_readiness > 0.7:
-            guidelines.append("User seems ready for deeper research")
-        
-        return "\n".join(guidelines)
-    
-    def _extract_topics(self, user_message: str) -> list:
-        """Extract topics from user message."""
-        # Simple keyword extraction
-        words = user_message.lower().split()
-        # Filter for meaningful words (length > 4, not common words)
-        topics = [w for w in words if len(w) > 4 and w not in 
-                 ['about', 'would', 'could', 'should', 'there', 'where']]
-        return topics[:3]  # Top 3 topics
-    
-    def _update_research_readiness(self, user_message: str):
-        """Update research readiness score."""
-        # Increase readiness if research-related terms appear
-        research_indicators = ['research', 'study', 'papers', 'literature', 
-                              'investigate', 'explore', 'deep dive']
-        
-        if any(term in user_message.lower() for term in research_indicators):
-            self.research_readiness = min(self.research_readiness + 0.2, 1.0)
-        
-        # Also increase based on conversation depth
-        if len(self.questions_asked) > 2:
-            self.research_readiness = min(self.research_readiness + 0.1, 1.0)
-
-class ChatbotResearchSession:
-    """Full-featured CLI chatbot for research planning and execution with parallel web search and projection."""
-    def __init__(self, context_manager=None, synthesizer=None, db_ops=None, user_profile: Optional[Dict] = None):
-        # Initialize with fallback mode detection
-        self.fallback_mode = False  # Force real mode
-        self.context_manager = context_manager
-        self.synthesizer = synthesizer
-        self.db_ops = db_ops
-        
-        # Initialize typing effect
-        self.typing_effect = TypingEffect(speed=0.02)  # Slightly faster for better UX
-        
-        # Force real mode - don't check dependencies
-        logger.info("Forcing real research mode - using actual research capabilities")
-        print("🔬 Running in REAL research mode with academic database access")
-        
-        self.history: List[Dict] = []
-        self.context: Dict = {}
-        self.user_profile = user_profile or {"name": "User"}
-        self.created_at = datetime.now(timezone.utc)
-        self.active = True
-        self.session_id = None
-        self.research_plan = None
-        self.status = None
-        self.synthesis = None
-        self.topic = None
-        self.questions = []
-        self.last_bot_message = ""
-        
-        # Initialize clients for real research
-        try:
-            self.chat_client = LLMChatClient()
-            self.doc_client = LLMDcClient()
-            logger.info("LLM clients initialized successfully")
-        except Exception as e:
-            logger.error("LLM client initialization failed; real mode is required for launch", exc_info=True)
-            raise RuntimeError(
-                "LLM stack failed to initialize. Configure the required provider credentials "
-                "(e.g., CEREBRAS_API_KEY) and network access before launching the chatbot."
-            ) from e
-        
-        # New attributes for parallel web search and projection
-        self.parallel_web_context = []
-        self.research_proposed = False
-        self.projection_given = False
-        self.research_approved = False
-        self.context_tracker = ConversationContext()
-
-        import random
-        self.random = random
-
-    def _is_research_query(self, message: str) -> bool:
-        """Detect if the message is a research query."""
-        message_lower = message.lower()
-        
-        # Research keywords
-        research_keywords = [
-            'research', 'study', 'find', 'search', 'explore', 'investigate',
-            'analyze', 'examine', 'look into', 'find out about', 'what is',
-            'how does', 'why does', 'latest', 'recent', 'developments',
-            'advances', 'breakthroughs', 'innovations', 'technology',
-            'papers', 'articles', 'studies', 'literature'
-        ]
-        
-        # Check if message contains research keywords
-        has_research_keywords = any(keyword in message_lower for keyword in research_keywords)
-        
-        # Check if message is long enough to be a research query
-        is_long_enough = len(message.split()) > 3
-        
-        # Check if message contains a topic (not just a greeting)
-        is_not_greeting = not any(greeting in message_lower for greeting in ['hello', 'hi', 'hey', 'how are you'])
-        
-        return has_research_keywords and is_long_enough and is_not_greeting
-
-    async def _perform_real_research(self, user_message: str) -> str:
-        """Perform real academic research using the enhanced research service."""
-        try:
-            print("🔍 Starting REAL comprehensive research...")
-            
-            # Use the enhanced research service for deep analysis
-            from src.services.research_service.enhanced_research import enhanced_research_service
-            
-            # Extract the actual research topic from the message
-            research_topic = self._extract_research_topic(user_message)
-            
-            print(f"📝 Research Topic: {research_topic}")
-            print("⏳ Performing comprehensive research with analysis...")
-            
-            # Perform comprehensive research
-            results = await enhanced_research_service.research_topic(
-                query=research_topic,
-                max_results=20  # Go deeper
-            )
-            
-            if results and not results.get('error'):
-                # Format comprehensive results
-                response = self._format_comprehensive_research_response(results, research_topic)
-                print("✅ Comprehensive research completed!")
-                return response
-            else:
-                # Fallback to basic search if enhanced research fails
-                print("⚠️  Enhanced research failed, falling back to basic search...")
-                return await self._perform_basic_research(user_message)
-            
-        except Exception as e:
-            print(f"❌ Error in comprehensive research: {e}")
-            return await self._perform_basic_research(user_message)
-
-    def _extract_research_topic(self, message: str) -> str:
-        """Extract the actual research topic from user message."""
-        # More intelligent topic extraction
-        topic = message.lower()
-        
-        # Remove common research request words but preserve the core topic
-        research_words = [
-            'research', 'study', 'analyze', 'analysis', 'comprehensive', 'detailed', 
-            'thorough', 'perform', 'conduct', 'find', 'latest', 'developments', 
-            'breakthroughs', 'papers', 'sources', 'go deep', 'deep', 'at least',
-            'proper', 'citations', 'quality assessment', 'synthesis', 'i want',
-            'detailed analysis of', 'content synthesis', 'and quality assessment'
-        ]
-        
-        for word in research_words:
-            topic = topic.replace(word, '')
-        
-        # Remove numbers that are likely not part of the topic
-        import re
-        topic = re.sub(r'\b\d+\b', '', topic)  # Remove standalone numbers
-        
-        # Clean up and return
-        topic = ' '.join(topic.split())  # Remove extra spaces
-        topic = topic.strip()
-        
-        # If topic is too short, try to extract the main subject
-        if len(topic.split()) < 3:
-            # Look for key terms that indicate the actual topic
-            key_terms = ['quantum computing', 'artificial intelligence', 'machine learning', 
-                        'renewable energy', 'climate change', 'healthcare', 'biotechnology',
-                        'nanotechnology', 'robotics', 'cybersecurity', 'blockchain']
-            
-            for term in key_terms:
-                if term in message.lower():
-                    return term
-        
-        return topic if topic else "research topic"
-
-    def _format_comprehensive_research_response(self, results: dict, topic: str) -> str:
-        """Format comprehensive research results with analysis."""
-        
-        response = f"🔬 **Comprehensive Research Analysis: {topic}**\n\n"
-        
-        # Summary section
-        response += f"📊 **Research Summary:**\n"
-        response += f"• Sources Analyzed: {results.get('sources_analyzed', 0)}\n"
-        response += f"• Key Findings: {len(results.get('key_findings', []))}\n"
-        response += f"• Citations Generated: {len(results.get('citations', []))}\n"
-        response += f"• Visualizations: {len(results.get('visualizations', {}))}\n\n"
-        
-        # Key findings
-        if results.get('key_findings'):
-            response += "🔍 **Key Findings:**\n"
-            for i, finding in enumerate(results['key_findings'][:10], 1):
-                response += f"{i}. {finding}\n"
-            response += "\n"
-        
-        # Detailed analysis
-        if results.get('detailed_analysis'):
-            response += "📋 **Detailed Analysis:**\n"
-            response += f"{results['detailed_analysis'][:500]}...\n\n"
-        
-        # Recommendations
-        if results.get('recommendations'):
-            response += "💡 **Recommendations:**\n"
-            for i, rec in enumerate(results['recommendations'][:5], 1):
-                response += f"{i}. {rec}\n"
-            response += "\n"
-        
-        # Citations
-        if results.get('citations'):
-            response += "📚 **Top Sources (with Citations):**\n"
-            for i, citation in enumerate(results['citations'][:5], 1):
-                title = citation.get('title', 'No title')
-                authors = citation.get('authors', [])
-                doi = citation.get('doi', 'No DOI')
-                
-                response += f"{i}. **{title}**\n"
-                if authors:
-                    response += f"   Authors: {', '.join(authors[:3])}\n"
-                response += f"   DOI: {doi}\n\n"
-        
-        # Citation formats
-        if results.get('citation_formats'):
-            response += "📖 **Citation Formats Available:**\n"
-            for format_name in results['citation_formats'].keys():
-                response += f"• {format_name.upper()}\n"
-            response += "\n"
-        
-        response += "🎯 **This is REAL academic research with comprehensive analysis, not just a list of sources!**\n\n"
-        response += "Would you like me to:\n"
-        response += "• Generate a full research report\n"
-        response += "• Create interactive visualizations\n"
-        response += "• Export citations in specific formats\n"
-        response += "• Dive deeper into specific findings\n"
-        
-        return response
-
-    async def _perform_basic_research(self, user_message: str) -> str:
-        """Fallback to basic research if enhanced research fails."""
-        try:
-            print("🔍 Performing basic research...")
-            
-            # Import search engine
-            from src.services.search_service.search_engine import SearchEngine
-            from src.storage.db.operations import DatabaseOperations
-            
-            # Initialize search engine
-            db_ops = DatabaseOperations(
-                os.environ.get('MONGODB_URL', 'mongodb://localhost:27017/nocturnal_archive'),
-                os.environ.get('REDIS_URL', 'redis://localhost:6379')
-            )
-            search_engine = SearchEngine(db_ops, os.environ.get('REDIS_URL', 'redis://localhost:6379'))
-            
-            # Perform academic search
-            print("📚 Searching academic databases...")
-            academic_results = []
-            
-            try:
-                from src.services.paper_service.openalex import OpenAlexClient
-                async with OpenAlexClient() as openalex:
-                    academic_data = await openalex.search_works(user_message, per_page=10)
-                    if academic_data and "results" in academic_data:
-                        academic_results = academic_data["results"]
-                        print(f"✅ Found {len(academic_results)} academic papers")
-            except Exception as e:
-                print(f"⚠️  Academic search failed: {e}")
-            
-            # Perform web search
-            print("🌐 Searching web sources...")
-            web_results = await search_engine.web_search(user_message, num_results=5)
-            print(f"✅ Found {len(web_results)} web sources")
-            
-            # Generate response with basic research results
-            response = self._format_research_response(user_message, academic_results, web_results)
-            
-            print("✅ Basic research completed!")
-            return response
-            
-        except Exception as e:
-            print(f"❌ Error in basic research: {e}")
-            return f"I encountered an error while researching '{user_message}'. Please try again."
-
-    def _format_research_response(self, query: str, academic_results: list, web_results: list) -> str:
-        """Format research results into a comprehensive response."""
-        
-        response = f"🔬 **Research Results for: {query}**\n\n"
-        
-        # Academic papers section
-        if academic_results:
-            response += "📚 **Academic Papers Found:**\n"
-            for i, paper in enumerate(academic_results[:5], 1):
-                title = paper.get('title', 'No title')
-                authors = paper.get('authorships', [])
-                author_names = [author.get('author', {}).get('display_name', 'Unknown') for author in authors[:3]]
-                doi = paper.get('doi', 'No DOI')
-                
-                response += f"{i}. **{title}**\n"
-                response += f"   Authors: {', '.join(author_names)}\n"
-                response += f"   DOI: {doi}\n\n"
-        
-        # Web sources section
-        if web_results:
-            response += "🌐 **Web Sources Found:**\n"
-            for i, result in enumerate(web_results[:3], 1):
-                title = result.get('title', 'No title')
-                url = result.get('url', 'No URL')
-                snippet = result.get('snippet', 'No description')
-                
-                response += f"{i}. **{title}**\n"
-                response += f"   URL: {url}\n"
-                response += f"   {snippet[:150]}...\n\n"
-        
-        # Summary
-        total_sources = len(academic_results) + len(web_results)
-        response += f"📊 **Summary:** Found {total_sources} sources total ({len(academic_results)} academic papers, {len(web_results)} web sources)\n\n"
-        
-        response += "Would you like me to:\n"
-        response += "• Analyze specific papers in detail\n"
-        response += "• Generate citations for these sources\n"
-        response += "• Create a comprehensive research summary\n"
-        response += "• Explore related topics\n\n"
-        
-        response += "Just let me know what aspect you'd like to dive deeper into!"
-        
-        return response
-
-    async def chat_turn(self, user_message: str) -> str:
-        """Process user message with fallback support."""
-        self.history.append({"role": "user", "content": user_message})
-        
-        # Update conversation context
-        if hasattr(self, 'context_tracker'):
-            self.context_tracker.update(user_message, self.last_bot_message)
-        
-        try:
-            # Check if this is a research query
-            if self._is_research_query(user_message):
-                print("🔬 Detected research query - using real academic research...")
-                response = await self._perform_real_research(user_message)
-            elif self.fallback_mode:
-                response = await self._simulate_chat_response(user_message)
-            else:
-                response = await self._full_chat_response(user_message)
-            
-            # Add typing effect to response
-            await self.typing_effect.type_message(response)
-            
-            # Store the response
-            self.last_bot_message = response
-            self.history.append({"role": "assistant", "content": response})
-            
-            return response
-                
-        except Exception as e:
-            logger.error(f"Error in chat_turn: {str(e)}")
-            error_response = await self._handle_error_gracefully(e, user_message)
-            await self.typing_effect.type_message(error_response)
-            return error_response
-
-    async def _parallel_web_search(self, user_message: str):
-        """Do silent parallel web search for background context."""
-        try:
-            from src.services.search_service.search_engine import SearchEngine
-            search_engine = SearchEngine(self.db_ops, os.environ.get('REDIS_URL', 'redis://localhost:6379'))
-            
-            # Extract key terms for search
-            search_terms = await self._extract_search_terms(user_message)
-            
-            # Do quick web search in background
-            results = await search_engine.web_search(search_terms, num_results=3)
-            
-            # Store context for later use
-            self.parallel_web_context.extend(results)
-            
-        except Exception as e:
-            # Silently fail - parallel search shouldn't interrupt conversation
-            pass
-
-    async def _extract_search_terms(self, message: str) -> str:
-        """Extract search terms from user message."""
-        try:
-            # Use LLM to extract key search terms
-            prompt = f"Extract 2-3 key search terms from this message for web search. Return ONLY the search terms, no JSON or formatting: {message}"
-            result = await self.doc_client.process_document(
-                title="Search Terms Extraction",
-                content=prompt,
-                model="llama-3.3-70b",
-                temperature=0.1,
-                max_tokens=100
-            )
-            terms = result.get("raw_text", "").strip()
-            return terms if terms else message
-        except:
-            return message
-
-    async def _simulate_chat_response(self, user_message: str) -> str:
-        """Provide simulated responses when in fallback mode."""
-        message_lower = user_message.lower()
-        
-        # Greeting responses
-        if any(word in message_lower for word in ['hello', 'hi', 'hey', 'start']):
-            return ("Hello! I'm the Nocturnal Archive research assistant. "
-                   "I can help you with comprehensive research on any topic. "
-                   "What would you like to research today?")
-        
-        # Research topic responses
-        if any(word in message_lower for word in ['research', 'study', 'topic', 'explore']):
-            if len(message_lower.split()) > 3:  # Likely contains a topic
-                topic = user_message.strip()
-                return (f"Great! I'd love to help you research '{topic}'. "
-                       "In simulation mode, I can show you what the research process would look like. "
-                       "Would you like me to demonstrate the research workflow for this topic?")
-            else:
-                return ("What topic would you like to research? "
-                       "For example: 'quantum computing', 'AI in healthcare', or 'blockchain technology'")
-        
-        # Research type responses
-        if any(word in message_lower for word in ['comprehensive', 'detailed', 'thorough']):
-            return ("Perfect! I'll conduct a comprehensive analysis. "
-                   "This would include:\n"
-                   "• 15-20 papers analyzed\n"
-                   "• Quality assessment\n"
-                   "• Citation network mapping\n"
-                   "• Trend analysis\n"
-                   "• Advanced visualizations\n"
-                   "• Multiple export formats\n\n"
-                   "Estimated time: 35 minutes\n\n"
-                   "Would you like me to start the research simulation?")
-        
-        if any(word in message_lower for word in ['quick', 'overview', 'summary']):
-            return ("Great! I'll provide a quick overview. "
-                   "This would include:\n"
-                   "• 5-8 key papers\n"
-                   "• Executive summary\n"
-                   "• Main findings\n"
-                   "• Basic visualizations\n\n"
-                   "Estimated time: 15 minutes\n\n"
-                   "Would you like me to start the research simulation?")
-        
-        # Confirmation responses
-        if any(word in message_lower for word in ['yes', 'start', 'go', 'begin']):
-            return ("🚀 Starting research simulation...\n\n"
-                   "This is where the actual research would happen.\n"
-                   "The system would:\n"
-                   "1. Search academic databases\n"
-                   "2. Analyze papers with AI\n"
-                   "3. Generate insights and visualizations\n"
-                   "4. Create professional reports\n\n"
-                   "For now, this is a simulation. The full system requires:\n"
-                   "• API keys for LLM services\n"
-                   "• Database connections\n"
-                   "• Web search capabilities\n\n"
-                   "Would you like to see what the final output would look like?")
-        
-        # Help responses
-        if any(word in message_lower for word in ['help', 'what can you do', 'capabilities']):
-            return ("I'm the Nocturnal Archive research assistant! Here's what I can do:\n\n"
-                   "🔬 **Research Capabilities:**\n"
-                   "• Comprehensive literature reviews\n"
-                   "• Market analysis and trends\n"
-                   "• Technology assessment\n"
-                   "• Quality evaluation of sources\n\n"
-                   "📊 **Output Formats:**\n"
-                   "• Executive summaries\n"
-                   "• Advanced visualizations\n"
-                   "• Multiple export formats (JSON, Markdown, HTML, LaTeX, CSV)\n\n"
-                   "⚡ **Speed:**\n"
-                   "• Quick overviews (15 minutes)\n"
-                   "• Comprehensive analysis (35 minutes)\n\n"
-                   "What would you like to research?")
-        
-        # Default response
-        return ("I'm here to help with research! "
-               "What topic would you like to explore? "
-               "Or ask me what I can do for you.")
-
-    async def _full_chat_response(self, user_message: str) -> str:
-        """Full chat response when all dependencies are available."""
-        try:
-            # Background web search (non-blocking)
-            asyncio.create_task(self._parallel_web_search(user_message))
-            
-            # Handle ambiguous inputs first
-            if self._is_ambiguous(user_message):
-                return await self._handle_ambiguous_input(user_message)
-            
-            # Natural flow decision tree
-            conversation_state = self._analyze_conversation_state()
-            
-            if conversation_state == "warming_up":
-                return await self._warm_conversation(user_message)
-            
-            elif conversation_state == "exploring":
-                if self._should_propose_research():
-                    return await self._propose_research()
-                return await self._normal_conversation(user_message)
-            
-            elif conversation_state == "ready_for_research":
-                if not self.research_proposed:
-                    return await self._propose_research()
-                elif self._is_research_approved(user_message):
-                    # Start research immediately (layered engine + saturation metrics)
-                    return await self._start_research_with_preferences({"comprehensive": True})
-                elif self.projection_given and self._is_projection_approved(user_message):
-                    return await self._start_research_with_preferences(self.research_preferences)
-                else:
-                    return await self._handle_research_hesitation(user_message)
-            
-            elif conversation_state == "researching":
-                return await self._handle_research_in_progress(user_message)
-            
-            elif conversation_state == "discussing_results":
-                return await self._handle_followup_question(user_message)
-            
-            else:
-                return await self._normal_conversation(user_message)
-                
-        except Exception as e:
-            return await self._handle_error_gracefully(e, user_message)
-
-    async def _handle_error_gracefully(self, error: Exception, user_message: str) -> str:
-        """Handle errors gracefully with user-friendly messages."""
-        logger.error(f"Error in chat: {str(error)}")
-        
-        # Convert technical errors to user-friendly messages
-        error_message = str(error).lower()
-        
-        if "connection" in error_message or "timeout" in error_message:
-            return ("I'm having trouble connecting to the research databases right now. "
-                   "This might be due to network issues or database configuration. "
-                   "Would you like to try again, or would you prefer to see a demo of what I can do?")
-        
-        elif "authentication" in error_message or "api key" in error_message:
-            return ("I need API keys to access the research services. "
-                   "Please check your .env.local file and ensure your API keys are configured. "
-                   "For now, I can show you what the research process would look like.")
-        
-        elif "database" in error_message:
-            return ("I'm having trouble connecting to the database. "
-                   "Please check your database configuration. "
-                   "Would you like to try again or see a demo?")
-        
-        else:
-            return ("I encountered an unexpected error while processing your request. "
-                   "This might be a temporary issue. Would you like to try again, "
-                   "or would you prefer to see what I can do in demo mode?")
-
-    def _detect_ambiguity_type(self, user_message: str) -> str:
-        """Detect type of ambiguity in user message."""
-        message_lower = user_message.lower()
-        words = message_lower.split()
-        
-        if len(words) < 5 and any(broad in message_lower for broad in ['everything', 'all', 'anything']):
-            return "too_broad"
-        elif len(words) < 3 or '?' not in user_message:
-            return "unclear_intent"
-        elif any(connector in message_lower for connector in ['and also', 'but also', 'oh and']):
-            return "mixed_topics"
-        else:
-            return "general"
-
-    async def _clarify_intent_naturally(self, user_message: str) -> str:
-        """Clarify user's intent naturally."""
-        return (
-            "I want to make sure I understand what you're looking for. "
-            "Could you tell me a bit more about what aspect interests you most?"
-        )
-
-    async def _handle_mixed_topics(self, user_message: str) -> str:
-        """Handle messages with multiple topics."""
-        return (
-            "I see you've mentioned several interesting points! "
-            "Which one would you like to explore first? We can always come back to the others."
-        )
-
-    async def _engage_exploratively(self, user_message: str) -> str:
-        """Engage exploratively with ambiguous input."""
-        messages = [
-            {
-                "role": "system",
-                "content": "The user's message is somewhat ambiguous. Engage with curiosity and help them clarify their interests."
-            },
-            {"role": "user", "content": user_message}
-        ]
-        
-        bot_response = await self.chat_client.chat(
-            messages=messages,
-            model="llama-3.3-70b",  # This model is correct for Cerebras
-            temperature=0.7,
-            max_tokens=800
-        )
-        self.history.append({"role": "assistant", "content": bot_response})
-        return bot_response
-
-    async def _categorize_followup(self, user_message: str) -> str:
-        """Categorize the type of follow-up question."""
-        message_lower = user_message.lower()
-        
-        if any(word in message_lower for word in ['clarify', 'explain', 'what do you mean']):
-            return "clarification"
-        elif any(word in message_lower for word in ['deeper', 'more detail', 'elaborate']):
-            return "deeper_dive"
-        elif any(word in message_lower for word in ['apply', 'implement', 'practice', 'use']):
-            return "practical_application"
-        elif any(word in message_lower for word in ['but', 'however', 'disagree']):
-            return "challenge"
-        else:
-            return "general"
-
-    async def _provide_clarification(self, user_message: str) -> str:
-        """Provide clarification on research results."""
-        prompt = f"""The user needs clarification about the research results.
-        
-    User question: {user_message}
-    Research synthesis: {str(self.synthesis)[:1000]}
-
-    Provide a clear, helpful clarification that:
-    - Directly addresses their confusion
-    - Uses simpler language if needed
-    - Gives concrete examples
-    - Maintains a helpful tone"""
-
-        result = await self.doc_client.process_document(
-            title="Clarification",
-            content=prompt,
-            model="llama-3.3-70b",
-            temperature=0.5,
-            max_tokens=400
-        )
-        
-        response = result.get("raw_text", "Let me clarify that point for you...")
-        self.history.append({"role": "assistant", "content": response})
-        return response
-
-    async def _provide_practical_insights(self, user_message: str) -> str:
-        """Provide practical applications of research findings."""
-        prompt = f"""The user wants practical applications of the research.
-        
-    User question: {user_message}
-    Research synthesis: {str(self.synthesis)[:1000]}
-
-    Provide practical insights that:
-    - Connect research to real-world applications
-    - Give actionable recommendations
-    - Consider implementation challenges
-    - Remain grounded in the research"""
-
-        result = await self.doc_client.process_document(
-            title="Practical Insights",
-            content=prompt,
-            model="llama-3.3-70b",
-            temperature=0.6,
-            max_tokens=500
-        )
-        
-        response = result.get("raw_text", "Here's how you might apply these findings...")
-        self.history.append({"role": "assistant", "content": response})
-        return response
-
-    async def _handle_challenge_gracefully(self, user_message: str) -> str:
-        """Handle challenges to research findings gracefully."""
-        response = (
-            "That's a valid point to raise. Research findings often have nuances and limitations. "
-            "Let me address your concern with what the research actually shows, including any "
-            "contradicting viewpoints or limitations in the current studies..."
-        )
-        
-        # Add more specific response based on the challenge
-        self.history.append({"role": "assistant", "content": response})
-        return response
-
-    async def _provide_general_followup(self, user_message: str) -> str:
-        """Provide general follow-up response."""
-        prompt = f"""Answer this follow-up question about the research results.
-        
-    Question: {user_message}
-    Research context: {str(self.synthesis)[:1000]}
-
-    Be helpful, thorough, and conversational."""
-
-        result = await self.doc_client.process_document(
-            title="Follow-up Response",
-            content=prompt,
-            model="llama-3.3-70b",
-            temperature=0.6,
-            max_tokens=400
-        )
-        
-        response = result.get("raw_text", "Based on the research findings...")
-        self.history.append({"role": "assistant", "content": response})
-        return response
-
-    async def _extract_followup_aspect(self, user_message: str) -> str:
-        """Extract the specific aspect user wants to explore."""
-        # Simple extraction - could be enhanced
-        return user_message[:100]  # Just use the message as the aspect
-
-    async def _analyze_conversation_depth(self) -> dict:
-        """Analyze conversation depth for proposal style."""
-        return {
-            'depth': self._calculate_conversation_depth(),
-            'engagement': self._measure_user_engagement(),
-            'style': self.context_tracker.conversation_style if hasattr(self, 'context_tracker') else 'neutral'
-        }
-
-    def _determine_proposal_style(self, analysis: dict) -> str:
-        """Determine the best proposal style."""
-        if analysis['engagement'] > 0.8 and analysis['depth'] > 0.7:
-            return "enthusiastic"
-        elif analysis['depth'] > 0.6:
-            return "analytical"
-        else:
-            return "gentle"
-
-    async def _generate_analytical_proposal(self) -> str:
-        """Generate an analytical research proposal."""
-        topic = self.topic or self._extract_implicit_topic()
-        
-        prompt = f"""Create an analytical research proposal for '{topic}' based on our conversation.
-        
-    Context: {self.get_context_summary()[-500:]}
-
-    The proposal should:
-    - Acknowledge the complexity of the topic
-    - Outline specific research questions we could explore
-    - Mention methodological approaches
-    - Be conversational but intellectually rigorous
-    - Invite the user to refine or proceed"""
-
-        result = await self.doc_client.process_document(
-            title="Analytical Proposal",
-            content=prompt,
-            model="llama-3.3-70b",
-            temperature=0.6,
-            max_tokens=400
-        )
-        
-        return result.get("raw_text", f"I see there are several interesting dimensions to {topic}. Would you like me to conduct a systematic research review?")
-
-    async def _generate_gentle_proposal(self) -> str:
-        """Generate a gentle research proposal."""
-        topic = self.topic or self._extract_implicit_topic()
-        
-        return (f"I've noticed we keep coming back to {topic}, and there seem to be some interesting "
-                f"questions emerging. If you'd like, I could look into the academic research on this "
-                f"topic and see what insights are available. Would that be helpful?")
-
-    def _should_propose_research(self) -> bool:
-        """Check if we have enough context to propose research."""
-        # Don't propose if already proposed or research is running
-        if self.research_proposed or self.status in {"running", "completed"}:
-            return False
-        
-        # Check if we have enough context - need at least 3 turns
-        if len(self.history) < 6:
-            return False
-        
-        # Check if we have a clear topic
-        topic, questions = self._extract_topic_and_questions(self.get_context_summary())
-        if not topic or topic == "Untitled Research":
-            return False
-        
-        # Check for research intent keywords in recent messages
-        recent_messages = [turn["content"].lower() for turn in self.history[-3:] if turn["role"] == "user"]
-        research_keywords = [
-            "research", "find papers", "literature review", "study", "review", 
-            "investigate", "collect papers", "gather sources", "quantum", "cryptography"
-        ]
-        has_research_intent = any(any(kw in msg for kw in research_keywords) for msg in recent_messages)
-        
-        if has_research_intent:
-            return True
-        
-        return False
-
-    async def _propose_research(self) -> str:
-        """Propose research in a natural, conversational way."""
-        self.research_proposed = True
-        
-        # Analyze conversation for natural entry point
-        conversation_analysis = await self._analyze_conversation_depth()
-        
-        # Generate a natural, contextual proposal
-        proposal_style = self._determine_proposal_style(conversation_analysis)
-        
-        if proposal_style == "enthusiastic":
-            proposal = await self._generate_enthusiastic_proposal()
-        elif proposal_style == "analytical":
-            proposal = await self._generate_analytical_proposal()
-        else:
-            proposal = await self._generate_gentle_proposal()
-        
-        self.history.append({"role": "assistant", "content": proposal})
-        return proposal
-
-    async def _generate_enthusiastic_proposal(self) -> str:
-        """Generate an enthusiastic research proposal."""
-        topic = self.topic or self._extract_implicit_topic()
-        
-        templates = [
-            f"This is fascinating! You know what? I think we're onto something really interesting with {topic}. "
-            f"I could dive deep into the academic literature and pull together a comprehensive analysis for you. "
-            f"There's likely some cutting-edge research we could explore - would you like me to start gathering papers and synthesizing the current state of knowledge?",
-            
-            f"I'm getting really intrigued by our discussion about {topic}! "
-            f"I have access to academic databases and could conduct a thorough literature review to map out "
-            f"the research landscape. We could uncover some fascinating insights - shall I start that research process?",
-            
-            f"You've touched on something that deserves deeper exploration! {topic} has so many dimensions "
-            f"we could investigate through academic research. I could search for peer-reviewed papers, "
-            f"analyze methodologies, and synthesize findings. Want me to put together a comprehensive research review?"
-        ]
-        
-        # Use LLM to make it more natural based on context
-        return await self._personalize_template(random.choice(templates))
-
-    def _should_propose_research(self) -> bool:
-        """Smarter detection of when to propose research."""
-        if self.research_proposed or self.status in {"running", "completed"}:
-            return False
-        
-        # Check conversation depth and complexity
-        depth_score = self._calculate_conversation_depth()
-        
-        # Check for research indicators beyond keywords
-        indicators = {
-            'question_complexity': self._assess_question_complexity(),
-            'topic_persistence': self._check_topic_persistence(),
-            'knowledge_gaps': self._identify_knowledge_gaps(),
-            'user_engagement': self._measure_user_engagement(),
-            'conversation_maturity': len(self.history) > 6
-        }
-        
-        # Weighted scoring
-        score = (
-            indicators['question_complexity'] * 0.3 +
-            indicators['topic_persistence'] * 0.25 +
-            indicators['knowledge_gaps'] * 0.2 +
-            indicators['user_engagement'] * 0.15 +
-            (1.0 if indicators['conversation_maturity'] else 0) * 0.1
-        )
-        
-        return score > 0.4
-
-    def _assess_question_complexity(self) -> float:
-        """Assess the complexity of user questions."""
-        recent_questions = [
-            turn["content"] for turn in self.history[-6:] 
-            if turn["role"] == "user"
-        ]
-        
-        complexity_indicators = [
-            "how", "why", "explain", "compare", "analyze", 
-            "implications", "trade-offs", "challenges", "future",
-            "state of the art", "research", "studies", "evidence"
-        ]
-        
-        complexity_score = 0
-        for question in recent_questions:
-            question_lower = question.lower()
-            score = sum(1 for indicator in complexity_indicators if indicator in question_lower)
-            complexity_score += min(score / 3, 1.0)  # Normalize per question
-        
-        return complexity_score / max(len(recent_questions), 1)
-
-    def _is_research_approved(self, user_message: str) -> bool:
-        """Check if user approved the research proposal."""
-        message_lower = user_message.lower()
-        
-        # Don't approve if we're already past this stage
-        if self.projection_given or self.status == "running":
-            return False
-            
-        approval_keywords = ["yes", "okay", "go ahead", "sure", "start", "sounds good"]
-        return any(keyword in message_lower for keyword in approval_keywords)
-    
-    async def _give_projection(self) -> str:
-        """Give projection based on gathered context."""
-        self.projection_given = True
-        
-        # Create projection based on context and parallel web searches
-        projection = await self._create_projection()
-        
-        projection_message = (
-            f"Here's what I'm probably gonna find when I dig into the research:\n\n"
-            f"{projection}\n\n"
-            f"Let me verify this with the actual research. Should I proceed?"
-        )
-        
-        self.history.append({"role": "assistant", "content": projection_message})
-        return projection_message
-
-    async def _create_projection(self) -> str:
-        """Create sophisticated projection with academic depth."""
-        try:
-            # Combine conversation context and web search results
-            context_summary = self.get_context_summary()
-            web_context = "\n".join([f"- {r.get('title', '')}: {r.get('snippet', '')}" 
-                                   for r in self.parallel_web_context[:5]])
-            
-            prompt = (
-                f"Based on this conversation context and recent web information, "
-                f"provide a sophisticated academic projection of research findings:\n\n"
-                f"Conversation: {context_summary}\n\n"
-                f"Recent web context: {web_context}\n\n"
-                f"Create a projection that includes:\n"
-                f"- Expected key findings and insights\n"
-                f"- Potential research gaps that might be identified\n"
-                f"- Current trends in the field\n"
-                f"- Methodological considerations\n"
-                f"- Potential limitations or challenges\n"
-                f"- Academic rigor and depth\n\n"
-                f"Project what the comprehensive academic research will likely reveal about this topic."
-            )
-            
-            result = await self.doc_client.process_document(
-                title="Research Projection",
-                content=prompt,
-                model="llama-3.3-70b",
-                temperature=0.3,
-                max_tokens=500
-            )
-            
-            projection = result.get("raw_text", "")
-            if not projection:
-                projection = (
-                    "Based on the research context and current literature trends, I expect to find:\n\n"
-                    "**Key Findings**: [Expected insights from academic papers]\n"
-                    "**Research Gaps**: [Areas where current literature is insufficient]\n"
-                    "**Methodological Insights**: [Different research approaches and their effectiveness]\n"
-                    "**Current Trends**: [Recent developments in the field]\n"
-                    "**Limitations**: [Potential challenges in current research]\n\n"
-                    "This projection is based on the current state of academic knowledge and will be verified through comprehensive research."
-                )
-            
-            return projection
-            
-        except Exception as e:
-            return (
-                "Based on the academic context gathered, I expect to find relevant research papers, "
-                "methodological insights, and potential research gaps. The comprehensive analysis will "
-                "provide a thorough understanding of the current state of knowledge in this field."
-            )
-
-    def _is_projection_approved(self, user_message: str) -> bool:
-        """Check if user approved the projection."""
-        approval_keywords = ["yes", "okay", "proceed", "go ahead", "sure", "verify", "check"]
-        return any(keyword in user_message.lower() for keyword in approval_keywords)
-
-    async def _start_research(self) -> str:
-        """Start the actual research process (layered engine with saturation metrics)."""
-        self.research_approved = True
-        self.status = "running"
-        
-        # Build research plan if not already built
-        if not self.research_plan:
-            self.research_plan = await self.build_research_plan()
-        
-        # Launch research using layered engine
-        await self._approve_and_launch_layered()
-        
-        start_message = (
-            f"Starting research now. This will take a moment as I search for academic papers "
-            f"and analyze the findings. I'll let you know when it's complete."
-        )
-        
-        self.history.append({"role": "assistant", "content": start_message})
-        
-        # Don't wait here - let the research run in background
-        # The user will check status or the bot will check in _handle_research_in_progress
-        
-        return start_message
-
-    async def _approve_and_launch_layered(self):
-        plan_str = self.research_plan if self.research_plan is not None else ""
-        topic, questions = self._extract_topic_and_questions(plan_str)
-        self.topic = topic
-        self.questions = questions
-        # Start layered research (multi-source + saturation)
-        self.session_id = await self.context_manager.start_layered_research(
-            topic=topic,
-            research_questions=questions or [topic],
-            max_layers=3,
-            user_id=self.user_profile.get("id", "default_user")
-        )
-        self.status = "running"
-
-    async def check_status(self):
-        if not self.session_id:
-            print("No research session running.")
-            return
-        status = await self.context_manager.get_session_status(self.session_id)
-        print(f"\n[Session Status: {status.get('status')}] Progress: {status.get('progress', {}).get('percentage', 0)}%")
-        if status.get('status') == 'completed':
-            self.status = 'completed'
-        return status
-
-    async def show_results(self):
-        if not self.session_id:
-            return "No research session found."
-        session = await self.context_manager._get_session(self.session_id)
-        synthesis = session.synthesis if session else None
-        if synthesis:
-            self.synthesis = synthesis
-            # Prepare artifact links if available
-            artifact_links = ""
-            try:
-                artifacts = synthesis.get('artifacts') if isinstance(synthesis, dict) else None
-                if artifacts and artifacts.get('report_markdown') and artifacts.get('report_json'):
-                    artifact_links = f"\n\nReports: {artifacts['report_markdown']} | {artifacts['report_json']}"
-            except Exception:
-                pass
-            # Compose message
-            syn_str = str(synthesis)
-            results_message = (
-                f"Research complete! Here are the findings:\n\n"
-                f"{syn_str[:2000]}{'...' if len(syn_str) > 2000 else ''}"
-                f"{artifact_links}\n\n"
-                f"You can ask me follow-up questions about the results, or start a new research topic."
-            )
-            
-            self.history.append({"role": "assistant", "content": results_message})
-            return results_message
-        else:
-            return "Research is still in progress. Please wait a moment."
-
-    def _is_followup_question(self, user_message: str) -> bool:
-        """Check if user is asking a follow-up question about results."""
-        if not self.synthesis:
-            return False
-        
-        # Check for question indicators
-        question_indicators = ["?", "explain", "clarify", "what about", "how", "why", "tell me more", "challenges", "implement"]
-        return any(indicator in user_message.lower() for indicator in question_indicators)
-
-    async def _handle_followup_question(self, user_message: str) -> str:
-        """Handle follow-up questions with ChatGPT-like depth and personality."""
-        
-        # Categorize the follow-up type
-        followup_type = await self._categorize_followup(user_message)
-        
-        if followup_type == "clarification":
-            return await self._provide_clarification(user_message)
-        elif followup_type == "deeper_dive":
-            return await self._provide_deeper_analysis(user_message)
-        elif followup_type == "practical_application":
-            return await self._provide_practical_insights(user_message)
-        elif followup_type == "challenge":
-            return await self._handle_challenge_gracefully(user_message)
-        else:
-            return await self._provide_general_followup(user_message)
-    
-    async def _handle_ambiguous_input(self, user_message: str) -> str:
-        """Handle ambiguous or unclear inputs gracefully."""
-        
-        ambiguity_type = self._detect_ambiguity_type(user_message)
-        
-        if ambiguity_type == "too_broad":
-            return await self._narrow_down_gracefully(user_message)
-        elif ambiguity_type == "unclear_intent":
-            return await self._clarify_intent_naturally(user_message)
-        elif ambiguity_type == "mixed_topics":
-            return await self._handle_mixed_topics(user_message)
-        else:
-            return await self._engage_exploratively(user_message)
-
-    async def _narrow_down_gracefully(self, user_message: str) -> str:
-        """Help user narrow down broad topics naturally."""
-        
-        prompt = f"""The user has asked a very broad question. Help them narrow it down conversationally.
-
-    User message: {user_message}
-    Conversation context: {self.get_context_summary()[-500:]}
-
-    Create a response that:
-    1. Acknowledges the breadth of their interest
-    2. Offers 2-3 specific directions they might explore
-    3. Asks an engaging question to help focus
-    4. Maintains enthusiasm and curiosity
-    5. Feels like a natural conversation, not an interrogation"""
-
-        result = await self.doc_client.process_document(
-            title="Narrowing Assistance",
-            content=prompt,
-            model="llama-3.3-70b",
-            temperature=0.8,
-            max_tokens=400
-        )
-        
-        return result.get("raw_text", "That's a fascinating area! Could you tell me what aspect interests you most?")
-        
-    def _add_personality_touches(self, response: str, style: str) -> str:
-        """Add personality touches to responses."""
-        
-        if style == "analytical":
-            # Add analytical personality markers
-            connectors = [
-                "Actually, this connects to an interesting point...",
-                "What's particularly fascinating here is...",
-                "This reminds me of a key insight from the research...",
-                "There's a subtle but important distinction here..."
-            ]
-            if not any(conn in response for conn in connectors):
-                response = f"{random.choice(connectors)} {response}"
-        
-        elif style == "enthusiastic":
-            # Add enthusiasm markers
-            if "!" not in response[:50]:  # Add excitement if missing
-                sentences = response.split(". ")
-                if len(sentences) > 1:
-                    sentences[0] += "!"
-                    response = ". ".join(sentences)
-        
-        elif style == "thoughtful":
-            # Add thoughtful pauses and considerations
-            thoughtful_phrases = [
-                "Hmm, ",
-                "You know, ",
-                "That's a great question - ",
-                "I've been thinking about this... "
-            ]
-            if not any(phrase in response[:30] for phrase in thoughtful_phrases):
-                response = f"{random.choice(thoughtful_phrases)}{response}"
-        
-        return response
-    
-    async def _provide_deeper_analysis(self, user_message: str) -> str:
-        """Provide deeper analysis with personality."""
-        
-        # Extract the specific aspect they want to dive into
-        aspect = await self._extract_followup_aspect(user_message)
-        
-        prompt = f"""Based on the research synthesis, provide a deeper, more nuanced analysis of the user's question.
-        
-    Research synthesis: {str(self.synthesis)}
-    User's follow-up: {user_message}
-    Specific aspect: {aspect}
-
-    Guidelines:
-    - Start with an engaging hook that shows you understand their curiosity
-    - Provide rich, detailed analysis with examples
-    - Use analogies or metaphors where helpful
-    - Connect to broader implications
-    - Maintain conversational tone while being thorough
-    - End with a thought-provoking insight or question"""
-
-        result = await self.doc_client.process_document(
-            title="Deep Dive Analysis",
-            content=prompt,
-            model="llama-3.3-70b",
-            temperature=0.7,
-            max_tokens=800
-        )
-        
-        response = result.get("raw_text", "")
-        
-        # Add personality touches
-        response = self._add_personality_touches(response, "analytical")
-        
-        self.history.append({"role": "assistant", "content": response})
-        return response
-    
-    async def _normal_conversation(self, user_message: str) -> str:
-        """Handle normal conversation flow with ChatGPT/Claude-style interaction."""
-        
-        # Build a rich context for the LLM
-        system_prompt = self._build_dynamic_system_prompt()
-        
-        # Prepare conversation history with context awareness
-        messages = [{"role": "system", "content": system_prompt}]
-        
-        # Add conversation history with smart truncation
-        messages.extend(self._prepare_conversation_history())
-        
-        # Inject subtle context from parallel searches
-        if self.parallel_web_context:
-            messages.append({
-                "role": "system", 
-                "content": f"[Background knowledge from recent searches: {self._summarize_web_context()}]"
-            })
-        
-        try:
-            bot_response = await self.chat_client.chat(
-                messages=messages,
-                model="llama-3.3-70b",  # This model is correct for Cerebras
-                temperature=0.7,
-                max_tokens=800
-            )
-            # Post-process for natural flow
-            bot_response = self._enhance_response_naturally(bot_response, user_message)
-            
-        except Exception as e:
-            bot_response = self._generate_fallback_response(user_message)
-        
-        self.history.append({"role": "assistant", "content": bot_response})
-        return bot_response
-
-    def _build_dynamic_system_prompt(self) -> str:
-        """Build a dynamic system prompt based on conversation state."""
-        
-        base_prompt = """You are an advanced AI research assistant with a warm, intellectually curious personality. 
-    You engage naturally in conversations, showing genuine interest in topics while maintaining academic rigor.
-
-    Key traits:
-    - Intellectually curious and enthusiastic about learning
-    - Naturally conversational while being precise when needed
-    - Proactively helpful without being pushy
-    - Subtly guide conversations toward productive research when appropriate
-    - Use natural transitions and conversational bridges
-    - Show personality through word choice and engagement style
-
-    Current capabilities include:
-    - Deep academic research and literature analysis
-    - Real-time web search integration
-    - Comprehensive paper synthesis
-    - Methodological guidance
-    - Critical analysis"""
-
-        # Add state-aware context
-        if len(self.history) > 4:
-            base_prompt += "\n\n[Note: The conversation is developing depth. Consider whether research might be valuable soon.]"
-        
-        if self.parallel_web_context:
-            base_prompt += "\n\n[You have access to recent web search context. Use it naturally when relevant.]"
-        
-        if self._has_research_indicators():
-            base_prompt += "\n\n[The user seems interested in deeper exploration. Be ready to suggest research naturally.]"
-        
-        return base_prompt
-
-    async def _handle_clarification_request(self, user_message: str) -> str:
-        """Handle requests for clarification with comprehensive academic guidance."""
-        try:
-            prompt = (
-                f"Based on the conversation history, provide a comprehensive explanation of how I can help with academic research.\n\n"
-                f"Conversation context: {self.get_context_summary()}\n\n"
-                f"User is asking for clarification: {user_message}\n\n"
-                f"Provide a detailed explanation of my capabilities for academic research assistance, "
-                f"including literature review, methodology guidance, critical analysis, and research synthesis."
-            )
-            
-            result = await self.doc_client.process_document(
-                title="Clarification Response",
-                content=prompt,
-                model="llama-3.3-70b",
-                temperature=0.3,
-                max_tokens=400
-            )
-            
-            response = result.get("raw_text", "")
-            if not response:
-                response = (
-                    "I can help you with comprehensive academic research in several ways:\n\n"
-                    "**Literature Review & Synthesis**: I can search academic databases, analyze papers, "
-                    "and synthesize findings across multiple sources.\n\n"
-                    "**Research Methodology**: I can help you choose appropriate research methods, "
-                    "design studies, and identify research gaps.\n\n"
-                    "**Critical Analysis**: I can provide deep analysis of academic papers, "
-                    "identify strengths/weaknesses, and suggest improvements.\n\n"
-                    "**Citation Management**: I can help organize sources, format citations, "
-                    "and ensure proper academic referencing.\n\n"
-                    "**Writing Assistance**: I can help structure arguments, improve clarity, "
-                    "and enhance academic writing.\n\n"
-                    "What specific aspect of your research would you like to focus on?"
-                )
-            
-            self.history.append({"role": "assistant", "content": response})
-            return response
-            
-        except Exception as e:
-            return "I can help with comprehensive academic research including literature reviews, methodology guidance, and critical analysis. What specific aspect would you like to explore?"
-
-    def _extract_implicit_topic(self) -> str:
-        """Extract topic from conversation if not explicitly set."""
-        
-        # Look for noun phrases in recent messages
-        user_messages = [
-            turn["content"] for turn in self.history[-6:] 
-            if turn["role"] == "user"
-        ]
-        
-        # Simple extraction - find the most discussed concept
-        all_text = " ".join(user_messages).lower()
-        
-        # Common research topics (extend this list based on your domain)
-        topic_keywords = [
-            "quantum", "cryptography", "security", "algorithm", "computing",
-            "research", "technology", "science", "study", "analysis"
-        ]
-        
-        for keyword in topic_keywords:
-            if keyword in all_text:
-                # Find surrounding context
-                index = all_text.find(keyword)
-                start = max(0, index - 20)
-                end = min(len(all_text), index + 30)
-                context = all_text[start:end].strip()
-                return context
-        
-        # Default to first substantial user message
-        for msg in user_messages:
-            if len(msg) > 20:
-                return msg[:50] + "..."
-        
-        return "the topic we've been discussing"
-
-    async def _personalize_template(self, template: str) -> str:
-        """Personalize template based on conversation context."""
-        
-        # Add conversation-specific details
-        recent_context = self.get_context_summary()[-500:]
-        
-        prompt = f"""Personalize this research proposal template based on our conversation:
-
-    Template: {template}
-
-    Recent conversation: {recent_context}
-
-    Make it feel natural and specific to what we've been discussing. Keep the same enthusiasm but make it more personal."""
-
-        result = await self.doc_client.process_document(
-            title="Personalize Proposal",
-            content=prompt,
-            model="llama-3.3-70b",
-            temperature=0.7,
-            max_tokens=300
-        )
-        
-        return result.get("raw_text", template)
-
-    def _calculate_conversation_depth(self) -> float:
-        """Calculate how deep/complex the conversation has become."""
-        
-        depth_score = 0.0
-        
-        # Factor 1: Message length
-        avg_length = sum(len(turn["content"]) for turn in self.history) / max(len(self.history), 1)
-        depth_score += min(avg_length / 200, 1.0) * 0.3
-        
-        # Factor 2: Question complexity
-        depth_score += self._assess_question_complexity() * 0.4
-        
-        # Factor 3: Topic persistence
-        depth_score += self._check_topic_persistence() * 0.3
-        
-        return min(depth_score, 1.0)
-
-    def _check_topic_persistence(self) -> float:
-        """Check if user is sticking to a topic."""
-        
-        if len(self.history) < 4:
-            return 0.0
-        
-        # Extract key terms from recent messages
-        recent_messages = [
-            turn["content"].lower() for turn in self.history[-6:] 
-            if turn["role"] == "user"
-        ]
-        
-        # Find common words (simple approach)
-        word_counts = {}
-        for msg in recent_messages:
-            words = msg.split()
-            for word in words:
-                if len(word) > 4:  # Skip small words
-                    word_counts[word] = word_counts.get(word, 0) + 1
-        
-        # If any substantial word appears multiple times, topic is persistent
-        max_count = max(word_counts.values()) if word_counts else 0
-        return min(max_count / 3, 1.0)
-
-    def _identify_knowledge_gaps(self) -> float:
-        """Identify if there are knowledge gaps to fill."""
-        
-        # Look for uncertainty markers
-        gap_indicators = [
-            "i don't know", "not sure", "wondering", "curious",
-            "how does", "why does", "what causes", "can you explain"
-        ]
-        
-        recent_messages = " ".join([
-            turn["content"].lower() for turn in self.history[-4:] 
-            if turn["role"] == "user"
-        ])
-        
-        gap_count = sum(1 for indicator in gap_indicators if indicator in recent_messages)
-        return min(gap_count / 3, 1.0)
-
-    def _measure_user_engagement(self) -> float:
-        """Measure how engaged the user is."""
-        
-        if len(self.history) < 2:
-            return 0.5
-        
-        # Check response length trend
-        user_messages = [
-            turn["content"] for turn in self.history 
-            if turn["role"] == "user"
-        ]
-        
-        if len(user_messages) < 2:
-            return 0.5
-        
-        # Are messages getting longer? (sign of engagement)
-        recent_avg = sum(len(msg) for msg in user_messages[-3:]) / 3
-        early_avg = sum(len(msg) for msg in user_messages[:3]) / 3
-        
-        if recent_avg > early_avg * 1.5:
-            return 1.0
-        elif recent_avg > early_avg:
-            return 0.7
-        else:
-            return 0.4
-
-    async def _warm_conversation(self, user_message: str) -> str:
-        """Handle early conversation warmly and naturally."""
-        
-        # Simple, warm system prompt
-        messages = [
-            {
-                "role": "system", 
-                "content": (
-                    "You are a friendly, intellectually curious AI assistant. "
-                    "This is early in the conversation, so be welcoming and engaging. "
-                    "Show interest in what the user is saying and ask natural follow-up questions. "
-                    "Be conversational, not formal."
-                )
-            },
-            *self.history
-        ]
-        
-        bot_response = await self.chat_client.chat(
-            messages=messages,
-            model="llama-3.3-70b",  # This model is correct for Cerebras
-            temperature=0.7,
-            max_tokens=800
-        )
-        self.history.append({"role": "assistant", "content": bot_response})
-        return bot_response
-
-    async def _handle_research_hesitation(self, user_message: str) -> str:
-        """Handle when user seems hesitant about research."""
-        
-        # Understand their concern
-        prompt = f"""The user seems hesitant about starting research. Their message: "{user_message}"
-
-    Provide a helpful, understanding response that:
-    1. Acknowledges their hesitation
-    2. Offers to clarify or adjust the research scope
-    3. Gives them control over the process
-    4. Remains friendly and supportive
-
-    Keep it conversational and brief."""
-
-        result = await self.doc_client.process_document(
-            title="Hesitation Response",
-            content=prompt,
-            model="llama-3.3-70b",
-            temperature=0.7,
-            max_tokens=200
-        )
-        
-        response = result.get("raw_text", "No problem! Would you like to explore the topic more first, or should we adjust what we're looking for?")
-        
-        self.history.append({"role": "assistant", "content": response})
-        return response
-
-    async def _handle_research_in_progress(self, user_message: str) -> str:
-        """Handle conversation while research is running."""
-        
-        # Check actual research status
-        if self.session_id:
-            status = await self.context_manager.get_session_status(self.session_id)
-            progress = status.get('progress', {}).get('percentage', 0)
-            
-            if status.get('status') == 'completed':
-                self.status = 'completed'
-                return await self.show_results()
-        
-        # Friendly progress update
-        messages = [
-            {
-                "role": "system",
-                "content": "Research is currently running. Be helpful and conversational while they wait."
-            },
-            {"role": "user", "content": user_message}
-        ]
-        
-        bot_response = await self.chat_client.chat(
-            messages=messages,
-            model="llama-3.3-70b",  # This model is correct for Cerebras
-            temperature=0.7,
-            max_tokens=800
-        )
-        # Add progress info if available
-        if 'progress' in locals():
-            bot_response += f"\n\n(Research is {progress}% complete)"
-        
-        self.history.append({"role": "assistant", "content": bot_response})
-        return bot_response
-
-    def _enhance_response_naturally(self, response: str, user_message: str) -> str:
-        """Add natural enhancements to responses."""
-        
-        # Don't enhance if already natural
-        if any(phrase in response[:50] for phrase in ["You know", "Actually", "Hmm", "That's"]):
-            return response
-        
-        # Add natural starter based on context
-        if "?" in user_message:
-            starters = ["That's a great question! ", "Good question - ", "Hmm, "]
-            response = random.choice(starters) + response
-        
-        return response
-
-    def _generate_fallback_response(self, user_message: str) -> str:
-        """Generate fallback response when LLM fails."""
-        
-        if "?" in user_message:
-            return "That's an interesting question! Could you tell me a bit more about what you're looking for?"
-        else:
-            return "I'm here to help with research and exploration. What would you like to know more about?"
-
-    def _analyze_conversation_state(self) -> str:
-        """Dynamically determine conversation state based on multiple factors."""
-        
-        # Don't need complex AI here - just smart logic!
-        conversation_length = len(self.history)
-        
-        # Early conversation
-        if conversation_length < 4:
-            return "warming_up"
-        
-        # Check if we're already researching
-        if self.status == "running":
-            return "researching"
-        
-        # Check if we have results
-        if self.synthesis:
-            return "discussing_results"
-        
-        # Check depth and engagement
-        if self.research_proposed and not self.projection_given:
-            return "ready_for_research"
-        
-        # Default exploring state
-        complexity = self._assess_question_complexity()
-        if complexity > 0.5 and conversation_length > 6:
-            return "ready_for_research"
-        
-        return "exploring"
-
-    def _is_ambiguous(self, user_message: str) -> bool:
-        """Check if user message is ambiguous."""
-        # Simple checks - no AI needed
-        message_lower = user_message.lower().strip()
-        
-        # Too short
-        if len(message_lower.split()) < 3:
-            return True
-        
-        # Very broad terms
-        broad_terms = ["everything", "all", "anything", "whatever", "stuff"]
-        if any(term in message_lower for term in broad_terms) and "?" in message_lower:
-            return True
-        
-        # Multiple unrelated topics
-        topic_keywords = ["and also", "oh and", "btw", "by the way", "another thing"]
-        if any(keyword in message_lower for keyword in topic_keywords):
-            return True
-        
-        return False
-
-    def _prepare_conversation_history(self) -> list:
-        """Prepare conversation history for LLM context."""
-        # Keep last 10 messages or less
-        return self.history[-10:]
-
-    def _summarize_web_context(self) -> str:
-        """Summarize web search results for context."""
-        if not self.parallel_web_context:
-            return "No recent web searches"
-        
-        # Simple summary of top 3 results
-        summaries = []
-        for result in self.parallel_web_context[:3]:
-            title = result.get('title', 'Unknown')
-            snippet = result.get('snippet', '')[:100]
-            summaries.append(f"{title}: {snippet}...")
-        
-        return " | ".join(summaries)
-
-    def _has_research_indicators(self) -> bool:
-        """Check if conversation has research indicators."""
-        recent_messages = " ".join([
-            turn["content"].lower() for turn in self.history[-4:] 
-            if turn["role"] == "user"
-        ])
-        
-        research_terms = [
-            "research", "papers", "study", "literature", 
-            "evidence", "findings", "what does the research say"
-        ]
-        
-        return any(term in recent_messages for term in research_terms)
-
-    async def _handle_topic_inquiry(self, user_message: str) -> str:
-        """Handle inquiries about specific topics with academic depth."""
-        try:
-            # Extract the topic being inquired about
-            topic_prompt = f"Extract the specific topic or concept being inquired about from: {user_message}"
-            topic_result = await self.doc_client.process_document(
-                title="Topic Extraction",
-                content=topic_prompt,
-                model="llama-3.3-70b",
-                temperature=0.1,
-                max_tokens=100
-            )
-            
-            topic = topic_result.get("raw_text", "").strip()
-            
-            # Create comprehensive response about the topic
-            response_prompt = (
-                f"Provide a comprehensive academic explanation of '{topic}' including:\n"
-                f"- Definition and key concepts\n"
-                f"- Current state of research\n"
-                f"- Related academic fields\n"
-                f"- Potential research directions\n"
-                f"- How it might relate to the user's research context\n\n"
-                f"User's research context: {self.get_context_summary()}"
-            )
-            
-            result = await self.doc_client.process_document(
-                title="Topic Explanation",
-                content=response_prompt,
-                model="llama-3.3-70b",
-                temperature=0.4,
-                max_tokens=400
-            )
-            
-            response = result.get("raw_text", f"I'm familiar with {topic}. Could you tell me more about how it relates to your research?")
-            
-            self.history.append({"role": "assistant", "content": response})
-            return response
-            
-        except Exception as e:
-            return "I'd be happy to discuss that topic in detail. Could you tell me more about how it relates to your research?"
-
-    async def _handle_scope_change(self, user_message: str) -> str:
-        """Handle scope changes with academic research methodology."""
-        try:
-            prompt = (
-                f"User wants to change the research scope: {user_message}\n\n"
-                f"Current research context: {self.get_context_summary()}\n\n"
-                f"Provide guidance on how to handle this scope change academically, including:\n"
-                f"- Whether to expand current research or start new\n"
-                f"- How to maintain academic rigor\n"
-                f"- Potential research questions\n"
-                f"- Methodology considerations"
-            )
-            
-            result = await self.doc_client.process_document(
-                title="Scope Change Guidance",
-                content=prompt,
-                model="llama-3.3-70b",
-                temperature=0.3,
-                max_tokens=400
-            )
-            
-            response = result.get("raw_text", "I can help you adjust the research scope. Should we expand the current research or start a new direction?")
-            
-            self.history.append({"role": "assistant", "content": response})
-            return response
-            
-        except Exception as e:
-            return "I can help you adjust the research scope. Would you like to expand the current research or explore a new direction?"
-
-    async def _prompt_for_research_preferences(self) -> str:
-        """Prompt user for research timeframe and depth preferences."""
-        preference_message = (
-            "🤖 Bot: I'm ready to research this topic comprehensively. "
-            "I can conduct thorough research in the background to get the most complete synthesis possible.\n\n"
-            "**Research Options:**\n"
-            "• **Comprehensive** (recommended): I'll research as much as I can for the most complete findings\n"
-            "• **Time-limited**: Set a specific timeframe (e.g., 'finish in 10 minutes' or 'take up to 1 hour')\n"
-            "• **Quick overview**: Just get the main points quickly\n\n"
-            "What's your preference? You can say:\n"
-            "- 'Go comprehensive' or 'Take your time'\n"
-            "- 'Finish in X minutes/hours'\n"
-            "- 'Quick overview only'\n"
-            "- Or just 'proceed' for comprehensive research"
-        )
-        self.history.append({"role": "assistant", "content": preference_message})
-        return preference_message
-
-    async def _parse_research_preferences(self, user_message: str) -> dict:
-        """Parse user's research timeframe and depth preferences."""
-        message_lower = user_message.lower()
-        
-        # Default to comprehensive research
-        preferences = {
-            "comprehensive": True,
-            "time_limit": None,
-            "quick_overview": False
-        }
-        
-        # Check for time limits
-        time_patterns = [
-            r"finish in (\d+)\s*(minute|minutes|hour|hours)",
-            r"(\d+)\s*(minute|minutes|hour|hours)",
-            r"time limit.*?(\d+)\s*(minute|minutes|hour|hours)",
-            r"(\d+)\s*(min|mins|hr|hrs)"
-        ]
-        
-        for pattern in time_patterns:
-            match = re.search(pattern, message_lower)
-            if match:
-                time_value = int(match.group(1))
-                time_unit = match.group(2)
-                if time_unit in ['minute', 'minutes', 'min', 'mins']:
-                    preferences["time_limit"] = time_value * 60  # Convert to seconds
-                elif time_unit in ['hour', 'hours', 'hr', 'hrs']:
-                    preferences["time_limit"] = time_value * 3600  # Convert to seconds
-                preferences["comprehensive"] = False
-                break
-        
-        # Check for quick overview
-        if any(phrase in message_lower for phrase in ["quick", "overview", "summary", "brief", "fast"]):
-            preferences["quick_overview"] = True
-            preferences["comprehensive"] = False
-        
-        # Check for comprehensive research
-        if any(phrase in message_lower for phrase in ["comprehensive", "thorough", "complete", "take your time", "go comprehensive"]):
-            preferences["comprehensive"] = True
-            preferences["quick_overview"] = False
-        
-        return preferences
-
-    def get_context_summary(self) -> str:
-        summary = "\n".join([
-            f"{turn['role'].capitalize()}: {turn['content']}" for turn in self.history
-        ])
-        return summary
-
-    async def build_research_plan(self):
-        """Use LLMDocClient to synthesize a research plan from the conversation."""
-        try:
-            plan_prompt = (
-                "Summarize the following conversation as a structured research plan. "
-                "List the main topic, sub-questions, and any constraints or context provided by the user.\n\n"
-            ) + self.get_context_summary()
-            # Use doc client for plan extraction
-            result = await self.doc_client.process_document(
-                title="Research Plan Extraction",
-                content=plan_prompt,
-                model="llama-3.3-70b",
-                temperature=0.3,
-                max_tokens=1500
-            )
-            plan = result.get("raw_text") or result.get("main_findings", [""])[0] or "[No plan extracted]"
-            self.research_plan = plan
-            return plan
-        except Exception as e:
-            return f"Error building plan: {str(e)}"
-
-    async def check_status(self):
-        if not self.session_id:
-            print("No research session running.")
-            return
-        status = await self.context_manager.get_session_status(self.session_id)
-        print(f"\n[Session Status: {status.get('status')}] Progress: {status.get('progress', {}).get('percentage', 0)}%")
-        if status.get('status') == 'completed':
-            self.status = 'completed'
-        return status
-
-    async def show_results(self):
-        if not self.session_id:
-            return "No research session found."
-        session = await self.context_manager._get_session(self.session_id)
-        synthesis = session.synthesis if session else None
-        if synthesis:
-            self.synthesis = synthesis
-            results_message = (
-                f"Research complete! Here are the findings:\n\n"
-                f"{str(synthesis)[:2000]}{'...' if len(str(synthesis)) > 2000 else ''}\n\n"
-                f"You can ask me follow-up questions about the results, or start a new research topic."
-            )
-            
-            self.history.append({"role": "assistant", "content": results_message})
-            return results_message
-        else:
-            return "Research is still in progress. Please wait a moment."
-
-    def _extract_topic_and_questions(self, plan: str):
-        topic = None
-        questions = []
-        for line in plan.splitlines():
-            if line.lower().startswith("topic:"):
-                topic = line.split(":", 1)[1].strip()
-            elif line.lower().startswith("questions:"):
-                continue
-            elif line.strip().startswith("-"):
-                questions.append(line.strip("- ").strip())
-        if not topic:
-            for turn in self.history:
-                if turn["role"] == "user":
-                    topic = turn["content"]
-                    break
-        return topic or "Untitled Research", questions
-
-    async def _start_research_with_preferences(self, preferences: dict) -> str:
-        """Start research with user-specified preferences for timeframe and depth."""
-        
-        # Set research parameters based on preferences
-        if preferences.get("time_limit"):
-            self.max_research_time = preferences["time_limit"]
-        
-        if preferences.get("quick_overview"):
-            self.research_depth = "quick"
-        elif preferences.get("comprehensive"):
-            self.research_depth = "comprehensive"
-        
-        # Start the research process
-        return await self._start_research()
-
-async def run_cli_chatbot():
-    print("\n🧑‍💻 Nocturnal Archive Research Chatbot (CLI Mode)")
-    print("Type 'exit' to quit. Type 'status' to check progress.\n")
-    
-    # Check system readiness
-    system_issues = []
-    
-    # Check API keys
-    required_keys = ['MISTRAL_API_KEY', 'COHERE_API_KEY', 'CEREBRAS_API_KEY']
-    for key in required_keys:
-        if not os.environ.get(key):
-            system_issues.append(f"Missing {key}")
-    
-    # Check database URLs
-    if not os.environ.get('MONGODB_URL') and not os.environ.get('MONGO_URL'):
-        system_issues.append("Missing database URL")
-    
-    if not os.environ.get('REDIS_URL'):
-        system_issues.append("Missing Redis URL")
-    
-    # Display system status
-    if system_issues:
-        print("⚠️  System Configuration Issues Detected:")
-        for issue in system_issues:
-            print(f"   • {issue}")
-        print("\n🔄 Running in simulation mode with limited functionality.")
-        print("   For full functionality, please configure your .env.local file.")
-        print("   See SETUP_GUIDE.md for detailed instructions.\n")
-    
-    try:
-        # Try to initialize full system
-        db_ops = None
-        llm_manager = None
-        synthesizer = None
-        context_manager = None
-        
-        try:
-            redis_url = os.environ.get('REDIS_URL', 'redis://localhost:6379')
-            mongo_url = os.environ.get('MONGODB_URL', os.environ.get('MONGO_URL', 'mongodb://localhost:27017/nocturnal_archive'))
-
-            db_ops = DatabaseOperations(mongo_url, redis_url)
-            llm_manager = LLMManager(redis_url)
-            knowledge_graph = KnowledgeGraph()
-            synthesizer = ResearchSynthesizer(
-                db_ops=db_ops,
-                llm_manager=llm_manager,
-                redis_url=redis_url,
-                kg_client=knowledge_graph
-            )
-            context_manager = ResearchContextManager(db_ops, synthesizer, redis_url)
-        except Exception as e:
-            logger.warning(f"Full system initialization failed: {e}")
-            print("⚠️  Some system components failed to initialize.")
-            print("   Running in fallback mode with simulated responses.\n")
-        
-        # Initialize chatbot session (will automatically detect fallback mode)
-        session = ChatbotResearchSession(context_manager, synthesizer, db_ops)
-        
-        print("✅ Chatbot initialized successfully!")
-        if session.fallback_mode:
-            print("📋 Available in simulation mode:")
-            print("   • Research topic discussions")
-            print("   • Workflow demonstrations")
-            print("   • Capability explanations")
-            print("   • Error-free conversation")
-        else:
-            print("🚀 Full functionality available!")
-            print("   • Real research execution")
-            print("   • Database integration")
-            print("   • LLM-powered analysis")
-        
-        print("\n" + "="*50)
-        print("Start your conversation! Try saying:")
-        print("• 'Hello' or 'Hi'")
-        print("• 'I want to research quantum computing'")
-        print("• 'What can you do?'")
-        print("• 'Help'")
-        print("="*50 + "\n")
-        
-        # Initialize typing effect for welcome message
-        typing_effect = TypingEffect(speed=0.02)
-        welcome_message = "Hello! I'm the Nocturnal Archive research assistant. I can help you with comprehensive research on any topic. What would you like to research today?"
-        await typing_effect.type_message(welcome_message)
-        
-        while session.active:
-            try:
-                user_input = input("\nYou: ").strip()
-                
-                if user_input.lower() in {"exit", "quit", "bye"}:
-                    await typing_effect.type_message("Goodbye! Thanks for using Nocturnal Archive!")
-                    break
-                
-                if user_input.lower() == "status":
-                    if not session.fallback_mode:
-                        await session.check_status()
-                    else:
-                        await typing_effect.type_message("Running in simulation mode - no active research sessions.")
-                    continue
-                
-                if user_input.lower() == "help":
-                    help_message = "Available commands:\n   • Type any research topic to start a conversation\n   • 'status' - Check research progress (full mode only)\n   • 'exit' or 'quit' - End the session\n   • 'help' - Show this help message"
-                    await typing_effect.type_message(help_message)
-                    continue
-                
-                if not user_input:
-                    await typing_effect.type_message("Please type something! I'm here to help with research.")
-                    continue
-                
-                # Process the response (typing effect is handled in chat_turn)
-                response = await session.chat_turn(user_input)
-                
-            except EOFError:
-                await typing_effect.type_message("Goodbye! Thanks for using Nocturnal Archive!")
-                break
-            except KeyboardInterrupt:
-                await typing_effect.type_message("Goodbye! Thanks for using Nocturnal Archive!")
-                break
-            except Exception as e:
-                logger.error(f"Unexpected error in chat loop: {str(e)}")
-                await typing_effect.type_message(f"I encountered an unexpected error: {str(e)}")
-                await typing_effect.type_message("Let's continue our conversation!")
-                continue
-                
-    except Exception as e:
-        logger.error(f"Failed to initialize chatbot: {str(e)}")
-        print(f"❌ Failed to initialize chatbot: {str(e)}")
-        print("\n🔧 Troubleshooting:")
-        print("1. Check your .env.local file configuration")
-        print("2. Ensure all required dependencies are installed")
-        print("3. Verify database connections")
-        print("4. Check API key configuration")
-        print("\n📖 For detailed setup instructions, see SETUP_GUIDE.md")