MCP Architector
MCP Architector is a local-first MCP server for storing, managing, and querying project architecture, modules, entries, and slices.
Manage projects: list projects, create/update architecture, stored locally in
~/.mcp-architectorDefine modules: add module details, files, dependencies, usage examples, and data flow
Handle horizontal facts: create/update/search/delete entries (APIs, entities, glossary, scripts, etc.)
Bulk import entries: batch upsert, replace, validate imports, and view import stats
Use slices: list built-in/custom filters and get compact, detail, or table views of entries
Validate data: check dataFlow consistency, moduleβentry links, storage/index drift, empty slices, entry counts
Rebuild indexes and data flow: rebuild entry index, rebuild dataFlow edges from module dependencies
Refactor support: scan, preview, and apply file/path/text/entry mutations with dry-run and confirmation
Access via resources: architecture and module details through URIs
Enforces best practices: requires explicit projectId, avoids duplication, links entries to modules via refs
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@MCP Architector add module auth with dependencies on user-service"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP Architector
Model Context Protocol (MCP) server for architecture and system design
Local-first MCP server that stores and manages project architecture information. All data is stored locally in ~/.mcp-architector for maximum privacy and confidentiality.
π¦ Install: npm install -g mcp-architector or use via npx
π npm: https://www.npmjs.com/package/mcp-architector
π GitHub: https://github.com/theSharque/mcp-architect
How to connect to Claude Desktop / IDE
Add the server to your MCP config. Example for claude_desktop_config.json:
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json
{
"mcpServers": {
"architector": {
"command": "npx",
"args": ["-y", "mcp-architector"],
"env": {
"MCP_PROJECT_ID": "${workspaceFolder}"
}
}
}
}For Cursor IDE: Settings β Features β Model Context Protocol β Edit Config, then add the same block inside mcpServers. See the Integration section for more options.
Related MCP server: LocalNest MCP
Cursor rule (recommended)
For Cursor IDE and Cursor Cloud Agents, use a phased onboarding rule so the agent does not dump the whole repo into context in one shot.
Copy
.cursor/rules/architector-onboarding.mdcinto your project (the repo you are documenting):mkdir -p /path/to/your-app/.cursor/rules cp /path/to/mcp-architector/.cursor/rules/architector-onboarding.mdc /path/to/your-app/.cursor/rules/Ensure MCP Architector is connected. The agent must call
list-projectsand passprojectIdon every write β do not rely on omitting it.Ask in chat, for example: "Onboard this repo into architector β phase 0 plan first" or "Import architecture module by module".
The rule is alwaysApply: false β Cursor attaches it when the task matches architecture import/onboarding. It enforces: structure β one module per step β validate after each step β compact tools only.
If you develop this server repo, keep the same file here so contributors and Cloud Agents follow the same workflow when updating ~/.mcp-architector/_qs_mcp-architector/.
Overview
Store and manage project architecture, modules, scripts, data flow, and usage examples - all locally with complete privacy.
Features
Local Storage: All data stored in
~/.mcp-architector(privacy-first)Project Architecture: Store and retrieve overall project architecture
Module Details: Detailed information about each module
Resources: Access architecture data via resources
Storage Structure
~/.mcp-architector/
βββ {projectId}/
βββ architecture.json # Modules + dataFlow (vertical structure)
βββ modules/
β βββ {moduleId}.json
β βββ ...
βββ entries/
β βββ index.json # Catalog (no duplicate bodies)
β βββ {entryId}.json # Canonical facts (API, domain, flows, β¦)
βββ slices/
β βββ {sliceId}.json # Custom filters only (no items)Data model
Layer | Purpose | Tools |
Modules | Vertical structure: components, dependencies, dataFlow |
|
Entries | Single source of truth for horizontal facts (one fact = one file) |
|
Slices | Read-only views over entries (built-in or custom filters) |
|
Anti-patterns (no duplication): Do not copy module.description into entry.summary. Link with refs.moduleName. Slices never store item copiesβonly filters in slices/*.json.
Do not edit ~/.mcp-architector directly β always use MCP tools so timestamps, merge semantics, and dataFlow inverse sync stay consistent.
Agent workflow
list-projectsβ findprojectIdfor this workspace (query by folder name). Pass it to every other tool. Never omit. Never usedefault-project.Structure task β
get-project-architecture/set-project-architecture.Each module β
set-module-detailswithfiles+facts[](endpoints, entities, glossary) in the same call, orset-entries/set-entrywithrefs.moduleName.Single module graph edge β
set-module-data-flow.Bulk rebuild flow (many modules) β
rebuild-data-flow.After edits, verify everything β
validate(summary +issues[]; no full project load).Need a category (all APIs, all domain terms) β
list-slicesβget-slicewithformat=compactortable; useoffsetwhenhasMoreis true.Find by name β
search-entriesβget-entryfor full payload.After code refactor (same modules) β
refactor-architecture:scanβ dryRun preview β apply withconfirm=true.
Scenario | Tool |
Update one module + its APIs/facts |
|
Bulk facts for a domain |
|
Patch dataFlow for one module |
|
Rebuild all module edges |
|
Diagnose graph + empty slices |
|
Catalog JSON corrupt (extra data after JSON) |
|
Sync paths/names after refactor |
|
Index out of sync |
|
Create project from scratch |
|
Onboard a fresh git clone (phased) | Copy |
Full project picture: modules alone do not populate slices β without http-endpoint (and other kinds) entries, slice api stays empty. New module β add facts or entries in the same step.
Example: set-module-details with facts: [{ kind: "http-endpoint", title: "POST /orders", ... }], then get-slice sliceId=api format=table.
Quick Start
For Users (using npm package)
# No installation needed - use directly in Cursor/Claude Desktop
# Just configure it as described in Integration section belowFor Developers
Clone the repository:
git clone https://github.com/theSharque/mcp-architect.git
cd mcp-architectInstall dependencies:
npm installBuild the project:
npm run buildUsage
Development Mode
Run with hot reload:
npm run devProduction Mode
Start the server:
npm startMCP Inspector
Debug and test your server with the MCP Inspector:
npm run inspectorIntegration
Cursor IDE
Open Cursor Settings β Features β Model Context Protocol
Click "Edit Config" button
Add one of the configurations below
Option 1: Via npm (Recommended)
Installs from npm registry automatically:
{
"mcpServers": {
"architector": {
"command": "npx",
"args": ["-y", "mcp-architector"],
"env": {
"MCP_PROJECT_ID": "${workspaceFolder}"
}
}
}
}Option 2: Via npm link (Development)
For local development with live changes:
{
"mcpServers": {
"architector": {
"command": "mcp-architector",
"env": {
"MCP_PROJECT_ID": "${workspaceFolder}"
}
}
}
}Requires: cd /path/to/mcp-architector && npm link -g
Option 3: Direct path
{
"mcpServers": {
"architector": {
"command": "node",
"args": ["/path/to/mcp-architector/dist/index.js"],
"env": {
"MCP_PROJECT_ID": "${workspaceFolder}"
}
}
}
}Claude Desktop
Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"architector": {
"command": "npx",
"args": ["-y", "mcp-architector"],
"env": {
"MCP_PROJECT_ID": "${workspaceFolder}"
}
}
}
}Continue.dev
Edit .continue/config.json:
{
"mcpServers": {
"architector": {
"command": "npx",
"args": ["-y", "mcp-architector"],
"env": {
"MCP_PROJECT_ID": "${workspaceFolder}"
}
}
}
}Using Project ID
projectId is required on every tool except list-projects. There is no default dump project.
Call
list-projectsfirst (optionally withquery= workspace folder name)Pass the matching
projectIdto every other toolIf none matches, create one with
set-project-architectureusing a stable id from the workspace path (e.g._qs_my-app)
MCP_PROJECT_ID is only a hint (isCurrent / suggestedProjectId). It is not used as a silent write target. default-project and unsubstituted ${workspaceFolder} ids are forbidden.
Tools
set-project-architecture
Creates or updates the overall architecture for a project. By default merges modules and dataFlow by name; omit dataFlow to preserve existing flow. dependsOn is canonical; providesTo is recomputed on save.
Input:
projectId(required): Project ID fromlist-projects. Never omit.default-projectis forbidden.description: Overall project descriptionmodules: Array of module objects with:name: Module namedescription: Brief description of the moduleinputs(optional): What this module requires to workoutputs(optional): What this module produces or generates
dataFlow(optional): Object describing data flow between modules (omit to keep existing):Key: module name
Value: object with:
dependsOn(optional): Array of module names this module depends onprovidesTo(optional): Derived on save from alldependsOnedgesdataTransformation(optional): How data is transformed between modules
replaceModules(optional): Replace entire modules list (defaultfalse= merge by name)replaceDataFlow(optional): Replace entire dataFlow (defaultfalse= merge by module name)
Output:
Project ID and success message
get-project-architecture
Retrieves the overall architecture of the project.
Input:
projectId(required): Project ID fromlist-projects. Never omit.default-projectis forbidden.
Output:
Complete project architecture
list-projects
Lists all projects in local storage (~/.mcp-architector). Call this first. Match the current workspace by folder name, then pass projectId to every other tool.
Input:
query(optional): Filter by substring in projectId or description (case-insensitive)
Output:
projects[]:projectId,description,moduleCount,updatedAt,isCurrent(hint fromMCP_PROJECT_ID),forbidden(default-projectand unsubstituted workspaceFolder dumps)suggestedProjectId: currentMCP_PROJECT_IDwhen it is a valid id, elsenullreminder: always passprojectId; never usedefault-project
Entries and slices
Tool | Purpose |
| Upsert one fact; response may include |
| Bulk upsert (max 200); optional |
| Full entry by |
| Remove entry |
| Catalog without payload; filter by |
| Compact text search with |
| Built-in + custom slices with entry counts |
| Filtered view: |
| Save custom filter ( |
| Remove custom slice |
| Rebuild |
| Repair leftover/corrupt catalog JSON; rebuild index |
Built-in sliceId values: api, persistence, events, domain, flows, integrations, config, runtime, decisions, scripts.
search-entries
Compact navigation searchβreturns enough context to pick a hit, then call get-entry for full payload.
Input: query (required), moduleName, kind, tags, limit (default 10, max 50), offset (default 0)
Output: summary, total, returned, offset, hasMore, results[] with snippet, matchedIn, slices, moduleName plus legacy summary, tags, refs
Recommended kind examples (any string allowed):
sliceId | kinds |
api |
|
persistence |
|
domain |
|
scripts |
|
set-module-details
Creates or updates detailed information about a module. Slices read entries, not module text β pass facts[] to create linked entries in one call.
Input:
projectId(required): Project ID fromlist-projectsname: Module namedescription: Detailed description of the moduleinputs: What the module accepts as inputoutputs: What the module produces as outputdependencies(optional): List of module dependencies (syncs todataFlow.dependsOnwhen provided)files(optional): List of files belonging to this modulefacts(optional): Array of horizontal facts (kind,title,summary, β¦) β each upserted as entry withrefs.moduleName= module nameusageExamples(optional): Array of usage examples with fields:title: Example titledescription(optional): Description of the examplecommand(optional): Command or code snippetinput(optional): Input dataoutput(optional): Expected outputnotes(optional): Additional notes about the example
notes(optional): Additional notes
Output:
Module ID and success message
set-module-data-flow
Patches dataFlow for a single module without sending the full architecture.
Input:
projectId(required): Project ID fromlist-projectsmoduleName: Module namedependsOn(optional): Modules this module depends on (canonical)dataTransformation(optional): How data is transformedsyncInverse(optional): RecomputeprovidesTo(defaulttrue)
Output:
Module name and success message
rebuild-data-flow
Rebuilds dataFlow for all modules from module file dependencies or existing dependsOn edges. Replaces bulk manual edits to architecture.json.
Input:
projectId(required): Project ID fromlist-projectssource(optional):module-dependencies(default) ordataFlow-dependsOnsyncInverse(optional): RecomputeprovidesTo(defaulttrue)pruneOrphans(optional): Remove invalid module references (defaulttrue)
Output:
edgesAdded,edgesRemoved,modulesUpdated, message
validate
Primary post-edit check. Read-only validation with a compact agent-friendly report. Does not modify data.
Checks (only rules we can verify from stored JSON):
dataFlow: inverse drift, dangling
dependsOn/providesTo, orphan flow keysmodule.dependenciesvsdataFlow.dependsOnentries:
entries-without-modules,entry-unlinked,orphan-entry-module,module-no-entries,module-missing-api/module-missing-persistence,entry-slice-orphan,module-too-many-entries,module-too-few-entriesstorage: missing
modules/{id}.json, orphan module files, entry index driftslices: empty built-in
api/domain/persistencewhen modules exist
Input: projectId, checkInverse, checkModuleDeps, checkEntryCoverage, checkStorage, checkEmptySlices, checkSliceCoverage, checkModuleEntryCounts, moduleEntryMax (default 50), moduleEntryMin (optional; omit to disable min check) β all boolean flags default true unless noted
Output: valid, issueCount, summary, stats, issuesByKind, issues[], coverage, checksRun
fix-data
Run when catalog JSON is corrupt (for example list-modules / validate fail with extra data after JSON). Trims leftover bytes after the first valid JSON object in architecture.json, modules/, entries/, and slices/; removes leftover .tmp files; rebuilds the entry index. Does not delete facts. Catalog writes use temp+rename so this leftover cannot recur.
Input: projectId, dryRun (optional, default false)
Output: summary, scanned, repaired, unreadable, tmpRemoved, indexItemCount, files[] (repaired/unreadable only)
refactor-architecture
Preview or apply in-architector sync after a code refactor when module boundaries stay the same. Agent is the source of truth β no workspace or git access. Default dryRun=true.
Workflow: (1) scan with file or text β compact hits, (2) build mutation ops, (3) dryRun preview, (4) apply with dryRun=false and confirm=true.
Operations (max 10 per call): scan, move-file, replace-path-prefix, rename-text, patch-entry, merge-files, remove-file-ref.
Scope (optional): moduleName, kinds, tags β limits which entries/modules are touched.
Orphan entries with empty refs.files and no refs.entryIds are deleted after file operations.
Input: projectId, operations[], scope, dryRun (default true), confirm (required when applying), limit, offset
Output: summary, stats, hits (scan) or paginated changes, warnings, hasMore
validate-architecture
Same as validate (legacy alias). Prefer validate after edits.
Output:
valid(boolean),issuesarray
get-module-details
Retrieves detailed information about a specific module.
Input:
projectId(required): Project ID fromlist-projectsmoduleName: Name of the module to retrieve
Output:
Complete module details
list-modules
Lists all modules in the project architecture.
Input:
projectId(required): Project ID fromlist-projects
Output:
Array of module summaries
delete-module
Deletes a module from the project architecture.
Input:
projectId(required): Project ID fromlist-projectsmoduleName: Name of the module to delete
Output:
Success message
Resources
architecture
Provides access to project architecture as a resource.
Usage:
Access via URI: arch://{projectId}
module
Provides access to module details as a resource.
Usage:
Access via URI: module://{projectId}/{moduleId}
Development
Project Structure
mcp-architector/
βββ src/
β βββ index.ts # Main server implementation
β βββ types.ts # Type definitions
β βββ storage.ts # Storage utilities
βββ dist/ # Compiled output (generated)
βββ package.json
βββ tsconfig.json
βββ README.mdProject ID
The server stores each project in ~/.mcp-architector/{projectId}/. projectId must be passed explicitly on every tool except list-projects.
Call
list-projects(withquery= workspace folder name) to find the idMCP_PROJECT_IDis only a listing hint (isCurrent/suggestedProjectId), not a silent write targetdefault-projectand unsubstituted${workspaceFolder}ids are forbidden
To start a new project, pass a stable id derived from the workspace path (e.g. _qs_my-app) to set-project-architecture.
Extending the Server
To add new tools, resources, or prompts, edit src/index.ts:
// Add a tool
server.registerTool(
"tool-name",
{ /* tool config */ },
async (params) => { /* handler */ }
);
// Add a resource
server.registerResource(
"resource-name",
new ResourceTemplate("uri-template", { /* options */ }),
{ /* resource config */ },
async (uri, params) => { /* handler */ }
);
// Add a prompt
server.registerPrompt(
"prompt-name",
{ /* prompt config */ },
(args) => { /* handler */ }
);License
MIT
Available Tools
28 toolsdelete-entriesDelete EntriesA
Bulk delete entries matching kind/moduleName/tags filter. Requires confirm=true. Use before full re-import or to clear a module slice. Prefer replace-entries with deleteOrphans for idempotent sync.
Inputs: confirm (required), projectId, kind, kinds, +2 more. Returns: deleted, message
delete-entryDelete EntryA
Removes one entry and updates the index. Use when a fact is obsolete. Do not use to delete modulesβuse delete-module. Cannot delete slice definitionsβuse delete-slice.
Inputs: id (required), projectId. Returns: message
delete-moduleDelete ModuleA
Deletes one module from architecture and its module detail file. Does not delete entriesβremove those with delete-entry if needed. Does not delete custom slices.
Inputs: moduleName (required), projectId. Returns: message
delete-sliceDelete SliceA
Deletes a custom slice definition only. Built-in slices (api, domain, β¦) cannot be deleted. Does not delete entriesβuse delete-entry.
Inputs: sliceId (required), projectId. Returns: message
get-entryGet EntryA
Returns one full entry by id. Use after list-entries or search-entries when you need payload and refs. Do not use for a full API listβuse get-slice sliceId=api. Do not use for module structureβuse get-module-details.
Inputs: id (required), projectId. Returns: entry
get-import-statsGet Import StatsA
Returns entry counts grouped by kind, module, and tag. Use after replace-entries/import to verify catalog size.
Inputs: projectId. Returns: byKind, byModule, byTag, total
get-module-detailsGet Module DetailsA
Returns one module's full detail (files, dependencies, examples). Use when you know the module name from get-project-architecture or list-modules. If module has files but get-slice is empty, add entries with refs.moduleName=this module. For cross-cutting API/domain lists use get-slice. moduleName must match architecture exactly.
Inputs: moduleName (required), projectId. Returns: module
get-project-architectureGet Project ArchitectureA
Returns vertical structure: project description, module list, dataFlow. Use for refactoring boundaries between components. For all HTTP endpoints or domain terms use get-sliceβnot this tool. For one module's files and examples use get-module-details. projectId from list-projects if unsure.
Inputs: projectId. Returns: architecture
get-sliceGet SliceA
Returns a horizontal project view: filtered entries transformed for agents. Empty slice = no entries with matching kind. Call list-slices first to pick sliceId. format=compact default; table for api/ui slice. Use offset/limit for pagination. Filter further by moduleName or tags.
Inputs: sliceId (required), projectId, moduleName, tags, +5 more. Returns: slice
import-entriesImport EntriesA
Max 50 entries per bulk callβsplit large catalogs into batches of ~50 to avoid oversized tool payloads. For full re-import: delete-entries once, then set-entries in 50-entry chunks; or replace-entries with deleteOrphans=false until the final batch (deleteOrphans=true). Alias for replace-entries (mode=replace). Pass filter as scope; send up to 50 entries per call.
Inputs: mode (required), filter (required), entries (required), projectId, +3 more. Returns: created, updated, deleted, entryIds, +1 more
list-entriesList EntriesA
Returns the entry catalog (id, kind, title, tags, moduleName)βno payload. Supports kind/moduleName/tags filters and pagination (limit max 200). Unlinked entries lack moduleName; run validate after edits. For typed horizontal views use get-slice.
Inputs: projectId, kind, moduleName, tags, +3 more. Returns: entries, total, returned, offset, +1 more
list-modulesList All ModulesA
Lists module summaries from architecture (name, description)βvertical structure only. For horizontal facts (endpoints, tables, terms) use list-slices then get-slice. After edits run validate. Use module names in set-entry refs.moduleName.
Inputs: projectId. Returns: modules
list-projectsList ProjectsA
Lists all projects in ~/.mcp-architector with projectId, description, moduleCount, updatedAt, isCurrent. Call first when tools return empty/wrong projectβthe workspace path may normalize to a different id (e.g. _qs_my-app). Then pass projectId to other tools. Optional query filters by id or description.
Inputs: query. Returns: projects
list-slicesList SlicesA
Lists built-in and custom slice views (filters over entriesβnot separate stored data). Empty slice = no entries with matching kind, not a missing slice definition. Use before get-slice to pick sliceId (api, domain, persistence, β¦).
Inputs: projectId. Returns: slices
rebuild-data-flowRebuild Data FlowB
Rebuilds dataFlow for all modules from module file dependencies or existing dependsOn edges. Recomputes providesTo and optionally syncs module files. Use instead of editing architecture.json directly.
Inputs: projectId, source, syncInverse, pruneOrphans. Returns: edgesAdded, edgesRemoved, modulesUpdated, message
rebuild-entry-indexRebuild Entry IndexA
Rebuilds entries/index.json from entry files on disk. Use when list-entries or get-slice miss entries that exist as files (index drift). Does not modify entry bodies.
Inputs: projectId. Returns: itemCount, message
refactor-architectureRefactor ArchitectureA
Preview or apply in-repo refactor sync to architector data (no workspace access). Default dryRun=true. Workflow: (1) scan with file/text to list hits, (2) build 1-3 mutation ops, (3) dryRun preview, (4) apply with dryRun=false and confirm=true. Mutations: move-file, replace-path-prefix, rename-text, patch-entry, merge-files, remove-file-ref. Orphan entries with empty refs.files and no entryIds are deleted. Does not change module names or dataFlow.
Inputs: operations (required), projectId, scope, dryRun, +3 more. Returns: dryRun, summary, stats, hits, +4 more
replace-entriesReplace EntriesA
Max 50 entries per bulk callβsplit large catalogs into batches of ~50 to avoid oversized tool payloads. For full re-import: delete-entries once, then set-entries in 50-entry chunks; or replace-entries with deleteOrphans=false until the final batch (deleteOrphans=true). Idempotent sync for up to 50 entries in scope; optionally delete orphans not in this batch. Match by upsertBy (default kind+title). For large catalogs use deleteOrphans=false on intermediate batches, true only on the last batch.
Inputs: scope (required), entries (required), projectId, moduleName, +2 more. Returns: created, updated, deleted, entryIds, +1 more
search-entriesSearch EntriesA
Compact navigation search over entries by title, summary, kind, and tags. Returns snippet, matchedIn, slices, and moduleName per hitβuse get-entry for full payload. Prefer get-slice when you know the category (api, domain). Filters (moduleName, kind, tags) narrow agent context. Default limit 10.
Inputs: query (required), projectId, moduleName, kind, +3 more. Returns: summary, total, returned, offset, +2 more
set-entriesSet EntriesA
Entries need vertical structure: create modules via set-project-architecture / set-module-details before or when adding entries. Set refs.moduleName to an existing module name from list-modules. Run validate after edits to find entries-without-modules, entry-unlinked, or empty slices. Max 50 entries per bulk callβsplit large catalogs into batches of ~50 to avoid oversized tool payloads. For full re-import: delete-entries once, then set-entries in 50-entry chunks; or replace-entries with deleteOrphans=false until the final batch (deleteOrphans=true). Set refs.moduleName per entry, or pass top-level moduleName as default. Prefer set-entries in 50-entry chunks over one huge replace-entries payload.
Inputs: entries (required), projectId, moduleName. Returns: entriesCreated, entriesUpdated, entryIds, message, +3 more
set-entrySet EntryA
Entries need vertical structure: create modules via set-project-architecture / set-module-details before or when adding entries. Set refs.moduleName to an existing module name from list-modules. Run validate after edits to find entries-without-modules, entry-unlinked, or empty slices. Creates or updates one canonical project fact (entry). Use when you discovered a concrete fact while working. Do not use for module structureβuse set-module-details. Do not copy module.description into summary; link via refs.moduleName only. Upsert: pass id to update, or omit id to match by kind+title or create new. Example: kind=http-endpoint, title='POST /orders', summary='Creates order', refs.moduleName='orders', refs.files=['src/OrderController.java'].
Inputs: kind (required), title (required), summary (required), projectId, +4 more. Returns: entryId, message, reminder, warning, +1 more
set-module-data-flowSet Module Data FlowA
Patches dataFlow for one module (dependsOn is canonical; providesTo is recomputed). Syncs module file dependencies. Prefer over set-project-architecture for single-module graph edits.
Inputs: moduleName (required), projectId, dependsOn, dataTransformation, +1 more. Returns: moduleName, message
set-module-detailsSet Module DetailsA
Creates or updates one vertical module (files, dependencies, dataFlow sync). IMPORTANT: Slices (api, domain, persistence) are built from entries, not from module text. When adding or updating a module, also add entries this module owns: pass facts[] (http-endpoint, entity, glossary, β¦) in this call (max 50 per call), or call set-entry / set-entries in 50-entry batches with refs.moduleName=. Max 50 entries per bulk callβsplit large catalogs into batches of ~50 to avoid oversized tool payloads. For full re-import: delete-entries once, then set-entries in 50-entry chunks; or replace-entries with deleteOrphans=false until the final batch (deleteOrphans=true). Without entries, get-slice will be empty for this module. After edits call validate to verify links. Does not replace other modules. Prefer over set-project-architecture for single-module edits.
Inputs: name (required), description (required), inputs (required), outputs (required), +6 more. Returns: moduleId, message, entriesCreated, entriesUpdated, +3 more
set-project-architectureSet Project ArchitectureA
Creates or updates vertical module structure (components and dataFlow)βnot horizontal facts. By default merges modules and dataFlow by name; omit dataFlow to keep existing flow. Use replaceModules or replaceDataFlow for full replace. For one module use set-module-details or set-module-data-flow. For bulk flow rebuild use rebuild-data-flow. Each new module still needs entriesβuse set-module-details with facts[] or set-entries after bulk structure. For APIs, domain terms, scripts use set-entry + get-sliceβnot this tool. If projectId is wrong, call list-projects first. Do not duplicate entry text in module descriptions.
Inputs: description (required), modules (required), projectId, dataFlow, +2 more. Returns: projectId, message
set-sliceSet SliceA
Saves a custom slice definition (filter onlyβno items). Items always live in entries. Use when built-in slices (api, domain, β¦) are not enough, e.g. filter kinds godot-scene + tag gameplay. Do not store duplicate entry text here. get-slice reads entries through this filter.
Inputs: id (required), title (required), projectId, description, +2 more. Returns: sliceId, message
validateValidate ProjectA
Run after set-project-architecture, set-module-details, set-entry, or set-entries. Returns a compact report (summary, stats, issues by kind)βno need to load the full project in the agent. Checks only known rules: dataFlow consistency, moduleβentry links, module detail files, entry index drift, empty api/domain/persistence slices, entry slice coverage, optional module-too-few-entries when moduleEntryMin is set. Fix issues[] then call validate again.
Inputs: projectId, checkInverse, checkModuleDeps, checkEntryCoverage, +5 more. Returns: projectId, valid, issueCount, summary, +5 more
validate-architectureValidate ArchitectureA
Alias for validate with the same checks. Prefer validate after edits. Legacy name kept for compatibility.
Inputs: projectId, checkInverse, checkModuleDeps, checkEntryCoverage, +5 more. Returns: projectId, valid, issueCount, summary, +5 more
validate-importValidate ImportA
Dry-run validation for a proposed import batch (max 50 entries). Max 50 entries per bulk callβsplit large catalogs into batches of ~50 to avoid oversized tool payloads. For full re-import: delete-entries once, then set-entries in 50-entry chunks; or replace-entries with deleteOrphans=false until the final batch (deleteOrphans=true). Checks duplicate upsert keys and unknown moduleName refs without writing.
Inputs: entries (required), projectId, upsertBy, checkDuplicates, +1 more. Returns: valid, warningCount, warnings
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelogβ¦
TDQS
Scored across 28 tools
Tools are well-described with distinct purposes, but the large number of entry manipulation tools (set-entry, set-entries, replace-entries, import-entries, delete-entry, delete-entries) could lead to confusion. However, descriptions clearly specify when to use each, making disambiguation possible with careful reading.
All tools use a consistent verb_noun pattern in snake_case (e.g., list-entries, set-module-details, delete-slice). Related operations share prefixes (set-*, delete-*, list-*, get-*, validate-*), making the API predictable and easy to navigate.
With 28 tools, the count is high but justified by the complexity of the domain (managing entries, modules, slices, projects, imports, validation, and bulk operations). Some redundancy (e.g., import-entries as alias for replace-entries) could be trimmed, but overall the tool set is well-scoped for a comprehensive architecture management server.
The tool set covers all essential operations: CRUD for entries, modules, slices, and projects; listing, searching, validation, bulk imports, data flow management, and refactoring. No obvious gaps are apparent; even edge cases like index drift and slice definition are addressed.
Maintenance
Related MCP Connectors
A MCP server built for developers enabling Git based project management with project and personalβ¦
Private-by-default, local-first memory/context/task orchestrator for MCP apps and agents.
Personal MCP server for humans who create. Proof of authorship, license control.
One MCP server for all your MCP servers: code mode, per-tool permissions, approvals and audit.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceA local MCP server providing persistent memory for AI coding assistants by storing and searching architectural decisions, patterns, and solutions. It also includes tools for git automation and mapping codebase expertise based on project history.MIT
- AlicenseBqualityDmaintenanceA local-first MCP server that provides AI agents with safe codebase access through file discovery, hybrid lexical-semantic search, and project introspection. It features durable local memory and semantic indexing while keeping all data and processing entirely on your local machine.7427 npm6MIT
- AlicenseNot gradedqualityDmaintenanceMCP server that provides persistent memory and contextual awareness to language models, enabling project onboarding, recall of architectural rules, and code consistency across sessions.32MIT
- FlicenseAqualityDmaintenanceA local-first MCP server providing secure workspace file operations, offline full-text search, and web search/fetch capabilities without requiring API keys.10-