兄弟们，别再往文件助手和收藏夹里疯狂囤垃圾了。GitHub 上刚出的这个离谱开源项目，直接把“稍后再看”做成了全自动的 AI 助理，白嫖党和信息囤积狂直接狂喜！

这玩意叫 SuperBrain，是开发者 sidinsearch 搞出的一个神仙工具。它本质上是一个完全自托管的 AI “第二大脑”，自带安卓端和 Python 后端。无论你在刷 YouTube、看帖子还是刷短视频，一键分享给它，AI 就会在后台帮你搞定一切。最狠的是它只用本地 SQLite 数据库，主打一个零订阅费、拒绝数据收割，真正的赛博防身。
产品猎手

核心点：

原生无缝接入：安卓分享菜单一键直连，刷到哪就能存到哪。

AI 自动提取：自动总结视频、转录音频，甚至能扒出短视频的 BGM。

智能模型路由：自动测速切换 Groq、Gemini 和本地 Ollama。

数据绝对私有：全本地存储，没有云端绑架，谁也偷不走你的隐私。

专治收藏吃灰：智能打标签加每日提醒，囤进去的资料这下真能看完了。

GitHub 地址：https://github.com/sidinsearch/superbrain…

sidinsearch/superbrain

Source: https://github.com/sidinsearch/superbrain

📱 App Screenshots

Table of Contents

• The Problem
• The Solution
• Features
• Architecture
• AI Model Router
• Getting Started
• Packages
• Instagram Credentials
• Installing the Android App
• Release Process
• Hosting Options
• Notifications
• API Reference
• Tech Stack
• Contributing
• License

The Problem

We all save content constantly — Instagram posts, YouTube videos, Reddit threads, articles, recipes — but every platform buries it in its own silo:

• Instagram Saved is a graveyard. No search, no categories, no reminders. You save hundreds of posts and never look at them again.
• YouTube Watch Later piles up endlessly with no way to know what each video was about without rewatching it.
• Browser bookmarks are a mess — unsorted folders full of dead links and forgotten context.
• Screenshots fill your gallery with no searchable text.

You spend time saving things you’ll never find again. You forget what you saved, why you saved it, and where you saved it.

The Solution

SuperBrain is a self-hosted Android app + Python backend that acts as your personal AI-powered content archive. Share any URL from any app — the backend analyses it with AI in seconds and gives you:

• A clean title and summary so you instantly know what it’s about
• Auto-assigned category and tags for filtering at a glance
• Background music identification from Instagram reels (via Shazam)
• Audio transcription from videos (Groq Whisper API + local Whisper)
• Smart Watch Later reminders that actually bring you back to your content

Everything is stored in a local SQLite database you own — no cloud subscriptions, no data harvesting, no vendor lock-in.

Features

✨ Content Analysis

📂 Organisation & Discovery

Architecture

superbrain/
├── backend/
│   ├── start.py                  # Interactive setup wizard & server launcher
│   ├── reset.py                  # Reset / clean utility (selective wipe)
│   ├── api.py                    # FastAPI REST API (18 endpoints) + queue worker
│   ├── main.py                   # Analysis orchestrator (parallel processing)
│   ├── core/
│   │   ├── model_router.py       # Multi-provider AI router with EMA ranking
│   │   ├── database.py           # SQLite (WAL mode) — posts, queue, collections
│   │   ├── link_checker.py       # URL validator (Instagram / YouTube / web)
│   │   └── category_manager.py   # Category normalisation & deduplication
│   ├── analyzers/
│   │   ├── visual_analyze.py     # Vision analysis (frame extraction + AI)
│   │   ├── audio_transcribe.py   # Groq Whisper → local Whisper fallback
│   │   ├── music_identifier.py   # Shazamio multi-segment recognition
│   │   ├── text_analyzer.py      # Caption / metadata AI analysis
│   │   ├── caption.py            # Instagram caption extractor
│   │   ├── youtube_analyzer.py   # Gemini native YouTube understanding
│   │   └── webpage_analyzer.py   # Multi-strategy web scraper + AI summary
│   ├── instagram/
│   │   ├── instagram_downloader.py  # Instaloader engine (auth/anonymous)
│   │   └── instagram_login.py      # One-time session setup with 2FA
│   ├── utils/
│   │   ├── db_stats.py           # Database statistics
│   │   └── manage_token.py       # API token management
│   ├── config/
│   │   ├── .api_keys.example     # Template for API keys
│   │   ├── openrouter_free_models.json
│   │   └── model_rankings.json   # Persisted provider performance data
│   ├── tests/
│   └── requirements.txt
│
└── superbrain-app/               # React Native (Expo SDK 54)
    ├── App.tsx                   # Navigation + notification handlers
    ├── src/
    │   ├── screens/
    │   │   ├── HomeScreen.tsx          # Feed with search, filters, categories
    │   │   ├── LibraryScreen.tsx       # Collections + failed analyses
    │   │   ├── PostDetailScreen.tsx    # Full post view (edit, re-analyse, delete)
    │   │   ├── CollectionDetailScreen.tsx
    │   │   ├── SettingsScreen.tsx      # Server URL + token configuration
    │   │   ├── ShareHandlerScreen.tsx  # Receives shared URLs from other apps
    │   │   ├── FailedAnalysisScreen.tsx
    │   │   └── SplashScreen.tsx
    │   ├── services/
    │   │   ├── api.ts                  # Axios client + offline queue & retry
    │   │   ├── postsCache.ts           # AsyncStorage cache + pending mutations
    │   │   ├── collections.ts          # Collection CRUD + offline sync
    │   │   └── notificationService.ts  # Watch Later scheduling + channels
    │   ├── components/
    │   │   └── CustomToast.tsx
    │   ├── types/index.ts
    │   └── theme/colors.ts
    └── android/                  # Native Android project (Gradle)

  └── superbrain-cli/               # npm wrapper for one-line backend install
    ├── bin/superbrain.js         # Cross-platform launcher (downloads/runs backend)
    ├── scripts/build.js          # Payload packager for npm release
    └── payload/                  # Bundled backend template shipped to users

AI Model Router

Free AI APIs have rate limits, downtime, and variable speed. SuperBrain solves this with a multi-provider model router that automatically selects the fastest available model and falls back transparently on failure — you never have to think about which provider is working.

Priority Chain

How It Works

• Performance ranking — tracks response times with an exponential moving average; faster models get promoted automatically
• Cooldown on failure — generic errors trigger a 5‑minute cooldown; rate limits (HTTP 429) trigger a 30‑minute cooldown
• Dynamic discovery — refreshes the OpenRouter free model list every 6 hours, scores models by context length, capabilities, recency, and provider trust
• Persistent rankings — saved to config/model_rankings.json so performance data survives server restarts

Supported Providers

Tip: You don’t need all providers — the router falls back automatically. Start with at least Gemini (most generous free tier). Ollama serves as the fully offline last resort.

Getting Started

Backend Setup Prerequisites

Method 1: npm One-Line Setup (Recommended)

This is the easiest way to run backend on any PC without cloning this repository.

# Run directly (no global install)
npx -y superbrain-server@latest

Optional global install:

npm install -g superbrain-server
superbrain-server

What this does on first run:

1. Downloads backend package to ~/.superbrain-server
2. Creates virtual environment
3. Installs dependencies
4. Runs interactive setup wizard
5. Starts API server and prints Access Token

Useful commands:

superbrain-server               # Starts the backend engine
superbrain-server status        # Show connection QR code & running server info
superbrain-server update        # Update the backend components
superbrain-server ngrok         # Configure Ngrok tunnel
superbrain-server reset         # Open interactive reset menu
superbrain-server reset --all   # Force complete data wipe

Method 2: Docker Setup

Use this when you want containerized, reproducible deployment.

cd superbrain/backend
cp .env.example .env

Edit .env and set at least:

• GEMINI_API_KEY (recommended)
• GROQ_API_KEY (optional)
• OPENROUTER_API_KEY (optional)

Then run:

docker compose up -d --build
docker compose logs -f superbrain-api

Health check:

curl http://localhost:5000/health

Method 3: Local Python Setup (Normal)

Use this when developing backend locally without Docker.

Windows (PowerShell):

cd superbrain\backend
python -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install -r requirements.txt
python start.py

Linux / macOS:

cd superbrain/backend
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
python start.py

Direct API run (without setup wizard):

python api.py

Connect Android App to Backend

1. Start backend using any method above.
2. Copy the Access Token shown by backend.
3. In Android app Settings, set backend URL and Access Token.
4. Verify /health endpoint returns OK.

Optional: Expose Backend for Phone Access

If phone cannot reach your PC directly, expose port 5000:

ngrok http 5000

Use the generated HTTPS URL in app Settings.

Tip: GOOGLE_API_KEY is accepted as a compatibility alias, but GEMINI_API_KEY is the preferred key name.

Packages

SuperBrain backend launcher is published in two registries:

• npmjs: superbrain-server

  • Stable install: npx -y superbrain-server@latest

• GitHub Packages: @sidinsearch/superbrain-server

  • One-time auth + install block (read:packages token required):
  • Note: only needed for GitHub Packages. Not needed for npmjs (superbrain-server) installs.

npm config set @sidinsearch:registry https://npm.pkg.github.com
npm config set //npm.pkg.github.com/:_authToken YOUR_GITHUB_TOKEN
npx -y @sidinsearch/superbrain-server@latest

GitHub Packages docs: Working with the npm registry

GitHub Packages is separate from the npmjs package page and may not appear in the repository Packages tab until it has been published and linked there.

Instagram Credentials

SuperBrain uses Instaloader to download Instagram posts. It can operate in two modes:

Without credentials (anonymous mode)

SuperBrain works without any Instagram account — but with limitations:

YouTube videos and web pages are not affected — they work fully without Instagram credentials.

With credentials (recommended)

Adding Instagram credentials removes all the above restrictions:

• ✅ Reliable downloads — authenticated sessions are not rate-limited for normal usage
• ✅ Access to all public posts — no more login-required blocks
• ✅ Posts from followed private accounts — if the authenticated account follows a private profile, those posts can be saved too
• ✅ Session caching — you log in once and the session is reused automatically until Instagram invalidates it

How to set up

Option 1 — During setup wizard (recommended)

start.py prompts for Instagram credentials during first-run setup. Enter your username and password when asked — they’re saved to config/.api_keys and a session file is created automatically.

Option 2 — Manual login

cd superbrain/backend
python instagram/instagram_login.py

This interactive script handles the full login flow including two-factor authentication (2FA). It saves:

• Credentials → config/.api_keys (gitignored)
• Session → .instaloader_session (gitignored)

⚠️ Security advice

Use a secondary / burner Instagram account — not your main personal account.

While credentials are stored locally and never transmitted anywhere other than Instagram’s servers, using a disposable account protects your primary account from any risk of rate-limit flags or session issues.

Credentials are stored in config/.api_keys which is gitignored — they will never be committed to version control. The cached session file (.instaloader_session) is also gitignored.

Installing the Android App

Option 1 — Download from Releases (easiest)

The latest APK is always available on the Releases page.

1. Download superbrain.apk from the latest release
2. On your Android device, enable Install from unknown sources
3. Open the APK to install

Option 2 — EAS Cloud Build

npm install -g eas-cli
eas login
cd superbrain-app
eas build --platform android --profile preview --non-interactive

EAS returns a download URL + QR code when done. No Android Studio required.

Option 3 — GitHub Actions

The repo includes:

• build workflow: On push to main, it builds APK, uploads artifact, publishes the GitHub npm package, and updates the release with superbrain.apk
• release APK workflow: Optional tag/release-driven APK pipeline for versioned tags

Automatic release targets:

1. Push to main updates release tag latest (stable).

How to get the newest APK from Actions artifacts:

1. Push your changes to main.
2. Open GitHub → Actions → Build APK (Gradle).
3. Open the latest successful run.
4. Download the artifact named like superbrain-release-<run_number>.
5. Extract it and rename superbrain.apk if needed.
6. Use it directly for testing/internal sharing.

Option 4 — Local Gradle Build

cd superbrain-app
npm install
cd android
./gradlew assembleRelease
# Output: android/app/build/outputs/apk/release/app-release.apk

Release Process

Use this push-based flow to keep GitHub release + APK + GitHub Packages aligned.

1. Push changes to main.
2. .github/workflows/build.yml runs automatically and does all of the following:

• Builds release APK.
• Uploads APK as an Actions artifact.
• Updates the branch release and attaches superbrain.apk.
• Publishes @sidinsearch/superbrain-server to GitHub Packages.

3. Verify:

• APK download works from the release.
• Package appears under GitHub Packages for the repository.

Recommended release notes install line:

npx -y superbrain-server@latest

Verification checklist:

1. latest (main) release contains superbrain.apk.
2. Repository Packages tab shows @sidinsearch/superbrain-server.
3. Install checks:

• npmjs: npx -y superbrain-server@latest
• GitHub Packages: npx -y @sidinsearch/superbrain-server@latest

Hosting Options

The backend is lightweight and runs anywhere with Python 3.10+:

For cloud hosting, open port 5000 in your firewall and point the app directly at your server’s public IP — no ngrok needed.

Notifications

SuperBrain uses Android notification channels to keep you engaged with your saved content without being noisy.

Watch Later

Adding a post to the Watch Later collection triggers:

Each reminder includes a Mark as Watched action button — tap it to remove from Watch Later and cancel all future reminders for that post.

Other Collections

Saving to any non-Watch Later collection fires an instant “Saved to SuperBrain” notification confirming the save.

API Reference

All endpoints require the X-API-Key header with the Access Token.

Interactive API docs are available at http://localhost:5000/docs (Swagger UI) and /redoc.

Tech Stack

Contributing

Contributions are welcome! Please follow these steps:

1. Fork the repository
2. Create a feature branch — git checkout -b feature/my-feature
3. Commit your changes — git commit -m "feat: add my feature"
4. Push to the branch — git push origin feature/my-feature
5. Open a Pull Request

For major changes, please open an issue first to discuss what you’d like to implement.

License

This project is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0).

Made with ❤️ by sidinsearch  ·  Copyright © 2026 sidinsearch  ·  AGPL-3.0 License