How do I use mcp-kb-server?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@mcp-kb-server remember that the API key is stored in .env" 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-kb-server

by dereknguyen269

Overview Schema Source Related Servers Discussions Admin

JavaScript

Local

MCP Knowledge Base Server

A Model Context Protocol (MCP) server providing persistent memory, knowledge base, and project summary capabilities with automatic project detection and an interactive dashboard.

How It Works

┌──────────────────────────────────────────────────────────────┐
│                   AI Assistant (Kiro, Claude, etc.)          │
│                                                              │
│  "Remember we use JWT"    "What do I know about auth?"       │
│  "Init KB from my docs"   "What changed since last summary?" │
└──────────────┬───────────────────────────┬───────────────────┘
               │ MCP Protocol (stdio)      │
               ▼                           ▼
┌──────────────────────────────────────────────────────────────┐
│                    mcp-kb-server                             │
│                                                              │
│  ┌─────────┐ ┌──────────┐ ┌─────────┐ ┌──────────┐          │
│  │ memory  │ │    kb    │ │ summary │ │dashboard │          │
│  │ .store  │ │ .add     │ │.project │ │.projects │          │
│  │ .search │ │ .search  │ │ .delta  │ └──────────┘          │
│  │ .list   │ │ .init ★  │ └─────────┘                       │
│  │ .delete │ └──────────┘                                    │
│  │ .update │   Auto-detect project_id from project_root      │
│  └─────────┘   package.json → git remote → directory name   │
│                                                              │
│  ┌────────────────────┐  ┌─────────────────────┐            │
│  │  memory.sqlite     │  │  kb.sqlite           │            │
│  │  + memory_fts(FTS5)│  │  + kb_fts (FTS5)     │            │
│  │  + wiki_links      │  │  + kb_meta (scoping) │            │
│  │  + expires/TTL     │  │  + sources + fts     │            │
│  └────────────────────┘  └─────────────────────┘            │
└──────────────────────────────────────────────────────────────┘

Related MCP server: Lspace MCP Server

Workflow Diagrams

1. Request Flow

Every tool call follows the same path from AI to database and back.

AI Assistant
    │
    │  JSON-RPC 2.0 over stdio
    ▼
server.js
    │
    ├─ Joi validation ──── invalid ──► error -32602
    │
    ├─ project_id resolution
    │     project_root provided?
    │     ├─ yes → detectProjectId()
    │     │         ├─ package.json name
    │     │         ├─ git remote URL
    │     │         └─ directory basename
    │     └─ no  → use explicit project_id
    │
    ├─ LRU query cache (read-only tools)
    │     hit  ──────────────────────► return cached result
    │     miss ─┐
    │           ▼
    ├─ tool handler (memory / kb / sources / wiki / summary)
    │           │
    │           ▼
    │     better-sqlite3 (synchronous)
    │     memory.sqlite  ──  kb.sqlite
    │           │
    │           ▼
    │     cache invalidated (on mutations)
    │
    └─ JSON-RPC result ──────────────► AI Assistant

2. Project Initialization (`kb.init`)

Run once when starting work on a project to populate the KB from existing docs.

Developer / AI
    │
    │  kb.init({ project_root: "/path/to/project" })
    ▼
Resolve project_id
    │  package.json → git remote → directory name
    ▼
Expand glob patterns
    │  default: ["**/*.md", "**/*.txt"]
    │  skip:    node_modules / .git / dist / build
    ▼
For each file
    ├─ already in KB? (matched by source path)
    │   └─ yes + overwrite=false → skip
    │
    ├─ read file content
    │   └─ binary or empty → skip
    │
    └─ extract title
        ├─ first "# Heading" in content
        └─ fallback: filename without extension
    ▼
Bulk INSERT (single SQLite transaction)
    │  kb_fts  ← title, content, source
    │  kb_meta ← rowid, project_id
    ▼
Return { scanned, added, skipped, added_titles }

3. Memory Lifecycle

                    ┌─────────────────────────────┐
                    │         AI Assistant         │
                    └──┬──────────┬───────────┬───┘
                       │          │           │
                  store/update  search      delete
                       │          │           │
                       ▼          ▼           ▼
              ┌────────────────────────────────────┐
              │           memory.sqlite             │
              │                                     │
              │  memory table                       │
              │  ┌──────────────────────────────┐   │
              │  │ id · project_id · scope      │   │
              │  │ content · tags · created_at  │   │
              │  │ updated_at · expires_at      │   │
              │  └──────────────────────────────┘   │
              │           │ FTS5 sync                │
              │  memory_fts (BM25 ranked search)     │
              │                                     │
              │  wiki_links (cross-references)       │
              └────────────────────────────────────┘
                       │
                  TTL purge
                  (auto on access, max 1×/60s/project)
                       │
                       ▼
              expired entries removed

4. Knowledge Base Flow

                 ┌──────────────────────────────────┐
                 │           Input sources           │
                 │                                   │
                 │  kb.init        kb.add            │
                 │  (bulk scan)    (single doc)      │
                 │  Dashboard      Dashboard          │
                 │  Import         New Document       │
                 └──────────┬───────────┬────────────┘
                            │           │
                            ▼           ▼
                 ┌──────────────────────────────────┐
                 │           kb.sqlite               │
                 │                                   │
                 │  kb_fts ── title, content, source │
                 │  kb_meta ─ rowid → project_id     │
                 └──────────────────────────────────┘
                            │
              ┌─────────────┼──────────────┐
              │             │              │
         kb.search    dashboard       wiki.link
         (FTS5/BM25   (split-panel    (cross-ref
          + Qdrant     list+detail)    to memory
          optional)                    or source)
              │
              ▼
         AI Assistant

5. Summary & Delta Flow

summary.project                        summary.delta
──────────────                         ─────────────

project_root                           project_root
    │                                      │
    ├─ auto-discover files                 ├─ run summary.project
    │   README, ARCHITECTURE,              │   (current snapshot)
    │   .kiro/resources/*.md, etc.         │
    │                                      ├─ search memory for
    ├─ memory.search (recent)              │   last "project-summary"
    │                                      │   scope entry
    ├─ kb.search (relevant docs)           │
    │                                      └─ diff current vs stored
    ▼                                          │
combined snapshot text                         ▼
    │                                  changed files / new memories /
    │  (AI stores result via            updated docs highlighted
    │   memory.store scope=
    │   "project-summary")
    ▼
searchable baseline for next delta

6. Dashboard Architecture

Browser                    HTTP Server (Node.js)           SQLite
  │                              │                            │
  │  GET /                       │                            │
  │ ─────────────────────────►   │                            │
  │  ◄── HTML (self-contained) ──│                            │
  │                              │                            │
  │  GET /api/projects           │  SELECT project_id,        │
  │ ─────────────────────────►   │  COUNT(*) FROM memory  ──► │
  │  ◄── [{ project_id, total }] │  ◄─────────────────────── │
  │                              │                            │
  │  GET /api/kb                 │  SELECT kb_fts JOIN        │
  │  ?project_id=x&limit=30      │  kb_meta WHERE             │
  │ ─────────────────────────►   │  project_id=x          ──► │
  │  ◄── { items, total }        │  ◄────────────────────── │
  │                              │                            │
  │  (click item)                │                            │
  │  GET /api/kb/:id         ──► │  SELECT * FROM kb_fts  ──► │
  │  ◄── { title, content, … }   │  ◄─────────────────────── │
  │                              │                            │
  │  GET /api/export/kb          │  SELECT all docs for       │
  │  ?project_id=x           ──► │  project → render .md  ──► │
  │  ◄── kb-x-2026-04-12.md      │  ◄─────────────────────── │
  │                              │                            │
  │  POST /api/kb/import         │  bulk INSERT kb_fts        │
  │  { project_id, docs[] }  ──► │  + kb_meta (transaction)──►│
  │  ◄── { ok, count }           │  ◄─────────────────────── │

7. Wiki Links & Lint

Entries (any type)
  memory ──┐
  kb     ──┼──► wiki.link ──► wiki_links table
  source ──┘                  (source_id, source_type,
                               target_id, target_type,
                               relation, project_id)
                                    │
                    ┌───────────────┼───────────────┐
                    │               │               │
               wiki.links      wiki.lint       wiki.export
               (lookup by      (health check)  (dump to .md)
                entry_id)           │
                    │          ┌────┴────────────────┐
                    │          │ orphan_memory        │
                    │          │ (no links at all)    │
                    │          │                      │
                    │          │ broken_links         │
                    │          │ (source or target    │
                    │          │  no longer exists)   │
                    │          │                      │
                    │          │ stale_sources        │
                    │          │ (90+ days, no links) │
                    │          └──────────────────────┘
                    ▼
             { outbound[], inbound[] }

Features

🧠 Memory Management

Long-term Memory: Store, search, list, update, and delete project-specific memory entries
Full-Text Search: FTS5 with BM25 ranking via use_fts flag, plus substring fallback
Tag Filtering: Filter memories by tag name, combine with text queries
Pagination: memory.list with total_count, offset, has_more
TTL / Expiry: Optional expires_at on entries, auto-purged on access
Project Isolation: Complete data isolation between projects

📚 Knowledge Base

Document Storage: Add and search documents with FTS5 full-text search
Project Scoping: project_id on all KB operations isolates docs per project
Bulk Init: kb.init scans a project directory and imports all .md/.txt files in one call
Vector Search: Optional Qdrant integration for semantic search
Source Tracking: Track document sources and metadata

📂 Sources Layer

Raw Ingest: Ingest .md, .txt, .csv, .pdf files via source.ingest
FTS Search: Full-text search across ingested source content
Project Isolation: Sources scoped per project

🔗 Wiki Links & Lint

Cross-references: wiki.link creates typed links between memory/KB/source entries
Link Lookup: wiki.links returns inbound and outbound links for any entry
Health Check: wiki.lint detects orphan entries, broken links, and stale sources
Export: wiki.export dumps all data as markdown files to a directory

📊 Project Summaries

Snapshot Generation: summary.project reads files + memory + KB into a single snapshot
Delta Summaries: summary.delta compares current state vs. last summary
Auto-Discovery: Finds instruction files (README, ARCHITECTURE, .kiro/resources/*.md, etc.)

🎨 Interactive Dashboard

Split-panel UI: KB, Memory, and Sources tabs show a paginated list on the left and a detail view on the right — no more infinite scroll dumps
Load More: All lists paginate in batches of 30
Project Management: Create and delete projects directly from the UI
KB Management: Add, edit, delete, import (JSON/.md), and export KB documents as Markdown
Memory Management: View and delete individual memory entries; export all as Markdown
Sources Viewer: Browse and preview ingested source files inline
Dark / Light mode, responsive layout, markdown rendering

🔒 Safety

Path validation, mismatch detection, XSS protection, parameterized SQL

Installation

npm install -g mcp-kb-server

Or use directly with npx:

npx mcp-kb-server

Usage

Configure MCP Client

{
  "mcpServers": {
    "kb-server": {
      "command": "npx",
      "args": ["mcp-kb-server"],
      "env": {}
    }
  }
}

With a custom data directory:

{
  "mcpServers": {
    "kb-server": {
      "command": "npx",
      "args": ["mcp-kb-server"],
      "env": {
        "DATA_DIR": "/path/to/your/data",
        "DASHBOARD_PORT": "4242"
      }
    }
  }
}

Available Tools

Memory Tools

All memory tools require either project_root (recommended) or project_id.

memory.store

{
  "project_root": "/path/to/project",
  "content": "We use JWT for auth — stateless, works with mobile",
  "scope": "decisions",
  "tags": ["auth", "jwt", "architecture"],
  "expires_at": "2027-01-01T00:00:00Z"
}

memory.search

{
  "project_root": "/path/to/project",
  "query": "authentication",
  "tag": "decision",
  "use_fts": true,
  "limit": 10
}

memory.list

{
  "project_root": "/path/to/project",
  "limit": 50,
  "offset": 0,
  "scope": "decisions"
}

Returns { total_count, offset, limit, has_more, entries }.

memory.update

{
  "project_root": "/path/to/project",
  "id": "uuid",
  "content": "Updated content",
  "tags": ["updated", "auth"],
  "expires_at": ""
}

memory.delete

{
  "project_root": "/path/to/project",
  "id": "uuid"
}

Knowledge Base Tools

kb.add

{
  "title": "API Reference",
  "content": "## Endpoints\n...",
  "source": "docs/api.md",
  "project_id": "my-project"
}

kb.search

{
  "query": "authentication",
  "project_id": "my-project",
  "limit": 5
}

kb.init ★ — Scan a project and bulk-import all docs into the KB

{
  "project_root": "/path/to/project",
  "patterns": ["**/*.md", "docs/**/*.txt"],
  "overwrite": false
}

Returns:

{
  "project_id": "my-project",
  "scanned": 42,
  "added": 38,
  "skipped": 4,
  "added_titles": ["Getting Started", "API Reference", "..."],
  "skipped_paths": ["CHANGELOG.md (empty or binary)", "..."]
}

Auto-detects project_id from project_root
Default patterns: ["**/*.md", "**/*.txt"]
Skips node_modules, .git, dist, build automatically
Uses first # Heading as title, falls back to filename
Skips already-imported files unless overwrite: true
Bulk-inserts in a single SQLite transaction

Source Tools

source.ingest — Ingest a raw file (md, txt, csv, pdf)

{
  "project_root": "/path/to/project",
  "filename": "spec.md",
  "content": "...",
  "file_type": "md"
}

source.list / source.search

{
  "project_root": "/path/to/project",
  "query": "authentication",
  "limit": 20,
  "offset": 0
}

Wiki Tools

wiki.link — Create a typed link between two entries

{
  "project_root": "/path/to/project",
  "source_id": "mem-uuid",
  "source_type": "memory",
  "target_id": "kb-rowid",
  "target_type": "kb",
  "relation": "implements"
}

wiki.links — Look up all links for an entry

{
  "project_root": "/path/to/project",
  "entry_id": "mem-uuid"
}

wiki.lint — Health check

{ "project_root": "/path/to/project" }

Returns { orphan_memory, broken_links, stale_sources, summary }.

wiki.export — Export everything as markdown files

{
  "project_root": "/path/to/project",
  "output_dir": "./wiki-export"
}

Summary Tools

summary.project

{
  "project_root": "/path/to/project",
  "auto_discover": true,
  "include_memory": true,
  "include_kb": true
}

summary.delta

{
  "project_root": "/path/to/project",
  "auto_discover": true
}

Dashboard Tool

dashboard.projects — Start the dashboard server and return the URL

{ "limit": 10 }

Returns { dashboard_url, file_path }. Open the URL in a browser.

Set DASHBOARD_PORT=4242 in env to auto-start on server boot.

Dashboard

The dashboard is a self-contained HTML app served locally.

KB Tab

Left panel: paginated document list (30/page) with search
Right panel: full document view with Edit / Delete actions
Toolbar: New Document, Import (JSON or .md), Export as Markdown

Memory Tab

Left panel: paginated entry list showing scope + preview
Right panel: full markdown content with Delete button
Header: Export all entries as Markdown

Sources Tab

Left panel: paginated file list with search
Right panel: inline file content preview (no modal)

Links / Lint Tabs

Links: look up cross-references by entry ID
Lint: detect orphans, broken links, stale sources

Project Management

Project selector in topbar — switches all tabs
"+" button to create a new project
"Delete Project" button to wipe all data for the current project

Import Format (JSON)

[
  { "title": "Getting Started", "content": "## Overview\n...", "source": "docs/intro.md" },
  { "title": "API Reference",   "content": "## Endpoints\n..." }
]

Export Format (Markdown)

KB export (kb-{project}-{date}.md):

# Knowledge Base — my-project

> Exported 2026-04-12T... · 38 documents

---

## Getting Started

**Source:** docs/intro.md
**ID:** 1

## Overview
...

Memory export (memory-{project}-{date}.md):

# Memory — my-project

> Exported 2026-04-12T... · 12 entries

---

### [decisions] uuid-here

**Tags:** auth, jwt
**Created:** 2026-03-01T...

We use JWT for auth — stateless, works with mobile.

Automatic Project Detection

project_id is auto-detected from project_root in this order:

package.json name field
Git remote origin URL (repo name)
Directory basename

All IDs are sanitized to lowercase alphanumeric + hyphens.

// Auto-detection
memory.store({ project_root: "/Users/me/my-app", content: "test" })
// → project_id: "my-app"

Environment Variables

Variable	Default	Purpose
`DATA_DIR`	`./data`	SQLite database location
`LOG_LEVEL`	`info`	Winston log level
`MAX_MEMORY_ENTRIES`	`1000`	Per-project memory cap
`MAX_KB_ENTRIES`	`500`	Per-project KB cap
`ENABLE_QDRANT`	`false`	Enable vector search
`QDRANT_URL`	`http://localhost:6333`	Qdrant endpoint
`VACUUM_INTERVAL`	`86400000`	DB vacuum interval (ms)
`DASHBOARD_PORT`	—	Auto-start dashboard on boot

Project Structure

mcp-kb-server/
├── src/
│   ├── server.js              # MCP entry point (JSON-RPC 2.0 over stdio)
│   ├── storage/db.js          # SQLite schema + migrations
│   ├── tools/
│   │   ├── memory.js          # memory.* tools
│   │   ├── kb.js              # kb.add / kb.search / kb.init
│   │   ├── sources.js         # source.ingest / list / search
│   │   ├── summary.js         # summary.project
│   │   ├── summaryDelta.js    # summary.delta
│   │   ├── wikiLinks.js       # wiki.link / wiki.links
│   │   ├── wikiLint.js        # wiki.lint
│   │   ├── wikiExport.js      # wiki.export
│   │   └── dashboard.js       # HTTP server + HTML dashboard
│   └── utils/
│       ├── projectId.js       # Auto-detection logic
│       ├── fileDiscovery.js   # Glob + file reading utilities
│       ├── config.js          # Env config
│       ├── validation.js      # Joi schemas
│       ├── performance.js     # LRU cache + vacuum scheduler
│       └── errors.js          # AppError / handleError
├── config/discovery.json      # Auto-discovery glob patterns
├── data/                      # SQLite databases (auto-created)
└── test/                      # 84 tests (node --test)

Database Schema

memory.sqlite

CREATE TABLE memory (
  id TEXT PRIMARY KEY,
  project_id TEXT NOT NULL DEFAULT 'legacy',
  scope TEXT NOT NULL,
  content TEXT NOT NULL,
  tags TEXT,
  created_at TEXT NOT NULL,
  updated_at TEXT,
  expires_at TEXT
);
CREATE VIRTUAL TABLE memory_fts USING fts5(content, tags);
CREATE TABLE wiki_links (
  id TEXT PRIMARY KEY,
  project_id TEXT NOT NULL,
  source_id TEXT, source_type TEXT,
  target_id TEXT, target_type TEXT,
  relation TEXT, created_at TEXT
);

kb.sqlite

CREATE VIRTUAL TABLE kb_fts USING fts5(title, content, source);
CREATE TABLE kb_meta (rowid INTEGER PRIMARY KEY, project_id TEXT);
CREATE TABLE sources (
  id TEXT PRIMARY KEY, project_id TEXT,
  slug TEXT, filename TEXT, file_type TEXT,
  content TEXT, file_path TEXT,
  ingested_at TEXT, size_bytes INTEGER
);
CREATE VIRTUAL TABLE sources_fts USING fts5(slug, content);

Development

git clone https://github.com/dereknguyen269/mcp-kb-server.git
cd mcp-kb-server
npm install
npm test        # runs all 84 tests

Run a single test file:

NODE_ENV=test node --test test/memory.test.js

Security

Project Isolation: SQL-level project_id filtering on every query
Path Validation: Prevents directory traversal
XSS Protection: All user content HTML-escaped in dashboard
Parameterized Queries: No SQL injection surface
No External Resources: Dashboard works fully offline

Performance

FTS5 / BM25: Ranked full-text search on memory, KB, and sources
LRU Query Cache: 50-entry cache, 5-min TTL, invalidated on mutations
Throttled Purge: Expired entry cleanup at most once per 60s per project
SQLite WAL: Concurrent reads without blocking writes
Bulk Transactions: kb.init and dashboard import use single transactions

Error Codes

Code	Meaning
`-32602`	Invalid params (missing fields, bad paths)
`-32601`	Method not found
`-32000`	Server / DB error

Version History

v1.2.0 (Current)

✅ kb.init — bulk-import project docs from filesystem in one MCP call
✅ Dashboard split-panel UI — list + detail for KB, Memory, Sources
✅ Paginated lists (30/page, Load more) across all tabs
✅ Import KB from JSON array or .md file via dashboard
✅ Export KB and Memory as Markdown downloads
✅ Create / delete projects from dashboard
✅ Delete individual memory entries from dashboard
✅ KB list filtered by project_id (was showing all projects)
✅ New Document correctly scoped to current project
✅ 84 tests

v1.1.0

✅ memory.delete / memory.update / memory.list
✅ Tag-based filtering, FTS5 on memory
✅ KB project scoping, TTL/expiry, LRU cache
✅ Sources layer (ingest md/txt/csv/pdf)
✅ Wiki links, lint, export tools

v1.0.0

✅ Auto project_id detection
✅ Interactive HTML dashboard (dark/light)
✅ KB management (add/edit/delete)
✅ Project scoping, path validation

Support

npm: https://www.npmjs.com/package/mcp-kb-server
GitHub: https://github.com/dereknguyen269/mcp-kb-server
Issues: https://github.com/dereknguyen269/mcp-kb-server/issues

Available Tools

25 tools

dashboard.projectsB

Generate an interactive dashboard (HTML written to ./temp) for browsing and managing the knowledge base and project memory.

Inputs: port, limit, project_id, project_root.

health.checkA

Get server health status and metrics

Inputs: detailed.

kb.addB

Add a document to the knowledge base. After adding, regenerate the index page with kb.index.

Inputs: title (required), content (required), source, vector, +3 more.

kb.deleteA

Delete a KB document by ID. After deleting, regenerate the index page with kb.index.

Inputs: id (required), project_id.

kb.getA

Fetch a single KB document by ID. Use after kb.search with max_content_length to retrieve the full content of a specific document.

Inputs: id (required), project_id.

kb.indexA

Read or replace the wiki index page (source='_index'). Call with no content to fetch the current index. Call with content to atomically replace it. The index is the LLM's navigation entry point — read it before searching, regenerate it after any kb.add/update/delete.

Inputs: project_id (required), content.

kb.initA

Scan a project directory for markdown and text files and bulk-import them into the knowledge base. Skips files already present (matched by source path). Returns a summary of what was added and skipped. After running, follow the workflow in .kiro/steering/kb-ingest.md for each added file to extract entities, create cross-references, and update the index and changelog.

Inputs: project_root (required), patterns, overwrite, project_id, +1 more.

kb.searchB

Search the knowledge base using SQLite FTS5 by default; optionally uses Qdrant vector similarity when a vector is provided. Tip: call kb.index first to read the table of contents before searching blind.

Inputs: query (required), limit, vector, qdrantUrl, +3 more.

kb.updateA

Update an existing KB document by ID. Replaces title, content, and/or source. After updating, regenerate the index page with kb.index.

Inputs: id (required), title, source, content, +1 more.

memory.deleteA

Delete a memory entry by ID. Use to remove outdated or incorrect information.

Inputs: id (required), project_id, project_root.

memory.getA

Fetch a single memory entry by ID. Use after memory.search with max_content_length to retrieve the full content of a specific entry.

Inputs: id (required), project_id, project_root.

memory.listA

List all memory entries for a project with pagination. Use when you need to see all memories, not just search results. Returns total_count so you know how many exist.

Inputs: limit, scope, offset, project_id, +2 more.

memory.searchC

Search long-term memory by substring match over stored content and tags.

Inputs: query (required), tag, limit, scope, +4 more.

memory.storeC

Store long-term memory. Stores content exactly as provided.

Inputs: content (required), tags, scope, expires_at, +2 more.

memory.updateB

Update an existing memory entry. Replaces content and/or tags. Use to correct or refine stored knowledge.

Inputs: id (required), tags, content, expires_at, +2 more.

source.getA

Fetch the full content of a single ingested source by ID. Use after source.search to retrieve the complete text of a specific document.

Inputs: id (required), project_id, project_root.

source.ingestA

Ingest one or more documents (md, txt, csv, pdf) into the raw sources layer. After ingesting, follow the workflow in .kiro/steering/kb-ingest.md to extract entities into the KB, create cross-references, and update the index and changelog.

Inputs: files (required), project_id, project_root.

source.listB

List all raw sources ingested for a project.

Inputs: limit, offset, project_id, project_root.

source.searchC

Full-text search over ingested raw sources.

Inputs: query (required), limit, project_id, project_root.

summary.deltaB

Generate a delta (change-only) project knowledge summary by comparing the current authoritative project state against the last stored project summary. This tool does NOT store anything automatically.

Inputs: project_root (required), include_kb, project_id, auto_discover, +2 more.

summary.projectA

Generate a ground-truth–aware project knowledge snapshot by reading authoritative instruction files, long-term memory, and the knowledge base. This tool does NOT store results automatically.

Inputs: project_root (required), include_kb, project_id, auto_discover, +2 more.

wiki.exportB

Export all wiki data (raw sources, KB entries, memory) as markdown files to a directory.

Inputs: output_dir (required), include_kb, project_id, project_root, +2 more.

wiki.linkC

Create a cross-reference link between two wiki entries (memory, source, or kb).

Inputs: source_id (required), target_id (required), source_type (required), target_type (required), +3 more.

wiki.linksB

List all cross-reference links for a given entry (inbound, outbound, or both).

Inputs: entry_id (required), direction, project_id, project_root.

wiki.lintA

Health-check the wiki: find orphan entries, broken links, stale sources, and missing cross-references. Use lint_mode='semantic' to get an LLM-ready payload for deeper analysis (contradictions, stale claims, missing entity pages, missing cross-references).

Inputs: lint_mode, project_id, project_root, max_kb_entries, +2 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

Deploy Server

Claude Code, inside the Godot 4 editorFlockbay puts an AI agent in the real Godot 4 editor: it writes GDScript, runs your game and fixes what breaks. Free, or bring your own Claude Code or Codex.flockbay.comAd

TDQS

B3.4/5.0

Scored 2026-08-18 07:50 across 25 tools

Disambiguation5/5

Each tool targets a distinct subsystem (wiki, memory, KB, source, summary, dashboard) and operation. Despite 25 tools, descriptions clearly differentiate them; no two tools appear to perform the same function, and domain prefixes (wiki., memory., kb., etc.) aid disambiguation.

Naming Consistency5/5

All tools follow a consistent 'noun.verb' pattern (e.g., memory.store, kb.search, source.ingest, summary.project). The naming uses dot-separated domain prefixes and action suffixes uniformly, making the pattern predictable and easy to navigate.

Tool Count3/5

With 25 tools, the count is at the high end of the 'borderline' range (16-25 felt heavy). While the tools are organized across multiple subsystems, the overall surface area is large and could be trimmed to reduce cognitive load, though it remains functionally justifiable.

Completeness3/5

The server provides good coverage for memory and KB (full CRUD plus index/search), but the source subsystem lacks update and delete operations, and the wiki subsystem only offers lint/export/link without direct create/read/update/delete. These gaps hinder full lifecycle management for those domains.

Maintenance

ActivityInactive

ResponsivenessNo recent community issues

Resources

Related MCP Connectors

hithereiamaliff-mcp-nextcloud
ai.smithery
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Cloud Storage File Systems Workplace & Productivity
239
https://server.smithery.ai/@hithereiamaliff/mcp-nextcloud/mcp
Living Memory
to.viibe
An MCP memory server. One memory your agents share — across models, devices and apps.
Knowledge & Memory Autonomous Agents AI & Machine Learning
22
https://lme.viibe.to/mcp
mcpC
com.wix
A Model Context Protocol server for Wix AI tools
Developer Tools Content Management Systems App Automation
215
https://mcp.wix.com/mcp
PlanExeADeprecated
io.github.PlanExeOrg
MCP server for generating rough-draft project plans from natural-language prompts.
Autonomous Agents Developer Tools Project Management
3403
https://mcp.planexe.org/mcp

Related MCP Servers

Agentic Tools MCP Server
Project Management Developer Tools Code Execution
Pimzino
A
license
B
quality
D
maintenance
A Model Context Protocol server providing AI assistants with comprehensive project, task, and subtask management capabilities with project-specific storage.
Updated a year ago (2025-06-20 14:42 UTC)
29
24 npm
88
MIT
Lspace MCP Serverofficial
Knowledge & Memory Developer Tools RAG Systems
Lspace-io
A
license
A
quality
D
maintenance
An open-source server implementing the Model Context Protocol (MCP) that enables capturing insights from AI sessions and transforming them into persistent, searchable knowledge accessible across tools.
Updated a year ago (2025-05-30 20:43 UTC)
7
9
Business Source 1.1
AGI MCP Server
Knowledge & Memory RAG Systems
QuixiAI
A
license
B
quality
C
maintenance
A Model Context Protocol server that provides persistent memory capabilities for AI systems, enabling true continuity of consciousness across conversations through episodic, semantic, procedural, and strategic memory types.
Updated a month ago (2026-09-29 19:59 UTC)
24
6
MIT
MCP Memory Server
Knowledge & Memory RAG Systems
StevenWangler
A
license
B
quality
D
maintenance
A Model Context Protocol server that provides knowledge graph-based persistent memory for LLMs, allowing them to store, retrieve, and reason about information across multiple conversations and sessions.
Updated a year ago (2025-06-26 01:16 UTC)
9
374,489 npm
2
MIT

MCP Knowledge Base Server

How It Works

Workflow Diagrams

1. Request Flow

2. Project Initialization (kb.init)

3. Memory Lifecycle

4. Knowledge Base Flow

5. Summary & Delta Flow

6. Dashboard Architecture

7. Wiki Links & Lint

Features

🧠 Memory Management

📚 Knowledge Base

📂 Sources Layer

🔗 Wiki Links & Lint

📊 Project Summaries

🎨 Interactive Dashboard

🔒 Safety

Installation

Usage

Configure MCP Client

Available Tools

Memory Tools

Knowledge Base Tools

Source Tools

Wiki Tools

Summary Tools

Dashboard Tool

Dashboard

KB Tab

Memory Tab

Sources Tab

Links / Lint Tabs

Project Management

Import Format (JSON)

Export Format (Markdown)

Automatic Project Detection

Environment Variables

Project Structure

Database Schema

Development

Security

Performance

Error Codes

Version History

v1.2.0 (Current)

v1.1.0

v1.0.0

Support

Available Tools

Tool Schema Changelog

TDQS

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

Agentic Tools MCP Server

Lspace MCP Serverofficial

AGI MCP Server

MCP Memory Server

2. Project Initialization (`kb.init`)