Tiny Tool Development

// Outer Tools / Not Applicable

ArchitecturalKnowledgeDB

Architecture memory for humans and agents: source-anchored recall, context packs, drift checks, and MCP access without replacing the files that own the truth.

Local architecture knowledge database for SADs, ADRs, UML, rules, provenance, drift checks, recall, and agent-ready context packs.

Use AKDB as the local architecture memory loop: import the current sources, ask for source-anchored context, inspect drift and provenance, do the work in the owning files, then reingest.

Ask on Discord Read GitHub documentation Back to catalogue
ArchitecturalKnowledgeDB system overview
system artCanonical schematic media; status, proof, and roadmap remain data-driven in the page.
// THE PAIN

Before the plugin enters the chat.

Architecture knowledge exists, but it is scattered across docs, diagrams, Git history, and people's memory.

PAIN

A large project can have SADs, ADRs, UML diagrams, rules, source-area notes, product facts, schemas, and commit history - and still make every agent session start from scratch.

When that material is not indexed together, architecture work turns into manual search, half-remembered decisions, stale diagrams, and prompts that cite whatever happened to be open. AKDB exists for the moment before a change, review, or agent task: collect the relevant decisions, diagrams, constraints, source paths, and provenance first.

What that feels like

  • Agents answer from prompt leftovers instead of current SAD, ADR, UML, and provenance.
  • Architecture diagrams and documents drift, but nobody sees the mismatch until review hurts.
  • Git history contains useful context, yet it is too slow to inspect for every task.
  • Cross-tool workflows need architecture context, but no single runtime should own the source files.
  • Public product pages and internal docs can drift when product facts are not projected deliberately.
// WHAT YOU GET

After — in the editor, not in a slide deck.

AKDB turns the architecture corpus into a local, queryable working memory while keeping Git/docs and Git/UML authoritative.

GAIN

Register a project, import the architecture corpus, scan Git provenance read-only, ask for search/recall/context packs through CLI, FastAPI, or MCP, run consistency and staleness checks, then update the owning files and reingest. The database is fast working state, not a second source of truth.

  • Project-aware SQLite and FTS knowledge bases for ADRs, documents, UML, rules, definitions, source areas, and provenance.
  • Authority-aware context packs for humans, coding agents, AIaGMW, and maintainer workflows.
  • Read-only Git provenance and drift checks that point to review work instead of editing source files silently.
  • CLI, FastAPI/admin UI, Docker, and 56 MCP tools with compact agent output by default.
  • A website/Atlas projection that finally lists AKDB as a real Outer Tool with its own product story.

// HOW IT WORKS

The product architecture, inspected from the plugin surface.

These are the moving parts I would place on the page so buyers can understand what they are actually getting beyond the slide narrative.

01 / Source authority

Files still own the truth.

SADs, ADRs, UML, schemas, product facts, gates, and owning repositories remain authoritative. AKDB imports and relates them so they can be used quickly.

02 / Ingest

Architecture material becomes project-scoped knowledge.

CLI/API/MCP workflows import ADRs, documents, rules, definitions, source areas, PlantUML, Mermaid, YAML, JSON, CSV, and product facts into a SQLite/FTS database.

03 / Provenance

Git context is scanned read-only.

Registered repositories supply selected commit and file-history signals without letting AKDB mutate source files, Git state, assets, or diagrams.

04 / Recall

Humans and agents ask for bounded context.

Search, recall, explore, context-pack, origin, rules-for-path, and compact MCP responses turn scattered architecture into usable task context.

05 / Projection

Website and Atlas explain the tool without changing runtime authority.

Product facts, curated page copy, product media, deploy snapshots, and Atlas relationships present AKDB publicly as an Outer Tool.

// FIT

Who actually reaches for this.

Architecture-heavy projects where decisions, diagrams, rules, source ownership, and Git history need to be retrievable before people or agents change the system.

ArchitecturalKnowledgeDB (AKDB) is a standalone Python outer tool in its own ArchitecturalKnowledgeDB repository. It creates project-aware SQLite knowledge bases, imports architecture documents and UML, scans selected Git metadata read-only, and serves humans, agents, AIaGMW, and companion workflows through CLI, FastAPI, and MCP stdio. It is the practical memory layer around the architecture corpus: register the project, reingest the current sources, ask for context before work, inspect drift during review, and keep the owning Git/docs and Git/UML files authoritative.

// SURFACE

Where it lives in Unreal.

Standalone Python CLI, FastAPI service with local admin UI, SQLite/FTS database, MCP stdio server, Docker entry points, product facts, and website/Atlas projection.

// CAPABILITY MAP

Feature groups with the value of each part made explicit.

Grouped from plugin modules, public APIs, automation hooks, and documented workflow surfaces.

Architecture corpus ingestion

AKDB is built around source material that already matters.

  • Import ADR Markdown, architecture docs, rules, definitions, source-area notes, PlantUML, Mermaid, YAML, JSON, CSV, schemas, and product-facts files.
  • Preserve local ids, source URIs, item types, links, and authority-relevant metadata.
  • Rebuild FTS records and derived database state without rewriting the owning files.
  • Keep project records isolated unless shared spaces are imported deliberately.

Search, recall, and context packs

The daily win is asking better questions before work starts.

  • Use lexical search for fast discovery across imported architecture records.
  • Use recall/explore to move through aliases, neighboring items, link types, and grounding.
  • Build context packs for agent tasks with source paths, authority levels, staleness, and provenance signals.
  • Switch MCP calls from compact to full detail only when the caller needs raw source/prose fields.

Drift and provenance review

Architecture maintenance gets a review queue instead of vague suspicion.

  • Run consistency checks across links, rules, diagrams, source references, and knowledge items.
  • Run status-quo drift to find current mismatches without treating Git timestamps as proof.
  • Run Git-timeline and full drift checks to explain when a confirmed mismatch may have emerged.
  • Ask origin/provenance tools why a path, ADR, rule, or UML element exists and how it evolved.

Agent-facing MCP surface

AKDB gives agents many small, named tools instead of one giant prompt dump.

  • Search, context-pack, origin, rules, Git provenance, staleness, drift, and task validation tools.
  • ADR and UML list/get/import/export/edit tools for database-side review workflows.
  • Recall, explore, remember, working-set, delta, review, roadmap, gaps, tensions, survey, and authoring tools.
  • Reingest and optional embedding tools for keeping the local database current.

Local-first operations

The operating model is simple enough to trust on a maintainer machine.

  • SQLite plus FTS5 is the default durable state.
  • FastAPI exposes health, project, search, context-pack, drift, import/export, UML, and MCP dispatch endpoints.
  • Typer CLI commands cover setup, registry import, search, context, repo registration, Git scan, consistency, and staleness.
  • Docker and docker-compose provide local service entry points when a mounted data/source setup is preferred.

Public and ecosystem projection

The website now treats AKDB as a first-class Outer Tool, not a hidden helper.

  • Product facts feed the catalog, deploy snapshot, facts loader, and Atlas product identity.
  • Hand-authored tool page and deep dive explain how AKDB is used, why it exists, and where it integrates.
  • Product art gives the Outer Tools list a real visual signal instead of a placeholder.
  • Atlas relationships connect AKDB to AIaGMW, project understanding, architecture drift, and agent context workflows.

// PRODUCT DOSSIER

The deeper buyer questions, answered from the actual product surface.

This section exists for products where a feature list is still too shallow: roles, scenarios, technical surfaces, decision rules, and concrete evaluation signals.

// HOW TO USE IT

The AKDB working loop is intentionally repeatable.

It is not a mystery service. It is a set of local steps you can run before, during, and after architecture work.

01

Bootstrap and register

Create the project, shared spaces, source roots, and repositories once.

  • Use setup for starter files when bootstrapping a new project.
  • Use project registry import when the workspace already has known repositories.
  • Keep portable source roots resolved through AKDB_SOURCE_ROOT.
02

Import the architecture corpus

Pull the current documents and diagrams into the database before asking it questions.

  • Import ADRs, architecture docs, UML, rules, definitions, and source areas.
  • Reingest after source changes instead of treating old rows as truth.
  • Use FTS immediately; enable vector recall only when the embedding endpoint is ready.
03

Ask before acting

Use search, recall, or context packs as the preflight for human or agent work.

  • Ask for the task context, not the whole repository.
  • Pass source paths when the work is scoped.
  • Let compact MCP output keep agent context focused.
04

Review drift and publish in files

Find likely mismatches, then update the files that own the architecture.

  • Use consistency and staleness as advisory review signals.
  • Change SAD, ADR, UML, or source files through the normal review path.
  • Reingest after the change so the working database catches up.

// WHY IT EXISTS

AKDB is the difference between stored documents and usable architecture memory.

The value is not that SQLite exists. The value is the authority-aware connection between decisions, diagrams, source paths, Git history, and agent prompts.

Authority

It remembers where truth lives.

Every useful answer must remain tied to the source that earned its authority.

  • Accepted decisions outrank imported summaries.
  • Current Git/UML files outrank stale database rows.
  • Provenance explains a claim; it does not become the claim.
Velocity

It makes architecture usable at task speed.

A context pack is faster than rereading an entire architecture tree.

  • Agents get the specific bundle they need for a task.
  • Maintainers can inspect origin and drift without manual archaeology.
  • Onboarding starts from source-anchored orientation instead of tribal memory.
Control

It keeps automation on the read side until another tool owns action.

AKDB can inform changes without becoming the mutation layer.

  • Read-only Git scan by default.
  • No Unreal asset mutation.
  • No silent source edits from database-side records.
Continuity

It gives recurring work a memory.

The next review can start from the last decisions, not from a blank prompt.

  • Recall neighborhoods connect terms, links, ADRs, UML, and notes.
  • Working sets and memories let agents resume with bounded context.
  • Drift reports turn vague maintenance risk into concrete follow-up.

// INTEGRATION SHAPE

AKDB connects strongly because it keeps its job narrow.

It gives context to other tools, but it does not absorb their responsibilities.

AIaGMW

Modeling gets context, not silent publication.

AIaGMW can read AKDB context and import indexed UML as reviewable patch proposals.

  • Workspace JSON remains AIaGMW-owned.
  • PlantUML publication remains Git/UML-owned.
  • AKDB supplies source-anchored context and diagram lookup.
Agents

MCP clients get named tools instead of vague prompts.

AKDB exposes search, context, drift, ADR/UML, recall, authoring, memory, review, and reingest tools over stdio.

  • AKDB_DEFAULT_PROJECT reduces repetitive project ids.
  • Compact output is the default for high-volume calls.
  • detail=full keeps deeper inspection explicit.
Website

The public surface is now deliberate.

Product facts, literal catalog entries, snapshot fallback, product media, and deep-dive copy make AKDB visible in Outer Tools.

  • Cloudflare builds do not need the sibling Git repo to list AKDB.
  • Atlas relationships can join AKDB by product identity.
  • The page can explain value without changing runtime behavior.
Companion workflows

Documentation and project-intelligence work can start from architecture evidence.

SDA, PIO-style workflows, and maintainer review passes can ask AKDB for context before drafting or routing work.

  • SDA can use context packs before documentation patches.
  • PIO can ask for guardrails and drift findings.
  • Other tools stay owners of their own mutation surfaces.

// IMPLEMENTATION SIGNALS

The page is grounded in the actual implemented AKDB package.

The public story is backed by concrete package surfaces, not only aspiration.

Runtime

One service model, three access paths.

Typer CLI, FastAPI/admin UI, and MCP stdio dispatch all route into the same SQLite-backed service model.

  • akdb / architectural-knowledge-db CLI entry points.
  • FastAPI health, project, import, context, drift, UML, and MCP endpoints.
  • akdb-mcp stdio server for compatible clients.
Storage

Project-aware SQLite with additive migrations.

SQLite/FTS provides the baseline while migrations extend cognition, entities, memory, and embeddings.

  • Schema migrations 001 through 007 are present.
  • FTS remains the no-provider baseline.
  • Optional vector recall is environment-gated.
Tests

The implementation has coverage for the important promises.

Tests cover import/export, project isolation, context packs, Git scanner, consistency, staleness, MCP, compact output, reingest, semantic hardening, and authoring.

  • test_mcp_compact.py guards agent token economy.
  • test_git_scanner.py guards read-only provenance behavior.
  • test_reingest.py guards refresh behavior.
Website

The presentation has its own regression checks.

Facts loader, product art, home, and Atlas tests catch missing product identity or placeholder media.

  • Snapshot fallback includes AKDB and the Track Shape outer tools.
  • Product art is explicit for card and hero surfaces.
  • Atlas integrity checks validate graph references.

// OPERATOR TOOLS

Concrete actions, expected result, and mutation boundary.

This is the part that keeps product marketing honest: buyers can see which buttons, APIs, or MCP tools matter and what they change.

// ACTION

setup / project import-registry

Why it matters
Creates project records, shared spaces, and repository registrations.
Operator result
AKDB knows which project and source roots a query belongs to.
Change surface
Writes AKDB database records and optional starter docs only when requested.
// ACTION

adr/document/uml import

Why it matters
Turns architecture files into indexed knowledge items and diagrams.
Operator result
Search, recall, context packs, and drift checks can see the current corpus.
Change surface
Writes database rows; source files remain unchanged.
// ACTION

repo add / git scan

Why it matters
Registers repositories and stores selected Git provenance metadata.
Operator result
Origin and drift reviews can cite file history and co-change signals.
Change surface
Read-only repository access; writes AKDB provenance rows.
// ACTION

search / akdb_recall / akdb_explore

Why it matters
Finds relevant architecture records and linked neighborhoods.
Operator result
A maintainer or agent gets a focused map of decisions, diagrams, terms, and related evidence.
Change surface
Read-only query.
// ACTION

context-pack

Why it matters
Assembles task-specific source-anchored context.
Operator result
Agent work starts with decisions, rules, diagrams, staleness, provenance, and source references.
Change surface
Read-only response.
// ACTION

consistency / stale run / drift run

Why it matters
Finds advisory mismatches between documents, diagrams, source references, symbols, and Git timeline signals.
Operator result
A review queue for architecture maintenance.
Change surface
Writes report/finding rows; does not edit source files.
// ACTION

origin explain / git provenance

Why it matters
Explains why a source path, ADR, rule, or UML element exists and how it evolved.
Operator result
Reviewers can distinguish current authority from supporting history.
Change surface
Read-only explanation.
// ACTION

MCP manifest / stdio dispatch

Why it matters
Advertises and executes AKDB tools for compatible agent clients.
Operator result
Agents can call named tools for search, context, drift, ADR/UML, recall, authoring, memory, and reingest.
Change surface
Depends on tool; bulk retrieval is compact by default.
// ACTION

akdb_reingest_project

Why it matters
Refreshes project knowledge from source folders and optionally rescans Git.
Operator result
The database catches up after source authority changed.
Change surface
Writes AKDB database state; should use an owned DB or stopped shared service.
// ACTION

akdb_embed_project

Why it matters
Embeds new or changed items when a vector/hybrid backend is configured.
Operator result
Semantic recall becomes available without removing the FTS baseline.
Change surface
Writes embedding/vector state; no-op when backend is unset.

// TYPICAL FLOW

From inspection to use without losing the product boundary.

01

Register the project, display name, shared spaces, and source roots or import a project registry.

02

Import ADRs, architecture documents, rules, definitions, source areas, PlantUML, Mermaid, YAML, JSON, CSV, and product facts.

03

Register source repositories and run the read-only Git scan for provenance and timeline evidence.

04

Use search or recall when you need to discover architecture context quickly.

05

Build a context pack before an agent task, modeling change, documentation update, or risky review.

06

Run consistency, status-quo drift, staleness, and origin checks to find mismatches worth reviewing.

07

Update the owning source files, then reingest so the database returns to current working state.

// PROOF AND BOUNDARIES

Signals that make the product specific, plus the limits worth saying out loud.

Each card turns implementation facts into buyer-facing proof without pretending the tool solves the wrong problem.

Classification Outer Tool, standalone Python, not Unreal plugin, not Fab package
Access paths CLI, FastAPI/admin UI, MCP stdio, Docker
MCP tools 56 advertised tools including search, context, drift, recall, authoring, memory, review, and reingest
Storage SQLite, FTS5, additive migrations, optional vector recall
Safety Registered repository scan is read-only by default
Authority model Git/docs, Git/UML, ADRs, schemas, and owning repositories remain normative
Website fix Outer Tools deploy snapshot now includes AKDB, TrackShape Toolchain, and Track Shape Editor
Test basis AKDB pytest suite plus website facts/art/Atlas tests

Outputs

What the plugin leaves behind when the workflow is doing useful work.

  • Context packs

    Task-specific bundles for humans and agents, with authority and provenance signals.

  • Recall neighborhoods

    Linked concept maps around terms, decisions, diagrams, memories, and source areas.

  • Drift findings

    Advisory status-quo, staleness, and Git-timeline findings for review.

  • Origin trails

    Explanations tying paths, knowledge items, UML elements, and rules back to evidence.

  • MCP responses

    Compact or full detail tool results for compatible local clients.

  • Project registry state

    Projects, shared spaces, source roots, and repository registrations.

  • Website projection

    Product card, hero media, tool page, deep dive, deploy snapshot, and Atlas node.

Inspection basis

The concrete code, API, and tool surfaces used to shape this product page.

  • Repository README

    Defines AKDB as a local architecture knowledge database and states the non-Unreal, non-Fab boundary.

  • Public docs

    Quick start, user manual, settings reference, troubleshooting, FAQ, and MCP access explain practical operation.

  • CLI/API code

    Typer commands and FastAPI routes expose setup, import, search, context, Git scan, drift, UML, and MCP dispatch.

  • MCP manifest

    The manifest advertises 56 tools and compact output behavior for bulk/list/search calls.

  • Service layer

    Projects, knowledge, import/export, UML, context, search, consistency, staleness, Git scanner, cognition, authoring, memory, review, guardrail, and reingest services.

  • Tests

    Pytest files cover project isolation, import/export, context packs, Git scanner, consistency, staleness, MCP stdio, compact output, semantic hardening, authoring, and reingest.

  • SAD and product facts

    AKDB's internal architecture and product-facts.yml define the website's factual projection boundary.

Integrations

Where the product connects without losing ownership of its own domain.

  • AIaGMW

    Reads AKDB context and imports indexed UML as reviewable patch proposals while Git/UML remains the publication authority.

  • MCP clients

    Use akdb-mcp for local stdio access to search, context, drift, recall, authoring, memory, and reingest tools.

  • Tiny Tool Website and Atlas

    Consume product facts, curated copy, product media, snapshot fallback, and Atlas relationships to present AKDB as a featured Outer Tool.

  • Smart Documentation Assistant

    Can use AKDB context packs and provenance before source documentation review or patch drafting.

  • Project Intelligence Orchestrator

    Can request architecture context, guardrails, and drift/provenance signals while keeping orchestration outside AKDB.

  • Optional embedding endpoint

    Vector/hybrid recall can be enabled through AKDB_RECALL_BACKEND and AKDB_EMBED_URL while FTS remains available.

Safety model

The boundaries that make the tool understandable before automation enters.

  • Source files are normative

    Imported database rows never outrank the owning SAD, ADR, UML, schema, gate, or repository file.

  • Read-only repository scan

    Git provenance collection stores selected metadata and does not mutate repositories by default.

  • Project isolation

    Records are project-scoped; shared spaces must be imported explicitly.

  • Compact agent default

    Bulk/list/search MCP tools strip large raw fields unless detail=full is requested.

  • Local-first runtime

    SQLite/FTS, CLI, FastAPI, MCP, and Docker workflows run locally without Unreal Engine or cloud services.

  • Presentation boundary

    Website and Atlas can showcase AKDB, but they are static publication surfaces, not AKDB runtime state.

Not for

The cases where the product promise would be the wrong expectation.

  • Teams expecting a hosted SaaS knowledge base.

  • Workflows where the database should silently edit source files, UML, or repositories.

  • Unreal plugin buyers looking for a Fab package.

  • Projects that have not decided which architecture files and repositories should be trusted.

  • Agent workflows that want unlimited raw repository access instead of bounded, source-anchored context.

// PRODUCT MEDIA

Tutorial and platform embeds stay attached to product context.

YouTube, Discord, LinkedIn, and Fab widgets are reserved for product presentation, explanation, support context, or tutorials. No third-party widget loads automatically.

Tutorial video

YouTube

Product walkthroughs, setup explanations, and tutorial material.

Embed source pending. No third-party widget is loaded here.

Open platform
Primary support context

Discord

Discord-first product support, quick questions, setup discussion, and community context.

Embed source pending. No third-party widget is loaded here.

Open platform
Professional context

LinkedIn

Company background, provider identity, project credibility, and listing context.

Embed source pending. No third-party widget is loaded here.

Open platform
Marketplace context

Fab

Product listing context, license details, purchase route, and marketplace availability.

Embed source pending. No third-party widget is loaded here.

Open platform

// INFORMATION

All essential product signals in one place.

Status Not Applicable
Category Outer Tools
Unreal Engine Not an Unreal Engine plugin
Source state Current implementation - standalone Python architecture knowledge database and MCP/HTTP/CLI service
Primary surface Standalone Python CLI, FastAPI service with local admin UI, SQLite/FTS database, MCP stdio server, Docker entry points, product facts, and website/Atlas projection.
Marketplace No product checkout linked
Direct sales None on this website
Support route Discord first; product context lives on this page
Listing context Fab for marketplace, LinkedIn for public provider identity
Fact surface 8 functions / 7 settings / 5 failure modes / 5 bridges
Boundary Standalone local architecture knowledge database that indexes SAD, ADR, UML, rules, source areas, Git provenance, and agent memory while keeping source files authoritative.
Primary workflow Register a project and its source repositories, import or reingest ADRs/documents/UML/rules/source areas, scan Git provenance read-only, ask search/recall/context-pack/MCP tools for task-specific architecture context, run consistency/staleness checks, then update owning source files and reingest.
Publication boundary Internal architecture and maintainer tool surface. Not an Unreal plugin, not a Fab package, and not the authoritative SAD/UML folder.

// NOTES

Practical boundaries.

AKDB is a standalone Outer Tool. It is not an Unreal plugin, not a Fab package, and not a cloud knowledge base.

The database is intentionally derived state. Source files, SAD/UML, ADRs, schemas, gates, and owning repositories remain authoritative.

The HTTP service and MCP server can share one SQLite database, but write-heavy reingest should use an owned DB or run with the shared service stopped.

The deployable website snapshot now carries AKDB and the Track Shape outer tools so Cloudflare builds do not silently lose the Outer Tools category.

Optional embeddings are explicit; FTS search and deterministic imports remain the dependable baseline.

AKDB is most valuable before action: collect context, inspect drift, understand origin, then let the right owner perform the change.

// LEGAL / PRIVACY

Static information page.

Purchases, downloads, marketplace accounts, and platform-specific license details are handled outside this website. Product or tutorial widgets are loaded only after activation, where configured.

Provider details are listed in the legal notice. The current site template does not set first-party cookies and does not load analytics scripts.

Legal Notice Privacy Policy

// RESOURCES

Open the channel that matches the next question.

Fab seller profile

No product-specific Fab listing is linked yet. The public seller profile remains available.

Open

GitHub documentation

Manuals, quickstarts, settings references, troubleshooting, technical notes, and release material live in GitHub.

Open

Discord support (primary)

Start quick questions, setup help, support context, and product-fit discussion on Discord.

Open

Plugin support email

Formal plugin support requests can be sent to the dedicated support mailbox.

Open

LinkedIn company context

Company background, public provider identity, and listing context are available on LinkedIn; support still starts on Discord.

Open

// RELATED

Nearby tools in the catalogue.

Outer Tools

AI-Assisted Graphical Modeling Workspace

Folder-based graphical UML editor with patch-first AI co-authoring and optional AKDB context enrichment.

View page
Outer Tools

TrackShape Toolchain

Deterministic Python toolchain for raster tracing, shape validation, Unreal spline compilation, reports, and optional MCP apply.

View page
Outer Tools

Track Shape Editor

Local graphical editor for deterministic track-shape JSON used before compiling or applying Unreal spline points.

View page

// TOOL NAVIGATION

Continue through the catalogue.

Each tool page keeps the product overview here and routes deep technical material to GitHub.

Previous: Unreal Code Integrator Next: AI-Assisted Graphical Modeling Workspace