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

local_deep_research/web_search_engines/search_engine_factory.py

@@ -0,0 +1,233 @@
+import os
+import importlib
+import inspect
+import logging
+from typing import Dict, List, Any, Optional
+
+from .search_engine_base import BaseSearchEngine
+from .search_engines_config import SEARCH_ENGINES, DEFAULT_SEARCH_ENGINE
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def create_search_engine(engine_name: str, llm=None, **kwargs) -> Optional[BaseSearchEngine]:
+    """
+    Create a search engine instance based on the engine name.
+    
+    Args:
+        engine_name: Name of the search engine to create
+        llm: Language model instance (required for some engines like meta)
+        **kwargs: Additional parameters to override defaults
+        
+    Returns:
+        Initialized search engine instance or None if creation failed
+    """
+    # If engine name not found, use default
+    if engine_name not in SEARCH_ENGINES:
+        logger.warning(f"Search engine '{engine_name}' not found, using default: {DEFAULT_SEARCH_ENGINE}")
+        engine_name = DEFAULT_SEARCH_ENGINE
+    
+    # Get engine configuration
+    engine_config = SEARCH_ENGINES[engine_name]
+    from local_deep_research.config import settings
+    
+    # Set default max_results from config if not provided in kwargs
+    if 'max_results' not in kwargs:
+        max_results = settings.search.max_results
+        if max_results == None: max_results=20
+        kwargs['max_results'] = max_results
+    
+    # Check for API key requirements
+    if engine_config.get("requires_api_key", False):
+        api_key_env = engine_config.get("api_key_env")
+        api_key = os.getenv(api_key_env) if api_key_env else None
+        
+        if not api_key:
+            logger.info(f"Required API key for {engine_name} not found in environment variable: {api_key_env}")
+            return None
+    
+    # Check for LLM requirements
+    if engine_config.get("requires_llm", False) and not llm:
+        logger.info(f"Engine {engine_name} requires an LLM instance but none was provided")
+        return None
+    
+    try:
+        # Load the engine class
+        module_path = engine_config["module_path"]
+        class_name = engine_config["class_name"]
+        
+        module = importlib.import_module(module_path)
+        engine_class = getattr(module, class_name)
+        
+        # Get the engine class's __init__ parameters to filter out unsupported ones
+        engine_init_signature = inspect.signature(engine_class.__init__)
+        engine_init_params = list(engine_init_signature.parameters.keys())
+        
+        # Combine default parameters with provided ones
+        all_params = {**engine_config.get("default_params", {}), **kwargs}
+        
+        # Filter out parameters that aren't accepted by the engine class
+        # Note: 'self' is always the first parameter of instance methods, so we skip it
+        filtered_params = {k: v for k, v in all_params.items() if k in engine_init_params[1:]}
+        
+        # Add LLM if required
+        if engine_config.get("requires_llm", False):
+            filtered_params["llm"] = llm
+        
+        # Add API key if required and not already in filtered_params
+        if engine_config.get("requires_api_key", False) and "api_key" not in filtered_params:
+            api_key_env = engine_config.get("api_key_env")
+            if api_key_env:
+                api_key = os.getenv(api_key_env)
+                if api_key:
+                    filtered_params["api_key"] = api_key
+        
+        logger.info(f"Creating {engine_name} with filtered parameters: {filtered_params.keys()}")
+        
+        # Create the engine instance with filtered parameters
+        engine = engine_class(**filtered_params)
+        
+        # Check if we need to wrap with full search capabilities
+        if kwargs.get("use_full_search", False) and engine_config.get("supports_full_search", False):
+            return _create_full_search_wrapper(engine_name, engine, llm, kwargs)
+        
+        return engine
+        
+    except Exception as e:
+        logger.info(f"Failed to create search engine '{engine_name}': {str(e)}")
+        return None
+
+
+def _create_full_search_wrapper(engine_name: str, base_engine: BaseSearchEngine, llm, params: Dict[str, Any]) -> Optional[BaseSearchEngine]:
+    """Create a full search wrapper for the base engine if supported"""
+    try:
+        engine_config = SEARCH_ENGINES[engine_name]
+        
+        # Get full search class details
+        module_path = engine_config.get("full_search_module")
+        class_name = engine_config.get("full_search_class")
+        
+        if not module_path or not class_name:
+            logger.warning(f"Full search configuration missing for {engine_name}")
+            return base_engine
+        
+        # Import the full search class
+        module = importlib.import_module(module_path)
+        full_search_class = getattr(module, class_name)
+        
+        # Get the wrapper's __init__ parameters to filter out unsupported ones
+        wrapper_init_signature = inspect.signature(full_search_class.__init__)
+        wrapper_init_params = list(wrapper_init_signature.parameters.keys())[1:]  # Skip 'self'
+        
+        # Extract relevant parameters for the full search wrapper
+        wrapper_params = {k: v for k, v in params.items() if k in wrapper_init_params}
+        
+        # Special case for SerpAPI which needs the API key directly
+        if engine_name == "serpapi" and "serpapi_api_key" in wrapper_init_params:
+            serpapi_api_key = os.getenv("SERP_API_KEY")
+            if serpapi_api_key:
+                wrapper_params["serpapi_api_key"] = serpapi_api_key
+                
+            # Map some parameter names to what the wrapper expects
+            if "language" in params and "search_language" not in params and "language" in wrapper_init_params:
+                wrapper_params["language"] = params["language"]
+                
+            if "safesearch" not in wrapper_params and "safe_search" in params and "safesearch" in wrapper_init_params:
+                wrapper_params["safesearch"] = "active" if params["safe_search"] else "off"
+        
+        # Special case for Brave which needs the API key directly
+        if engine_name == "brave" and "api_key" in wrapper_init_params:
+            brave_api_key = os.getenv("BRAVE_API_KEY")
+            if brave_api_key:
+                wrapper_params["api_key"] = brave_api_key
+                
+            # Map some parameter names to what the wrapper expects
+            if "language" in params and "search_language" not in params and "language" in wrapper_init_params:
+                wrapper_params["language"] = params["language"]
+                
+            if "safesearch" not in wrapper_params and "safe_search" in params and "safesearch" in wrapper_init_params:
+                wrapper_params["safesearch"] = "moderate" if params["safe_search"] else "off"
+        
+        # Always include llm if it's a parameter
+        if "llm" in wrapper_init_params:
+            wrapper_params["llm"] = llm
+        
+        # If the wrapper needs the base engine and has a parameter for it
+        if "web_search" in wrapper_init_params:
+            wrapper_params["web_search"] = base_engine
+        
+        logger.debug(f"Creating full search wrapper for {engine_name} with filtered parameters: {wrapper_params.keys()}")
+        
+        # Create the full search wrapper with filtered parameters
+        full_search = full_search_class(**wrapper_params)
+        
+        return full_search
+        
+    except Exception as e:
+        logger.error(f"Failed to create full search wrapper for {engine_name}: {str(e)}")
+        return base_engine
+
+
+
+def get_available_engines(include_api_key_services: bool = True):
+    """Get a list of available engine names"""
+    if include_api_key_services:
+        return list(SEARCH_ENGINES.keys())
+    else:
+        return [name for name, config in SEARCH_ENGINES.items() 
+                if not config.get("requires_api_key", False)]
+
+
+def get_search(search_tool: str, llm_instance, 
+               max_results: int = 10, 
+               region: str = "us",
+               time_period: str = "y",
+               safe_search: bool = True,
+               search_snippets_only: bool = False,
+               search_language: str = "English",
+               max_filtered_results: Optional[int] = None):
+    """
+    Get search tool instance based on the provided parameters.
+    
+    Args:
+        search_tool: Name of the search engine to use
+        llm_instance: Language model instance
+        max_results: Maximum number of search results
+        region: Search region/locale
+        time_period: Time period for search results
+        safe_search: Whether to enable safe search
+        search_snippets_only: Whether to return just snippets (vs. full content)
+        search_language: Language for search results
+        max_filtered_results: Maximum number of results to keep after filtering
+        
+    Returns:
+        Initialized search engine instance
+    """
+    # Common parameters
+    params = {
+        "max_results": max_results,
+        "llm": llm_instance,  # Only used by engines that need it
+    }
+    
+    # Add max_filtered_results if provided
+    if max_filtered_results is not None:
+        params["max_filtered_results"] = max_filtered_results
+    
+    # Add engine-specific parameters
+    if search_tool in ["duckduckgo", "serpapi", "google_pse", "brave"]:
+        params.update({
+            "region": region,
+            "safe_search": safe_search,
+            "use_full_search": not search_snippets_only
+        })
+    
+    if search_tool in ["serpapi", "brave", "google_pse"]:
+        params["search_language"] = search_language
+        
+    if search_tool == "serpapi":
+        params["time_period"] = time_period
+    
+    # Create and return the search engine
+    return create_search_engine(search_tool, **params)

local_deep_research/web_search_engines/search_engines_config.py

@@ -0,0 +1,54 @@
+"""
+Configuration file for search engines.
+Loads search engine definitions from the user's configuration.
+"""
+import logging
+import os
+import toml
+from pathlib import Path
+from local_deep_research.config import CONFIG_DIR
+
+logger = logging.getLogger(__name__)
+
+# Get search engines configuration directly from TOML file
+SEARCH_ENGINES = {}
+DEFAULT_SEARCH_ENGINE = "wikipedia"  # Default fallback if not specified in config
+
+# Path to the search engines configuration file
+SEARCH_ENGINES_FILE = CONFIG_DIR / "search_engines.toml"
+
+# Load directly from TOML file
+if os.path.exists(SEARCH_ENGINES_FILE):
+    try:
+        # Load the TOML file directly
+        config_data = toml.load(SEARCH_ENGINES_FILE)
+        
+        # Extract search engine definitions
+        for key, value in config_data.items():
+            if key == "DEFAULT_SEARCH_ENGINE":
+                DEFAULT_SEARCH_ENGINE = value
+            elif isinstance(value, dict):
+                SEARCH_ENGINES[key] = value
+        
+        logger.info(f"Loaded {len(SEARCH_ENGINES)} search engines from configuration file")
+    except Exception as e:
+        logger.error(f"Error loading search engines from TOML file: {e}")
+else:
+    logger.warning(f"Search engines configuration file not found: {SEARCH_ENGINES_FILE}")
+
+# Add alias for 'auto' if it exists
+if 'auto' in SEARCH_ENGINES and 'meta' not in SEARCH_ENGINES:
+    SEARCH_ENGINES['meta'] = SEARCH_ENGINES['auto']
+
+# Register local document collections
+try:
+    from local_deep_research.local_collections import register_local_collections
+    register_local_collections(SEARCH_ENGINES)
+    logger.info(f"Registered local document collections as search engines")
+except ImportError:
+    logger.info("No local collections configuration found. Local document search is disabled.")
+
+# Ensure the meta search engine is still available at the end if it exists
+if 'auto' in SEARCH_ENGINES:
+    meta_config = SEARCH_ENGINES["auto"]
+    SEARCH_ENGINES["auto"] = meta_config

local_deep_research-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 LearningCircuit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

local_deep_research-0.1.0.dist-info/METADATA

@@ -0,0 +1,328 @@
+Metadata-Version: 2.2
+Name: local-deep-research
+Version: 0.1.0
+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
+        
+        Copyright (c) 2025 LearningCircuit
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/LearningCircuit/local-deep-research
+Project-URL: Bug Tracker, https://github.com/LearningCircuit/local-deep-research/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langchain>=0.3.18
+Requires-Dist: langchain-community>=0.3.17
+Requires-Dist: langchain-core>=0.3.34
+Requires-Dist: langchain-ollama>=0.2.3
+Requires-Dist: langchain-openai>=0.3.5
+Requires-Dist: langchain_anthropic>=0.3.7
+Requires-Dist: duckduckgo_search>=7.3.2
+Requires-Dist: python-dateutil>=2.9.0
+Requires-Dist: typing_extensions>=4.12.2
+Requires-Dist: justext
+Requires-Dist: playwright
+Requires-Dist: beautifulsoup4
+Requires-Dist: flask>=2.0.1
+Requires-Dist: flask-cors>=3.0.10
+Requires-Dist: flask-socketio>=5.1.1
+Requires-Dist: sqlalchemy>=1.4.23
+Requires-Dist: wikipedia
+Requires-Dist: arxiv>=1.4.3
+Requires-Dist: PyPDF2>=2.0.0
+Requires-Dist: sentence-transformers
+Requires-Dist: faiss-cpu
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: toml>=0.10.2
+Requires-Dist: platformdirs>=3.0.0
+Requires-Dist: dynaconf
+
+# Local Deep Research
+
+A powerful AI-powered research assistant that performs deep, iterative analysis using multiple LLMs and web searches. The system can be run locally for privacy or configured to use cloud-based LLMs for enhanced capabilities.
+
+## Features
+
+- 🔍 **Advanced Research Capabilities**
+  - Automated deep research with intelligent follow-up questions
+  - Citation tracking and source verification
+  - Multi-iteration analysis for comprehensive coverage
+  - Full webpage content analysis (not just snippets)
+
+- 🤖 **Flexible LLM Support**
+  - Local AI processing with Ollama models
+  - Cloud LLM support (Claude, GPT)
+  - Supports all Langchain models
+  - Configurable model selection based on needs
+
+- 📊 **Rich Output Options**
+  - Detailed research findings with citations
+  - Comprehensive research reports
+  - Quick summaries for rapid insights
+  - Source tracking and verification
+
+- 🔒 **Privacy-Focused**
+  - Runs entirely on your machine when using local models
+  - Configurable search settings
+  - Transparent data handling
+
+- 🌐 **Enhanced Search Integration**
+  - **Auto-selection of search sources**: The "auto" search engine intelligently analyzes your query and selects the most appropriate search engine based on the query content
+  - Wikipedia integration for factual knowledge
+  - arXiv integration for scientific papers and academic research
+  - PubMed integration for biomedical literature and medical research
+  - DuckDuckGo integration for web searches (may experience rate limiting)
+  - SerpAPI integration for Google search results (requires API key)
+  - **Google Programmable Search Engine** integration for custom search experiences (requires API key)
+  - The Guardian integration for news articles and journalism (requires API key)
+  - **Local RAG search for private documents** - search your own documents with vector embeddings
+  - Full webpage content retrieval
+  - Source filtering and validation
+  - Configurable search parameters
+
+- 📑 **Local Document Search (RAG)**
+  - Vector embedding-based search of your local documents
+  - Create custom document collections for different topics
+  - Privacy-preserving - your documents stay on your machine
+  - Intelligent chunking and retrieval 
+  - Compatible with various document formats (PDF, text, markdown, etc.)
+  - Automatic integration with meta-search for unified queries
+
+## Example Research: Fusion Energy Developments
+
+The repository includes complete research examples demonstrating the tool's capabilities. For instance, our [fusion energy research analysis](https://github.com/LearningCircuit/local-deep-research/blob/main/examples/fusion-energy-research-developments.md) provides a comprehensive overview of:
+
+- Latest scientific breakthroughs in fusion research (2022-2025)
+- Private sector funding developments exceeding $6 billion
+- Expert projections for commercial fusion energy timelines
+- Regulatory frameworks being developed for fusion deployment
+- Technical challenges that must be overcome for commercial viability
+
+This example showcases the system's ability to perform multiple research iterations, follow evidence trails across scientific and commercial domains, and synthesize information from diverse sources while maintaining proper citation.
+
+## Installation
+
+1. Clone the repository:
+```bash
+git clone https://github.com/yourusername/local-deep-research.git
+cd local-deep-research
+```
+
+2. Install dependencies:
+```bash
+pip install -r requirements.txt
+playwright install
+```
+
+3. Install Ollama (for local models):
+```bash
+# Install Ollama from https://ollama.ai
+ollama pull mistral  # Default model - many work really well choose best for your hardware (fits in GPU)
+```
+
+4. Configure environment variables:
+```bash
+# Copy the template
+cp .env.template .env
+
+# Edit .env with your API keys (if using cloud LLMs)
+ANTHROPIC_API_KEY=your-api-key-here  # For Claude
+OPENAI_API_KEY=your-openai-key-here  # For GPT models
+GUARDIAN_API_KEY=your-guardian-api-key-here  # For The Guardian search
+```
+
+## Usage
+Terminal usage (not recommended):
+```bash
+python main.py
+```
+
+### Web Interface
+
+The project includes a web interface for a more user-friendly experience:
+
+```bash
+python app.py
+```
+
+This will start a local web server, accessible at `http://127.0.0.1:5000` in your browser.
+
+#### Web Interface Features:
+
+- **Dashboard**: Intuitive interface for starting and managing research queries
+- **Real-time Updates**: Track research progress with live updates
+- **Research History**: Access and manage past research queries
+- **PDF Export**: Download completed research reports as PDF documents
+- **Research Management**: Terminate ongoing research processes or delete past records
+
+![Web Interface](./web1.png)
+![Web Interface](./web2.png)
+### Configuration
+**Please report your best settings in issues so we can improve the default settings.**
+
+Key settings in `config.py`:
+```python
+# LLM Configuration
+DEFAULT_MODEL = "mistral"  # Change based on your needs
+DEFAULT_TEMPERATURE = 0.7
+MAX_TOKENS = 8000
+
+# Search Configuration
+MAX_SEARCH_RESULTS = 40
+SEARCH_REGION = "us-en"
+TIME_PERIOD = "y"
+SAFE_SEARCH = True
+SEARCH_SNIPPETS_ONLY = False
+
+# Choose search tool: "wiki", "arxiv", "duckduckgo", "guardian", "serp", "local_all", or "auto"
+search_tool = "auto"  # "auto" will intelligently select the best search engine for your query
+```
+
+## Local Document Search (RAG)
+
+The system includes powerful local document search capabilities using Retrieval-Augmented Generation (RAG). This allows you to search and retrieve content from your own document collections.
+
+### Setting Up Local Collections
+
+Create a file named `local_collections.py` in the project root directory:
+
+```python
+# local_collections.py
+import os
+from typing import Dict, Any
+
+# Registry of local document collections
+LOCAL_COLLECTIONS = {
+    # Research Papers Collection
+    "research_papers": {
+        "name": "Research Papers",
+        "description": "Academic research papers and articles",
+        "paths": [os.path.abspath("local_search_files/research_papers")],  # Use absolute paths
+        "enabled": True,
+        "embedding_model": "all-MiniLM-L6-v2",
+        "embedding_device": "cpu",
+        "embedding_model_type": "sentence_transformers",
+        "max_results": 20,
+        "max_filtered_results": 5,
+        "chunk_size": 800,  # Smaller chunks for academic content
+        "chunk_overlap": 150,
+        "cache_dir": ".cache/local_search/research_papers"
+    },
+    
+    # Personal Notes Collection
+    "personal_notes": {
+        "name": "Personal Notes",
+        "description": "Personal notes and documents",
+        "paths": [os.path.abspath("local_search_files/personal_notes")],  # Use absolute paths
+        "enabled": True,
+        "embedding_model": "all-MiniLM-L6-v2",
+        "embedding_device": "cpu",
+        "embedding_model_type": "sentence_transformers",
+        "max_results": 30,
+        "max_filtered_results": 10,
+        "chunk_size": 500,  # Smaller chunks for notes
+        "chunk_overlap": 100,
+        "cache_dir": ".cache/local_search/personal_notes"
+    }
+}
+```
+
+Create directories for your collections:
+
+```bash
+mkdir -p local_search_files/research_papers
+mkdir -p local_search_files/personal_notes
+```
+
+Add your documents to these folders, and the system will automatically index them and make them available for searching.
+
+### Using Local Search
+
+You can use local search in several ways:
+
+1. **Auto-selection**: Set `search_tool = "auto"` in `config.py` and the system will automatically use your local collections when appropriate for the query.
+
+2. **Explicit Selection**: Set `search_tool = "research_papers"` to search only that specific collection.
+
+3. **Search All Local Collections**: Set `search_tool = "local_all"` to search across all your local document collections.
+
+4. **Query Syntax**: Use `collection:collection_name your query` to target a specific collection within a query.
+
+### Search Engine Options
+
+The system supports multiple search engines that can be selected by changing the `search_tool` variable in `config.py`:
+
+- **Auto** (`auto`): Intelligent search engine selector that analyzes your query and chooses the most appropriate source (Wikipedia, arXiv, local collections, etc.)
+- **Wikipedia** (`wiki`): Best for general knowledge, facts, and overview information
+- **arXiv** (`arxiv`): Great for scientific and academic research, accessing preprints and papers
+- **PubMed** (`pubmed`): Excellent for biomedical literature, medical research, and health information
+- **DuckDuckGo** (`duckduckgo`): General web search that doesn't require an API key
+- **The Guardian** (`guardian`): Quality journalism and news articles (requires an API key)
+- **SerpAPI** (`serp`): Google search results (requires an API key)
+- **Google Programmable Search Engine** (`google_pse`): Custom search experiences with control over search scope and domains (requires API key and search engine ID)
+- **Local Collections**: Any collections defined in your `local_collections.py` file
+
+> **Note:** The "auto" option will intelligently select the best search engine based on your query. For example, if you ask about physics research papers, it might select arXiv or your research_papers collection, while if you ask about current events, it might select The Guardian or DuckDuckGo.
+
+> **Support Free Knowledge:** If you frequently use the search engines in this tool, please consider making a donation to these organizations. They provide valuable services and rely on user support to maintain their operations:
+> - [Donate to Wikipedia](https://donate.wikimedia.org)
+> - [Support The Guardian](https://support.theguardian.com)
+> - [Support arXiv](https://arxiv.org/about/give)
+> - [Donate to DuckDuckGo](https://duckduckgo.com/donations)
+> - [Support PubMed/NCBI](https://www.nlm.nih.gov/pubs/donations/donations.html)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+- Built with [Ollama](https://ollama.ai) for local AI processing
+- Search powered by multiple sources:
+  - [Wikipedia](https://www.wikipedia.org/) for factual knowledge (default search engine)
+  - [arXiv](https://arxiv.org/) for scientific papers
+  - [PubMed](https://pubmed.ncbi.nlm.nih.gov/) for biomedical literature
+  - [DuckDuckGo](https://duckduckgo.com) for web search
+  - [The Guardian](https://www.theguardian.com/) for quality journalism
+  - [SerpAPI](https://serpapi.com) for Google search results (requires API key)
+- Built on [LangChain](https://github.com/hwchase17/langchain) framework
+- Uses [justext](https://github.com/miso-belica/justext) for content extraction
+- [Playwright](https://playwright.dev) for web content retrieval
+- Uses [FAISS](https://github.com/facebookresearch/faiss) for vector similarity search
+- Uses [sentence-transformers](https://github.com/UKPLab/sentence-transformers) for embeddings
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
+3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
+4. Push to the branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
+
+## Star History
+ 
+ [![Star History Chart](https://api.star-history.com/svg?repos=LearningCircuit/local-deep-research&type=Date)](https://www.star-history.com/#LearningCircuit/local-deep-research&Date)