EngineerBrain — Organizational Knowledge Brain

This project is EngineerBrain — Know IT Solution’s internal knowledge layer at engineerbrain.knowitsolution.com. It is not “another chatbot,” and it is not a human-only wiki. It is an organizational brain: any authorized MCP-capable AI agent can search company standards, plan and review against them, then learn back into the corpus with a human gate.

In short: company knowledge lives in one place (rules, how-tos, blueprints, checklists). Agents in Cursor, Claude, Copilot, Windsurf, Cline, or other MCP clients call the same tool catalog. People operate the corpus in Knowledge Admin — models do not silently overwrite standards.

Note: EngineerBrain is proprietary / internal to Know IT — not a public downloadable product. This article explains the pattern and capabilities so organizations that want a similar layer can talk through adoption with us.

Why we built it

As teams leaned on AI for delivery, a clear failure mode showed up: each agent reinvented patterns from the public web. Company standards, domain playbooks (telecom, sales, support, and so on), and real bug lessons stayed stuck in chat threads or tribal memory.

So we built the org brain around three plain goals:

• One company truth — agents pull rules and skills before coding instead of reinventing Know IT every time
• Any IDE, one catalog — not locked to Cursor; connect via MCP stdio or HTTP, then install harness in the product repo
• Humans stay in the loop — lessons land in an inbox → promote / merge / reject in Admin; no silent auto-write into always-on rules

What this project actually does

From an “what can an organization use this for?” angle, the package covers:

• Typed knowledge search — rules, skills, blueprints, architecture, examples, checklists, templates; keyword by default, optional hybrid (keyword ∪ vector) for paraphrased questions
• Plan and review against standards — plans grounded in the corpus; review / quality-gate / PR checks from company checklists
• Learn-back — free-text draft → human confirm → inbox → promote/merge, with suggested Related links back to hubs
• Several ways in — MCP stdio (local IDE), MCP HTTP (team/CI), Knowledge Admin (browser + SSO), and agent rules in the product repo
• Admin for operators — Ask (cite/plan), multi-filter catalog, Related map, link hygiene, capture, inbox

What it is not: an automatic ChatGPT plugin · a full replacement for every personal wiki · or “shipping Know IT’s entire brain” to a customer without audience filtering — customer corpora are stood up and governed on their own go-live path.

Stack (and why this shape)

We chose a stack that runs as a real MCP server and lets humans operate the corpus in a browser:

• Core: Node.js + TypeScript — MCP over stdio (Cursor and peers) and Fastify HTTP (/mcp plus health and knowledge API)
• Knowledge: filesystem Markdown with frontmatter (domain, audience, status, owner) — searchable and reviewable in git
• Search: keyword by default; optional hybrid via Qdrant + embeddings when paraphrase recall matters
• Knowledge Admin: Nuxt + Vuexy — humans triage inbox / Ask / knowledge map with SSO
• Ops: Docker Compose for local/stack; MCP read/write tokens stay separate from Admin SSO cookies

The important architectural point: one corpus, many clients — no second brain per IDE, and no confusion between a human wiki and an agent delivery loop.

If an organization adopted this pattern

Imagine your company wants a similar shared brain. A practical path looks like this:

1. Stand up a Day-0 corpus — always-on rules, stack skills, hubs for the domains you actually ship in (do not dump the entire internet on day one)
2. Connect MCP — point IDEs or shared HTTP at your instance; install agent rules / slash commands at the product root
3. Teach the usage loop — session-start → retrieve before coding → quality-gate → capture only reusable lessons
4. Name corpus owners — Admin for promote/merge; set audience and time-bound docs (campaigns/promotions) deliberately

What the organization really gets is not only “faster AI coding,” but knowledge that compounds across sessions and tools — fixed bugs become skills; every agent shares the same standards.

Practical caveats when you take this into production:

• Do not put secrets, PII, or internal pricing into docs with the wrong audience
• Keep MCP tokens separate from Admin SSO — do not call tools with web cookies
• Start with a few high-traffic hubs and grow Related links — avoid a day-one dump of every document
• Measure retrieval with your own golden queries (we publish a public bench approach on the landing) — not an LLM chat score

What we shipped in this round

• MCP server (stdio + HTTP) with search / plan / review / learn-back tools
• Markdown corpus + hybrid search (when Qdrant is enabled)
• Knowledge Admin (Ask, catalog, map, inbox, capture)
• Public landing that explains the product + a re-runnable benchmark link
• Harness / agent rules for major IDEs via generate_agent_rule

Know IT’s role

We design and operate EngineerBrain as our own company brain — corpus, MCP tools, Admin, harness, and the landing that explains the pattern to customers and partners. The goal is twofold: teams ship against one shared organizational truth, and we have a concrete reference for how an organization can start an MCP knowledge layer and split human vs agent responsibilities.

See it live

Read the overview at engineerbrain.knowitsolution.com — gallery screenshots are real pages from this landing / Admin set. If your organization wants a shared brain for AI agents, reach out through the contact channels on knowitsolution.com.