better-dsh 0.2.4 → 0.2.5

package/docs/80_upstream-docs-and-skills/hermes-dev-skill/src/docs/user-guide/skills/optional/research/research-rss-feeds.md

@@ -0,0 +1,114 @@
+---
+title: "Rss Feeds — Read RSS, Atom, JSON feeds; discover feeds behind a page"
+sidebar_label: "Rss Feeds"
+description: "Read RSS, Atom, JSON feeds; discover feeds behind a page"
+---
+
+{/* This page is auto-generated from the skill's SKILL.md by website/scripts/generate-skill-docs.py. Edit the source SKILL.md, not this page. */}
+
+# Rss Feeds
+
+Read RSS, Atom, JSON feeds; discover feeds behind a page.
+
+## Skill metadata
+
+| | |
+|---|---|
+| Source | Optional — install with `hermes skills install official/research/rss-feeds` |
+| Path | `optional-skills/research/rss-feeds` |
+| Version | `1.0.0` |
+| Author | Teknium (teknium1), Hermes Agent |
+| License | MIT |
+| Platforms | linux, macos, windows |
+| Tags | `RSS`, `Atom`, `Feeds`, `Monitoring`, `Research`, `Blogs`, `Releases` |
+| Related skills | [`reddit-reading`](/docs/user-guide/skills/optional/social-media/social-media-reddit-reading), [`competitor-news-monitor`](/docs/user-guide/skills/bundled/research/research-competitor-news-monitor), [`grounded-citations`](/docs/user-guide/skills/bundled/research/research-grounded-citations), [`youtube-content`](/docs/user-guide/skills/bundled/media/media-youtube-content), [`blogwatcher`](/docs/user-guide/skills/optional/research/research-blogwatcher) |
+
+## Reference: full SKILL.md
+
+:::info
+The following is the complete skill definition that Hermes loads when this skill is triggered. This is what the agent sees as instructions when the skill is active.
+:::
+
+# RSS Feeds Skill
+
+Reads any RSS 2.0, RSS 1.0/RDF, Atom, or JSON Feed URL into a clean, date-sorted list of
+entries, and discovers the feed behind an ordinary page URL (`<link rel="alternate">` or
+the usual `/feed`, `/rss.xml`, `/atom.xml` paths). Standard library only, nothing to
+install. It does not fetch full article bodies — pass an entry's link to `web_extract` for
+that.
+
+## When to Use
+
+- "What's new on &lt;blog/site>", "latest releases of &lt;GitHub repo>", "recent posts in
+  &lt;subreddit>", "read this feed", "does this site have an RSS feed".
+- Building a recurring digest with `cronjob_manage` (feeds are cheaper and more stable than
+  scraping the HTML front page every run). For a persistent read/unread database across
+  many feeds install the optional `blogwatcher` skill; this skill is the zero-install read.
+- Anything where a structured list of `title / link / date / author / summary` beats a
+  rendered page: podcasts, changelogs, YouTube channels, newsrooms, forum categories.
+
+## Prerequisites
+
+None. Python 3.10+, network access to the feed host.
+
+## How to Run
+
+Run through `terminal` with the skill-relative script path:
+
+```bash
+python3 scripts/feed.py read https://hnrss.org/frontpage --limit 10
+python3 scripts/feed.py read https://simonwillison.net/            # page URL → discovers the feed
+python3 scripts/feed.py read URL --since 2026-09-01 --json          # only newer entries, machine-readable
+python3 scripts/feed.py discover https://example.com/               # list candidate feed URLs
+```
+
+## Quick Reference
+
+| Source | Feed URL pattern |
+|---|---|
+| GitHub releases / commits / tags | `https://github.com/OWNER/REPO/releases.atom`, `…/commits/BRANCH.atom`, `…/tags.atom` |
+| Subreddit / Reddit search | `https://www.reddit.com/r/NAME/.rss`, `https://www.reddit.com/search.rss?q=…` (1 req/min anon; see `reddit-reading`) |
+| YouTube channel | `https://www.youtube.com/feeds/videos.xml?channel_id=UC…` |
+| Hacker News | `https://hnrss.org/frontpage`, `https://hnrss.org/newest?q=TERM` |
+| arXiv category | `https://rss.arxiv.org/rss/cs.CL` |
+| Substack / Medium / WordPress / Ghost | `SITE/feed`, `medium.com/feed/@user`, `SITE/rss/` |
+| Podcasts | the show's RSS URL from its hosting page (`discover` finds it) |
+
+Output fields per entry: `title`, `link`, `published` (UTC ISO 8601), `author`, `summary`
+(HTML stripped, ≤ 2000 chars). Entries are sorted newest-first.
+
+## Procedure
+
+① If you only have a site URL, run `read` on it directly; the script discovers the feed
+and reports which URL it used (`discovered_from`). Use `discover` when you want to choose
+between several advertised feeds (comments feed vs posts feed, per-category feeds).
+
+② Bound the request: `--limit` for "latest N", `--since YYYY-MM-DD` for "since last
+check". For a cron digest persist the last-seen `published` value and pass it as
+`--since` next run.
+
+③ For full text, hand the entry `link` to `web_extract`; feed summaries are frequently
+truncated or the first paragraph only.
+
+④ Cite the entry `link`, not the feed URL, when the result feeds a report
+(`grounded-citations`).
+
+## Pitfalls
+
+- A 200 response with HTML means the URL is a page, not a feed; the script falls through
+  to discovery automatically, but a site with no `<link rel="alternate">` and none of the
+  common paths reports `no feed found` — check the site's footer or `/sitemap.xml` before
+  concluding there is none.
+- Reddit feeds share Reddit's anonymous throttle (about one request per minute per IP).
+  Chain them through `reddit-reading`, which waits out the window, when you need more
+  than one Reddit call.
+- Dates: RSS `pubDate` is RFC 822 and Atom uses ISO 8601; the script normalises both to
+  UTC. Feeds that omit dates sort to the bottom and are dropped by `--since`.
+- Some feeds are Cloudflare-fronted and 403 non-browser clients; `blocked-page-recovery`
+  handles that class.
+
+## Verification
+
+`python3 scripts/feed.py read https://github.com/NousResearch/hermes-agent/releases.atom
+--limit 1` prints one entry with a `releases/tag/` link and a `[atom]` format tag;
+`discover https://simonwillison.net/` prints an `/atom/` URL.

package/docs/80_upstream-docs-and-skills/hermes-dev-skill/src/docs/user-guide/skills/optional/research/research-scrapling.md

@@ -0,0 +1,351 @@
+---
+title: "Scrapling — Scrape sites with stealth browsing and Cloudflare bypass"
+sidebar_label: "Scrapling"
+description: "Scrape sites with stealth browsing and Cloudflare bypass"
+---
+
+{/* This page is auto-generated from the skill's SKILL.md by website/scripts/generate-skill-docs.py. Edit the source SKILL.md, not this page. */}
+
+# Scrapling
+
+Scrape sites with stealth browsing and Cloudflare bypass.
+
+## Skill metadata
+
+| | |
+|---|---|
+| Source | Optional — install with `hermes skills install official/research/scrapling` |
+| Path | `optional-skills/research\scrapling` |
+| Version | `1.0.0` |
+| Author | FEUAZUR |
+| License | MIT |
+| Platforms | linux, macos, windows |
+| Tags | `Web Scraping`, `Browser`, `Cloudflare`, `Stealth`, `Crawling`, `Spider` |
+| Related skills | [`duckduckgo-search`](/docs/user-guide/skills/optional/research/research-duckduckgo-search), [`domain-intel`](/docs/user-guide/skills/optional/research/research-domain-intel) |
+
+## Reference: full SKILL.md
+
+:::info
+The following is the complete skill definition that Hermes loads when this skill is triggered. This is what the agent sees as instructions when the skill is active.
+:::
+
+# Scrapling
+
+[Scrapling](https://github.com/D4Vinci/Scrapling) is a web scraping framework with anti-bot bypass, stealth browser automation, and a spider framework. It provides three fetching strategies (HTTP, dynamic JS, stealth/Cloudflare) and a full CLI.
+
+**This skill is for educational and research purposes only.** Users must comply with local/international data scraping laws and respect website Terms of Service.
+
+## When to Use
+
+- Scraping static HTML pages (faster than browser tools)
+- Scraping JS-rendered pages that need a real browser
+- Bypassing Cloudflare Turnstile or bot detection
+- Crawling multiple pages with a spider
+- When the built-in `web_extract` tool does not return the data you need
+
+## Installation
+
+```bash
+pip install "scrapling[all]"
+scrapling install
+```
+
+Minimal install (HTTP only, no browser):
+```bash
+pip install scrapling
+```
+
+With browser automation only:
+```bash
+pip install "scrapling[fetchers]"
+scrapling install
+```
+
+## Quick Reference
+
+| Approach | Class | Use When |
+|----------|-------|----------|
+| HTTP | `Fetcher` / `FetcherSession` | Static pages, APIs, fast bulk requests |
+| Dynamic | `DynamicFetcher` / `DynamicSession` | JS-rendered content, SPAs |
+| Stealth | `StealthyFetcher` / `StealthySession` | Cloudflare, anti-bot protected sites |
+| Spider | `Spider` | Multi-page crawling with link following |
+
+## CLI Usage
+
+### Extract Static Page
+
+```bash
+scrapling extract get 'https://example.com' output.md
+```
+
+With CSS selector and browser impersonation:
+
+```bash
+scrapling extract get 'https://example.com' output.md \
+  --css-selector '.content' \
+  --impersonate 'chrome'
+```
+
+### Extract JS-Rendered Page
+
+```bash
+scrapling extract fetch 'https://example.com' output.md \
+  --css-selector '.dynamic-content' \
+  --disable-resources \
+  --network-idle
+```
+
+### Extract Cloudflare-Protected Page
+
+```bash
+scrapling extract stealthy-fetch 'https://protected-site.com' output.html \
+  --solve-cloudflare \
+  --block-webrtc \
+  --hide-canvas
+```
+
+### POST Request
+
+```bash
+scrapling extract post 'https://example.com/api' output.json \
+  --json '{"query": "search term"}'
+```
+
+### Output Formats
+
+The output format is determined by the file extension:
+- `.html` -- raw HTML
+- `.md` -- converted to Markdown
+- `.txt` -- plain text
+- `.json` / `.jsonl` -- JSON
+
+## Python: HTTP Scraping
+
+### Single Request
+
+```python
+from scrapling.fetchers import Fetcher
+
+page = Fetcher.get('https://quotes.toscrape.com/')
+quotes = page.css('.quote .text::text').getall()
+for q in quotes:
+    print(q)
+```
+
+### Session (Persistent Cookies)
+
+```python
+from scrapling.fetchers import FetcherSession
+
+with FetcherSession(impersonate='chrome') as session:
+    page = session.get('https://example.com/', stealthy_headers=True)
+    links = page.css('a::attr(href)').getall()
+    for link in links[:5]:
+        sub = session.get(link)
+        print(sub.css('h1::text').get())
+```
+
+### POST / PUT / DELETE
+
+```python
+page = Fetcher.post('https://api.example.com/data', json={"key": "value"})
+page = Fetcher.put('https://api.example.com/item/1', data={"name": "updated"})
+page = Fetcher.delete('https://api.example.com/item/1')
+```
+
+### With Proxy
+
+```python
+page = Fetcher.get('https://example.com', proxy='http://user:pass@proxy:8080')
+```
+
+## Python: Dynamic Pages (JS-Rendered)
+
+For pages that require JavaScript execution (SPAs, lazy-loaded content):
+
+```python
+from scrapling.fetchers import DynamicFetcher
+
+page = DynamicFetcher.fetch('https://example.com', headless=True)
+data = page.css('.js-loaded-content::text').getall()
+```
+
+### Wait for Specific Element
+
+```python
+page = DynamicFetcher.fetch(
+    'https://example.com',
+    wait_selector=('.results', 'visible'),
+    network_idle=True,
+)
+```
+
+### Disable Resources for Speed
+
+Blocks fonts, images, media, stylesheets (~25% faster):
+
+```python
+from scrapling.fetchers import DynamicSession
+
+with DynamicSession(headless=True, disable_resources=True, network_idle=True) as session:
+    page = session.fetch('https://example.com')
+    items = page.css('.item::text').getall()
+```
+
+### Custom Page Automation
+
+```python
+from playwright.sync_api import Page
+from scrapling.fetchers import DynamicFetcher
+
+def scroll_and_click(page: Page):
+    page.mouse.wheel(0, 3000)
+    page.wait_for_timeout(1000)
+    page.click('button.load-more')
+    page.wait_for_selector('.extra-results')
+
+page = DynamicFetcher.fetch('https://example.com', page_action=scroll_and_click)
+results = page.css('.extra-results .item::text').getall()
+```
+
+## Python: Stealth Mode (Anti-Bot Bypass)
+
+For Cloudflare-protected or heavily fingerprinted sites:
+
+```python
+from scrapling.fetchers import StealthyFetcher
+
+page = StealthyFetcher.fetch(
+    'https://protected-site.com',
+    headless=True,
+    solve_cloudflare=True,
+    block_webrtc=True,
+    hide_canvas=True,
+)
+content = page.css('.protected-content::text').getall()
+```
+
+### Stealth Session
+
+```python
+from scrapling.fetchers import StealthySession
+
+with StealthySession(headless=True, solve_cloudflare=True) as session:
+    page1 = session.fetch('https://protected-site.com/page1')
+    page2 = session.fetch('https://protected-site.com/page2')
+```
+
+## Element Selection
+
+All fetchers return a `Selector` object with these methods:
+
+### CSS Selectors
+
+```python
+page.css('h1::text').get()              # First h1 text
+page.css('a::attr(href)').getall()      # All link hrefs
+page.css('.quote .text::text').getall() # Nested selection
+```
+
+### XPath
+
+```python
+page.xpath('//div[@class="content"]/text()').getall()
+page.xpath('//a/@href').getall()
+```
+
+### Find Methods
+
+```python
+page.find_all('div', class_='quote')       # By tag + attribute
+page.find_by_text('Read more', tag='a')    # By text content
+page.find_by_regex(r'\$\d+\.\d{2}')       # By regex pattern
+```
+
+### Similar Elements
+
+Find elements with similar structure (useful for product listings, etc.):
+
+```python
+first_product = page.css('.product')[0]
+all_similar = first_product.find_similar()
+```
+
+### Navigation
+
+```python
+el = page.css('.target')[0]
+el.parent                # Parent element
+el.children              # Child elements
+el.next_sibling          # Next sibling
+el.prev_sibling          # Previous sibling
+```
+
+## Python: Spider Framework
+
+For multi-page crawling with link following:
+
+```python
+from scrapling.spiders import Spider, Request, Response
+
+class QuotesSpider(Spider):
+    name = "quotes"
+    start_urls = ["https://quotes.toscrape.com/"]
+    concurrent_requests = 10
+    download_delay = 1
+
+    async def parse(self, response: Response):
+        for quote in response.css('.quote'):
+            yield {
+                "text": quote.css('.text::text').get(),
+                "author": quote.css('.author::text').get(),
+                "tags": quote.css('.tag::text').getall(),
+            }
+
+        next_page = response.css('.next a::attr(href)').get()
+        if next_page:
+            yield response.follow(next_page)
+
+result = QuotesSpider().start()
+print(f"Scraped {len(result.items)} quotes")
+result.items.to_json("quotes.json")
+```
+
+### Multi-Session Spider
+
+Route requests to different fetcher types:
+
+```python
+from scrapling.fetchers import FetcherSession, AsyncStealthySession
+
+class SmartSpider(Spider):
+    name = "smart"
+    start_urls = ["https://example.com/"]
+
+    def configure_sessions(self, manager):
+        manager.add("fast", FetcherSession(impersonate="chrome"))
+        manager.add("stealth", AsyncStealthySession(headless=True), lazy=True)
+
+    async def parse(self, response: Response):
+        for link in response.css('a::attr(href)').getall():
+            if "protected" in link:
+                yield Request(link, sid="stealth")
+            else:
+                yield Request(link, sid="fast", callback=self.parse)
+```
+
+### Pause/Resume Crawling
+
+```python
+spider = QuotesSpider(crawldir="./crawl_checkpoint")
+spider.start()  # Ctrl+C to pause, re-run to resume from checkpoint
+```
+
+## Pitfalls
+
+- **Browser install required**: run `scrapling install` after pip install -- without it, `DynamicFetcher` and `StealthyFetcher` will fail
+- **Timeouts**: DynamicFetcher/StealthyFetcher timeout is in **milliseconds** (default 30000), Fetcher timeout is in **seconds**
+- **Cloudflare bypass**: `solve_cloudflare=True` adds 5-15 seconds to fetch time -- only enable when needed
+- **Resource usage**: StealthyFetcher runs a real browser -- limit concurrent usage
+- **Legal**: always check robots.txt and website ToS before scraping. This library is for educational and research purposes
+- **Python version**: requires Python 3.10+

package/docs/80_upstream-docs-and-skills/hermes-dev-skill/src/docs/user-guide/skills/optional/research/research-searxng-search.md

@@ -0,0 +1,212 @@
+---
+title: "Searxng Search — Free keyless meta-search aggregating 70+ engines"
+sidebar_label: "Searxng Search"
+description: "Free keyless meta-search aggregating 70+ engines"
+---
+
+{/* This page is auto-generated from the skill's SKILL.md by website/scripts/generate-skill-docs.py. Edit the source SKILL.md, not this page. */}
+
+# Searxng Search
+
+Free keyless meta-search aggregating 70+ engines.
+
+## Skill metadata
+
+| | |
+|---|---|
+| Source | Optional — install with `hermes skills install official/research/searxng-search` |
+| Path | `optional-skills/research\searxng-search` |
+| Version | `1.0.1` |
+| Author | hermes-agent |
+| License | MIT |
+| Platforms | linux, macos |
+| Tags | `search`, `searxng`, `meta-search`, `self-hosted`, `free`, `fallback` |
+| Related skills | [`duckduckgo-search`](/docs/user-guide/skills/optional/research/research-duckduckgo-search), [`domain-intel`](/docs/user-guide/skills/optional/research/research-domain-intel) |
+
+## Reference: full SKILL.md
+
+:::info
+The following is the complete skill definition that Hermes loads when this skill is triggered. This is what the agent sees as instructions when the skill is active.
+:::
+
+# SearXNG Search
+
+Free meta-search using [SearXNG](https://searxng.org/) — a privacy-respecting, self-hosted search aggregator that queries 70+ search engines simultaneously.
+
+**No API key required** when using a public instance. Can also be self-hosted for full control. Automatically appears as a fallback when the main web search toolset (`FIRECRAWL_API_KEY`) is not configured.
+
+## Configuration
+
+SearXNG requires a `SEARXNG_URL` environment variable pointing to your SearXNG instance:
+
+```bash
+# Public instances (no setup required)
+SEARXNG_URL=https://searxng.example.com
+
+# Self-hosted SearXNG
+SEARXNG_URL=http://localhost:8888
+```
+
+If no instance is configured, this skill is unavailable and the agent falls back to other search options.
+
+## Detection Flow
+
+Check what is actually available before choosing an approach:
+
+```bash
+# Check if SEARXNG_URL is set and the instance is reachable
+curl -s --max-time 5 "${SEARXNG_URL}/search?q=test&format=json" | head -c 200
+```
+
+Decision tree:
+1. If `SEARXNG_URL` is set and the instance responds, use SearXNG
+2. If `SEARXNG_URL` is unset or unreachable, fall back to other available search tools
+3. If the user wants SearXNG specifically, help them set up an instance or find a public one
+
+## Method 1: CLI via curl (Preferred)
+
+Use `curl` via `terminal` to call the SearXNG JSON API. This avoids assuming any particular Python package is installed.
+
+```bash
+# Text search (JSON output)
+curl -s --max-time 10 \
+  "${SEARXNG_URL}/search?q=python+async+programming&format=json&engines=google,bing&limit=10"
+
+# With Safesearch off
+curl -s --max-time 10 \
+  "${SEARXNG_URL}/search?q=example&format=json&safesearch=0"
+
+# Specific categories (general, news, science, etc.)
+curl -s --max-time 10 \
+  "${SEARXNG_URL}/search?q=AI+news&format=json&categories=news"
+```
+
+### Common CLI Flags
+
+| Flag | Description | Example |
+|------|-------------|---------|
+| `q` | Query string (URL-encoded) | `q=python+async` |
+| `format` | Output format: `json`, `csv`, `rss` | `format=json` |
+| `engines` | Comma-separated engine names | `engines=google,bing,ddg` |
+| `limit` | Max results per engine (default 10) | `limit=5` |
+| `categories` | Filter by category | `categories=news,science` |
+| `safesearch` | 0=none, 1=moderate, 2=strict | `safesearch=0` |
+| `time_range` | Filter: `day`, `week`, `month`, `year` | `time_range=week` |
+
+### Parsing JSON Results
+
+```bash
+# Extract titles and URLs from JSON
+curl -s --max-time 10 "${SEARXNG_URL}/search?q=fastapi&format=json&limit=5" \
+  | python3 -c "
+import json, sys
+data = json.load(sys.stdin)
+for r in data.get('results', []):
+    print(r.get('title',''))
+    print(r.get('url',''))
+    print(r.get('content','')[:200])
+    print()
+"
+```
+
+Returns per result: `title`, `url`, `content` (snippet), `engine`, `parsed_url`, `img_src`, `thumbnail`, `author`, `published_date`
+
+## Method 2: Python API via `requests`
+
+Use the SearXNG REST API directly from Python with the `requests` library:
+
+```python
+import os, requests, urllib.parse
+
+base_url = os.environ.get("SEARXNG_URL", "")
+if not base_url:
+    raise RuntimeError("SEARXNG_URL is not set")
+
+query = "fastapi deployment guide"
+params = {
+    "q": query,
+    "format": "json",
+    "limit": 5,
+    "engines": "google,bing",
+}
+
+resp = requests.get(f"{base_url}/search", params=params, timeout=10)
+resp.raise_for_status()
+data = resp.json()
+
+for r in data.get("results", []):
+    print(r["title"])
+    print(r["url"])
+    print(r.get("content", "")[:200])
+    print()
+```
+
+## Self-Hosting SearXNG
+
+To run your own SearXNG instance:
+
+```bash
+# Using Docker
+docker run -d -p 8888:8080 \
+  -v $(pwd)/searxng:/etc/searxng \
+  searxng/searxng:latest
+
+# Then set
+SEARXNG_URL=http://localhost:8888
+```
+
+Or install via pip:
+```bash
+pip install searxng
+# Edit /etc/searxng/settings.yml
+searxng-run
+```
+
+Public SearXNG instances are available at:
+- `https://searxng.example.com` (replace with any public instance)
+
+## Workflow: Search then Extract
+
+SearXNG returns titles, URLs, and snippets — not full page content. To get full page content, search first and then extract the most relevant URL with `web_extract`, browser tools, or `curl`.
+
+```bash
+# Search for relevant pages
+curl -s "${SEARXNG_URL}/search?q=fastapi+deployment&format=json&limit=3"
+# Output: list of results with titles and URLs
+
+# Then extract the best URL with web_extract
+```
+
+## Limitations
+
+- **Instance availability**: If the SearXNG instance is down or unreachable, search fails. Always check `SEARXNG_URL` is set and the instance is reachable.
+- **No content extraction**: SearXNG returns snippets, not full page content. Use `web_extract`, browser tools, or `curl` for full articles.
+- **Rate limiting**: Some public instances limit requests. Self-hosting avoids this.
+- **Engine coverage**: Available engines depend on the SearXNG instance configuration. Some engines may be disabled.
+- **Results freshness**: Meta-search aggregates external engines — result freshness depends on those engines.
+
+## Troubleshooting
+
+| Problem | Likely Cause | What To Do |
+|---------|--------------|------------|
+| `SEARXNG_URL` not set | No instance configured | Use a public SearXNG instance or set up your own |
+| Connection refused | Instance not running or wrong URL | Check the URL is correct and the instance is running |
+| Empty results | Instance blocks the query | Try a different instance or self-host |
+| Slow responses | Public instance under load | Self-host or use a less-loaded public instance |
+| `json` format not supported | Old SearXNG version | Try `format=rss` or upgrade SearXNG |
+
+## Pitfalls
+
+- **Always set `SEARXNG_URL`**: Without it, the skill cannot function.
+- **URL-encode queries**: Spaces and special characters must be URL-encoded in curl, or use `urllib.parse.quote()` in Python.
+- **Use `format=json`**: The default format may not be machine-readable. Always request JSON explicitly.
+- **Set a timeout**: Always use `--max-time` or `timeout=` to avoid hanging on unreachable instances.
+- **Self-hosting is best**: Public instances may go down, rate-limit, or block. A self-hosted instance is reliable.
+
+## Instance Discovery
+
+If `SEARXNG_URL` is not set and the user asks about SearXNG, help them either:
+1. Find a public SearXNG instance (search for "public searxng instance")
+2. Set up their own with Docker or pip
+
+Public instances are listed at: https://searxng.org/