GhostCrab MCP + mindBrain SQLite — structured domain navigation for Autogen sessions

[FrancoisLamotte]

What problem this solves

AutoGen gives agents memory — but each agent's memory is its own island.

AutoGen 0.4 exposes a Memory protocol with three built-in implementations:
ListMemory (chronological, in-memory), ChromaDBVectorMemory (local vector similarity),
and RedisMemory (Redis vectors). Each AssistantAgent gets its own instance.
There is no shared registry across agents on the same team by default.

When a planner agent records an architecture decision, the coder agent cannot see it
unless it is explicitly re-injected into the conversation. Context fragments across turns,
runs, and team members. SelectorGroupChat and RoundRobinGroupChat orchestrate turn
selection — but have no structured, persistent view of what agents have done,
what is blocked, or whether a phase gate has been reached.

This request adds two complementary components that solve this without touching AutoGen core.

---

What a domain looks like in practice

A domain is any bounded context where agents need to
reason over structured relationships : not just retrieve text.

mindBrain separates two levels:

Ontology (the model) : the schema of a domain:
entity types, relationship types, constraints, vocabularies.
Defined once, shared across every agent on the team, across every run.

Knowledge Graph (the projected instance) : the populated graph:
real entities, real edges, real state : queryable via projections.

Example: multi-agent project delivery

Ontology (model)              Knowledge Graph (instance)
─────────────────             ──────────────────────────
Project                       "Platform Modernization Q3"
└── has Task                  └── Task: "Rotate JWT keys"
      └── has_status                has_status: BLOCKED
      └── depends_on          Task: "Define ERP contract"
      └── assigned_to               assigned_to: implementer
Decision                      Decision: "Stateless JWT over Redis"
└── IMPLEMENTS Requirement          IMPLEMENTS: req-auth-perf
Phase                         Phase: BUILDING → readiness_score: 88

The orchestrator agent calls ghostcrab_pragma_query(projection="task_summary"):
returns task counts by status without scanning conversation history.
ghostcrab_pragma_query(projection="phase_readiness") returns score 88 → triggers
ghostcrab_phase_transition to REVIEW. Workers write facts; the orchestrator reads
pre-computed projections. No re-derivation from chat logs.

Example: ERP domain

Ontology (model)              Knowledge Graph (instance)
─────────────────             ──────────────────────────
Account                       "Acme Corp" (tier=enterprise)
└── has CostCenter            └── CostCenter: "Engineering"
└── has ApprovalFlow          └── ApprovalFlow: PO > €5k → CFO
GLEntry                       GL-20260501: amount=€12,400
└── linked_to CostCenter            linked_to: "Engineering"

A finance_agent in an AutoGen team resolves a billing anomaly by calling
mindbrain_query(mode="faceted", filters={"component": "billing", "type": "GLEntry"}).
Account structure, approval rules, and GL history are returned as structured records —
not ranked passages from a document index.
No re-injection of spreadsheet data between sessions.

Example: CRM domain

Ontology (model)              Knowledge Graph (instance)
─────────────────             ──────────────────────────
Account                       "NovaTech" (tier=enterprise)
└── has Contact               └── Contact: "Maria Chen" (VP Engineering)
└── has Deal                  └── Deal: "Platform License" (stage=negotiation)
└── has Interaction           └── Call: 2026-05-14, sentiment=positive
└── has Constraint            └── Constraint: "No multi-year commitment"

A sales_agent building a renewal brief queries the shared namespace:
mindbrain_query(mode="faceted", filters={"type": "Account", "slug": "novatech"}).
Account tier, deal stage, interaction history, and contractual constraint
are returned in a single structured response — visible to every agent
in the team through the shared MindBrainMemory instance.

Example: Customer Support domain

Ontology (model)              Knowledge Graph (instance)
─────────────────             ──────────────────────────
Ticket                        TK-9821: priority=critical
└── linked_to Component       └── linked_to: "Auth Service"
└── references Incident       └── Incident: "JWT outage 2026-04-30"
KnownIssue                    KI-44: "Token expiry on clock skew"
└── affects Component               affects: "Auth Service"
└── has Resolution            Resolution: "Force clock sync + rolling restart"

A support_agent calls ghostcrab_graph_traverse(start_id="TK-9821", relation="references", depth=2)
and immediately surfaces the linked incident, the known issue, and its resolution —
without searching knowledge bases or escalating blindly.
The reviewer_agent in the same team can validate the resolution link
using the same shared registry.

---

The meta-ontology: where mindBrain becomes strategic

Each domain above is useful alone. The real leverage is connecting them.

         ERP ←──────────────────┐
                                 │
         CRM ←─────── mindBrain ─┼──→ Project Management
                                 │
         Support ←───────────────┘
                                 │
                                 └──→ Knowledge / Documentation

A single AutoGen team working on a cross-domain task —
say, an enterprise renewal involving a billing dispute,
an open critical support ticket, and a stalled deal —
queries all four domains from the same shared namespace in one pass.

The orchestrator does not relay natural-language context between specialized agents.
It reads the graph. Relations carry their semantics natively.
Context does not degrade across turns or team members.

That is the difference between per-agent memory and a shared ontology registry.
AutoGen's Memory protocol was designed to accept a custom implementation.
MindBrain provides the shared, structured backend that the built-in options cannot offer.

---

Two components, one integration

mindBrain (SQLite : Personal edition)

The data layer. It organizes domain knowledge into three constructs:

• Facets : typed dimensions — status, type, assignee, phase, priority, tier, sentiment, ...
• Semantic graphs : named typed relations — DEPENDS_ON, ASSIGNED_TO, IMPLEMENTS, LINKED_TO, AFFECTS, VALIDATES, ...
• Projections (pg_pragma) : pre-computed orchestrator views — task summary by status, agent load, blocker queue, phase readiness score, critical path — surfaced at zero inference cost

GhostCrab MCP

The gateway layer exposed through AutoGen's native autogen-ext MCP workbench.
Two surfaces on the same server:

• MindBrainMemory — implements the AutoGen Memory protocol; shared instance across all agents on the team
• McpWorkbench — exposes structured tools directly to agents: faceted query, graph traversal, projection reads, phase transitions, agent signals

AutoGen Team (planner / coder / critic / orchestrator)
       │ shared MindBrainMemory instance
       ▼
MindBrainMemory  ── implements Memory protocol ──►  autogen-core
       │ MCP (SSE or stdio)
       ▼
GhostCrab MCP Server
       │
       ▼
mindBrain SQLite
├── facets      — typed query dimensions
├── graphs      — semantic edges across domains
└── pg_pragma   — orchestrator projections (task_summary, phase_readiness, blockers, agent_load)

---

Why this belongs outside AutoGen core

It should stay external.

AutoGen already exposes the right extension point: the Memory protocol with
add, query, update_context, and clear. MindBrain implements that protocol
without modifying AutoGen itself.

Domain ontologies are specific to each team's application context.
The framework cannot know in advance what entities to model,
how to relate them, or what projections an orchestrator needs.
That belongs to the team builder.

If GhostCrab is absent : a ListMemory fallback keeps agents functional.
If mindBrain is empty : agents start with a blank namespace and populate it
through normal add calls during the first team run.

---

Setup

One shared instance. One workbench. All agents.

from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_ext.tools.mcp import McpWorkbench, SseServerParams
from mindbrain.autogen.memory import MindBrainMemory

ghostcrab_params = SseServerParams(url="http://localhost:8080/mcp")

async with McpWorkbench(ghostcrab_params) as workbench:

    # One shared MindBrainMemory instance — all agents see the same registry
    shared_context = MindBrainMemory(mcp_client=workbench, namespace="project_x")

    planner = AssistantAgent("planner", model_client=..., memory=[shared_context], workbench=workbench)
    coder   = AssistantAgent("coder",   model_client=..., memory=[shared_context], workbench=workbench)
    critic  = AssistantAgent("critic",  model_client=..., memory=[shared_context])

    team = RoundRobinGroupChat([planner, coder, critic])
    await team.run(task="Design a faceted indexing module.")

When planner adds an architecture decision via add(), coder retrieves it
through query() on the next turn — no explicit re-prompt needed.

Local development (stdio)

from autogen_ext.tools.mcp import McpWorkbench, StdioServerParams

ghostcrab_params = StdioServerParams(command="./ghostcrab", args=["serve", "--stdio"])

→ Full configuration, skill files, and tested AutoGen walkthrough:
https://github.com/mindflight-orchestrator/ghostcrab-personal-mcp/blob/main/ghostcrab-integrations/autogen/SKILL_ghostcrab-architect_autogen.md

https://github.com/mindflight-orchestrator/ghostcrab-personal-mcp/blob/main/ghostcrab-integrations/autogen/SKILL_autogen_ghostcrab-runtime_.md

---

What MindBrain adds that ChromaDB/Redis do not

Capability	ChromaDB / Redis (AutoGen default)	MindBrain via GhostCrab
Cross-agent shared registry	❌ isolated per agent instance	✅ single namespace, all agents
Structured / faceted search	Vector similarity only	Faceted + graph + vector
Ontology-typed entities	None	Types, relationships, constraints
Orchestrator projections	None	pg_pragma: task_summary, phase_readiness, blockers, agent_load
Cross-session persistence without re-index	❌	✅ SQLite
Self-hosted / air-gap	✅ (ChromaDB) / ❌ (Redis)	✅
Agent signal / phase control	None	ghostcrab_agent_signal, ghostcrab_phase_transition

---

Scope of this request

• Adds GhostCrab MCP + mindBrain SQLite (Personal edition) to the AutoGen integrations catalog
• No changes to AutoGen core, AgentChat, or team orchestration patterns
• Requires autogen-ext[mcp]>=0.4.6 — already available for MCP workbench use
• Works with RoundRobinGroupChat, SelectorGroupChat, and custom team patterns

Repository	https://github.com/mindflight-orchestrator/ghostcrab-personal-mcp
License	Apache 2.0
Transport	SSE (deployed), stdio (local dev), CLI
Backend	SQLite (bundled via mindBrain Personal)
AutoGen compatibility	autogen-agentchat>=0.4.6, autogen-ext[mcp]>=0.4.6, autogen-core>=0.4.6
Integration type	Memory protocol implementation + McpWorkbench toolset