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

local_deep_research/migrate_db.py

@@ -60,7 +60,9 @@ def main():
         action="store_true",
         help="Only check what would be migrated, don't perform actual migration",
     )
-    parser.add_argument("--verbose", action="store_true", help="Enable verbose logging")
+    parser.add_argument(
+        "--verbose", action="store_true", help="Enable verbose logging"
+    )
 
     args = parser.parse_args()
 

local_deep_research/report_generator.py

@@ -36,7 +36,9 @@ class IntegratedReportGenerator:
         """
         self.model = llm or get_llm()
         # Use provided search_system or create a new one
-        self.search_system = search_system or AdvancedSearchSystem(llm=self.model)
+        self.search_system = search_system or AdvancedSearchSystem(
+            llm=self.model
+        )
         self.searches_per_section = (
             searches_per_section  # Control search depth per section
         )
@@ -57,7 +59,9 @@ class IntegratedReportGenerator:
 
         return report
 
-    def _determine_report_structure(self, findings: Dict, query: str) -> List[Dict]:
+    def _determine_report_structure(
+        self, findings: Dict, query: str
+    ) -> List[Dict]:
         """Analyze content and determine optimal report structure."""
         combined_content = findings["current_knowledge"]
         prompt = f"""
@@ -84,7 +88,9 @@ class IntegratedReportGenerator:
         Each subsection must include its purpose after the | symbol.
         """
 
-        response = search_utilities.remove_think_tags(self.model.invoke(prompt).content)
+        response = search_utilities.remove_think_tags(
+            self.model.invoke(prompt).content
+        )
 
         # Parse the structure
         structure = []
@@ -141,7 +147,9 @@ class IntegratedReportGenerator:
                 self.search_system.max_iterations = 1  # Keep search focused
 
                 # Perform search for this subsection
-                subsection_results = self.search_system.analyze_topic(subsection_query)
+                subsection_results = self.search_system.analyze_topic(
+                    subsection_query
+                )
 
                 # Restore original iterations setting
                 self.search_system.max_iterations = original_max_iterations
@@ -151,7 +159,9 @@ class IntegratedReportGenerator:
                     "current_knowledge" in subsection_results
                     and subsection_results["current_knowledge"]
                 ):
-                    section_content.append(subsection_results["current_knowledge"])
+                    section_content.append(
+                        subsection_results["current_knowledge"]
+                    )
                 else:
                     section_content.append(
                         "*Limited information was found for this subsection.*\n"
@@ -215,8 +225,10 @@ class IntegratedReportGenerator:
         # Format links from search system
         # Get utilities module dynamically to avoid circular imports
         utilities = importlib.import_module("local_deep_research.utilities")
-        formatted_all_links = utilities.search_utilities.format_links_to_markdown(
-            all_links=self.search_system.all_links_of_system
+        formatted_all_links = (
+            utilities.search_utilities.format_links_to_markdown(
+                all_links=self.search_system.all_links_of_system
+            )
         )
 
         # Create final report with all parts
@@ -240,5 +252,7 @@ class IntegratedReportGenerator:
         return {"content": final_report_content, "metadata": metadata}
 
     def _generate_error_report(self, query: str, error_msg: str) -> str:
-        error_report = f"=== ERROR REPORT ===\nQuery: {query}\nError: {error_msg}"
+        error_report = (
+            f"=== ERROR REPORT ===\nQuery: {query}\nError: {error_msg}"
+        )
         return error_report

local_deep_research/search_system.py

@@ -8,15 +8,48 @@ from .advanced_search_system.findings.repository import FindingsRepository
 from .advanced_search_system.questions.standard_question import (
     StandardQuestionGenerator,
 )
-from .advanced_search_system.strategies.iterdrag_strategy import IterDRAGStrategy
+from .advanced_search_system.strategies.adaptive_decomposition_strategy import (
+    AdaptiveDecompositionStrategy,
+)
+from .advanced_search_system.strategies.browsecomp_optimized_strategy import (
+    BrowseCompOptimizedStrategy,
+)
+from .advanced_search_system.strategies.constrained_search_strategy import (
+    ConstrainedSearchStrategy,
+)
+from .advanced_search_system.strategies.early_stop_constrained_strategy import (
+    EarlyStopConstrainedStrategy,
+)
+from .advanced_search_system.strategies.evidence_based_strategy_v2 import (
+    EnhancedEvidenceBasedStrategy,
+)
+from .advanced_search_system.strategies.iterative_reasoning_strategy import (
+    IterativeReasoningStrategy,
+)
+from .advanced_search_system.strategies.iterdrag_strategy import (
+    IterDRAGStrategy,
+)
+from .advanced_search_system.strategies.parallel_constrained_strategy import (
+    ParallelConstrainedStrategy,
+)
 from .advanced_search_system.strategies.parallel_search_strategy import (
     ParallelSearchStrategy,
 )
-from .advanced_search_system.strategies.rapid_search_strategy import RapidSearchStrategy
+from .advanced_search_system.strategies.rapid_search_strategy import (
+    RapidSearchStrategy,
+)
+from .advanced_search_system.strategies.recursive_decomposition_strategy import (
+    RecursiveDecompositionStrategy,
+)
+from .advanced_search_system.strategies.smart_decomposition_strategy import (
+    SmartDecompositionStrategy,
+)
 from .advanced_search_system.strategies.source_based_strategy import (
     SourceBasedSearchStrategy,
 )
-from .advanced_search_system.strategies.standard_strategy import StandardSearchStrategy
+from .advanced_search_system.strategies.standard_strategy import (
+    StandardSearchStrategy,
+)
 from .citation_handler import CitationHandler
 from .config.llm_config import get_llm
 from .config.search_config import get_search
@@ -31,18 +64,38 @@ class AdvancedSearchSystem:
 
     def __init__(
         self,
-        strategy_name: str = "source-based",
+        strategy_name: str = "source-based",  # Default to comprehensive research strategy
         include_text_content: bool = True,
         use_cross_engine_filter: bool = True,
         llm: BaseChatModel | None = None,
         search: BaseSearchEngine | None = None,
         max_iterations: int | None = None,
         questions_per_iteration: int | None = None,
+        use_atomic_facts: bool = False,
     ):
         """Initialize the advanced search system.
 
         Args:
-            strategy_name: The name of the search strategy to use ("standard" or "iterdrag")
+            strategy_name: The name of the search strategy to use. Options:
+                - "standard": Basic iterative search strategy
+                - "iterdrag": Iterative Dense Retrieval Augmented Generation
+                - "source-based": Focuses on finding and extracting from sources
+                - "parallel": Runs multiple search queries in parallel
+                - "rapid": Quick single-pass search
+                - "recursive": Recursive decomposition of complex queries
+                - "iterative": Loop-based reasoning with persistent knowledge
+                - "adaptive": Adaptive step-by-step reasoning
+                - "smart": Automatically chooses best strategy based on query
+                - "browsecomp": Optimized for BrowseComp-style puzzle queries
+                - "evidence": Enhanced evidence-based verification with improved candidate discovery
+                - "constrained": Progressive constraint-based search that narrows candidates step by step
+                - "parallel-constrained": Parallel constraint-based search with combined constraint execution
+                - "early-stop-constrained": Parallel constraint search with immediate evaluation and early stopping at 99% confidence
+                - "dual-confidence": Dual confidence scoring with positive/negative/uncertainty
+                - "dual-confidence-with-rejection": Dual confidence with early rejection of poor candidates
+                - "concurrent-dual-confidence": Concurrent search & evaluation with progressive constraint relaxation
+                - "modular": Modular architecture using constraint checking and candidate exploration modules
+                - "browsecomp-entity": Entity-focused search for BrowseComp questions with knowledge graph building
             include_text_content: If False, only includes metadata and links in search results
             use_cross_engine_filter: Whether to filter results across search
                 engines.
@@ -53,6 +106,8 @@ class AdvancedSearchSystem:
                 perform. Will be read from the settings if not specified.
             questions_per_iteration: The number of questions to include in
                 each iteration. Will be read from the settings if not specified.
+            use_atomic_facts: Whether to use atomic fact decomposition for
+                complex queries when using the source-based strategy.
 
         """
         # Get configuration
@@ -103,6 +158,7 @@ class AdvancedSearchSystem:
                 include_text_content=include_text_content,
                 use_cross_engine_filter=use_cross_engine_filter,
                 all_links_of_system=self.all_links_of_system,
+                use_atomic_facts=use_atomic_facts,
             )
         elif strategy_name.lower() == "parallel":
             logger.info("Creating ParallelSearchStrategy instance")
@@ -120,6 +176,319 @@ class AdvancedSearchSystem:
                 search=self.search,
                 all_links_of_system=self.all_links_of_system,
             )
+        elif (
+            strategy_name.lower() == "recursive"
+            or strategy_name.lower() == "recursive-decomposition"
+        ):
+            logger.info("Creating RecursiveDecompositionStrategy instance")
+            self.strategy = RecursiveDecompositionStrategy(
+                model=self.model,
+                search=self.search,
+                all_links_of_system=self.all_links_of_system,
+            )
+        elif strategy_name.lower() == "iterative":
+            logger.info("Creating IterativeReasoningStrategy instance")
+            # For iterative reasoning, use more iterations to allow thorough exploration
+            # while keeping search iterations separate
+            self.strategy = IterativeReasoningStrategy(
+                model=self.model,
+                search=self.search,
+                all_links_of_system=self.all_links_of_system,
+                max_iterations=20,  # Increased reasoning iterations
+                confidence_threshold=0.95,  # Increased from 0.85 to require very high confidence
+                search_iterations_per_round=self.max_iterations
+                or 1,  # Search iterations from settings
+                questions_per_search=self.questions_per_iteration,
+            )
+        elif strategy_name.lower() == "adaptive":
+            logger.info("Creating AdaptiveDecompositionStrategy instance")
+            self.strategy = AdaptiveDecompositionStrategy(
+                model=self.model,
+                search=self.search,
+                all_links_of_system=self.all_links_of_system,
+                max_steps=self.max_iterations,
+                min_confidence=0.8,
+                source_search_iterations=2,
+                source_questions_per_iteration=self.questions_per_iteration,
+            )
+        elif strategy_name.lower() == "smart":
+            logger.info("Creating SmartDecompositionStrategy instance")
+            self.strategy = SmartDecompositionStrategy(
+                model=self.model,
+                search=self.search,
+                all_links_of_system=self.all_links_of_system,
+                max_iterations=self.max_iterations,
+                source_search_iterations=2,
+                source_questions_per_iteration=self.questions_per_iteration,
+            )
+        elif strategy_name.lower() == "browsecomp":
+            logger.info("Creating BrowseCompOptimizedStrategy instance")
+            self.strategy = BrowseCompOptimizedStrategy(
+                model=self.model,
+                search=self.search,
+                all_links_of_system=self.all_links_of_system,
+                max_browsecomp_iterations=15,  # BrowseComp strategy main iterations
+                confidence_threshold=0.9,
+                max_iterations=self.max_iterations,  # Source-based sub-searches
+                questions_per_iteration=self.questions_per_iteration,  # Source-based sub-searches
+            )
+        elif strategy_name.lower() == "evidence":
+            logger.info("Creating EnhancedEvidenceBasedStrategy instance")
+            self.strategy = EnhancedEvidenceBasedStrategy(
+                model=self.model,
+                search=self.search,
+                all_links_of_system=self.all_links_of_system,
+                max_iterations=20,  # Main evidence-gathering iterations
+                confidence_threshold=0.95,  # Increased from 0.85 to require very high confidence
+                candidate_limit=20,  # Increased from 10
+                evidence_threshold=0.9,  # Increased from 0.6 to require strong evidence
+                max_search_iterations=self.max_iterations,  # Source-based sub-searches
+                questions_per_iteration=self.questions_per_iteration,
+                min_candidates_threshold=10,  # Increased from 3
+                enable_pattern_learning=True,
+            )
+        elif strategy_name.lower() == "constrained":
+            logger.info("Creating ConstrainedSearchStrategy instance")
+            self.strategy = ConstrainedSearchStrategy(
+                model=self.model,
+                search=self.search,
+                all_links_of_system=self.all_links_of_system,
+                max_iterations=20,
+                confidence_threshold=0.95,  # Increased from 0.85 to require very high confidence
+                candidate_limit=100,  # Increased from 30
+                evidence_threshold=0.9,  # Increased from 0.6 to require strong evidence
+                max_search_iterations=self.max_iterations,
+                questions_per_iteration=self.questions_per_iteration,
+                min_candidates_per_stage=20,  # Increased from 5
+            )
+        elif strategy_name.lower() in [
+            "parallel-constrained",
+            "parallel_constrained",
+        ]:
+            logger.info("Creating ParallelConstrainedStrategy instance")
+            self.strategy = ParallelConstrainedStrategy(
+                model=self.model,
+                search=self.search,
+                all_links_of_system=self.all_links_of_system,
+                max_iterations=20,
+                confidence_threshold=0.95,  # Increased from 0.85 to require very high confidence
+                candidate_limit=100,
+                evidence_threshold=0.9,  # Increased from 0.6 to require strong evidence
+                max_search_iterations=self.max_iterations,
+                questions_per_iteration=self.questions_per_iteration,
+                min_candidates_per_stage=20,  # Correct parameter name for parent class
+                parallel_workers=100,  # Run up to 100 searches in parallel
+            )
+        elif strategy_name.lower() in [
+            "early-stop-constrained",
+            "early_stop_constrained",
+        ]:
+            logger.info("Creating EarlyStopConstrainedStrategy instance")
+            self.strategy = EarlyStopConstrainedStrategy(
+                model=self.model,
+                search=self.search,
+                all_links_of_system=self.all_links_of_system,
+                max_iterations=20,
+                confidence_threshold=0.95,
+                candidate_limit=100,
+                evidence_threshold=0.9,
+                max_search_iterations=self.max_iterations,
+                questions_per_iteration=self.questions_per_iteration,
+                min_candidates_per_stage=20,
+                parallel_workers=100,  # Increased parallelism as requested
+                early_stop_threshold=0.99,  # Stop when we find 99%+ confidence
+                concurrent_evaluation=True,  # Evaluate candidates as we find them
+            )
+        elif strategy_name.lower() in ["smart-query", "smart_query"]:
+            from .advanced_search_system.strategies.smart_query_strategy import (
+                SmartQueryStrategy,
+            )
+
+            logger.info("Creating SmartQueryStrategy instance")
+            self.strategy = SmartQueryStrategy(
+                model=self.model,
+                search=self.search,
+                all_links_of_system=self.all_links_of_system,
+                max_iterations=20,
+                confidence_threshold=0.95,
+                candidate_limit=100,
+                evidence_threshold=0.9,
+                max_search_iterations=self.max_iterations,
+                questions_per_iteration=self.questions_per_iteration,
+                min_candidates_per_stage=20,
+                parallel_workers=100,  # High parallelism
+                early_stop_threshold=0.99,  # Stop when we find 99%+ confidence
+                concurrent_evaluation=True,  # Evaluate candidates as we find them
+                use_llm_query_generation=True,  # Use smart query generation
+                queries_per_combination=3,  # Generate multiple queries
+            )
+        elif strategy_name.lower() in ["dual-confidence", "dual_confidence"]:
+            from .advanced_search_system.strategies.dual_confidence_strategy import (
+                DualConfidenceStrategy,
+            )
+
+            logger.info("Creating DualConfidenceStrategy instance")
+            self.strategy = DualConfidenceStrategy(
+                model=self.model,
+                search=self.search,
+                all_links_of_system=self.all_links_of_system,
+                max_iterations=20,
+                confidence_threshold=0.95,
+                candidate_limit=100,
+                evidence_threshold=0.9,
+                max_search_iterations=self.max_iterations,
+                questions_per_iteration=self.questions_per_iteration,
+                min_candidates_per_stage=20,
+                parallel_workers=100,
+                early_stop_threshold=0.95,  # Lower threshold since dual confidence is more accurate
+                concurrent_evaluation=True,
+                use_llm_query_generation=True,
+                queries_per_combination=3,
+                use_entity_seeding=True,
+                use_direct_property_search=True,
+                uncertainty_penalty=0.2,  # Penalty for uncertain evidence
+                negative_weight=0.5,  # How much negative evidence counts against
+            )
+        elif strategy_name.lower() in [
+            "dual-confidence-with-rejection",
+            "dual_confidence_with_rejection",
+        ]:
+            from .advanced_search_system.strategies.dual_confidence_with_rejection import (
+                DualConfidenceWithRejectionStrategy,
+            )
+
+            logger.info("Creating DualConfidenceWithRejectionStrategy instance")
+            self.strategy = DualConfidenceWithRejectionStrategy(
+                model=self.model,
+                search=self.search,
+                all_links_of_system=self.all_links_of_system,
+                max_iterations=20,
+                confidence_threshold=0.95,
+                candidate_limit=100,
+                evidence_threshold=0.9,
+                max_search_iterations=self.max_iterations,
+                questions_per_iteration=self.questions_per_iteration,
+                min_candidates_per_stage=20,
+                parallel_workers=100,
+                early_stop_threshold=0.95,
+                concurrent_evaluation=True,
+                use_llm_query_generation=True,
+                queries_per_combination=3,
+                use_entity_seeding=True,
+                use_direct_property_search=True,
+                uncertainty_penalty=0.2,
+                negative_weight=0.5,
+                rejection_threshold=0.3,  # Reject if negative confidence > 30%
+                positive_threshold=0.2,  # Unless positive confidence > 20%
+                critical_constraint_rejection=0.2,  # Stricter for critical constraints
+            )
+        elif strategy_name.lower() in [
+            "concurrent-dual-confidence",
+            "concurrent_dual_confidence",
+        ]:
+            from .advanced_search_system.strategies.concurrent_dual_confidence_strategy import (
+                ConcurrentDualConfidenceStrategy,
+            )
+
+            logger.info("Creating ConcurrentDualConfidenceStrategy instance")
+            self.strategy = ConcurrentDualConfidenceStrategy(
+                model=self.model,
+                search=self.search,
+                all_links_of_system=self.all_links_of_system,
+                max_iterations=20,
+                confidence_threshold=0.95,
+                candidate_limit=100,
+                evidence_threshold=0.9,
+                max_search_iterations=self.max_iterations,
+                questions_per_iteration=self.questions_per_iteration,
+                min_candidates_per_stage=20,
+                parallel_workers=10,  # Concurrent evaluation threads
+                early_stop_threshold=0.95,
+                concurrent_evaluation=True,
+                use_llm_query_generation=True,
+                queries_per_combination=3,
+                use_entity_seeding=True,
+                use_direct_property_search=True,
+                uncertainty_penalty=0.2,
+                negative_weight=0.5,
+                rejection_threshold=0.3,
+                positive_threshold=0.2,
+                critical_constraint_rejection=0.2,
+                # Concurrent-specific parameters
+                min_good_candidates=3,
+                target_candidates=5,
+                max_candidates=10,
+                min_score_threshold=0.65,
+                exceptional_score=0.95,
+                quality_plateau_threshold=0.1,
+                max_search_time=30.0,
+                max_evaluations=30,
+            )
+        elif strategy_name.lower() in ["modular", "modular-strategy"]:
+            from .advanced_search_system.strategies.modular_strategy import (
+                ModularStrategy,
+            )
+
+            logger.info("Creating ModularStrategy instance")
+            self.strategy = ModularStrategy(
+                model=self.model,
+                search=self.search,
+                all_links_of_system=self.all_links_of_system,
+                constraint_checker_type="dual_confidence",  # dual_confidence, strict, threshold
+                exploration_strategy="adaptive",  # parallel, adaptive, constraint_guided, diversity
+                early_rejection=True,  # Enable fast pre-screening
+                early_stopping=True,  # Enable early stopping
+                llm_constraint_processing=True,  # Enable LLM-driven constraint processing
+                immediate_evaluation=True,  # Enable immediate candidate evaluation
+            )
+        elif strategy_name.lower() in ["modular-parallel", "modular_parallel"]:
+            from .advanced_search_system.strategies.modular_strategy import (
+                ModularStrategy,
+            )
+
+            logger.info(
+                "Creating ModularStrategy with parallel exploration and dual confidence"
+            )
+            self.strategy = ModularStrategy(
+                model=self.model,
+                search=self.search,
+                all_links_of_system=self.all_links_of_system,
+                constraint_checker_type="dual_confidence",  # Concurrent evaluation with +/-/? scoring
+                exploration_strategy="parallel",  # Parallel constraint searches
+            )
+        elif strategy_name.lower() in [
+            "focused-iteration",
+            "focused_iteration",
+        ]:
+            from .advanced_search_system.strategies.focused_iteration_strategy import (
+                FocusedIterationStrategy,
+            )
+
+            logger.info("Creating FocusedIterationStrategy instance")
+            # PRESERVE SIMPLEQA PERFORMANCE: Keep proven 96.51% accuracy configuration
+            # Original optimal settings: max_iterations=8, questions_per_iteration=5
+            self.strategy = FocusedIterationStrategy(
+                model=self.model,
+                search=self.search,
+                all_links_of_system=self.all_links_of_system,
+                max_iterations=8,  # PROVEN OPTIMAL FOR SIMPLEQA (96.51% accuracy)
+                questions_per_iteration=5,  # PROVEN OPTIMAL FOR SIMPLEQA
+                use_browsecomp_optimization=True,  # Enable BrowseComp optimizations
+            )
+        elif strategy_name.lower() in [
+            "browsecomp-entity",
+            "browsecomp_entity",
+        ]:
+            from .advanced_search_system.strategies.browsecomp_entity_strategy import (
+                BrowseCompEntityStrategy,
+            )
+
+            logger.info("Creating BrowseCompEntityStrategy instance")
+            self.strategy = BrowseCompEntityStrategy(
+                model=self.model,
+                search=self.search,
+                all_links_of_system=self.all_links_of_system,
+            )
         else:
             logger.info("Creating StandardSearchStrategy instance")
             self.strategy = StandardSearchStrategy(
@@ -135,13 +504,17 @@ class AdvancedSearchSystem:
         if hasattr(self, "progress_callback") and self.progress_callback:
             self.strategy.set_progress_callback(self.progress_callback)
 
-    def _progress_callback(self, message: str, progress: int, metadata: dict) -> None:
+    def _progress_callback(
+        self, message: str, progress: int, metadata: dict
+    ) -> None:
         """Handle progress updates from the strategy."""
         logger.info(f"Progress: {progress}% - {message}")
         if hasattr(self, "progress_callback"):
             self.progress_callback(message, progress, metadata)
 
-    def set_progress_callback(self, callback: Callable[[str, int, dict], None]) -> None:
+    def set_progress_callback(
+        self, callback: Callable[[str, int, dict], None]
+    ) -> None:
         """Set a callback function to receive progress updates."""
         self.progress_callback = callback
         if hasattr(self, "strategy"):
@@ -185,17 +558,25 @@ class AdvancedSearchSystem:
 
         # Update our attributes for backward compatibility
 
-        self.questions_by_iteration = self.strategy.questions_by_iteration.copy()
+        self.questions_by_iteration = (
+            self.strategy.questions_by_iteration.copy()
+        )
         # Send progress message with search info
 
         # Only extend if they're different objects in memory to avoid duplication
         # This check prevents doubling the list when they reference the same object
         # Fix for issue #301: "too many links in detailed report mode"
-        if id(self.all_links_of_system) != id(self.strategy.all_links_of_system):
+        if id(self.all_links_of_system) != id(
+            self.strategy.all_links_of_system
+        ):
             self.all_links_of_system.extend(self.strategy.all_links_of_system)
 
         # Include the search system instance for access to citations
         result["search_system"] = self
         result["all_links_of_system"] = self.all_links_of_system
+
+        # Ensure query is included in the result
+        if "query" not in result:
+            result["query"] = query
         result["questions_by_iteration"] = self.questions_by_iteration
         return result

local_deep_research/test_migration.py

@@ -24,7 +24,9 @@ def check_db_content(db_path, description):
         # 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_")
+            row[0]
+            for row in cursor.fetchall()
+            if not row[0].startswith("sqlite_")
         ]
 
         if not tables:
@@ -56,7 +58,9 @@ def check_db_content(db_path, description):
                     key_cols = (
                         "id, query, status"
                         if table == "research_history"
-                        else "id, key, value" if table == "settings" else "id, message"
+                        else "id, key, value"
+                        if table == "settings"
+                        else "id, message"
                     )
                     cursor.execute(f"SELECT {key_cols} FROM {table} LIMIT 3")
                     sample = cursor.fetchall()
@@ -110,13 +114,19 @@ def main():
             if choice == "y":
                 # Run the migration script directly
                 try:
-                    from src.local_deep_research.setup_data_dir import setup_data_dir
+                    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__)))
+                        os.path.dirname(
+                            os.path.dirname(os.path.abspath(__file__))
+                        )
+                    )
+                    from local_deep_research.setup_data_dir import (
+                        setup_data_dir,
                     )
-                    from local_deep_research.setup_data_dir import setup_data_dir
 
                 setup_data_dir()
 

local_deep_research/utilities/db_utils.py

@@ -1,19 +1,22 @@
 import os
-from functools import cache
 from typing import Any, Dict
 
+from cachetools import LRUCache
 from loguru import logger
 from sqlalchemy import create_engine
 from sqlalchemy.orm import Session, sessionmaker
 
+from ..utilities.threading_utils import thread_specific_cache
 from ..web.services.settings_manager import SettingsManager
 
 # Database path.
-DATA_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "data"))
+DATA_DIR = os.path.abspath(
+    os.path.join(os.path.dirname(__file__), "..", "..", "data")
+)
 DB_PATH = os.path.join(DATA_DIR, "ldr.db")
 
 
-@cache
+@thread_specific_cache(cache=LRUCache(maxsize=1))
 def get_db_session() -> Session:
     """
     Returns:
@@ -24,7 +27,7 @@ def get_db_session() -> Session:
     return session_class()
 
 
-@cache
+@thread_specific_cache(cache=LRUCache(maxsize=1))
 def get_settings_manager() -> SettingsManager:
     """
     Returns: