ExternalBrain

Self-improving, self-hosted memory across every AI coding tool, project, and team (Claude Code, Cursor, Copilot, any MCP client). Autoskill proposes new skills from your sessions, so each project improves automatically. Inspectable, grounded, and yours. Built for teams and enterprise.

Generate Convert Improve

Install / Use

claude mcp add bejranonda -- npx -y github:bejranonda/ExternalBrain

If the server publishes to npm under a different name, use that package instead — check the repo README.

About this skill

🔌

MCP Server

Model Context Protocol server

Quality Score

83/100

Skill content

View source on GitHub

External Brain: Self-Improving, Compounding AI Coding Intelligence Across Every Tool, Project, and Team

Standard AI memory is trapped in one tool, one project, one person — and stays static. Claude Code doesn't share with Cursor, lessons learned on one repo don't carry to the next, and basic memory just accumulates raw chat history. External Brain is a self-improving, compounding intelligence engine across every MCP tool, project, and team. It extracts structured rules and recipes from finished sessions, reinforces what pays off, decays obsolete guidance, and doubles the power of every AI tool from your team's real work. Built for teams and enterprise, on your own infrastructure.

External Brain is a self-hosted MCP (Model Context Protocol) server + webapp that powers self-improving AI coding intelligence. It ingests your coding sessions, extracts durable knowledge (skills, rules, recipes, anti-patterns, project decisions), retrieves it by semantic meaning when you start a new task, and answers questions about your own codebase through a grounded Oracle — every answer cited back to the sessions and skills that support it.

Unlike basic memory built into individual AI tools, that intelligence is one shared, self-improving, inspectable layer across every MCP client — it stays on your own infrastructure instead of sitting in a separate black box locked inside each tool.

Provider-agnostic (Google Gemini, GLM, OpenAI, Anthropic Claude), runs on a single VM with Docker Compose, and MIT-licensed — fork it and build your own.

Architecture diagram showing how External Brain connects AI coding tools like Claude Code and Cursor via MCP to a Postgres + pgvector knowledge store

Why Use External Brain? — Self-Improving Compounding Intelligence Across Every Tool, Project, and Team

Modern AI coding tools have memory now. The real problem is where that memory lives, how static it remains, and how far it reaches:

Siloed & Static — per tool, per project, per person. Claude Code doesn't share with Cursor or Copilot; a lesson learned on one repo doesn't carry to the next; and your teammates each start from zero. Knowledge that should compound stays stuck in one place.
A black box. You can't see what it kept, fix it when it's wrong, or curate it. You just hope it remembered the right thing.
Not yours. It's locked inside one vendor's cloud, tied to that one tool. You can't inspect it, move it, or share it on your terms.

External Brain is the missing self-improving intelligence layer that spans every AI coding tool, every project, and your whole team: one shared, inspectable, self-hosted store you actually own. A rule captured once ("we use Zod not Yup", "the deploy breaks if you skip the migration step", "this service owns auth") is served back to every tool, on every project, for every teammate who needs it. With user / project / team / org scopes, it was built for enterprise knowledge reuse, so the lessons one engineer learns become the team's, not a silo's.

And it doesn't sit still. Autoskill watches your sessions, proposes new skills it notices you reusing, reinforces the rules that pay off, and lets the weak ones fade. Each project gets better day by day, on its own, through self-improving feedback loops.

Key Features

🧠 Automatic knowledge extraction — finished sessions are mined for durable, reusable lessons. No manual note-taking.
🔌 Universal MCP compatibility — works with Claude Code, Cursor, Windsurf, Google Antigravity, GitHub Copilot (VS Code, JetBrains, CLI), and any MCP-capable agent as first-class clients.
🔎 Semantic retrieval with pgvector — relevant skills are injected into context before the model generates, by meaning, not keyword match.
💬 Grounded Oracle with citations — ask "how did we fix the deploy bug?" in plain English and get an answer cited to real sessions and skills.
📝 Meeting transcript → decisions & action items — paste a transcript and review/confirm the decisions, owned action items, and open questions it surfaced. Flag-gated (MEETING_UPLOAD_ENABLED), off by default.
📈 Self-improving knowledge base — a daily pipeline synthesizes cross-session knowledge; low-value skills decay; useful ones surface; and post-session proposals suggest new rules, increasingly tuned to what you accept vs reject. The brain gets sharper the more you use it.
🏠 Self-hosted & private — your knowledge stays in your Postgres, on your infrastructure. Secure-by-default auth, Bearer-gated MCP.
👥 Team & enterprise knowledge sharing — user / project / team / org scopes mean a skill learned once is reused across other projects and teammates, with team-wide access to the same decisions. Built for enterprise knowledge reuse, not one-person silos.
🪶 Clean, progressive-disclosure UI — a quiet dashboard that opens into depth only when you ask. Not a wall of dials.
🧭 Self-explaining with built-in docs — a built-in /docs glossary (every concept in plain English, EN/TH/DE), inline tooltips on jargon, and an in-app cheat-sheet of the exact prompts to type to your agent.
🌐 Multilingual UI — English, Thai (ไทย), and German, switchable on every surface including unauthenticated pages.

What it is not: another AI coding tool. External Brain doesn't write code — it's the memory substrate that makes whatever tool you already use smarter over time.

The Conceptual Foundation: The DIKW-T Framework

Traditional Personal Knowledge Management (PKM) systems and AI memory tools are static: they accumulate data, but they lack the dynamic time-series dimension required to understand how engineering knowledge evolves.

External Brain grounds its architecture in the industry-standard DIKW Pyramid (Data → Information → Knowledge → Wisdom), upgraded with an active Time-Series (+ Time) engine that turns static storage into an evolving, self-improving intelligence platform.

DIKW-T Model: Evolution Framework

The 4 Stages of Knowledge Evolution

| Stage | Definition | In External Brain & Connected Workflows | | :--- | :--- | :--- | | 1. Data (Raw Input & Ingestion) | Raw, unstructured, and unprocessed inputs — the scattered puzzle pieces. | Quick notes, terminal outputs, raw git diffs, session prompts, tool calls, and unprocessed meeting transcripts. | | 2. Information (Structured Context & Processing) | Data that has been categorized, tagged, and organized to answer "Who, What, Where, and When." | Typed session summaries, files touched, bidirectional graph links ([[ ]]), project metadata, and YAML frontmatter (status: active, tags: #auth). | | 3. Knowledge (Synthesized Understanding & Automation) | Synthesized understanding that answers "How." The puzzle pieces are assembled into actionable recipes. | Autonomous extraction agents (KEA / Hermes) synthesize scattered sessions into evergreen skill documents, typed rules, heuristics, and anti-patterns. | | 4. Wisdom + Time (Actionable Evolution & Versioning) | Understanding "Why" things changed, evaluating past outcomes, and making future decisions based on historical context across time. | Time-series tracking, commit history, and continuous reinforcement/decay. The grounded Oracle explains not just what the rule is, but how and why the architecture evolved over months of coding sessions. |

How It Translates to the Cloud App Workflow

Ingestion ([Data]): An engineer interacts with an AI agent or captures an idea on mobile/desktop → Synced as raw session data.
Processing ([Information]): The system indexes metadata, links entities, and structures files by project and tag scopes.
Automation ([Knowledge]): Background extraction agents read the connected graph and synthesize atomic, reusable rules and skills.
Versioning & Evolution ([Wisdom]): As git commits and new sessions accrue over time, the system tracks the project's evolution, reinforces winning patterns, decays obsolete ones, and serves grounded answers through the Oracle.

Quickstart — Self-Host External Brain in Minutes

Requires Docker Engine 24+ and one LLM provider key (Google Gemini has a free tier and is the easiest start). Full guide: docs/QUICKSTART.md.

git clone https://github.com/bejranonda/ExternalBrain.git external-brain
cd external-brain

cp .env.example .env          # add one provider key (e.g. GOOGLE_GEMINI_API_KEY)
./scripts/dev-up.sh           # build · migrate · seed · start — idempotent

Alternatively, run directly via Docker Compose:

docker compose -f deploy/docker-compose.yml up -d

Webapp: http://localhost:3000 | MCP HTTP: http://localhost:3100/mcp

dev-up.sh runs an auth-posture audit at the end and prints PASS/FAIL. For a public-internet server deployment (Caddy + auto-TLS, real auth enforced, nightly backups), use ./scripts/deploy.sh instead — see docs/DEPLOY_CHECKLIST.md.

Sign in & create your workspace

New users can self-register from /signin → "Create one" (email + password) and get their own personal workspace immediately. Registration is secure-by-default: it requires a voucher code (minted by the operator at /admin) unless you set REGISTRATION_REQUIRES_VOUCHER=false to open signup fully. Any signed-in user can also create additional organizations from Settings → Organization → New organization. See docs/SECURITY.md for the full posture.

Two public URLs matter. https://<your-host>/ is the landing page — what Brain is, what it does, which tools it works with, and links into the docs. It renders for anonymous visitors only; signed-in users are still routed straight to their project.

https://<your-host>/start is the front door for anyone holding a voucher code — it prefills from ?voucher=CODE, explains both setup routes, and is where every voucher error on /signin sends people. That is the link worth printing on a card or pasting into a channel.

Fresh deployments serve robots.txt with Disallow: /, because an invite-only instance shouldn't be indexed. Set BRAIN_ROBOTS_DISALLOW_ALL=false when you want your landing page found.