local-deep-research 0.1.0__py3-none-any.whl → 0.1.12__py3-none-any.whl

local_deep_research/defaults/main.toml

@@ -14,6 +14,11 @@ knowledge_accumulation_context_limit = 2000000
 # Enable fact checking (experimental, works better with large LLMs)
 enable_fact_checking = false
 
+[web]
+port = 5000
+host = "0.0.0.0"
+debug = true
+
 [search]
 # Search tool to use (auto, wikipedia, arxiv, duckduckgo, serp, google_pse, etc.)
 # "auto" intelligently selects based on query content (recommended)

local_deep_research/search_system.py

@@ -25,6 +25,11 @@ class AdvancedSearchSystem:
         self.citation_handler = CitationHandler(self.model)
         self.progress_callback = None
         self.all_links_of_system = list()
+        
+        # Check if search is available, log warning if not
+        if self.search is None:
+            print("WARNING: Search system initialized with no search engine! Research will not be effective.")
+            self._update_progress("WARNING: No search engine available", None, {"error": "No search engine configured properly"})
 
         
 
@@ -114,6 +119,23 @@ class AdvancedSearchSystem:
             "phase": "init",
             "iterations_planned": total_iterations
         })
+        
+        # Check if search engine is available
+        if self.search is None:
+            error_msg = "Error: No search engine available. Please check your configuration."
+            self._update_progress(error_msg, 100, {
+                "phase": "error", 
+                "error": "No search engine available",
+                "status": "failed"
+            })
+            return {
+                "findings": [],
+                "iterations": 0,
+                "questions": {},
+                "formatted_findings": "Error: Unable to conduct research without a search engine.",
+                "current_knowledge": "",
+                "error": error_msg
+            }
 
         while iteration < self.max_iterations:
             iteration_progress_base = (iteration / total_iterations) * 100
@@ -133,7 +155,21 @@ class AdvancedSearchSystem:
                                      int(question_progress_base),
                                      {"phase": "search", "iteration": iteration + 1, "question_index": q_idx + 1})
                 
-                search_results = self.search.run(question)
+                try:
+                    if self.search is None:
+                        self._update_progress(f"Search engine unavailable, skipping search for: {question}", 
+                                            int(question_progress_base + 2),
+                                            {"phase": "search_error", "error": "No search engine available"})
+                        search_results = []
+                    else:
+                        search_results = self.search.run(question)
+                except Exception as e:
+                    error_msg = f"Error during search: {str(e)}"
+                    print(f"SEARCH ERROR: {error_msg}")
+                    self._update_progress(error_msg, 
+                                        int(question_progress_base + 2),
+                                        {"phase": "search_error", "error": str(e)})
+                    search_results = []
                 
                 if search_results is None:
                     self._update_progress(f"No search results found for question: {question}", 
@@ -155,57 +191,81 @@ class AdvancedSearchSystem:
                                      int(question_progress_base + 5),
                                      {"phase": "analysis"})
                 print("NR OF SOURCES: ", len(self.all_links_of_system))
-                result = self.citation_handler.analyze_followup(
-                    question, search_results, current_knowledge, nr_of_links=len(self.all_links_of_system)
-                )
-                links = extract_links_from_search_results(search_results)
-                self.all_links_of_system.extend(links)
-                section_links.extend(links)
-                formatted_links = ""  
-                if links:
-                    formatted_links=format_links(links=links)
-                
-                logger.debug(f"Generated questions: {formatted_links}")                           
-                if result is not None:
-                    results_with_links = str(result["content"])
-                    findings.append(
-                        {
-                            "phase": f"Follow-up {iteration}.{questions.index(question) + 1}",
-                            "content": results_with_links,
-                            "question": question,
-                            "search_results": search_results,
-                            "documents": result["documents"],
-                        }
-                    )
 
-                    if settings.general.knowledge_accumulation != KnowledgeAccumulationApproach.NO_KNOWLEDGE:
-                        current_knowledge = current_knowledge + "\n\n\n New: \n" + results_with_links
-                    
-                    print(current_knowledge)
-                    if settings.general.knowledge_accumulation == KnowledgeAccumulationApproach.QUESTION:
-                        self._update_progress(f"Compress Knowledge for: {question}", 
-                                     int(question_progress_base + 0),
-                                     {"phase": "analysis"})
-                        current_knowledge = self._compress_knowledge(current_knowledge , query, section_links)
+                try:
+                    result = self.citation_handler.analyze_followup(
+                        question, search_results, current_knowledge, nr_of_links=len(self.all_links_of_system)
+                    )
+                    links = extract_links_from_search_results(search_results)
+                    self.all_links_of_system.extend(links)
+                    section_links.extend(links)
+                    formatted_links = ""  
+                    if links:
+                        formatted_links=format_links(links=links)
                     
-                    self._update_progress(f"Analysis complete for question: {question}", 
-                                         int(question_progress_base + 10),
-                                         {"phase": "analysis_complete"})
+                    logger.debug(f"Generated questions: {formatted_links}")                           
+                    if result is not None:
+                        results_with_links = str(result["content"])
+                        findings.append(
+                            {
+                                "phase": f"Follow-up {iteration}.{questions.index(question) + 1}",
+                                "content": results_with_links,
+                                "question": question,
+                                "search_results": search_results,
+                                "documents": result["documents"],
+                            }
+                        )
 
+                        if settings.general.knowledge_accumulation != KnowledgeAccumulationApproach.NO_KNOWLEDGE:
+                            current_knowledge = current_knowledge + "\n\n\n New: \n" + results_with_links
+                        
+                        print(current_knowledge)
+                        if settings.general.knowledge_accumulation == KnowledgeAccumulationApproach.QUESTION:
+                            self._update_progress(f"Compress Knowledge for: {question}", 
+                                        int(question_progress_base + 0),
+                                        {"phase": "analysis"})
+                            current_knowledge = self._compress_knowledge(current_knowledge , query, section_links)
+                        
+                        self._update_progress(f"Analysis complete for question: {question}", 
+                                            int(question_progress_base + 10),
+                                            {"phase": "analysis_complete"})
+                except Exception as e:
+                    error_msg = f"Error analyzing results: {str(e)}"
+                    print(f"ANALYSIS ERROR: {error_msg}")
+                    self._update_progress(error_msg, 
+                                        int(question_progress_base + 10),
+                                        {"phase": "analysis_error", "error": str(e)})
             iteration += 1
             
             self._update_progress(f"Compressing knowledge after iteration {iteration}", 
                                  int((iteration / total_iterations) * 100 - 5),
                                  {"phase": "knowledge_compression"})
+
             if settings.general.knowledge_accumulation == KnowledgeAccumulationApproach.ITERATION:
-                current_knowledge = self._compress_knowledge(current_knowledge , query, section_links)
+                try:
+                    current_knowledge = self._compress_knowledge(current_knowledge , query, section_links)
+                except Exception as e:
+                    error_msg = f"Error compressing knowledge: {str(e)}"
+                    print(f"COMPRESSION ERROR: {error_msg}")
+                    self._update_progress(error_msg, 
+                                        int((iteration / total_iterations) * 100 - 3),
+                                        {"phase": "compression_error", "error": str(e)})
+
 
             
             self._update_progress(f"Iteration {iteration} complete", 
                                  int((iteration / total_iterations) * 100),
                                  {"phase": "iteration_complete", "iteration": iteration})
             
-            formatted_findings = self._save_findings(findings, current_knowledge, query)
+            try:
+                formatted_findings = self._save_findings(findings, current_knowledge, query)
+            except Exception as e:
+                error_msg = f"Error saving findings: {str(e)}"
+                print(f"SAVE ERROR: {error_msg}")
+                self._update_progress(error_msg, 
+                                    int((iteration / total_iterations) * 100),
+                                    {"phase": "save_error", "error": str(e)})
+                formatted_findings = "Error: Could not format findings due to an error."
 
         self._update_progress("Research complete", 95, {"phase": "complete"})
         
@@ -213,7 +273,7 @@ class AdvancedSearchSystem:
             "findings": findings,
             "iterations": iteration,
             "questions": self.questions_by_iteration,
-            "formatted_findings": formatted_findings,
+            "formatted_findings": formatted_findings if 'formatted_findings' in locals() else "Error: Findings not available.",
             "current_knowledge": current_knowledge
         }