_{Model compute support: thanks to SiliconFlow for free model credits and inference support · Partnership details}

🆕 Big update: OpenBiliClaw now runs inside DeepSeek Harness

New DSH client plugin — install OpenBiliClaw into DeepSeek Harness: a persistent fourth column (Recommendations / Library / Chat / Profile / Settings) in the DSH web GUI, plus 22 Agent Bridge tools so agents can read recommendations, answer probes, and close the learning loop — browse cross-platform personalized content while you work in DSH. → github.com/whiteguo233/dsh-openbiliclaw

📱 Want a native app? The Flutter mobile client (Android / iOS / Web / desktop) lives in the separate repo OpenBiliClaw-mobile: recommendations, chat, profile, favorites / watch-later / 30-day history — all talking to the same local backend.

🇨🇳 Mainland China sources: Gitee v0.3.233 source is synced to the latest mainline. Get installers from the GitHub Release. 123 Cloud still holds v0.3.213 files; the latest domestic installer mirror is pending.

OpenBiliClaw in 10 Seconds

A local-first AI discovery agent that learns your taste across Bilibili, Xiaohongshu (RedNote), Douyin, YouTube, TikTok, X, Zhihu, Reddit, Linux.do, Bangumi, V2EX, Weibo, GitHub, Instagram, and the open web — without handing your profile to another platform.

Install the browser extension · Deploy the local backend with an AI coding agent

_{Star the project if you like the direction.}

Quick Start

Four steps for most users. Firefox, Docker, scripted, and manual setup paths all live in Setup Details.

1. Install the extension — one-click from the Chrome Web Store (auto-updates), or download the zip from Latest Release for the newest build (the store listing can lag a few days behind).

2. Install the backend — grab the desktop installer from the same Latest Release (macOS .dmg / Windows .exe, works out of the box, lives in the menu bar / tray). Each platform ships two variants: the lean installer (default; downloads the bge-m3 embedding model on first launch) and the -with-embedding installer (bge-m3 baked in, ~1.1GB, offline-ready) — pick with-embedding for a poor / offline network, lean otherwise. Gitee source is synced through v0.3.233. Get the latest installers from the GitHub Release; 123 Cloud still holds v0.3.213 files. Or, to customize or edit the source, paste this into Claude Code / Codex CLI / Cursor or another AI coding agent:

   Please follow https://raw.githubusercontent.com/whiteguo233/OpenBiliClaw/main/docs/agent-install.md to deploy the OpenBiliClaw backend for me (use Bash `curl` to fetch the document, NOT WebFetch — WebFetch summarises markdown and drops critical commands).
   

3. Connect a source — log in to Bilibili (the default init source), or choose Xiaohongshu / Douyin / YouTube / X / Zhihu / Reddit / Linux.do / V2EX / Weibo / GitHub. Sources that need an account reuse the installed extension; GitHub uses the official REST API anonymously for public repositories. A public username can seed initialization from starred repositories, while a PAT is optional and only improves rate limits and identity verification. TikTok and Instagram are opt-in sources in Settings → Sources. Log in using the browser with the extension installed; site access for both is included in the extension’s default permissions. TikTok can discover public videos without login; signed-in keyword search uses extension-synced credentials. Instagram can import your likes, saves, and follows through read-only browser tasks. Both need overseas connectivity: the backend follows your configured network/proxy route, while browser tasks use the browser's own proxy. See TikTok setup and Instagram setup and permissions for requirements and current limits.

4. Open the UI — visit http://127.0.0.1:8420/web, or scan the extension QR code to open http://<your-LAN-IP>:8420/m/ on your phone and save it to your home screen. For a native app experience, install the Flutter client from its separate repo (Android / iOS / Web / desktop; installers on its Latest Release) and point it at the same backend in its settings.

Away from your LAN, the native Android / iOS apps from OpenBiliClaw-mobile embed tsnet, and the computer can let OpenBiliClaw itself join the same tailnet. Its Web, Linux, macOS, and Windows Flutter builds are outside this feature's support scope. Desktop installers bundle the helper. On the computer, open either Desktop Web or the browser extension's Settings → General → Embedded Tailnet access. Enable it, then either leave the credential blank for browser login, enter a tskey-auth-… Auth Key, or enter a tskey-client-… OAuth Client Secret plus one of that client's authorized device tags; fully restart the app afterward. The credential is staged privately for the next start and is never written to config.toml, echoed by the API, or logged. Source / scripted installs first run openbiliclaw tailnet build-helper with Go 1.26.6, then openbiliclaw tailnet enable and restart. The computer needs no system-wide Tailscale; this default-off edge is tailnet-private and enables no Funnel/Serve. Enable the app password in the local Web settings as defense in depth (source installs may also use openbiliclaw set-password). See Embedded Tailnet.

Optional keyword grounding: add parallel to [discovery].inspiration_search_backends. Existing defaults stay unchanged; see Discovery. keenable can be added the same way; see Discovery.

query inspiration → configured provider chain
                  ├ optional Parallel Search MCP ← title / URL / excerpts  ← https://search.parallel.ai/mcp
                  ├ optional Keenable Search API ← title / URL / snippets  ← https://api.keenable.ai/v1/search/public
                  → keyword grounding (no direct recommendation-pool writes)

Why OpenBiliClaw?

The name comes from Bilibili (Bili = Bilibili, Claw = "the claw that grabs content for you") — the project started as a Bilibili-only tool. Since v0.3.0 it has evolved into a general cross-platform Agent covering Bilibili / Xiaohongshu / Douyin / YouTube / TikTok / X / Zhihu / Reddit / Linux.do / Bangumi / V2EX / Weibo / GitHub / Instagram and the open web, with more platforms on the roadmap.

Recommendation systems are essentially a middleman — the platform sits between millions of videos and millions of users, matching and distributing content at scale. Modern systems are far more sophisticated than "just optimizing CTR": they jointly weigh click-through rate, completion rate, like/coin probability, dwell time, user retention, creator ecosystem health, ad revenue, and a dozen other objectives, compressing them into a single weighted ranking score. Sounds scientific, but here's the catch: the weights are set by the platform, and the optimization targets ultimately serve the platform — user satisfaction is valued as a means to retention and monetization, not as an end in itself. You think you're choosing content, but really the middleman decides what you get to see. The result: recommendations look more and more like what you've already watched, and the occasional surprise is pure luck.

OpenBiliClaw is fundamentally different. It's a locally-running AI Agent that doesn't care what everyone else watches. Instead, it understands who you are:

🧠 Understands why you like things, not just what you've watched

It infers your MBTI, cognitive style, and deep psychological needs from your behaviour, building a five-layer soul profile (Event → Preference → Awareness → Insight → Soul). It's not matching video tags — it's understanding you as a person.

🔮 Actively breaks your filter bubble

This is the core differentiator: the system guesses domains you might enjoy but have never explored. Someone into mechanical watches might love architectural aesthetics; a quantum physics viewer might resonate with philosophy — it uses psychological bridging logic to proactively explore, promotes correct guesses to real interests, and quietly retires wrong ones.

🔒 100% local, 100% yours

Core behavior, recommendation, and dialogue data lives in SQLite on your disk; config, profiles, credentials, and caches also stay in local files. LLM calls use your own API key by default, with an experimental option to reuse local Codex CLI ChatGPT OAuth credentials. There is no OpenBiliClaw-operated cloud account, and no one else can see your profile. How this Agent grows is entirely your call — send feedback, chat with it, swap LLMs, migrate it, or edit the database.

💡 How it compares

	Bilibili Official	Keyword Filter Plugins	OpenBiliClaw
Recommendation logic	Collaborative filtering	Tag matching	Psychological profiling + 5-layer memory
Content sources	Single platform	Single platform	Cross-platform: Bilibili · Xiaohongshu · Douyin · YouTube · TikTok · X · Zhihu · Reddit · Linux.do · Bangumi · V2EX · Weibo · GitHub · Instagram · more
Filter bubble	Gets narrower	Doesn't address it	Speculative interests actively break it
Data ownership	Platform-owned	Usually cloud	100% local
Explains why	"Guess you'll like"	None	Friend-like explanations
Customizable	No	Low	Swap LLMs / edit profile / write Skills

📸 Feature Preview

Five core surfaces: the browser extension handles in-page interaction and login sessions, the Desktop Web (/web) gives you a big-screen recommendation home, the Mobile Web (/m) is built for phones, a native Flutter client (OpenBiliClaw-mobile, separate repo) covers Android / iOS / Web / desktop, and a DSH client plugin brings the same panels into the DSH web GUI as a fourth column (plus 22 Agent Bridge tools). Every non-extension surface only calls your local API — cookie sync and platform tasks still run through the extension.

Smart Recommendations Friend-like explanations of why you'd enjoy it

Soul Profile Deep personality analysis in natural language

Structured Traits MBTI · core traits · deep needs

Chat Tuning Tell it what you want to see

🖥️ Desktop Web Preview

After starting the backend, open http://127.0.0.1:8420/web (or just http://127.0.0.1:8420/, which redirects automatically) for a full-screen recommendation dashboard.

Desktop Home Delight hero · recommendation grid · friend-like reasons	Recommendation Card Grid Cover + reason · like / skip / watch later / favorite / chat
Profile + Live Dashboard Sidebar runtime board + activity · personality sketch · core traits · MBTI

📱 Mobile Web Preview

Recommendations Delight + pool status · friend-like reason View / like / later / save / not interested / chat

Profile Personality sketch · core traits · deep needs · MBTI

Chat Shared main chat history with the extension

📱 Want a native app? The separate repo OpenBiliClaw-mobile (Flutter) ships Android / iOS / Web / Linux / macOS / Windows clients with recommendations, chat, profile, favorites / watch-later / 30-day history, and an inbox — Bilibili covers load straight from the CDN to skip two hops. Grab the signed Android APK or the self-signing iOS IPA from its Latest Release (iOS needs re-signing with your own Apple account). Preview build; not yet long-term tested.

More screenshots

Recommendation Feedback Like / more like this / less / not interested

Values & Interests Inner drivers · speculative interest directions

Cognitive Style Information processing · content taste

Recent Updates

📌 Latest: v0.3.233 (2026-10-30)

• More trustworthy portraits: Bilibili history, favorites and follows carry real interaction times; imported backlog is no longer read as your behaviour, and library volume can no longer infer personality.
• Cleaner interests: a new "using tools ≠ taste" gate keeps ops-style topics from becoming interests (14 compound topics filtered in a real rebuild, while "software testing" stayed).
• ChatGPT subscriptions work again: fixes the Codex json_mode initialization failure that failed structured profiling calls wholesale.
• Repair existing portraits: the new openbiliclaw profile-repair-provenance command (dry-run by default) removes MBTI-as-evidence items and falsified timeline claims.

Full changelog: docs/changelog.md.

Community

QQ Community

Discord Community Scan or click to join — this invite does not expire.

Setup Details

For most users, setup is four steps: install the extension, ask an AI coding agent to deploy the backend, log in to the content platforms in the same browser, and optionally open the Mobile Web app from your phone.

1. Install the browser extension

The extension is the main interface. It shows the sidebar on supported sites, records feedback, and runs bounded read-only tasks for sources including Zhihu, Reddit, Linux.do, V2EX, and Weibo. Linux.do, V2EX, and Weibo task tabs are isolated from passive behavior collection; Weibo public discovery still runs independently in the backend.

Built on Manifest V3, the extension works in any Chrome-compatible browser — Chrome, Edge, Brave, Arc, Vivaldi, Opera, and more; a Safari (macOS) build is also provided. Releases automatically attach openbiliclaw-extension-v*-safari.dmg (Developer ID-signed and notarized when Apple credentials are configured, otherwise an ad-hoc experimental build that requires Safari's "Allow Unsigned Extensions"), and you can also convert the local build to an Xcode project via Apple's safari-web-extension-converter (see the Safari build guide).

Recommended · download the latest build from the Latest Release aggregate page (gets the newest features and fixes — the Chrome Web Store listing usually lags by a few days to a couple of weeks due to review scheduling):

1. Open OpenBiliClaw Latest Release, the newest user-facing aggregate openbiliclaw-v* release
2. Chrome / Edge / Brave users download openbiliclaw-extension-v*.zip; Firefox users install openbiliclaw-extension-v*-firefox.xpi when it is present, otherwise download openbiliclaw-extension-v*-firefox.zip and load it temporarily through about:debugging; Safari (macOS) users download openbiliclaw-extension-v*-safari.dmg, launch the app once, then enable OpenBiliClaw in Safari Settings → Extensions
3. Open the extensions page (Chrome: chrome://extensions/ · Edge: edge://extensions/ · Brave: brave://extensions/), enable "Developer mode" in the top right
4. Chrome / Edge / Brave users drag the downloaded .zip file into the page to install; Firefox .xpi files install directly, while the temporary zip must be unzipped before loading manifest.json

Convenient · one-click from the Chrome Web Store (the browser keeps it auto-updated — best if you don't want to update manually; downside: the version can lag behind Releases):

👉 Install OpenBiliClaw on the Chrome Web Store — click "Add to Chrome".

Extension updates depend on the install channel: Chrome Web Store / Edge Add-ons and the Firefox AMO listed build after approval are updated by the browser; GitHub Release Chrome zips / Firefox signed XPIs / Firefox temporary zips / Safari DMGs, developer-mode loads, and Firefox temporary installs must download the new package and reload it manually. Firefox AMO listed review is asynchronous; until the listed version is publicly approved, use the *-firefox.zip temporary package from Releases. After approval, Firefox will update the listed install natively. The backend "auto update" switch only updates the local backend source checkout, not the browser extension.

unzip openbiliclaw-extension-v*-firefox.zip -d openbiliclaw-firefox

# Or build from source
git clone https://github.com/whiteguo233/OpenBiliClaw.git
cd OpenBiliClaw/extension
npm install
npm run build:firefox          # writes dist-firefox/
npm run package:firefox        # also produces unsigned openbiliclaw-extension-v*-firefox.zip
# With AMO credentials configured, sign it into the installable XPI:
# AMO_JWT_ISSUER=... AMO_JWT_SECRET=... npm run sign:firefox:only

2. Deploy the backend (two options)

Most users: the desktop installer is the least effort. Want to edit the source, swap LLMs, or customize deeply? Use the AI one-line deploy.

Option A: Download the desktop installer (experimental, easiest)

Grab the installer for your OS from the openbiliclaw-v* aggregate Latest Release. The aggregate page shows:

🇨🇳 Mainland China sources: Gitee v0.3.233 source is synced to the latest mainline. Get installers from the GitHub Release. 123 Cloud still holds v0.3.213 files; the latest domestic installer mirror is pending.

• Current backend source tag: backend-v*

• Current extension release: extension-v*, with openbiliclaw-extension-v*.zip / openbiliclaw-extension-v*-firefox.zip (Firefox temporary debugging); AMO signing-enabled releases also include openbiliclaw-extension-v*-firefox.xpi (regular Firefox install)

• Current desktop installer release: desktop-v*, with available .dmg / .exe assets when the same-version desktop channel has shipped; missing channels are shown as unpublished instead of being backfilled from a previous release

• macOS: download the DMG that matches your Mac: OpenBiliClaw-macos-v*-arm64.dmg for Apple silicon, or OpenBiliClaw-macos-v*-x64.dmg for Intel when the release provides it. Quit the old version, open the DMG, drag the app into Applications, then launch it. New packages use Developer ID signing and Apple notarization; no quarantine-removal command is needed.

• Windows: download OpenBiliClaw-windows-*-Setup.exe — double-click to install. The final wizard page offers a checked "Launch OpenBiliClaw" checkbox; the newly installed version starts only when you click Finish (upgrades stop mutex-less old instances first; when the running app is an AppMutex build, Setup/Uninstall first show the standard "OpenBiliClaw is currently running" prompt and re-check after you close it — clicking Finish hands off to the new version, and unchecking skips the launch). /SILENT / /VERYSILENT installs have no wizard pages and still launch the new version automatically once Setup succeeds; with the app still running, a silent install/uninstall paired with /SUPPRESSMSGBOXES is cancelled instead, so close the app first.

The macOS app still targets 10.15+. Only the optional Tailnet helper built with Go 1.26.6 has a measured minimum of macOS 12; on 10.15 / 11 the local app continues normally while this remote edge is unavailable.

It bundles local Ollama + bge-m3 embedding (works out of the box), the default source dependencies including X's twitter-cli and Reddit's rdt-cli, and the default-off embedded Tailnet helper. The latter lets the desktop app join your tailnet without installing system Tailscale. Enable it from Desktop Web or the browser extension's Settings → General, choose browser login, an Auth Key, or an OAuth Client Secret plus an authorized device tag, then fully restart the app. Reddit's rdt command backend prefers the connected extension's synced reddit_session; rdt login remains a manual fallback, and unauthenticated runs fall back to extension tasks. It lives in the macOS menu bar / Windows system tray; right-click for "Open Web UI / View runtime logs / Quit". Data uses the same directory as the AI / script installers: ~/OpenBiliClaw (macOS / Linux) / %USERPROFILE%\OpenBiliClaw (Windows), and survives upgrades and uninstalls. Data from older packaged builds under ~/Library/Application Support/OpenBiliClaw / %LOCALAPPDATA%\OpenBiliClaw is copied back on first launch without overwriting existing files. If a broken config.toml / config.local.toml prevents startup, the desktop package backs the bad file up as *.invalid, regenerates the default config, then opens /setup/ so initialization can run again; data/ is left untouched.

macOS signing and notarization: GitHub Actions requires Developer ID signing and Apple notarization; failed validation produces no experimental fallback. A normal internet-download confirmation may appear on first launch. Quit the old version before upgrading. See signing details.

Windows: choose “More info → Run anyway” if SmartScreen appears. The desktop app remains a pre-release; use Option B below to customize its source.

Option B: AI one-line deploy (customizable / editable source)

Paste this whole prompt into Claude Code, Codex CLI, Cursor, Windsurf, or another AI coding agent. The parenthetical note is for the agent; you do not need to understand it.

Please follow https://raw.githubusercontent.com/whiteguo233/OpenBiliClaw/main/docs/agent-install.md to deploy the OpenBiliClaw backend for me (use Bash `curl` to fetch the document, NOT WebFetch — WebFetch summarises markdown and drops critical commands).

The agent will clone the repo, install dependencies, start the backend with the LAN-accessible default bind (0.0.0.0:8420), run a health check, and ask a few questions with defaults. Before auto-init, it verifies that the ordered global LLM instance chain and the independent embedding service answer real lightweight calls; if either fails, init is blocked until you fix the service. If unsure, pick the default. Xiaohongshu, Douyin, YouTube, X, Zhihu, Reddit, Linux.do, Bangumi, V2EX, Weibo, and GitHub signals are used in the initial profile only when you explicitly opt in. Bangumi and GitHub public discovery need no login; public collections or starred repositories seed the profile only after a public identity is resolved. Weibo public discovery is also anonymous, while personal initialization requires a signed-in Weibo browser and extension.

Source installs do not compile the Tailnet helper by default. Only when the user explicitly wants native Android / iOS app access away from the LAN, install Go 1.26.6 and run openbiliclaw tailnet build-helper, then openbiliclaw tailnet enable, and fully restart. The first Docker image does not bundle this helper.

Chrome Web Store / AMO builds only declare local-backend permissions by default. When you select a protocol and enter another LAN or remote endpoint, the browser requests scheme://host/*; WebExtension host permissions cannot be port-scoped across browsers, while actual requests remain pinned to the configured port. Public hosts require HTTPS. Enable the default-off device flow first with ext-key generate and ext-key enable.

With a public DNS name, the shortest path is the docker-compose.https.yml overlay: Caddy obtains and renews the certificate automatically, and desktop, mobile, and the extension share https://<domain>. Commands and required access controls are in the HTTPS deployment guide.

3. Log in to content platforms in the same browser

By default, log in to Bilibili and keep Bilibili selected to build the first profile and recommendations. Otherwise select another signed-in source such as Xiaohongshu, Douyin, YouTube, X, Zhihu, Reddit, Linux.do, or V2EX, or choose Bangumi / GitHub with a public username. Keep at least one source that can return profile signals. Bangumi / GitHub without identity still support public discovery but cannot initialize a profile alone; a GitHub PAT is optional.

4. Open Desktop or Mobile Web

The backend serves both a desktop and a mobile Web UI. Neither syncs cookies or crawls pages — they only call your local API.

openbiliclaw start

• Desktop: open http://127.0.0.1:8420/web (or http://127.0.0.1:8420/, auto-redirects). Two-column editorial layout with recommendations, 30-day history, profile, chat, messages, and settings all on one page.
• Mobile: click the phone icon in the extension header to scan the QR code, or type http://<your-LAN-IP>:8420/m/ manually. Best for browsing recommendations, revisiting 30-day history, profile, and chat on your phone.
• Native Flutter client: download the Android APK (arm64-v8a for modern devices, armeabi-v7a for older ones) or the unsigned iOS IPA (re-sign with your own Apple account) from the Latest Release. Use the computer's LAN IP nearby; away from the LAN, the native Android / iOS app's embedded tsnet can pair with the computer's default-off embedded Tailnet path. Join both nodes to the same tailnet, use its MagicDNS name / Tailnet IP, and enable the app password. This does not cover the repo's Web, Linux, macOS, or Windows Flutter builds.

During openbiliclaw init, you'll be asked whether to allow LAN access (default Y). If you chose N or want to change it later, edit [api].host in config.toml (0.0.0.0 = LAN-reachable over available IPv4 and IPv6, 127.0.0.1 = local only). QR links prefer IPv4 and automatically use a bracketed IPv6 literal when IPv4 is unavailable.

Security note: binding 0.0.0.0 makes the backend reachable by every device on the network. The [api.auth] password gate is off by default, which leaves history, profile, and write endpoints (likes/comments/follows) open to the LAN with zero authentication. The Bilibili credential routes and the settings write/probe routes (PUT /api/config, probe-service, discover-models) are the exception — they always require a local or authenticated caller. On any untrusted network (public Wi-Fi, shared hotspot, port forwarded to the internet), run openbiliclaw set-password to enable the gate immediately.

After opening /m/, save it as a home-screen shortcut: on iPhone / iPad, use Safari's Share menu and choose "Add to Home Screen"; on Android Chrome / Chromium browsers, use the menu item "Install app" or "Add to Home screen". LAN HTTP may only create a shortcut in some Android browsers; full PWA install prompts are more reliable behind HTTPS in a trusted local setup.

The bottom bar now has four top-level tabs: Recommendations, Content Library, Profile, and Chat. Content Library contains Watch Later, Favorites, and History as child tabs. History pages through the last 30 days as opened, surfaced-but-unopened, and recently removed content; multiple removal contexts stay on one card, and Favorite and Watch Later can be restored independently. Old direct links to the three former tabs migrate to the matching Content Library child.

curl -fsSL https://raw.githubusercontent.com/whiteguo233/OpenBiliClaw/main/scripts/install.sh | bash

[Net.ServicePointManager]::SecurityProtocol = [Net.ServicePointManager]::SecurityProtocol -bor [Net.SecurityProtocolType]::Tls12; iwr https://raw.githubusercontent.com/whiteguo233/OpenBiliClaw/main/scripts/install.ps1 -UseBasicParsing | iex

mkdir -p ~/openbiliclaw && cd ~/openbiliclaw
curl -fsSLO https://raw.githubusercontent.com/whiteguo233/OpenBiliClaw/main/docker-compose.prebuilt.yml
docker compose -f docker-compose.prebuilt.yml up -d
# then open http://127.0.0.1:8420/setup/ to finish initialization

Please follow https://raw.githubusercontent.com/whiteguo233/OpenBiliClaw/main/docs/docker-deployment.md to deploy the OpenBiliClaw backend via Docker Compose (use Bash `curl` to fetch the document, NOT WebFetch).

# macOS
# Install and launch the official Ollama.app; it creates the ollama CLI link.
open https://ollama.com/download/mac

# Linux
curl -fsSL https://ollama.com/install.sh | sh && ollama serve &

uv run openbiliclaw setup-embedding

# Clone
git clone https://github.com/whiteguo233/OpenBiliClaw.git
cd OpenBiliClaw

# Using uv (recommended)
uv sync

# Or using pip
python -m venv .venv
source .venv/bin/activate
pip install -e ".[dev]"

# Copy config template
cp config.example.toml config.toml

# Edit config (set LLM API keys, etc.)
vim config.toml

# One-command init (fetch history · build profile · first discovery)
openbiliclaw init

# Optional: enable local Ollama as an independent embedding provider
openbiliclaw setup-embedding

# Manual content discovery
openbiliclaw discover

# Optional: Douyin discovery (requires [sources.douyin]; search / hot / feed are triggered from the home page via DOM)
openbiliclaw discover --source douyin

# Optional: read-only Linux.do bookmarks / likes / read-history smoke (does not write memory by default)
openbiliclaw fetch-linuxdo

# Optional: formal Linux.do search / hot / feed / creator / related discovery
openbiliclaw discover-linuxdo --limit 30
# Equivalent: openbiliclaw discover --source linuxdo --limit 30

# Optional: standalone Douyin search / hot / feed recall debugging
openbiliclaw discover-douyin --keyword mechanical-keyboard --source search,feed --no-cache --no-evaluate

# Optional: public Weibo discovery (enable [sources.weibo] first; public reads do not write profile)
openbiliclaw discover --source weibo
openbiliclaw discover-weibo mechanical-keyboard
openbiliclaw discover-weibo-hot
openbiliclaw discover-weibo-creator 1234567890

# Get recommendations
openbiliclaw recommend

# View user profile
openbiliclaw profile

cd extension
npm install
npm run package

🤖 Integrate with OpenClaw / Hermes / WorkBuddy Agents

This repo ships a workspace skill and a versioned, host-neutral Agent Bridge. Point any skill-aware or local-JSON-capable agent (OpenClaw / Hermes / WorkBuddy / Claude Code / Codex CLI / Cursor, etc.) at this checkout and it can drive your local OpenBiliClaw directly.

What you get after integration

• ✨ Proactive recommendations — the system continuously discovers content in the background; when it finds a high-scoring surprise, it pushes to OpenClaw via WebSocket — you don't have to ask
• 🔮 Proactive interest probing — confirm, reject, defer, or discuss speculative interests
• 🧭 Proactive avoidance probing — the same four-state contract for content boundaries; nothing is filtered until you confirm it
• 💬 Durable Socratic dialogue — every supported storage backend can return a stable turn_id and history for retries and host changes
• 📖 Read the current soul profile — MBTI, core traits, deep needs, interest domains
• 🎯 Fetch multi-source recommendations — platform scope, reshuffle, append, inventory availability, explanations and content metadata
• 💬 Write durable feedback back into the learning loop — recommendation and delight-card actions are idempotent
• 💾 Local-first saved lists — favorite/watch-later membership is local; native sync requires explicit authorization
• 🔄 Sync Bilibili account signals — pull history / favorites / following and feed them into the memory system

One-sentence integration prompt

Paste the following into OpenClaw (or Claude Code / Codex CLI / Cursor) — it will read the guide and wire everything up:

Please follow https://raw.githubusercontent.com/whiteguo233/OpenBiliClaw/main/docs/openclaw-quickstart.md to integrate this repository into the Agent Bridge (target host: OpenClaw; use Bash `curl` to fetch the document, NOT WebFetch — WebFetch summarises markdown and drops critical commands).

Usage examples

After integration, it's not just "you ask, it answers" — the system comes to you. Here are the two core scenarios:

Scenario 1: System proactively pushes a surprise recommendation

OpenClaw is running listen in the background. After a refresh cycle, the system finds a high-scoring piece of content:

OpenClaw (receives WebSocket delight.candidate, comes to you proactively):

Just found something you might unexpectedly enjoy: "Why You Can't Actually Lie Flat Even Back in a Small Town" — the Minsky moment of county economies. You've been deep in geopolitics and macro debt; this one dissects how land finance and the debt cycle mesh together. [BV1KMwuzdEcB]

Want to check it out?

You: "That one nailed it."

OpenClaw (internally runs submit-feedback --recommendation-id 4268 --feedback-type like --request-id feedback-4268-like-1, reusing that ID on retries)

You never asked for a recommendation — the system surfaced it on its own.

Scenario 2: System proactively asks about your interests

OpenClaw receives an interest.probe event (or pulls next-probe) and finds a speculative-interest hypothesis waiting for confirmation:

OpenClaw (comes to you proactively):

I've been picking up signals that you might be into architectural aesthetics (e.g., parametric design, concrete minimalism) — you've been watching a lot of content about structure and space lately. Does this direction resonate with you?

You: "Yeah, I've been looking at a lot of parametric design stuff. Tadao Ando's exposed concrete aesthetic really gets me."

OpenClaw (internally runs chat --message "Yeah, I've been looking at…", returns a Socratic follow-up):

Here's my hypothesis — you're not just interested in buildings, you're drawn to how minimal elements create maximum tension. Ando's approach to concrete is the same aesthetic drive as your obsession with "making the gears mesh" when you analyze LLM architectures. Am I close?

The dialogue automatically feeds back into the soul profile — the next discovery cycle will incorporate architectural aesthetics as a real interest and start searching in that direction.

Scenario 3: You can also just ask for recommendations

Of course, the traditional "you ask → it answers" flow works too:

You: "Recommend three Bilibili videos worth watching today."

OpenClaw (internally runs recommend --limit 3, formats and replies)

The whole loop stays local — the agent host just calls the CLI bridge; your profile and data never leave the SQLite file on your disk.

📖 Full command reference and troubleshooting: Agent Bridge Integration Guide and capability contract. Hosts should run capabilities at startup instead of caching an old subset.

✨ Key Features

• 🧠 Five-Layer Soul Profile — Event → Preference → Awareness → Insight → Soul, inferring MBTI, cognitive style, and deep needs (details)
• 🔮 Interest Probes — psychological bridging guesses domains you might love but have never explored; right guesses become real interests, wrong ones quietly retire
• 🧭 Avoidance Probes — proactively confirms content forms and style boundaries you want to avoid; nothing is filtered until you confirm
• 🌐 Cross-Platform Sources — Bilibili / Xiaohongshu / Douyin / YouTube / TikTok / X / Zhihu / Reddit / Linux.do / Bangumi / V2EX / Weibo / GitHub / Instagram / generic Web, so your interests stop being siloed (details)
• 🎯 Smart Diversity — topic quotas + cross-platform interleaving + small-source protection; goodbye to "all AI all day"
• ⚡ Instant, deduplicated reshuffle — ~0.6s; current cards, recommendation history, and the durable seen ledger are excluded by default
• 💬 Warm Recommendations — friend-like explanations of why you'd enjoy something, not "because you watched similar videos"
• 🔄 Continuous Learning — Socratic dialogue + behavioral analysis + instant feedback; it understands you better over time
• ⭐ Local-First Favorites / Watch Later — cards save to local SQLite first and auto-sync stays off by default; desktop Web hydrates the sidebar count badges on first load; the 2026-07-14 real-account regression completed both actions across all seven platforms as synced/already_synced
• 🕘 30-Day Content History — extension, desktop, and mobile share opened, surfaced-but-unopened, and recently removed views; covers are paged and lazy-loaded, and removed local saves can be restored
• 🧩 Browser Extension — Chrome / Edge / Brave / Arc / Firefox / Safari; side-panel recommendations + cross-site behavior collection, install and go
• 📱 Flutter Native Client — separate repo OpenBiliClaw-mobile; Android / iOS / Web / Linux / macOS / Windows against the same local backend, with Bilibili covers hitting the CDN directly to skip two hops
• 🛜 App-Embedded Tailnet Access — the native Android / iOS OpenBiliClaw-mobile app and computer each embed tsnet, so those mobile clients can reach your backend through your own tailnet without a system Tailscale install or a public Funnel; Web and desktop Flutter builds are not supported by this path
• 🚀 Guided Init in the UI — the packaged /setup/ wizard, Desktop Web, and the extension can all initialize with one click; no terminal required
• 📦 Cross-Machine Migration — export/import portable config, SQLite, profiles, cookies, and the image cache from Desktop settings; imports are validated and staged, can be inspected or cancelled, then apply on restart with rollback copies. .obcbackup contains plaintext secrets but excludes the source machine's API-login password, session-signing secret, and extension device keys
• 🔬 Self-Optimizing Eval Loops — five modules each carry an LLM-as-judge loop that improves prompt quality over rounds
• 🔒 Fully Private — SQLite, config, profiles, and caches stay local; LLM calls use your own key, and each instance is built for exactly one person
• 🔌 Local Embedding — optional Ollama + bge-m3, automatic acceleration with CPU fallback, no extra API key
• 🔧 Fully Controllable — create multiple independent channels of the same LLM type and drag global or per-module failover chains; edit your profile or add custom Skills

🏛️ Architecture Overview

Extension presence: runtime-stream → API atomic heartbeat → data/runtime/extension_presence.json → full/discovery worker → browser task queues. Idle connections renew every 20 seconds; active leases expire after 60 seconds, while normal disconnects retain their configured grace. See the Runtime module.

Douyin discovery backoff: claimed task failure → durable dy_tasks cooldown → producer before keyword claim / client / pending-claim gates. Native search streams reach the page immediately while a bounded clone is parsed frame by frame. Valid partial items retain the failure; paths sharing the discovery client and task queue respect the cooldown across restarts and direct fallback.

Douyin hot-word rotation: enqueued choices from dy_tasks over the last 6h → each newly created plugin client → prefer unselected board words, preserving rotation when the runtime recreates its transport each round.

Desktop scripts: packaged desktop/shared scripts → DesktopAssets (fixed dependency order, two content versions, precompressed gzip) → one defer request from /web. Shared sources and original asset paths remain available to mobile and extension surfaces. No Node build, installation, or configuration changes are required. See the Desktop Web module.

Cover display: UI → pooled API connection → image service (disk originals → bounded rendition cache) → UI. An unavailable image service falls back to in-process handling.

TikTok covers: image proxy → DoH public-address validation → pinned IP / original TLS identity → cache, following the configured network route.

TikTok: formal discovery / inspiration → shared request pacing and durable cooldown → signed Web API → candidate pool; only auto mode allows yt-dlp fallback. See the acceptance record.

TikTok login sync: extension cookie → validate and persist → safe runtime rebuild on effective credential change → keyword search; unchanged credentials do not restart tasks.

TikTok account flow: manual init / explicitly enabled incremental sync → source enabled policy (startup / reload) → bootstrap_profile (likes / favorites / following; history optional; frozen budgets) → extension durable acceptance / viewer-owned lists → account binding / staged result → idempotent events → profile. Native saves use a separate local membership → durable native-save job → exact-video favorite / reload read-only confirmation path. Installed Chrome login and explicit empty-list handling have passed. Nonempty real-account profiling/incremental sync remain unverified; native favorites are deferred. See the acceptance ledger and #295.

Local embedding: requests / diagnostics → Ollama automatic acceleration → valid vector; runner failure → CPU retry → validated result. CPU selection is shared for the backend process lifetime; restarting retries automatic acceleration.

Recommendation requests: main API → default dedicated recommendation process → current SQLite candidates → full ranking → atomic commit → cards + total/platform inventory. The main API relays inventory events and observes background refills while clients are connected.

Chat: session style → durable turn freezes style → API-owned agent task → conversation context and saved notes + skill tools (web search / URL reading) + expression style → persisted events / SSE → completed reply. The original task continues after an HTTP disconnect; retries of a completed turn replay its saved events.

Configuration: save / approve → shared apply queue → replace only the loop for known chat settings; drain and rebuild for other changes. Local chat updates preserve active conversations and learning tasks.

Background configuration: successful full apply → queue settles → parent confirms old children exited → workers / recommendation / images read new settings. The active data directory and durable candidates survive; model repairs can resume pool filling.

Full candidate evaluation: named profile + negative evidence + candidate text → LLM (default) OR pure Jev → metadata validation / isolated cache → admission. Jev connection: shared Web / popup / mobile form → config API validation → local URL/token/pinned-model/limits → runtime rebuild; read responses never return the token. Jev text path: full descriptions (no early 400-character trim) → budgeted whole-source excerpts → full-source cache identity; originals stay unchanged. Jev evaluation and Director share local full profile → candidate/intent-specific facts → selected-model budget check. No automatic model switching, source-profile rewriting or removal of explicit exclusions; unknown model capacities require registration in settings or TOML. Local whole-source excerpts carry coverage and provenance. Each candidate's complete question group stays in one batch; overflow reduces batch size first, and oversized mandatory inputs remain pending. Shared rules and identical mandatory profile facts are sent once, without additional evaluation rounds. The three Web settings surfaces can select experimental, text-only Jev evaluation with controlled topic/IP vocabularies, explicit unknowns and dual input guards. Failures never silently invoke an LLM. Settings can save a local token, with existing environment credentials still supported; live Chinese-content quality remains unverified. See evaluation details.

Optional Director, disabled by default: recommendation profile + latest 3 experienced screens + shortlist → shared screen objective / evidence / soft roles → recurrent Jev pairs / Agent + Jev repair / Agent-only preplanning (at most one Agent validation correction) → fresh eligibility check → atomic screen commit → actual-visibility ACK → future drafts. Agent planning identifies useful supply first, then uses request-local short refs restored before strict validation. Horizon coverage, legal short tails and early-stop reasons remain validated; one correction shares the original planning deadline, and repair does not mechanically fill semantic shortfalls. All three modes use the same policy to organize focused, complementary, independently useful choices, without a fixed exploration ratio. Jev is an independent decision provider, also available for discovery filtering, not a chat-LLM fallback. Web surfaces and CLI preserve screen identity and exact feedback; configure through TOML. Live model quality remains unverified. See the decision module and Director runtime.

The full architecture overview ASCII diagrams (runtime concurrency gates, agent orchestration, source adapters, discovery / recommendation / saved-sync pipelines) have been moved to a separate document to keep the README compact:

Publication date preference: [sources.<name>].recommendation_date_* per source → out-of-window candidates are filtered before LLM evaluation → effective inventory → PoolCurator soft/strict serving semantics.

Remote Android / iOS app: App (embedded tsnet) → user's tailnet → desktop Go tsnet helper → 127.0.0.1:<effective server port> → FastAPI; enrollment follows local settings UI → PUT /api/config (write-only credential) → private one-shot staging → stdin → helper. The port normally comes from [api].port and follows startup / packaged OPENBILICLAW_PORT overrides. This path is default-off, needs no system Tailscale on the computer, exposes no Funnel/Serve, and migrates neither node identity nor staged credentials.

📖 Architecture Overview

Optional visual and danmaku prewarming

When [discovery].keyframe_enabled is on and multimodal embedding is available, keyframes build the same visual centroids used by P1; the P1 cover bonus is still controlled only by visual_profile_enabled. Keyframe cache provenance includes the sampling algorithm, keyframe_max_frames, embedding fingerprint, and dimension, so a model or sampling change rebuilds safely. Partial keyframe results carry stable sampled slots: successful slots may enter cache first, but completion is recorded only for confirmed no-data or a complete sample whose every embedding succeeds. Failed slots remain eligible for the next cycle.

keyframe_fetch_limit, danmaku_fetch_limit, and danmaku_max_chars are range-validated in both the config file and config API. Danmaku summaries use the full danmaku_max_chars value for document embedding rather than a silent fixed prefix. Cross-platform visual bonuses keep zero fixed; on multi-platform batches both signs align to the observed global side maximum under the combined cap, while single-platform batches retain absolute magnitude. Zero / missing values stay zero. See docs/modules/recommendation.md and docs/architecture.md for the full contract.

Remote extension access uses explicit, default-off device authentication: ext-key generate → digest-only backend config → /api/auth/extension-token short session. HTTP uses a Bearer header; only WebSocket and image proxy URLs carry the short session query.

Public-domain Docker deployments may add the default-off Caddy HTTPS overlay. It obtains and renews a trusted certificate, proxies REST and WebSockets through shared loopback, and restricts host port 8420 to loopback. Trusted LAN and self-managed deployments can instead use the built-in TLS Proxy for exact HTTPS Origin/Host checks and explicit local-CA SANs; with no remote SAN its generated certificate is localhost-only. The two edges are mutually exclusive, and the default HTTP path is unchanged.

Full architecture detail (runtime state machine, pool accounting, profile overrides, and more) lives in Architecture and the visual architecture diagrams.

Content Discovery Engine

Multi-source adapter architecture — every platform plugs in through the SourceAdapter protocol, each with its own discovery approach:

What happens after discovery:

• Safe fetching — the backend never logs in for you or crawls content you cannot see. Account-bound sources reuse existing browser sessions; public-API sources such as GitHub read public data only. First-run profile signals are pulled only after you click “Start initialization.” Periodic account re-pull is off by default, and GitHub is explicitly init-and-on-demand rather than an extension polling source. Linux.do tasks permit GET only, and _t is used solely as a login boolean.
• Continuous unified evaluation — raw candidates share one eval pool and are scored against your Soul profile, content text, and recent negative feedback. The default 3×30 workers refill immediately, scheduling counts only durable stock, and serial admission is capped by current headroom. Optional embedding prefiltering starts in shadow mode before enforce may skip clearly low-similarity items; the learned scorer likewise records privacy-safe comparisons against the full LLM before a read-only gate can justify manually enabling hybrid relevance, which does not reduce LLM calls yet.
• Diversity selection — platform quotas → topic dedup → style balancing → cross-platform interleaving → count caps; only Bilibili is enabled out of the box, other platforms are switched on in settings.

Per-platform task pipelines, pool accounting, and fallback strategies are documented in the Discovery Engine docs.

Soul Engine

Infers from user behavior:

• Personality Portrait — Natural language user profile
• MBTI — Four dimensions with confidence scores
• Cognitive Style — Information processing preferences
• Deep Needs — Psychological content drivers
• Speculative Interests — System-predicted potential interest domains (e.g., molecular gastronomy, architectural aesthetics, watchmaking...)

🏗️ Project Structure

OpenBiliClaw/
├── src/openbiliclaw/          # Python backend core
│   ├── agent/                 # Agent orchestration & Skill system
│   ├── soul/                  # Soul Engine (profiling · MBTI · interest/avoidance probes)
│   ├── memory/                # Multi-layer memory system
│   ├── discovery/             # Discovery engine (strategies · candidate pool · quota balancing · diversity)
│   ├── recommendation/        # Recommendation & expression engine
│   ├── sources/               # Source adapters, including GitHub's official REST API path
│   │   ├── github_client      # GitHub public REST client + optional PAT identity probe
│   │   ├── github             # Repository and public-star event normalization
│   ├── youtube/               # Google Takeout import parser
│   ├── api/                   # Local FastAPI (config rollback / degraded mode / popup API)
│   ├── tls_proxy.py           # Default-off LAN/self-managed HTTPS edge
│   ├── runtime/               # Refresh, feedback coalescing, presence gate, shared CLI/desktop autostart reconcile, Ollama, degraded RuntimeContext
│   ├── bilibili/              # Bilibili API layer (WBI signing · rate control)
│   ├── llm/                   # Multi-model LLM adapters + structured JSON tolerance
│   ├── i18n/                  # Locale contract, UI + semantic catalogs, output-language policy
│   └── storage/               # Data storage layer
├── extension/                 # Chrome/Firefox/Safari extension (including Linux.do/V2EX/Weibo read-only task bridges)
├── extension/                 # Chrome extension (Bilibili + XHS + Douyin + YouTube + X + Zhihu + Reddit + Weibo recovery/tasks)
├── skills/                    # Built-in Skill definitions
├── docs/                      # Documentation
└── tests/                     # Tests (1900+)

The native mobile client (Flutter, Android / iOS / Web / Linux / macOS / Windows) lives in the separate repo OpenBiliClaw-mobile.

🛠️ Tech Stack

📖 Documentation

• Documentation Hub — All-in-one entry point
• FAQ — quick answers for install / connection / update issues
• Project Spec — Complete design & planning
• Architecture — System architecture deep dive
• Memory Design — Multi-layer memory architecture
• Discovery Engine — multi-source discovery + platform mix + diversity selection
• Soul Engine — Deep profiling + MBTI + interest speculation
• CLI Reference · Config Reference
• Contributing Guide
• Flutter Mobile Client — native app in a separate repo (Android / iOS / Web / desktop)

📜 Release History

The current release is summarized in Recent Updates above; full history lives in docs/changelog.md. Most users should use the openbiliclaw-v* aggregate Latest Release for extension packages and available desktop installers; automation-channel releases remain available as backend-v*, extension-v*, and desktop-v*.

🗺️ Roadmap

OpenBiliClaw aims to be your personalized entry point to the entire web. Started on Bilibili, it now covers Xiaohongshu, Douyin, YouTube, TikTok, X, Zhihu, Reddit, Linux.do, Bangumi, V2EX, Weibo, GitHub, Instagram, and the generic Web; next:

• More content sources — additional BBS, forums, and vertical communities; each platform follows the shared source contract and acceptance gates
• Cross-platform interest fusion — your mechanical-keyboard interest from Bilibili + your coffee-gear interest from Xiaohongshu + your short-video taste from Douyin likes/favorites + your long-form watching and subscriptions from YouTube + the news you like/bookmark on X = one complete you. Profile fusion stops your interests from being fragmented across silos
• Smarter cross-source discovery — "you started following coffee gear on Xiaohongshu, here's a hand-drip documentary on Bilibili you might love"
• Community ecosystem — user-defined SourceAdapters, shared discovery strategies, contributed platform adapters

🤝 Contributing

Contributions welcome! See the Contributing Guide to get started.

🙏 Acknowledgements

• Thanks to @addtion99 for proposing configurable browser-extension backend host / port settings and sharing the popup-side implementation idea in #8.
• Thanks to @jiaobenhaimo for contributing Safari extension, watch-later bookmarks, YouTube repost detection, and marketing filter designs in #53. The OR-join dedup fix and watch-later feature have been merged into main.
• Thanks to @tangle111-design for exploring style_key viewing modes, recommendation tone, Bilibili initialization, and LLM / profile workflow improvements in #69. The relevant ideas have been reviewed, split up, and selectively merged into main.
• Thanks to @DongLanQwQ0 for polishing desktop web interactions — side-drawer collapse animation, a delight-card drag dead zone, and a stacked toast notification system — in #102. Merged into main.
• Thanks to @DongLanQwQ0 for the desktop web theme-engine rework to oklch in #110 — a single --hue-primary control point with a 12-hue tunable color picker, a five-step accent ramp, and unified interaction states. Merged into main.
• Thanks to @wuwafly3 for continued work on multimodal recommendations: #100 introduced the DashScope (Alibaba Model Studio) multimodal embedding provider and image-only cover vectors, while #135 added the user visual profile (P1), Bilibili danmaku semantics (P2), video keyframes (P3), and cross-platform visual weighting pipeline. Mainline follow-up hardened the contracts and retry behavior, added configuration surfaces, and completed real-environment validation.
• Thanks to @LHMQ878 for fixing the agent_bootstrap TOML instance-section matching in #182: quoted section headers such as [llm.instances."openai"] are now treated as the same table as bare keys, preventing duplicate table declarations and tomllib failures when bootstrap is run again. Merged into main.
• Thanks to @Patrick5D for the event source-attribution persistence in #179: top-level events.source_platform / content_id / source_confidence columns, the unified source-resolution priority, and the schema v6 incremental migration — the data foundation for platform-scoped data revocation and profile rebuild. Mainline added follow-up hardening for unknown platform slugs and confidence-evidence enforcement. Merged into main.
• Thanks to @OctoBored for restoring the live Star History chart in the Chinese and English READMEs in #196, replacing the dead badge and temporary notice; mainline also escaped the URL ampersands during merge. Merged into main.

⭐ Star History

If OpenBiliClaw gave you back control of your feed, a star is the most direct vote for "keep adding platforms".

Privacy at a glance

Default data flow: browser extension → your configured local OpenBiliClaw backend → SQLite on your machine. The extension does not send data to servers operated by OpenBiliClaw developers. Linux.do _t is reduced to a browser-local login boolean; cookie values, CSRF data, and raw site responses are not uploaded. If you configure a cloud LLM or embedding provider, the relevant content is sent to that provider according to your configuration. See the Privacy Policy. Default data flow: browser extension → your configured local OpenBiliClaw backend → SQLite / data files on your machine. The extension does not send data to servers operated by OpenBiliClaw developers. If you configure a cloud LLM or embedding provider, the relevant content is sent to that provider according to your configuration. A .obcbackup you explicitly export from Settings may contain model/source API keys, cookies, your profile, and history, and it is not encrypted. It excludes the source machine's entire API-auth section (including passwords, sessions, and device keys), but must still be transferred only between trusted devices. See the Privacy Policy.

📄 License

MIT

Friend Links