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

local_deep_research/advanced_search_system/strategies/direct_search_strategy.py

@@ -0,0 +1,217 @@
+"""
+Direct search strategy for focused single-query searches.
+
+This strategy is optimized for:
+1. Entity identification queries (who, what, which)
+2. Single-pass searches without iteration
+3. Minimal LLM calls for efficiency
+"""
+
+import logging
+from typing import Dict
+
+from ...citation_handler import CitationHandler
+from ...config.llm_config import get_llm
+from ...config.search_config import get_search
+from ..filters.cross_engine_filter import CrossEngineFilter
+from ..findings.repository import FindingsRepository
+from .base_strategy import BaseSearchStrategy
+
+logger = logging.getLogger(__name__)
+
+
+class DirectSearchStrategy(BaseSearchStrategy):
+    """
+    Direct search strategy that performs a single focused search and synthesis.
+
+    Key features:
+    1. No question generation - uses the original query directly
+    2. Single search pass - no iterations
+    3. Minimal LLM calls - only for final synthesis
+    4. Optimized for entity identification and focused queries
+    """
+
+    def __init__(
+        self,
+        search=None,
+        model=None,
+        citation_handler=None,
+        include_text_content: bool = True,
+        use_cross_engine_filter: bool = True,
+        filter_reorder: bool = True,
+        filter_reindex: bool = True,
+        cross_engine_max_results: int = None,
+        all_links_of_system=None,
+    ):
+        """Initialize with minimal components for efficiency."""
+        super().__init__(all_links_of_system=all_links_of_system)
+        self.search = search or get_search()
+        self.model = model or get_llm()
+        self.progress_callback = None
+
+        self.include_text_content = include_text_content
+        self.use_cross_engine_filter = use_cross_engine_filter
+        self.filter_reorder = filter_reorder
+        self.filter_reindex = filter_reindex
+
+        # Initialize the cross-engine filter
+        self.cross_engine_filter = CrossEngineFilter(
+            model=self.model,
+            max_results=cross_engine_max_results,
+            default_reorder=filter_reorder,
+            default_reindex=filter_reindex,
+        )
+
+        # Use provided citation_handler or create one
+        self.citation_handler = citation_handler or CitationHandler(self.model)
+        self.findings_repository = FindingsRepository(self.model)
+
+    def analyze_topic(self, query: str) -> Dict:
+        """
+        Direct search implementation - single query, single synthesis.
+        """
+        logger.info(f"Starting direct search on topic: {query}")
+        findings = []
+        total_citation_count_before_this_search = len(self.all_links_of_system)
+
+        self._update_progress(
+            "Initializing direct search",
+            5,
+            {
+                "phase": "init",
+                "strategy": "direct",
+                "query": query[:100],
+            },
+        )
+
+        # Check search engine
+        if not self._validate_search_engine():
+            return {
+                "findings": [],
+                "iterations": 1,
+                "questions_by_iteration": {1: [query]},
+                "formatted_findings": "Error: Unable to conduct research without a search engine.",
+                "current_knowledge": "",
+                "error": "No search engine available",
+            }
+
+        try:
+            # Single direct search
+            self._update_progress(
+                f"Searching: {query[:200]}...",
+                20,
+                {"phase": "searching", "query": query},
+            )
+
+            search_results = self.search.run(query)
+
+            if not search_results:
+                search_results = []
+
+            self._update_progress(
+                f"Found {len(search_results)} results",
+                40,
+                {
+                    "phase": "search_complete",
+                    "result_count": len(search_results),
+                },
+            )
+
+            # Optional: Apply cross-engine filter
+            if self.use_cross_engine_filter and search_results:
+                self._update_progress(
+                    "Filtering search results",
+                    50,
+                    {"phase": "filtering"},
+                )
+
+                filtered_results = self.cross_engine_filter.filter_results(
+                    search_results,
+                    query,
+                    reorder=self.filter_reorder,
+                    reindex=self.filter_reindex,
+                    start_index=len(self.all_links_of_system),
+                )
+
+                self._update_progress(
+                    f"Filtered to {len(filtered_results)} results",
+                    60,
+                    {
+                        "phase": "filtering_complete",
+                        "filtered_count": len(filtered_results),
+                    },
+                )
+            else:
+                filtered_results = search_results
+
+            # Add to all links
+            self.all_links_of_system.extend(filtered_results)
+
+            # Final synthesis
+            self._update_progress(
+                "Generating synthesis",
+                80,
+                {"phase": "synthesis"},
+            )
+
+            final_citation_result = self.citation_handler.analyze_followup(
+                query,
+                filtered_results,
+                previous_knowledge="",
+                nr_of_links=total_citation_count_before_this_search,
+            )
+
+            if final_citation_result:
+                synthesized_content = final_citation_result["content"]
+                documents = final_citation_result.get("documents", [])
+            else:
+                synthesized_content = "No relevant results found."
+                documents = []
+
+            # Create finding
+            finding = {
+                "phase": "Direct Search",
+                "content": synthesized_content,
+                "question": query,
+                "search_results": filtered_results,
+                "documents": documents,
+            }
+            findings.append(finding)
+
+            # Add documents to repository
+            self.findings_repository.add_documents(documents)
+
+            # Format findings
+            formatted_findings = (
+                self.findings_repository.format_findings_to_text(
+                    findings, synthesized_content
+                )
+            )
+
+        except Exception as e:
+            import traceback
+
+            error_msg = f"Error in direct search: {str(e)}"
+            logger.error(error_msg)
+            logger.error(traceback.format_exc())
+            synthesized_content = f"Error: {str(e)}"
+            formatted_findings = f"Error: {str(e)}"
+            finding = {
+                "phase": "Error",
+                "content": synthesized_content,
+                "question": query,
+                "search_results": [],
+                "documents": [],
+            }
+            findings.append(finding)
+
+        self._update_progress("Search complete", 100, {"phase": "complete"})
+
+        return {
+            "findings": findings,
+            "iterations": 1,
+            "questions_by_iteration": {1: [query]},
+            "formatted_findings": formatted_findings,
+            "current_knowledge": synthesized_content,
+            "all_links_of_system": self.all_links_of_system,
+        }

local_deep_research/advanced_search_system/strategies/dual_confidence_strategy.py

@@ -0,0 +1,320 @@
+"""
+Enhanced strategy with dual confidence scoring (positive/negative) for better accuracy.
+"""
+
+import re
+from dataclasses import dataclass
+from typing import Dict, List
+
+from loguru import logger
+
+from ..candidates.base_candidate import Candidate
+from ..constraints.base_constraint import Constraint
+from .smart_query_strategy import SmartQueryStrategy
+
+
+@dataclass
+class ConstraintEvidence:
+    """Evidence for a constraint with dual confidence scores."""
+
+    positive_confidence: float  # How sure we are the constraint IS satisfied
+    negative_confidence: (
+        float  # How sure we are the constraint is NOT satisfied
+    )
+    uncertainty: float  # How uncertain we are (neither positive nor negative)
+    evidence_text: str
+    source: str
+
+
+class DualConfidenceStrategy(SmartQueryStrategy):
+    """
+    Enhanced strategy that uses dual confidence scoring:
+    - Positive confidence: Evidence that constraint IS satisfied
+    - Negative confidence: Evidence that constraint is NOT satisfied
+    - Uncertainty: Lack of clear evidence either way
+
+    This allows for more accurate scoring and better early stopping decisions.
+    """
+
+    def __init__(
+        self,
+        *args,
+        uncertainty_penalty: float = 0.2,
+        negative_weight: float = 0.5,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+        self.uncertainty_penalty = uncertainty_penalty
+        self.negative_weight = negative_weight
+
+    def _evaluate_evidence(
+        self, evidence_list: List[Dict], constraint: Constraint
+    ) -> float:
+        """Enhanced evidence evaluation with dual confidence."""
+        if not evidence_list:
+            # No evidence means high uncertainty
+            return 0.5 - self.uncertainty_penalty
+
+        # Convert evidence to dual confidence format
+        constraint_evidence = []
+        for evidence in evidence_list:
+            dual_evidence = self._analyze_evidence_dual_confidence(
+                evidence, constraint
+            )
+            constraint_evidence.append(dual_evidence)
+
+        # Calculate overall score
+        total_positive = sum(e.positive_confidence for e in constraint_evidence)
+        total_negative = sum(e.negative_confidence for e in constraint_evidence)
+        total_uncertainty = sum(e.uncertainty for e in constraint_evidence)
+
+        # Normalize
+        evidence_count = len(constraint_evidence)
+        avg_positive = total_positive / evidence_count
+        avg_negative = total_negative / evidence_count
+        avg_uncertainty = total_uncertainty / evidence_count
+
+        # Calculate final score
+        # High positive + low negative = high score
+        # Low positive + high negative = low score
+        # High uncertainty = penalty
+        score = (
+            avg_positive
+            - (avg_negative * self.negative_weight)
+            - (avg_uncertainty * self.uncertainty_penalty)
+        )
+
+        # Clamp to [0, 1]
+        return max(0.0, min(1.0, score))
+
+    def _analyze_evidence_dual_confidence(
+        self, evidence: Dict, constraint: Constraint
+    ) -> ConstraintEvidence:
+        """Analyze evidence to extract dual confidence scores."""
+        text = evidence.get("text", "")
+
+        # Use LLM to analyze evidence with dual confidence
+        prompt = f"""
+Analyze this evidence for the constraint "{constraint.value}" (type: {constraint.type.value}).
+
+Evidence:
+{text[:1000]}
+
+Provide three confidence scores (0-1):
+1. POSITIVE_CONFIDENCE: How confident are you that this constraint IS satisfied?
+2. NEGATIVE_CONFIDENCE: How confident are you that this constraint is NOT satisfied?
+3. UNCERTAINTY: How uncertain are you (lack of clear evidence)?
+
+The three scores should approximately sum to 1.0.
+
+Format:
+POSITIVE: [score]
+NEGATIVE: [score]
+UNCERTAINTY: [score]
+"""
+
+        try:
+            response = self.model.invoke(prompt).content
+
+            # Extract scores
+            positive = self._extract_score(response, "POSITIVE")
+            negative = self._extract_score(response, "NEGATIVE")
+            uncertainty = self._extract_score(response, "UNCERTAINTY")
+
+            # Normalize if needed
+            total = positive + negative + uncertainty
+            if total > 0:
+                positive /= total
+                negative /= total
+                uncertainty /= total
+            else:
+                # Default to high uncertainty
+                uncertainty = 0.8
+                positive = 0.1
+                negative = 0.1
+
+            return ConstraintEvidence(
+                positive_confidence=positive,
+                negative_confidence=negative,
+                uncertainty=uncertainty,
+                evidence_text=text[:500],
+                source=evidence.get("source", "search"),
+            )
+
+        except Exception as e:
+            logger.error(f"Error analyzing evidence: {e}")
+            # Default to high uncertainty
+            return ConstraintEvidence(
+                positive_confidence=0.1,
+                negative_confidence=0.1,
+                uncertainty=0.8,
+                evidence_text=text[:500],
+                source=evidence.get("source", "search"),
+            )
+
+    def _extract_score(self, text: str, label: str) -> float:
+        """Extract confidence score from LLM response."""
+        pattern = rf"{label}:\s*\[?(\d*\.?\d+)\]?"
+        match = re.search(pattern, text, re.IGNORECASE)
+        if match:
+            try:
+                return float(match.group(1))
+            except:
+                pass
+        return 0.1  # Default low score
+
+    def _gather_evidence_for_constraint(
+        self, candidate: Candidate, constraint: Constraint
+    ) -> List[Dict]:
+        """Enhanced evidence gathering with targeted searches."""
+        evidence = []
+
+        # Build specific queries for this constraint
+        queries = [
+            f'"{candidate.name}" {constraint.value} verification',
+            f'"{candidate.name}" {constraint.value} true or false',
+            f"Is {candidate.name} {constraint.value}?",
+        ]
+
+        # For negative evidence, also search for contradictions
+        if constraint.type.value == "property":
+            queries.append(f'"{candidate.name}" NOT {constraint.value}')
+            queries.append(f'"{candidate.name}" opposite of {constraint.value}')
+
+        # Execute searches
+        for query in queries[:3]:  # Limit searches
+            if query.lower() not in self.searched_queries:
+                self.searched_queries.add(query.lower())
+                try:
+                    results = self._execute_search(query)
+                    content = results.get("current_knowledge", "")
+
+                    if content:
+                        evidence.append(
+                            {
+                                "text": content,
+                                "source": f"search: {query}",
+                                "query": query,
+                            }
+                        )
+                except Exception as e:
+                    logger.error(f"Error gathering evidence for {query}: {e}")
+
+        return evidence
+
+    def _evaluate_candidate_immediately(self, candidate: Candidate) -> float:
+        """Enhanced evaluation with detailed constraint scoring."""
+        try:
+            logger.info(
+                f"Evaluating candidate: {candidate.name} with dual confidence"
+            )
+
+            total_score = 0.0
+            constraint_scores = []
+            detailed_results = []
+
+            for i, constraint in enumerate(self.constraint_ranking):
+                # Gather evidence
+                evidence = self._gather_evidence_for_constraint(
+                    candidate, constraint
+                )
+
+                # Evaluate with dual confidence
+                score = self._evaluate_evidence(evidence, constraint)
+                constraint_scores.append(score)
+
+                # Store detailed results
+                if evidence:
+                    dual_evidence = [
+                        self._analyze_evidence_dual_confidence(e, constraint)
+                        for e in evidence
+                    ]
+                    avg_positive = sum(
+                        e.positive_confidence for e in dual_evidence
+                    ) / len(dual_evidence)
+                    avg_negative = sum(
+                        e.negative_confidence for e in dual_evidence
+                    ) / len(dual_evidence)
+                    avg_uncertainty = sum(
+                        e.uncertainty for e in dual_evidence
+                    ) / len(dual_evidence)
+
+                    detailed_results.append(
+                        {
+                            "constraint": constraint.value,
+                            "score": score,
+                            "positive": avg_positive,
+                            "negative": avg_negative,
+                            "uncertainty": avg_uncertainty,
+                        }
+                    )
+
+                    symbol = (
+                        "✓" if score >= 0.8 else "○" if score >= 0.5 else "✗"
+                    )
+                    logger.info(
+                        f"{symbol} {candidate.name} | {constraint.value}: {int(score * 100)}% "
+                        f"(+{int(avg_positive * 100)}% -{int(avg_negative * 100)}% ?{int(avg_uncertainty * 100)}%)"
+                    )
+
+                # Early exit for critical failures with high negative confidence
+                if score < 0.2 and constraint.weight > 0.8:
+                    logger.info(
+                        f"Critical constraint failed with high confidence: {constraint.value}"
+                    )
+                    break
+
+            # Calculate weighted average
+            if constraint_scores:
+                weights = [
+                    c.weight
+                    for c in self.constraint_ranking[: len(constraint_scores)]
+                ]
+                total_score = sum(
+                    s * w for s, w in zip(constraint_scores, weights)
+                ) / sum(weights)
+
+            # Log detailed breakdown
+            logger.info(f"\nDetailed analysis for {candidate.name}:")
+            for result in detailed_results:
+                logger.info(
+                    f"  {result['constraint']}: {result['score']:.2%} "
+                    f"(+{result['positive']:.0%} -{result['negative']:.0%} ?{result['uncertainty']:.0%})"
+                )
+
+            # Update best candidate if needed
+            with self.evaluation_lock:
+                self.evaluated_candidates[candidate.name] = total_score
+
+                if total_score > self.best_score:
+                    self.best_score = total_score
+                    self.best_candidate = candidate.name
+
+                    logger.info(
+                        f"New best: {candidate.name} with {total_score:.2%}"
+                    )
+
+                    # Check for early stop
+                    if total_score >= self.early_stop_threshold:
+                        logger.info(
+                            f"EARLY STOP: {candidate.name} reached {total_score:.2%}!"
+                        )
+                        self.found_answer.set()
+
+                        if self.progress_callback:
+                            self.progress_callback(
+                                f"Found answer: {candidate.name} ({int(total_score * 100)}% confidence)",
+                                95,
+                                {
+                                    "phase": "early_stop",
+                                    "final_answer": candidate.name,
+                                    "confidence": total_score,
+                                    "detailed_results": detailed_results,
+                                },
+                            )
+
+            return total_score
+
+        except Exception as e:
+            logger.error(f"Error evaluating {candidate.name}: {e}")
+            return 0.0