local-deep-research 0.5.2__py3-none-any.whl → 0.5.3__py3-none-any.whl

local_deep_research/__version__.py

@@ -1 +1 @@
-__version__ = "0.5.2"
+__version__ = "0.5.3"

local_deep_research/config/llm_config.py

@@ -397,6 +397,24 @@ def get_llm(
                 llm = ChatOllama(
                     model=model_name, base_url=base_url, **common_params
                 )
+
+                # Log the actual client configuration after creation
+                logger.debug(
+                    f"ChatOllama created - base_url attribute: {getattr(llm, 'base_url', 'not found')}"
+                )
+                if hasattr(llm, "_client"):
+                    client = llm._client
+                    logger.debug(f"ChatOllama _client type: {type(client)}")
+                    if hasattr(client, "_client"):
+                        inner_client = client._client
+                        logger.debug(
+                            f"ChatOllama inner client type: {type(inner_client)}"
+                        )
+                        if hasattr(inner_client, "base_url"):
+                            logger.debug(
+                                f"ChatOllama inner client base_url: {inner_client.base_url}"
+                            )
+
                 # Test invoke to validate model works
                 logger.info("Testing Ollama model with simple invocation")
                 test_result = llm.invoke("Hello")
@@ -545,7 +563,49 @@ def wrap_llm_without_think_tags(
             self.base_llm = base_llm
 
         def invoke(self, *args, **kwargs):
-            response = self.base_llm.invoke(*args, **kwargs)
+            # Log detailed request information for Ollama models
+            if hasattr(self.base_llm, "base_url"):
+                logger.debug(
+                    f"LLM Request - Base URL: {self.base_llm.base_url}"
+                )
+                logger.debug(
+                    f"LLM Request - Model: {getattr(self.base_llm, 'model', 'unknown')}"
+                )
+                logger.debug(
+                    f"LLM Request - Args count: {len(args)}, Kwargs: {list(kwargs.keys())}"
+                )
+
+                # Log the prompt if it's in args
+                if args and len(args) > 0:
+                    prompt_text = (
+                        str(args[0])[:200] + "..."
+                        if len(str(args[0])) > 200
+                        else str(args[0])
+                    )
+                    logger.debug(f"LLM Request - Prompt preview: {prompt_text}")
+
+                # Check if there's any client configuration
+                if hasattr(self.base_llm, "_client"):
+                    client = self.base_llm._client
+                    if hasattr(client, "_client") and hasattr(
+                        client._client, "base_url"
+                    ):
+                        logger.debug(
+                            f"LLM Request - Client base URL: {client._client.base_url}"
+                        )
+
+            try:
+                response = self.base_llm.invoke(*args, **kwargs)
+                logger.debug(f"LLM Response - Success, type: {type(response)}")
+            except Exception as e:
+                logger.error(f"LLM Request - Failed with error: {str(e)}")
+                # Log any URL information from the error
+                error_str = str(e)
+                if "http://" in error_str or "https://" in error_str:
+                    logger.error(
+                        f"LLM Request - Error contains URL info: {error_str}"
+                    )
+                raise
 
             # Process the response content if it has a content attribute
             if hasattr(response, "content"):

local_deep_research/error_handling/__init__.py

@@ -0,0 +1,13 @@
+"""
+Error Handling Module for Local Deep Research
+
+This module provides comprehensive error handling capabilities including:
+- Error categorization and analysis
+- User-friendly error report generation
+- Integration with partial research results
+"""
+
+from .error_reporter import ErrorReporter
+from .report_generator import ErrorReportGenerator
+
+__all__ = ["ErrorReporter", "ErrorReportGenerator"]

local_deep_research/error_handling/error_reporter.py

@@ -0,0 +1,236 @@
+"""
+ErrorReporter - Main error categorization and handling logic
+"""
+
+import re
+from enum import Enum
+from typing import Dict, Optional, Any
+from loguru import logger
+
+
+class ErrorCategory(Enum):
+    """Categories of errors that can occur during research"""
+
+    CONNECTION_ERROR = "connection_error"
+    MODEL_ERROR = "model_error"
+    SEARCH_ERROR = "search_error"
+    SYNTHESIS_ERROR = "synthesis_error"
+    FILE_ERROR = "file_error"
+    UNKNOWN_ERROR = "unknown_error"
+
+
+class ErrorReporter:
+    """
+    Analyzes and categorizes errors to provide better user feedback
+    """
+
+    def __init__(self):
+        self.error_patterns = {
+            ErrorCategory.CONNECTION_ERROR: [
+                r"POST predict.*EOF",
+                r"Connection refused",
+                r"timeout",
+                r"Connection.*failed",
+                r"HTTP error \d+",
+                r"network.*error",
+                r"\[Errno 111\]",
+                r"host\.docker\.internal",
+                r"host.*localhost.*Docker",
+                r"127\.0\.0\.1.*Docker",
+                r"localhost.*1234.*Docker",
+                r"LM.*Studio.*Docker.*Mac",
+            ],
+            ErrorCategory.MODEL_ERROR: [
+                r"Model.*not found",
+                r"Invalid.*model",
+                r"Ollama.*not available",
+                r"API key.*invalid",
+                r"Authentication.*error",
+                r"max_workers must be greater than 0",
+                r"TypeError.*Context.*Size",
+                r"'<' not supported between",
+                r"No auth credentials found",
+                r"401.*API key",
+            ],
+            ErrorCategory.SEARCH_ERROR: [
+                r"Search.*failed",
+                r"No search results",
+                r"Search engine.*error",
+                r"Rate limit.*exceeded",
+                r"The search is longer than 256 characters",
+                r"Failed to create search engine",
+                r"could not be found",
+                r"GitHub API error",
+                r"database.*locked",
+            ],
+            ErrorCategory.SYNTHESIS_ERROR: [
+                r"Error.*synthesis",
+                r"Failed.*generate",
+                r"Synthesis.*timeout",
+                r"detailed.*report.*stuck",
+                r"report.*taking.*long",
+                r"progress.*100.*stuck",
+            ],
+            ErrorCategory.FILE_ERROR: [
+                r"Permission denied",
+                r"File.*not found",
+                r"Cannot write.*file",
+                r"Disk.*full",
+                r"No module named.*local_deep_research",
+                r"HTTP error 404.*research results",
+                r"Attempt to write readonly database",
+            ],
+        }
+
+    def categorize_error(self, error_message: str) -> ErrorCategory:
+        """
+        Categorize an error based on its message
+
+        Args:
+            error_message: The error message to categorize
+
+        Returns:
+            ErrorCategory: The categorized error type
+        """
+        error_message = str(error_message).lower()
+
+        for category, patterns in self.error_patterns.items():
+            for pattern in patterns:
+                if re.search(pattern.lower(), error_message):
+                    logger.debug(
+                        f"Categorized error as {category.value}: {pattern}"
+                    )
+                    return category
+
+        return ErrorCategory.UNKNOWN_ERROR
+
+    def get_user_friendly_title(self, category: ErrorCategory) -> str:
+        """
+        Get a user-friendly title for an error category
+
+        Args:
+            category: The error category
+
+        Returns:
+            str: User-friendly title
+        """
+        titles = {
+            ErrorCategory.CONNECTION_ERROR: "Connection Issue",
+            ErrorCategory.MODEL_ERROR: "LLM Service Error",
+            ErrorCategory.SEARCH_ERROR: "Search Service Error",
+            ErrorCategory.SYNTHESIS_ERROR: "Report Generation Error",
+            ErrorCategory.FILE_ERROR: "File System Error",
+            ErrorCategory.UNKNOWN_ERROR: "Unexpected Error",
+        }
+        return titles.get(category, "Error")
+
+    def get_suggested_actions(self, category: ErrorCategory) -> list:
+        """
+        Get suggested actions for resolving an error
+
+        Args:
+            category: The error category
+
+        Returns:
+            list: List of suggested actions
+        """
+        suggestions = {
+            ErrorCategory.CONNECTION_ERROR: [
+                "Check if the LLM service (Ollama/LM Studio) is running",
+                "Verify network connectivity",
+                "Try switching to a different model provider",
+                "Check the service logs for more details",
+            ],
+            ErrorCategory.MODEL_ERROR: [
+                "Verify the model name is correct",
+                "Check if the model is downloaded and available",
+                "Validate API keys if using external services",
+                "Try switching to a different model",
+            ],
+            ErrorCategory.SEARCH_ERROR: [
+                "Check internet connectivity",
+                "Try reducing the number of search results",
+                "Wait a moment and try again",
+                "Check if search service is configured correctly",
+                "For local documents: ensure the path is absolute and folder exists",
+                "Try a different search engine if one is failing",
+            ],
+            ErrorCategory.SYNTHESIS_ERROR: [
+                "The research data was collected successfully",
+                "Try switching to a different model for report generation",
+                "Check the partial results below",
+                "Review the detailed logs for more information",
+            ],
+            ErrorCategory.FILE_ERROR: [
+                "Check disk space availability",
+                "Verify write permissions",
+                "Try changing the output directory",
+                "Restart the application",
+            ],
+            ErrorCategory.UNKNOWN_ERROR: [
+                "Check the detailed logs below for more information",
+                "Try running the research again",
+                "Report this issue if it persists",
+                "Contact support with the error details",
+            ],
+        }
+        return suggestions.get(category, ["Check the logs for more details"])
+
+    def analyze_error(
+        self, error_message: str, context: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Perform comprehensive error analysis
+
+        Args:
+            error_message: The error message to analyze
+            context: Optional context information
+
+        Returns:
+            dict: Comprehensive error analysis
+        """
+        category = self.categorize_error(error_message)
+
+        analysis = {
+            "category": category,
+            "title": self.get_user_friendly_title(category),
+            "original_error": error_message,
+            "suggestions": self.get_suggested_actions(category),
+            "severity": self._determine_severity(category),
+            "recoverable": self._is_recoverable(category),
+        }
+
+        # Add context-specific information
+        if context:
+            analysis["context"] = context
+            analysis["has_partial_results"] = bool(
+                context.get("findings")
+                or context.get("current_knowledge")
+                or context.get("search_results")
+            )
+
+        return analysis
+
+    def _determine_severity(self, category: ErrorCategory) -> str:
+        """Determine error severity level"""
+        severity_map = {
+            ErrorCategory.CONNECTION_ERROR: "high",
+            ErrorCategory.MODEL_ERROR: "high",
+            ErrorCategory.SEARCH_ERROR: "medium",
+            ErrorCategory.SYNTHESIS_ERROR: "low",  # Can often show partial results
+            ErrorCategory.FILE_ERROR: "medium",
+            ErrorCategory.UNKNOWN_ERROR: "high",
+        }
+        return severity_map.get(category, "medium")
+
+    def _is_recoverable(self, category: ErrorCategory) -> bool:
+        """Determine if error is recoverable with user action"""
+        recoverable = {
+            ErrorCategory.CONNECTION_ERROR: True,
+            ErrorCategory.MODEL_ERROR: True,
+            ErrorCategory.SEARCH_ERROR: True,
+            ErrorCategory.SYNTHESIS_ERROR: True,
+            ErrorCategory.FILE_ERROR: True,
+            ErrorCategory.UNKNOWN_ERROR: False,
+        }
+        return recoverable.get(category, False)

local_deep_research/error_handling/report_generator.py

@@ -0,0 +1,403 @@
+"""
+ErrorReportGenerator - Create user-friendly error reports
+"""
+
+from typing import Dict, Any, Optional
+from loguru import logger
+
+from .error_reporter import ErrorReporter
+
+
+class ErrorReportGenerator:
+    """
+    Generates comprehensive, user-friendly error reports
+    """
+
+    def __init__(self, llm=None):
+        """
+        Initialize error report generator
+
+        Args:
+            llm: Optional LLM instance (unused, kept for compatibility)
+        """
+        self.error_reporter = ErrorReporter()
+
+    def generate_error_report(
+        self,
+        error_message: str,
+        query: str,
+        partial_results: Optional[Dict[str, Any]] = None,
+        search_iterations: int = 0,
+        research_id: Optional[int] = None,
+    ) -> str:
+        """
+        Generate a comprehensive error report
+
+        Args:
+            error_message: The error that occurred
+            query: The research query
+            partial_results: Any partial results that were collected
+            search_iterations: Number of search iterations completed
+            research_id: Research ID for reference
+
+        Returns:
+            str: Formatted error report in Markdown
+        """
+        try:
+            # Analyze the error
+            context = {
+                "query": query,
+                "search_iterations": search_iterations,
+                "research_id": research_id,
+                "partial_results": partial_results,
+            }
+
+            if partial_results:
+                context.update(partial_results)
+
+            error_analysis = self.error_reporter.analyze_error(
+                error_message, context
+            )
+
+            # Build the simplified report
+            report_parts = []
+
+            # Header with user-friendly error message and logs reference
+            user_friendly_message = self._make_error_user_friendly(
+                error_message
+            )
+            category_title = error_analysis.get("title", "Error")
+
+            report_parts.append("# ⚠️ Research Failed")
+            report_parts.append(f"\n**Error Type:** {category_title}")
+            report_parts.append(f"\n**What happened:** {user_friendly_message}")
+            report_parts.append(
+                '\n*For detailed error information, scroll down to the research logs and select "Errors" from the filter.*'
+            )
+
+            # Support links - moved up for better visibility
+            report_parts.append("\n## 💬 Get Help")
+            report_parts.append("We're here to help you get this working:")
+            report_parts.append(
+                "- 📖 **Documentation & guides:** [Wiki](https://github.com/LearningCircuit/local-deep-research/wiki)"
+            )
+            report_parts.append(
+                "- 💬 **Chat with the community:** [Discord #help-and-support](https://discord.gg/ttcqQeFcJ3)"
+            )
+            report_parts.append(
+                "- 🐛 **Report bugs or get help:** [GitHub Issues](https://github.com/LearningCircuit/local-deep-research/issues) *(don't hesitate to ask if you're stuck!)*"
+            )
+            report_parts.append(
+                "- 💭 **Join discussions:** [Reddit r/LocalDeepResearch](https://www.reddit.com/r/LocalDeepResearch/) *(checked less frequently)*"
+            )
+
+            # Show partial results if available (in expandable section)
+            if error_analysis.get("has_partial_results"):
+                partial_content = self._format_partial_results(partial_results)
+                if partial_content:
+                    report_parts.append(
+                        f"\n<details>\n<summary>📊 Partial Results Available</summary>\n\n{partial_content}\n</details>"
+                    )
+
+            return "\n".join(report_parts)
+
+        except Exception as e:
+            # Fallback: always return something, even if error report generation fails
+            logger.exception(f"Failed to generate error report: {e}")
+            return f"""# ⚠️ Research Failed
+
+**What happened:** {error_message}
+
+## 💬 Get Help
+We're here to help you get this working:
+- 📖 **Documentation & guides:** [Wiki](https://github.com/LearningCircuit/local-deep-research/wiki)
+- 💬 **Chat with the community:** [Discord #help-and-support](https://discord.gg/ttcqQeFcJ3)
+- 🐛 **Report bugs or get help:** [GitHub Issues](https://github.com/LearningCircuit/local-deep-research/issues) *(don't hesitate to ask if you're stuck!)*
+
+*Note: Error report generation failed - showing basic error information.*"""
+
+    def _format_partial_results(
+        self, partial_results: Optional[Dict[str, Any]]
+    ) -> str:
+        """
+        Format partial results for display
+
+        Args:
+            partial_results: Partial results data
+
+        Returns:
+            str: Formatted partial results
+        """
+        if not partial_results:
+            return ""
+
+        formatted_parts = []
+
+        # Current knowledge summary
+        if "current_knowledge" in partial_results:
+            knowledge = partial_results["current_knowledge"]
+            if knowledge and len(knowledge.strip()) > 50:
+                formatted_parts.append("### Research Summary\n")
+                formatted_parts.append(
+                    knowledge[:1000] + "..."
+                    if len(knowledge) > 1000
+                    else knowledge
+                )
+                formatted_parts.append("")
+
+        # Search results
+        if "search_results" in partial_results:
+            results = partial_results["search_results"]
+            if results:
+                formatted_parts.append("### Search Results Found\n")
+                for i, result in enumerate(results[:5], 1):  # Show top 5
+                    title = result.get("title", "Untitled")
+                    url = result.get("url", "")
+                    formatted_parts.append(f"{i}. **{title}**")
+                    if url:
+                        formatted_parts.append(f"   - URL: {url}")
+                formatted_parts.append("")
+
+        # Findings
+        if "findings" in partial_results:
+            findings = partial_results["findings"]
+            if findings:
+                formatted_parts.append("### Research Findings\n")
+                for i, finding in enumerate(findings[:3], 1):  # Show top 3
+                    content = finding.get("content", "")
+                    if content and not content.startswith("Error:"):
+                        phase = finding.get("phase", f"Finding {i}")
+                        formatted_parts.append(f"**{phase}:**")
+                        formatted_parts.append(
+                            content[:500] + "..."
+                            if len(content) > 500
+                            else content
+                        )
+                        formatted_parts.append("")
+
+        if formatted_parts:
+            formatted_parts.append(
+                "*Note: The above results were successfully collected before the error occurred.*"
+            )
+
+        return "\n".join(formatted_parts) if formatted_parts else ""
+
+    def _get_technical_context(
+        self,
+        error_analysis: Dict[str, Any],
+        partial_results: Optional[Dict[str, Any]],
+    ) -> str:
+        """
+        Get additional technical context for the error
+
+        Args:
+            error_analysis: Error analysis results
+            partial_results: Partial results if available
+
+        Returns:
+            str: Technical context information
+        """
+        context_parts = []
+
+        # Add timing information if available
+        if partial_results:
+            if "start_time" in partial_results:
+                context_parts.append(
+                    f"- **Start Time:** {partial_results['start_time']}"
+                )
+
+            if "last_activity" in partial_results:
+                context_parts.append(
+                    f"- **Last Activity:** {partial_results['last_activity']}"
+                )
+
+            # Add model information
+            if "model_config" in partial_results:
+                config = partial_results["model_config"]
+                context_parts.append(
+                    f"- **Model:** {config.get('model_name', 'Unknown')}"
+                )
+                context_parts.append(
+                    f"- **Provider:** {config.get('provider', 'Unknown')}"
+                )
+
+            # Add search information
+            if "search_config" in partial_results:
+                search_config = partial_results["search_config"]
+                context_parts.append(
+                    f"- **Search Engine:** {search_config.get('engine', 'Unknown')}"
+                )
+                context_parts.append(
+                    f"- **Max Results:** {search_config.get('max_results', 'Unknown')}"
+                )
+
+            # Add any error codes or HTTP status
+            if "status_code" in partial_results:
+                context_parts.append(
+                    f"- **Status Code:** {partial_results['status_code']}"
+                )
+
+            if "error_code" in partial_results:
+                context_parts.append(
+                    f"- **Error Code:** {partial_results['error_code']}"
+                )
+
+        # Add error-specific context based on category
+        category = error_analysis.get("category")
+        if category:
+            if "connection" in category.value.lower():
+                context_parts.append(
+                    "- **Network Error:** Connection-related issue detected"
+                )
+                context_parts.append(
+                    "- **Retry Recommended:** Check service status and try again"
+                )
+            elif "model" in category.value.lower():
+                context_parts.append(
+                    "- **Model Error:** Issue with AI model or configuration"
+                )
+                context_parts.append(
+                    "- **Check:** Model service availability and parameters"
+                )
+
+        return "\n".join(context_parts) if context_parts else ""
+
+    def generate_quick_error_summary(
+        self, error_message: str
+    ) -> Dict[str, str]:
+        """
+        Generate a quick error summary for API responses
+
+        Args:
+            error_message: The error message
+
+        Returns:
+            dict: Quick error summary
+        """
+        error_analysis = self.error_reporter.analyze_error(error_message)
+
+        return {
+            "title": error_analysis["title"],
+            "category": error_analysis["category"].value,
+            "severity": error_analysis["severity"],
+            "recoverable": error_analysis["recoverable"],
+        }
+
+    def _make_error_user_friendly(self, error_message: str) -> str:
+        """
+        Replace cryptic technical error messages with user-friendly versions
+
+        Args:
+            error_message: The original technical error message
+
+        Returns:
+            str: User-friendly error message, or original if no replacement found
+        """
+        # Dictionary of technical errors to user-friendly messages
+        error_replacements = {
+            "max_workers must be greater than 0": (
+                "The LLM failed to generate search questions. This usually means the LLM service isn't responding properly.\n\n"
+                "**Try this:**\n"
+                "- Check if your LLM service (Ollama/LM Studio) is running\n"
+                "- Restart the LLM service\n"
+                "- Try a different model"
+            ),
+            "POST predict.*EOF": (
+                "Lost connection to Ollama. This usually means Ollama stopped responding or there's a network issue.\n\n"
+                "**Try this:**\n"
+                "- Restart Ollama: `ollama serve`\n"
+                "- Check if Ollama is still running: `ps aux | grep ollama`\n"
+                "- Try a different port if 11434 is in use"
+            ),
+            "HTTP error 404.*research results": (
+                "The research completed but the results can't be displayed. The files were likely generated successfully.\n\n"
+                "**Try this:**\n"
+                "- Check the `research_outputs` folder for your report\n"
+                "- Ensure the folder has proper read/write permissions\n"
+                "- Restart the LDR web interface"
+            ),
+            "Connection refused|\\[Errno 111\\]": (
+                "Cannot connect to the LLM service. The service might not be running or is using a different address.\n\n"
+                "**Try this:**\n"
+                "- Start your LLM service (Ollama: `ollama serve`, LM Studio: launch the app)\n"
+                "- **Docker on Mac/Windows:** Change URL from `http://localhost:1234` to `http://host.docker.internal:1234`\n"
+                "- **Docker on Linux:** Use your host IP instead of localhost (find with `hostname -I`)\n"
+                "- Check the service URL in settings matches where your LLM is running\n"
+                "- Verify the port number is correct (Ollama: 11434, LM Studio: 1234)"
+            ),
+            "The search is longer than 256 characters": (
+                "Your search query is too long for GitHub's API (max 256 characters).\n\n"
+                "**Try this:**\n"
+                "- Shorten your research query\n"
+                "- Use a different search engine (DuckDuckGo, Searx, etc.)\n"
+                "- Break your research into smaller, focused queries"
+            ),
+            "No module named.*local_deep_research": (
+                "Installation issue detected. The package isn't properly installed.\n\n"
+                "**Try this:**\n"
+                "- Reinstall: `pip install -e .` from the project directory\n"
+                "- Check you're using the right Python environment\n"
+                "- For Docker users: rebuild the container"
+            ),
+            "Failed to create search engine|could not be found": (
+                "Search engine configuration problem.\n\n"
+                "**Try this:**\n"
+                "- Use the default search engine (auto)\n"
+                "- Check search engine settings in Advanced Options\n"
+                "- Ensure required API keys are set for external search engines"
+            ),
+            "TypeError.*Context.*Size|'<' not supported between": (
+                "Model configuration issue. The context size setting might not be compatible with your model.\n\n"
+                "**Try this:**\n"
+                "- Check your model's maximum context size\n"
+                "- Leave context size settings at default\n"
+                "- Try a different model"
+            ),
+            "Model.*not found in Ollama": (
+                "The specified model isn't available in Ollama.\n\n"
+                "**Try this:**\n"
+                "- Check available models: `ollama list`\n"
+                "- Pull the model: `ollama pull <model-name>`\n"
+                "- Use the exact model name shown in `ollama list` (e.g., 'gemma2:9b' not 'gemma:latest')"
+            ),
+            "No auth credentials found|401.*API key": (
+                "API key is missing or incorrectly configured.\n\n"
+                "**Try this:**\n"
+                "- Set API key in the web UI settings (not in .env files)\n"
+                "- Go to Settings → Advanced → enter your API key\n"
+                "- For custom endpoints, ensure the key format matches what your provider expects"
+            ),
+            "Attempt to write readonly database": (
+                "Permission issue with the database file.\n\n"
+                "**Try this:**\n"
+                "- On Windows: Run as Administrator\n"
+                "- On Linux/Mac: Check folder permissions\n"
+                "- Delete and recreate the database file if corrupted"
+            ),
+            "Invalid value.*SearXNG|database.*locked": (
+                "SearXNG configuration or rate limiting issue.\n\n"
+                "**Try this:**\n"
+                "- Keep 'Search snippets only' enabled (don't turn it off)\n"
+                "- Restart SearXNG: `docker restart searxng`\n"
+                "- If rate limited, wait a few minutes or use a VPN"
+            ),
+            "host.*localhost.*Docker|127\\.0\\.0\\.1.*Docker|localhost.*1234.*Docker|LM.*Studio.*Docker.*Mac": (
+                "Docker networking issue - can't connect to services on host.\n\n"
+                "**Try this:**\n"
+                "- **On Mac/Windows Docker:** Replace 'localhost' or '127.0.0.1' with 'host.docker.internal'\n"
+                "- **On Linux Docker:** Use your host's actual IP address (find with `hostname -I`)\n"
+                "- **Example:** Change `http://localhost:1234` to `http://host.docker.internal:1234`\n"
+                "- Ensure the service port isn't blocked by firewall\n"
+                "- Alternative: Use host networking mode (see wiki for setup)"
+            ),
+        }
+
+        # Check each pattern and replace if found
+        for pattern, replacement in error_replacements.items():
+            import re
+
+            if re.search(pattern, error_message, re.IGNORECASE):
+                return f"{replacement}\n\nTechnical error: {error_message}"
+
+        # If no specific replacement found, return original message
+        return error_message

local_deep_research/web/routes/history_routes.py

@@ -254,7 +254,7 @@ def get_research_details(research_id):
     )
 
 
-@history_bp.route("/report/<int:research_id>")
+@history_bp.route("/history/report/<int:research_id>")
 def get_report(research_id):
     conn = get_db_connection()
     conn.row_factory = lambda cursor, row: {

local_deep_research/web/services/research_service.py

@@ -17,6 +17,7 @@ from ...utilities.threading_utils import thread_context, thread_with_app_context
 from ..database.models import ResearchStrategy, ResearchHistory
 from ..models.database import calculate_duration
 from .socket_service import SocketIOService
+from ...error_handling.report_generator import ErrorReportGenerator
 
 # Output directory for research results
 _PROJECT_ROOT = Path(__file__).parents[4]
@@ -657,8 +658,40 @@ def run_research_process(
                 )
 
                 try:
-                    # Get the synthesized content from the LLM directly
-                    clean_markdown = raw_formatted_findings
+                    # Check if we have an error in the findings and use enhanced error handling
+                    if isinstance(
+                        raw_formatted_findings, str
+                    ) and raw_formatted_findings.startswith("Error:"):
+                        logger.info(
+                            "Generating enhanced error report using ErrorReportGenerator"
+                        )
+
+                        # Get LLM for error explanation if available
+                        try:
+                            llm = get_llm(research_id=research_id)
+                        except Exception:
+                            llm = None
+                            logger.warning(
+                                "Could not get LLM for error explanation"
+                            )
+
+                        # Generate comprehensive error report
+                        error_generator = ErrorReportGenerator(llm)
+                        clean_markdown = error_generator.generate_error_report(
+                            error_message=raw_formatted_findings,
+                            query=query,
+                            partial_results=results,
+                            search_iterations=results.get("iterations", 0),
+                            research_id=research_id,
+                        )
+
+                        logger.info(
+                            "Generated enhanced error report with %d characters",
+                            len(clean_markdown),
+                        )
+                    else:
+                        # Get the synthesized content from the LLM directly
+                        clean_markdown = raw_formatted_findings
 
                     # Extract all sources from findings to add them to the summary
                     all_links = []
@@ -878,10 +911,77 @@ def run_research_process(
                     "solution": "Check API configuration and credentials."
                 }
 
+            # Generate enhanced error report for failed research
+            enhanced_report_content = None
+            try:
+                # Get LLM for error explanation if available
+                try:
+                    llm = get_llm(research_id=research_id)
+                except Exception:
+                    llm = None
+                    logger.warning(
+                        "Could not get LLM for error explanation in failure handler"
+                    )
+
+                # Get partial results if they exist
+                partial_results = results if "results" in locals() else None
+                search_iterations = (
+                    results.get("iterations", 0) if partial_results else 0
+                )
+
+                # Generate comprehensive error report
+                error_generator = ErrorReportGenerator(llm)
+                enhanced_report_content = error_generator.generate_error_report(
+                    error_message=f"Research failed: {str(e)}",
+                    query=query,
+                    partial_results=partial_results,
+                    search_iterations=search_iterations,
+                    research_id=research_id,
+                )
+
+                logger.info(
+                    "Generated enhanced error report for failed research (length: %d)",
+                    len(enhanced_report_content),
+                )
+
+                # Save enhanced error report as the actual report file
+                try:
+                    reports_folder = OUTPUT_DIR
+                    report_filename = f"research_{research_id}_error_report.md"
+                    report_path = reports_folder / report_filename
+
+                    with open(report_path, "w", encoding="utf-8") as f:
+                        f.write(enhanced_report_content)
+
+                    logger.info(
+                        "Saved enhanced error report to: %s", report_path
+                    )
+
+                    # Store the report path so it can be retrieved later
+                    report_path_to_save = str(
+                        report_path.relative_to(reports_folder.parent)
+                    )
+
+                except Exception as report_error:
+                    logger.exception(
+                        "Failed to save enhanced error report: %s", report_error
+                    )
+                    report_path_to_save = None
+
+            except Exception as error_gen_error:
+                logger.exception(
+                    "Failed to generate enhanced error report: %s",
+                    error_gen_error,
+                )
+                enhanced_report_content = None
+                report_path_to_save = None
+
             # Update metadata with more context about the error
             metadata = {"phase": "error", "error": user_friendly_error}
             if error_context:
                 metadata.update(error_context)
+            if enhanced_report_content:
+                metadata["has_enhanced_report"] = True
 
             # If we still have an active research record, update its log
             if research_id in active_research:
@@ -934,6 +1034,10 @@ def run_research_process(
                 research.duration_seconds = duration_seconds
                 research.metadata = metadata
 
+                # Add error report path if available
+                if "report_path_to_save" in locals() and report_path_to_save:
+                    research.report_path = report_path_to_save
+
                 db_session.commit()
 
             try:

local_deep_research/web/static/js/components/progress.js

@@ -630,18 +630,20 @@
                 cancelButton.style.display = 'none';
             }
         } else if (data.status === 'failed' || data.status === 'cancelled') {
-            // Show error message
-            if (window.ui) {
-                window.ui.showError(data.error || 'Research was unsuccessful');
+            // For failed research, try to show the error report if available
+            if (data.status === 'failed') {
+                if (viewResultsButton) {
+                    viewResultsButton.textContent = 'View Error Report';
+                    viewResultsButton.href = `/research/results/${currentResearchId}`;
+                    viewResultsButton.style.display = 'inline-block';
+                }
             } else {
-                console.error('Research failed:', data.error || 'Unknown error');
-            }
-
-            // Update button to go back to home
-            if (viewResultsButton) {
-                viewResultsButton.textContent = 'Start New Research';
-                viewResultsButton.href = '/';
-                viewResultsButton.style.display = 'inline-block';
+                // For cancelled research, go back to home
+                if (viewResultsButton) {
+                    viewResultsButton.textContent = 'Start New Research';
+                    viewResultsButton.href = '/';
+                    viewResultsButton.style.display = 'inline-block';
+                }
             }
 
             // Hide cancel button
@@ -917,8 +919,12 @@
             cancelButton.style.display = 'none';
         }
 
-        // Show results button (might have partial results)
-        showResultsButton();
+        // Show error report button
+        if (viewResultsButton) {
+            viewResultsButton.textContent = 'View Error Report';
+            viewResultsButton.href = `/research/results/${currentResearchId}`;
+            viewResultsButton.style.display = 'inline-block';
+        }
 
         // Show notification if enabled
         showNotification('Research Error', `There was an error with your research: ${data.error}`);

local_deep_research/web/static/js/components/results.js

@@ -98,7 +98,7 @@
             resultsContainer.innerHTML = '<div class="text-center my-5"><i class="fas fa-spinner fa-pulse"></i><p class="mt-3">Loading research results...</p></div>';
 
             // Fetch result from API
-            const response = await fetch(`/research/api/report/${researchId}`);
+            const response = await fetch(`/research/api/history/report/${researchId}`);
 
             if (!response.ok) {
                 throw new Error(`HTTP error ${response.status}`);

local_deep_research/web/templates/pages/research.html

@@ -48,7 +48,7 @@
                             <label for="mode-quick" class="mode-option active" data-mode="quick" role="radio" aria-checked="true" tabindex="0">
                                 <div class="mode-icon"><i class="fas fa-bolt" aria-hidden="true"></i></div>
                                 <div class="mode-info">
-                                    <h3>Quick Summary</h3>
+                                    <h2>Quick Summary</h2>
                                     <p>Generated in a few minutes</p>
                                 </div>
                             </label>
@@ -57,7 +57,7 @@
                             <label for="mode-detailed" class="mode-option" data-mode="detailed" role="radio" aria-checked="false" tabindex="-1">
                                 <div class="mode-icon"><i class="fas fa-microscope" aria-hidden="true"></i></div>
                                 <div class="mode-info">
-                                    <h3>Detailed Report</h3>
+                                    <h2>Detailed Report</h2>
                                     <p>In-depth analysis (takes longer)</p>
                                 </div>
                             </label>

{local_deep_research-0.5.2.dist-info → local_deep_research-0.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: local-deep-research
-Version: 0.5.2
+Version: 0.5.3
 Summary: AI-powered research assistant with deep, iterative analysis using LLMs and web searches
 Author-Email: LearningCircuit <185559241+LearningCircuit@users.noreply.github.com>, HashedViking <6432677+HashedViking@users.noreply.github.com>
 License: MIT License

{local_deep_research-0.5.2.dist-info → local_deep_research-0.5.3.dist-info}/RECORD

@@ -1,9 +1,9 @@
-local_deep_research-0.5.2.dist-info/METADATA,sha256=kAVbaFqnR6nls4PM_vMyRtVnZuj4z1LthPtEz3YREJk,17676
-local_deep_research-0.5.2.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-local_deep_research-0.5.2.dist-info/entry_points.txt,sha256=GcXS501Rjh-P80S8db7hnrQ23mS_Jg27PwpVQVO77as,113
-local_deep_research-0.5.2.dist-info/licenses/LICENSE,sha256=Qg2CaTdu6SWnSqk1_JtgBPp_Da-LdqJDhT1Vt1MUc5s,1072
+local_deep_research-0.5.3.dist-info/METADATA,sha256=sJGfKxEAI9Nn8wafKK3qnTOaj8sJzq2mqNvl130ep0s,17676
+local_deep_research-0.5.3.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+local_deep_research-0.5.3.dist-info/entry_points.txt,sha256=GcXS501Rjh-P80S8db7hnrQ23mS_Jg27PwpVQVO77as,113
+local_deep_research-0.5.3.dist-info/licenses/LICENSE,sha256=Qg2CaTdu6SWnSqk1_JtgBPp_Da-LdqJDhT1Vt1MUc5s,1072
 local_deep_research/__init__.py,sha256=j1ktf_e9HeXPe86NHibY5aINtZfTSGRTvLNtz9BJZa4,1071
-local_deep_research/__version__.py,sha256=isJrmDBLRag7Zc2UK9ZovWGOv7ji1Oh-zJtJMNJFkXw,22
+local_deep_research/__version__.py,sha256=tgzuqHKcEdKBaP57F5oXxq4XlW2n9J4Fj8ZGu7nGOZg,22
 local_deep_research/advanced_search_system/__init__.py,sha256=sGusMj4eFIrhXR6QbOM16UDKB6aI-iS4IFivKWpMlh0,234
 local_deep_research/advanced_search_system/answer_decoding/__init__.py,sha256=BmmbIPQnouYyboFD61CDq71fW5On555w7dbt42s9gV4,148
 local_deep_research/advanced_search_system/answer_decoding/browsecomp_answer_decoder.py,sha256=4FDMP4n_z5DOzVIisH3_kexRqNm1AO3MDe-Md3WtgE0,12856
@@ -135,11 +135,14 @@ local_deep_research/citation_handlers/forced_answer_citation_handler.py,sha256=o
 local_deep_research/citation_handlers/precision_extraction_handler.py,sha256=wJkoWzu4ODAZRJoCH5WPZVD96UnsrfBDvW8cE4FCm_Q,19835
 local_deep_research/citation_handlers/standard_citation_handler.py,sha256=PaJDvkwWOW6J4ZtA1VYSE78F4p3xiMtH1ZvdIBceyDQ,2987
 local_deep_research/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-local_deep_research/config/llm_config.py,sha256=2f4hoAAGg4yVlsiZZKyLjIWj0u4a3FFzfFKkgFm6Dbs,18775
+local_deep_research/config/llm_config.py,sha256=_IIYxtdn9S3ry2OVrBX9ztLNg3frSp2vNqDcqhie-aY,21512
 local_deep_research/config/search_config.py,sha256=DP7SbdcqGPu1yxv3fxtqd1vda5pVY3fH66DyDKuzJio,2209
 local_deep_research/defaults/.env.template,sha256=_eVCy4d_XwpGXy8n50CG3wH9xx2oqJCFKS7IbqgInDk,491
 local_deep_research/defaults/__init__.py,sha256=EUnb-wRT2mtv6lqM0hB16KfHJkR7d8JBNCIbEKwu48k,1342
 local_deep_research/defaults/default_settings.json,sha256=0dfTFkplu7wnLJQYLBf4wKER55EmYbp_rMAJ5kgmUXc,124250
+local_deep_research/error_handling/__init__.py,sha256=3kiEhchFP-gDeD_qM3lhtQqeVx7enqIwm_4hBKtohLg,396
+local_deep_research/error_handling/error_reporter.py,sha256=tPBWUftpw6NWIcoRJJbaGaLApx7CQdcz3AppGDWKmnM,8583
+local_deep_research/error_handling/report_generator.py,sha256=EQnKC2uENEWNAhOA2swJTxEG5CEwZDTHY4dlM1s4kM0,17303
 local_deep_research/metrics/__init__.py,sha256=u1yUJndwNie8Pq3HGx2NxmFCVwIl0EvkxSxiMFpzSyM,331
 local_deep_research/metrics/database.py,sha256=Nd6jTN__ZLM2lHld9sHT_tiVe3XNFgNeanFhIVuAVhw,1686
 local_deep_research/metrics/db_models.py,sha256=X3ow1uXjjmZhdARE7MV37pQhr3UQknB1X5iWdTiJtSs,3464
@@ -159,7 +162,6 @@ local_deep_research/migrate_db.py,sha256=-Ql7bC2VmXlWtDOXj7CGVBvBlSk--wHyZCniWJn
 local_deep_research/report_generator.py,sha256=J7Y7_soTAPkIajzbkIAPeq1ziTsXPMMz4Fwl6C-n6Zw,9282
 local_deep_research/search_system.py,sha256=BpHhWXj82iVAJajpwyHaYyeBcNKbYY5DG2oxoNDERlo,27194
 local_deep_research/setup_data_dir.py,sha256=7MJa2MMdDUnktJVHwMpyNL2079-qylpIyyLpVbF5AUY,1134
-local_deep_research/test_migration.py,sha256=vzgGkY2EkmvQYJtUGD7Vt14i8jf04oCvNkzMnwuMBzY,6683
 local_deep_research/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 local_deep_research/utilities/db_utils.py,sha256=BE3oP7WRbtlaqOxMrVFoAo11NpTk3RlC9w8tZUC_INU,1681
 local_deep_research/utilities/enums.py,sha256=yFwmodt93uETdQd7qyW4vOUhiAzZF-BHBbVYHKN7scU,223
@@ -185,11 +187,11 @@ local_deep_research/web/models/settings.py,sha256=rXBI9vY5k3ndR8dPd3fZJy-6HwYltQ
 local_deep_research/web/routes/api_routes.py,sha256=7hOFqF7Y3Qc5PwugXRoSi1CEVIcXUeW6nSwWayLB0P4,20052
 local_deep_research/web/routes/benchmark_routes.py,sha256=bXiURrmWoaGtbOQ3jhgXgxjs3Qa440Jqk1CPZ1QMyO0,15725
 local_deep_research/web/routes/globals.py,sha256=cCCSW0MPxHKNXDy0kGG5HqOz197i1iyqJdWRI72DCWw,454
-local_deep_research/web/routes/history_routes.py,sha256=ZKuLJRahQfSzyxVDTm02QqrLgPHNZ1OsUv1kaO-6cbc,12839
+local_deep_research/web/routes/history_routes.py,sha256=fFdZbMBWAQmtgTipWD1zNeRDhXRGAYiJhCmWrlWYaaY,12847
 local_deep_research/web/routes/metrics_routes.py,sha256=b0fYdhH_OvyvMRjdswA41qPNV4DIWrZjoOnlysEBcAE,41619
 local_deep_research/web/routes/research_routes.py,sha256=fVMV9WDO2T6XVVH1oU_bCXR1ekg6XNbnvkc61NB-DQs,27964
 local_deep_research/web/routes/settings_routes.py,sha256=0VZPWSZ9-yQNFNdid_rC4jzqKI2sE0AjucuIstZx548,60600
-local_deep_research/web/services/research_service.py,sha256=w0eNd_Q21Ky2dk7GxpFE84zpScDLwjSm_QMLKCEyx1E,43426
+local_deep_research/web/services/research_service.py,sha256=UXzq9Kx5t3fOv4IHKk2fP413XvEEwDzUapF5ehZzAIM,48027
 local_deep_research/web/services/resource_service.py,sha256=aU7SDADxcIAAuIymL_TOxUV_HvEMAfL8gZSB5gVSzFM,4674
 local_deep_research/web/services/settings_manager.py,sha256=EsAqZ5LTFFJcrWdCEheQYUqMWCwh7AUGe6Jefi8-Df4,19744
 local_deep_research/web/services/settings_service.py,sha256=W3TdSb1_WTBdKVQEvi4swXBP99dMm2IT7H-5Y1weEH4,3535
@@ -204,9 +206,9 @@ local_deep_research/web/static/js/components/fallback/formatting.js,sha256=OoP38
 local_deep_research/web/static/js/components/fallback/ui.js,sha256=O4fMeHXodvpFTEgSYR2TmcbL5Kyt2Hq1Tv2O7B3fDpk,7210
 local_deep_research/web/static/js/components/history.js,sha256=TiE1R1U81L0bOuKhBgmB-9gS-66YNgmi_yIy-rG_5uY,15507
 local_deep_research/web/static/js/components/logpanel.js,sha256=IiTpKPSEn7KtKT4xh9X6FcMZWfloj5eTDa8Oday2lhs,42808
-local_deep_research/web/static/js/components/progress.js,sha256=tw2RchReAeU5mQcN9KgYKD6Qh1uhv2RTsBHL5aOJ1IU,42130
+local_deep_research/web/static/js/components/progress.js,sha256=8cydtosQZpdX2MTpYEq9GPARCWV5azKMaRHxYiDvJoM,42542
 local_deep_research/web/static/js/components/research.js,sha256=EGWDdpswJnvH3GNlmp5albNzMv6-_20uF2D0qB73-zo,86577
-local_deep_research/web/static/js/components/results.js,sha256=3gIfl44dxsG0pMG7MHBIRAT7c_R5Lc0A5WakSdTzxV8,35755
+local_deep_research/web/static/js/components/results.js,sha256=3kDk0kodglBqIODh_ve0I9ERIZkITz2yB5isUUda-bc,35763
 local_deep_research/web/static/js/components/settings.js,sha256=qnRxnx9LdyOpjIEKfb4mJdES9sLkNKvyzxy4OGUqmGQ,169998
 local_deep_research/web/static/js/components/settings_sync.js,sha256=LWDZ2EE8ChCxI5TPmPm9F4rOiYIEzEJxSCE1GLXk-2w,3925
 local_deep_research/web/static/js/main.js,sha256=z7gJvwL6A7xqAYloen8uoshdOLeRWohM57xsfrCDUuI,8143
@@ -232,7 +234,7 @@ local_deep_research/web/templates/pages/details.html,sha256=Led51_cv97e_Z057_7QV
 local_deep_research/web/templates/pages/history.html,sha256=dGeXmpp1WTsd3Em_8k1cscwOJEPO_7puu04KC966QhA,1982
 local_deep_research/web/templates/pages/metrics.html,sha256=IYG08UNnWAATqCDh0fRskJONKjHTLGgLWcrztiAm0Yg,81507
 local_deep_research/web/templates/pages/progress.html,sha256=iRKGkgyo9wBKrYAiwk61MbnaDUxeQf8SGP3wGoHWteQ,2546
-local_deep_research/web/templates/pages/research.html,sha256=KnIZQ1GiyJ2wRwQWJi9fn2ozzF1x0NL8xaEZsx059QM,9634
+local_deep_research/web/templates/pages/research.html,sha256=Nn_LatiSZfKxa-Oq7z1WaV65GfPHu35YvYJDlHiTDs0,9634
 local_deep_research/web/templates/pages/results.html,sha256=n5tHESU5iRcjwjga4y589r41B9NEqHIvzpMsXlRL0vw,3591
 local_deep_research/web/templates/pages/star_reviews.html,sha256=Bg3cGwRjNBBSvC9ZoqZqjY-6_0-cM4VZHRGlTai_Wng,24361
 local_deep_research/web/templates/settings_dashboard.html,sha256=A1fBe1D29v8G3ys94_rIiBP6Ky-rtYL6TRbDluoBMPI,4342
@@ -262,4 +264,4 @@ local_deep_research/web_search_engines/engines/search_engine_wikipedia.py,sha256
 local_deep_research/web_search_engines/search_engine_base.py,sha256=sRgtszDM9RqNw_oVdmGk8CmKS_9EJYR-LyE1as53cp8,12401
 local_deep_research/web_search_engines/search_engine_factory.py,sha256=eMaFup2p4u1nP4fTmjzfLUAl_mUZkoE1mUABBIvNzDM,12095
 local_deep_research/web_search_engines/search_engines_config.py,sha256=oJ5GL9BhFvWFgmFtvwJ7AZ9o-uPLEfTNhJJouHF40iA,5296
-local_deep_research-0.5.2.dist-info/RECORD,,
+local_deep_research-0.5.3.dist-info/RECORD,,

local_deep_research/test_migration.py

@@ -1,188 +0,0 @@
-#!/usr/bin/env python
-"""
-Migration test script for Local Deep Research.
-This script checks the contents of both the legacy and new databases to diagnose migration issues.
-"""
-
-import os
-import sqlite3
-import sys
-import time
-
-
-def check_db_content(db_path, description):
-    """Check what tables and how many rows are in a database."""
-    if not os.path.exists(db_path):
-        print(f"❌ {description} database not found at: {db_path}")
-        return False
-
-    print(f"📊 Examining {description} database at: {db_path}")
-    try:
-        conn = sqlite3.connect(db_path)
-        cursor = conn.cursor()
-
-        # Get list of tables
-        cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
-        tables = [
-            row[0]
-            for row in cursor.fetchall()
-            if not row[0].startswith("sqlite_")
-        ]
-
-        if not tables:
-            print("   ℹ️ No user tables found in database")
-            conn.close()
-            return False
-
-        print(f"   📋 Tables found: {', '.join(tables)}")
-
-        # For each table, count rows
-        for table in tables:
-            cursor.execute(f"SELECT COUNT(*) FROM {table}")
-            count = cursor.fetchone()[0]
-            print(f"   📝 Table '{table}' has {count} rows")
-
-            # If table has rows, show sample
-            if count > 0:
-                cursor.execute(f"SELECT * FROM {table} LIMIT 1")
-                columns = [description[0] for description in cursor.description]
-                print(f"      Columns: {', '.join(columns)}")
-
-                # For specific tables, get key columns
-                if table in [
-                    "research_history",
-                    "research_logs",
-                    "research",
-                    "settings",
-                ]:
-                    key_cols = (
-                        "id, query, status"
-                        if table == "research_history"
-                        else "id, key, value"
-                        if table == "settings"
-                        else "id, message"
-                    )
-                    cursor.execute(f"SELECT {key_cols} FROM {table} LIMIT 3")
-                    sample = cursor.fetchall()
-                    for row in sample:
-                        print(f"      Sample data: {row}")
-
-        conn.close()
-        return True
-    except Exception as e:
-        print(f"❌ Error examining database: {e}")
-        return False
-
-
-def main():
-    """Main function to test the migration."""
-    # Import necessary constants
-    try:
-        # Set up paths
-        current_dir = os.path.dirname(os.path.abspath(__file__))
-        project_root = os.path.abspath(os.path.join(current_dir, "..", ".."))
-
-        # Determine paths
-        data_dir = os.path.join(project_root, "data")
-        new_db_path = os.path.join(data_dir, "ldr.db")
-
-        legacy_research_history_db = os.path.join(
-            project_root, "src", "local_deep_research", "research_history.db"
-        )
-        legacy_deep_research_db = os.path.join(data_dir, "deep_research.db")
-
-        # Print paths for verification
-        print("=" * 60)
-        print("DATABASE PATHS")
-        print("=" * 60)
-        print(f"New database path: {new_db_path}")
-        print(f"Legacy research history DB: {legacy_research_history_db}")
-        print(f"Legacy deep research DB: {legacy_deep_research_db}")
-        print("=" * 60)
-
-        # Check all databases
-        check_db_content(legacy_research_history_db, "Legacy research_history")
-        check_db_content(legacy_deep_research_db, "Legacy deep_research")
-
-        # Now check for the new database or create it if needed
-        if os.path.exists(new_db_path):
-            check_db_content(new_db_path, "New ldr")
-        else:
-            print(f"ℹ️ New database doesn't exist yet at: {new_db_path}")
-            print("Would you like to run a test migration? (y/n)")
-            choice = input("> ").lower()
-            if choice == "y":
-                # Run the migration script directly
-                try:
-                    from src.local_deep_research.setup_data_dir import (
-                        setup_data_dir,
-                    )
-                except ImportError:
-                    # If that fails, try with the direct import
-                    sys.path.append(
-                        os.path.dirname(
-                            os.path.dirname(os.path.abspath(__file__))
-                        )
-                    )
-                    from local_deep_research.setup_data_dir import (
-                        setup_data_dir,
-                    )
-
-                setup_data_dir()
-
-                # Import migration function
-                try:
-                    from src.local_deep_research.web.database.migrate_to_ldr_db import (
-                        migrate_to_ldr_db,
-                    )
-                except ImportError:
-                    # If that fails, try with the direct import
-                    from local_deep_research.web.database.migrate_to_ldr_db import (
-                        migrate_to_ldr_db,
-                    )
-
-                print("Running migration...")
-                success = migrate_to_ldr_db()
-
-                # Wait briefly to ensure file system has time to update
-                time.sleep(1)
-
-                if success:
-                    print("\n✅ Migration completed. Checking new database:")
-                    check_db_content(new_db_path, "New ldr")
-                else:
-                    print("❌ Migration failed")
-
-        # Get the paths from the migration script to verify
-        try:
-            try:
-                from src.local_deep_research.web.models.database import (
-                    DB_PATH,
-                    LEGACY_DEEP_RESEARCH_DB,
-                    LEGACY_RESEARCH_HISTORY_DB,
-                )
-            except ImportError:
-                from local_deep_research.web.models.database import (
-                    DB_PATH,
-                    LEGACY_DEEP_RESEARCH_DB,
-                    LEGACY_RESEARCH_HISTORY_DB,
-                )
-
-            print("\n" + "=" * 60)
-            print("PATHS FROM DATABASE MODULE")
-            print("=" * 60)
-            print(f"DB_PATH: {DB_PATH}")
-            print(f"LEGACY_RESEARCH_HISTORY_DB: {LEGACY_RESEARCH_HISTORY_DB}")
-            print(f"LEGACY_DEEP_RESEARCH_DB: {LEGACY_DEEP_RESEARCH_DB}")
-        except ImportError as e:
-            print(f"Could not import paths from database module: {e}")
-
-    except Exception as e:
-        print(f"Error in test script: {e}")
-        return 1
-
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())