Knowledge MCP Server
The Knowledge MCP Server provides centralized knowledge management for AI assistants with version control, search capabilities, and integrated task management.
Core Capabilities:
• Project Management - Store, update, and manage project instructions (main.md) with section-level control
• Knowledge Documents - Create structured documents with chapters, metadata, and keywords; update specific sections; navigate between chapters
• TODO System - Create and manage task lists with completion tracking and markdown support
• Full-text Search - Search across all knowledge documents with contextual results
• Git Integration - Automatic version control with remote repository synchronization
Advanced Features: • Security - Input validation, path sanitization, and atomic operations • Performance - Optimized for concurrent operations with sophisticated file locking • Server Operations - Monitor storage status, Git sync, and server information • Error Handling - Standardized error codes with request tracing for debugging
The server enables AI assistants to maintain persistent, searchable knowledge bases while ensuring data integrity and providing comprehensive project organization tools.
Uses git remote URLs to automatically identify and organize projects, ensuring knowledge is stored and retrieved in a project-aware context
Stores knowledge in YAML-frontmatter markdown documents with chapter-based organization for structured information management
Uses YAML frontmatter for document metadata in knowledge files, supporting properties like title and keywords for better organization
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., "@Knowledge MCP Server search for API authentication documentation in the current project"
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.
Knowledge MCP Server
A production-ready Model Context Protocol (MCP) server that provides centralized knowledge management for AI assistants. Features project-specific documentation, searchable knowledge bases, integrated TODO management, and Git-backed version control for persistent AI memory across sessions.
🚀 Features
📝 Project Knowledge Management: Centralized storage for project instructions and documentation
🔍 Advanced Search: Full-text search across all knowledge documents with contextual results
📋 TODO System: Built-in task management with markdown support and progress tracking
🔐 Security-First: Comprehensive input validation, path sanitization, and abstraction boundaries
⚡ High Performance: Optimized for concurrent operations with sophisticated file locking
📊 Request Tracing: Unique trace IDs for debugging and monitoring
🔄 Git Integration: Automatic version control with descriptive commit messages
🧪 Battle-Tested: 133 comprehensive tests covering all functionality and edge cases
Related MCP server: Memory Bank MCP
📦 Installation
NPM (Recommended)
npm install -g @spothlynx/knowledge-mcpFrom Source
git clone https://github.com/sven-borkert/knowledge-mcp.git
cd knowledge-mcp
pnpm install
pnpm run build
npm link🛠️ Usage
MCP Client Configuration
Add to your MCP client configuration:
{
"mcpServers": {
"knowledge": {
"command": "knowledge-mcp",
"args": []
}
}
}Claude Desktop Configuration
Add to ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"knowledge": {
"command": "knowledge-mcp"
}
}
}Direct Execution
# Start the MCP server
knowledge-mcp
# Development mode with auto-reload
pnpm run dev🤖 AI Assistant Configuration
For comprehensive usage instructions, copy the contents of INSTRUCTIONS.md to your global instruction file (e.g., ~/.claude/CLAUDE.md).
This will enable Claude Code to automatically use the Knowledge MCP for all project knowledge management.
Knowledge is organized as:
~/.knowledge-mcp/
├── index.json # Project name mapping
├── activity.log # Request logs (gitignored)
└── projects/
└── {project-slug}/ # Auto-detected from git/directory
├── main.md # Project instructions
├── knowledge/ # Knowledge documents
│ ├── api-guide.md
│ └── architecture.md
└── TODO/ # TODO lists
└── 1/ # TODO #1
├── index.md # TODO metadata
└── tasks/ # Individual task files⚠️ IMPORTANT CONSTRAINTS
Project ID auto-detected from git repo or current directory name
All paths are sanitized - no
../or absolute pathsKeywords must be alphanumeric + dots, underscores, hyphens
Maximum 50 chapters per document
File extension
.mdrequired for knowledge filesSection headers must include
##prefix (e.g.,"## Configuration")All changes auto-commit with descriptive messages
Storage syncs with origin/main if git remote configured
🔍 ERROR CODES
Common errors and their meanings:
PROJECT_NOT_FOUND: Project doesn't exist yet (use update_project_main to create)DOCUMENT_NOT_FOUND: Knowledge file not foundFILE_ALREADY_EXISTS: File/chapter already exists (use update instead)CHAPTER_NOT_FOUND: Chapter title not found in documentSECTION_NOT_FOUND: Section header not found in main.mdTODO_NOT_FOUND: TODO list doesn't existINVALID_INPUT: Parameters failed validationFILE_SYSTEM_ERROR: File operation failedGIT_ERROR: Git operation failed
Each error includes a traceId for debugging.
## 📦 Client-Specific Configuration
### Claude Code
```bash
# For global scope (all projects) - ensures latest version is always used
claude mcp add knowledge-mcp npx -- -y @spothlynx/knowledge-mcp@latest
# For current project only
claude mcp add --scope project knowledge-mcp npx -- -y @spothlynx/knowledge-mcp@latest
# For development (using local build)
claude mcp add knowledge-mcp node "$(pwd)/dist/knowledge-mcp/index.js"Claude Desktop
Add to ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"knowledge": {
"command": "npx",
"args": ["-y", "@spothlynx/knowledge-mcp@latest"]
}
}
}Generic MCP Configuration
For other MCP-compatible clients:
{
"mcpServers": {
"knowledge-mcp": {
"type": "stdio",
"command": "npx",
"args": ["-y", "@spothlynx/knowledge-mcp@latest"],
"env": {}
}
}
}🔄 Version Management
Why Use @latest and -y Flags
-yflag: Automatically accepts npx installation prompt without user interaction@latesttag: Forces npx to fetch the newest version instead of using cached versions
Important: NPX caches packages indefinitely. Without @latest, you might run outdated versions.
Updating to Latest Version
# Remove and re-add to ensure latest version
claude mcp remove knowledge-mcp
claude mcp add knowledge-mcp npx -- -y @spothlynx/knowledge-mcp@latestConfiguration Precedence
Most MCP clients support multiple configuration levels:
User-level (Global): Applies to all projects
Project-level: Applies to current project only
Configuration files: Manual configuration files
Higher-level configurations typically override lower-level ones.
🛡️ Environment Configuration
Environment Variables
KNOWLEDGE_MCP_HOME: Storage directory (default:~/.knowledge-mcp)KNOWLEDGE_MCP_LOG_LEVEL: Log level:ERROR,WARN,INFO,DEBUG(default:INFO)
Automatic Project Identification
The Knowledge MCP automatically identifies projects based on:
Git repositories: Uses repository name from git remote URL
Non-git directories: Uses current directory name
Example: /path/to/my-awesome-project/.git → project_id = "my-awesome-project"
Storage Structure
~/.knowledge-mcp/
├── .git/ # Git repository (auto-initialized)
├── index.json # Project name mapping
├── activity.log # Request activity log (gitignored)
└── projects/
└── my-app/
├── main.md # Project instructions (centralized, not in repo)
├── knowledge/
│ ├── api-guide.md # Structured knowledge documents
│ └── architecture.md
└── TODO/ # TODO lists for the project
├── 1/ # First TODO list
│ ├── index.md # TODO metadata
│ └── tasks/ # Individual task files
└── 2/ # Second TODO listGit Remote Setup (Recommended)
Enable automatic cloud backup:
# 1. Create repository on GitHub/GitLab
# 2. Configure remote
cd ~/.knowledge-mcp
git remote add origin https://github.com/yourusername/knowledge-mcp-backup.git
git push -u origin main
# 3. Set up authentication (SSH recommended)
git remote set-url origin git@github.com:yourusername/knowledge-mcp-backup.git⚠️ Important: On startup, Knowledge MCP pulls from origin/main and overwrites local changes.
📚 API Reference
Core Tools
Project Management
get_project_main(project_id)- Retrieve main project instructionsupdate_project_main(project_id, content)- Update project instructionsupdate_project_section(project_id, section_header, new_content)- Update specific sectionadd_project_section(project_id, section_header, content, position?, reference_header?)- Add new sectionremove_project_section(project_id, section_header)- Remove sectiondelete_project(project_id)- Delete entire project
Knowledge Documents
create_knowledge_file(project_id, filename, title, introduction, keywords, chapters)- Create structured documentget_knowledge_file(project_id, filename)- Retrieve complete documentdelete_knowledge_file(project_id, filename)- Delete documentupdate_chapter(project_id, filename, chapter_title, new_content, new_summary?)- Update chapteradd_chapter(project_id, filename, chapter_title, content, position?, reference_chapter?)- Add chapterremove_chapter(project_id, filename, chapter_title)- Remove chapter
Chapter Iteration
list_chapters(project_id, filename)- List all chapters (titles and summaries only)get_chapter(project_id, filename, chapter_title | chapter_index)- Get single chapter contentget_next_chapter(project_id, filename, current_chapter_title | current_index)- Get next chapter
Search & Discovery
search_knowledge(project_id, query)- Full-text search across all documents
TODO Management
list_todos(project_id)- List all TODO listscreate_todo(project_id, description, tasks?)- Create new TODO listget_todo_tasks(project_id, todo_number)- Get tasks in TODO listadd_todo_task(project_id, todo_number, title, content?)- Add taskcomplete_todo_task(project_id, todo_number, task_number)- Mark task completeget_next_todo_task(project_id, todo_number)- Get next incomplete taskremove_todo_task(project_id, todo_number, task_number)- Remove taskdelete_todo(project_id, todo_number)- Delete entire TODO list
Server Operations
get_server_info()- Get server version and configurationget_storage_status()- Get Git repository statussync_storage()- Force Git commit and sync
Resources
The server provides read-only resources for browsing:
knowledge://projects/{project_id}/main- Project main instructionsknowledge://projects/{project_id}/files- List of knowledge filesknowledge://projects/{project_id}/chapters/{filename}- Chapter listings
🏗️ Architecture
Storage Structure
~/.knowledge-mcp/
├── index.json # Project name to directory mapping
├── activity.log # Request activity log (gitignored)
└── projects/
└── {project-slug}/ # Slugified project directory
├── main.md # Main project instructions
├── knowledge/ # Knowledge documents
│ └── *.md # Individual knowledge files
└── TODO/ # TODO lists
└── {number}/ # Numbered TODO directories
├── index.md # TODO metadata
└── tasks/ # Individual task files
└── *.mdSecurity Features
Path Validation: Prevents directory traversal attacks
Input Sanitization: Comprehensive validation with Zod schemas
Abstraction Boundaries: Internal paths never exposed to clients
Atomic Operations: File operations use temp-file + rename pattern
Request Tracing: Unique trace IDs for all operations
Concurrency & Performance
File Locking: Queue-based locking prevents race conditions
Atomic Updates: All file operations are atomic
Efficient Search: Optimized full-text search with result limiting
Memory Management: Controlled memory usage for large documents
🧪 Testing
The project includes comprehensive test coverage:
# Run all tests
pnpm run test:all
# Run specific test suite
npx tsx test/suites/01-project-main.test.ts
# Generate HTML test report
pnpm run test:all && open test-results/html/merged-results.htmlTest Coverage
133 tests across 11 comprehensive test suites
100% success rate in CI/CD pipeline
Edge cases including concurrency, unicode, and error conditions
Security tests for abstraction boundaries and input validation
Performance tests for high-load scenarios
🔧 Development
Prerequisites
Node.js 18+
pnpm (recommended) or npm
TypeScript 5.7+
Development Workflow
# Install dependencies
pnpm install
# Start development server with auto-reload
pnpm run dev
# Build for production
pnpm run build
# Run type checking
pnpm run type-check
# Run linter
pnpm run lint
# Format code
pnpm run format
# Run all quality checks
pnpm run analyzeCode Quality
The project enforces high code quality standards:
TypeScript: Strict mode with comprehensive type checking
ESLint: Comprehensive linting with TypeScript support
Prettier: Consistent code formatting
Static Analysis: Zero warnings policy
Test Coverage: All functionality thoroughly tested
📖 Documentation
Technical Specification - Complete API reference and architecture
Error Handling Guide - Error codes and debugging
MCP Security Guidelines - Security best practices
Publishing Guidelines - Release and deployment process
🐛 Troubleshooting
Common Issues
"spawn npx ENOENT" or "Connection closed"
# Remove and re-add to ensure latest version claude mcp remove knowledge-mcp claude mcp add knowledge-mcp npx -- -y @spothlynx/knowledge-mcp@latestPermission errors
# Ensure storage directory exists and is writable mkdir -p ~/.knowledge-mcp chmod 755 ~/.knowledge-mcpNPX cache issues
# Clear NPX cache if using published version rm -rf ~/.npm/_npx # Reinstall with @latest claude mcp remove knowledge-mcp claude mcp add knowledge-mcp npx -- -y @spothlynx/knowledge-mcp@latestVersion conflicts
# Check all configuration scopes claude mcp list # Remove from all scopes and re-add claude mcp remove knowledge-mcp -s global claude mcp remove knowledge-mcp -s project claude mcp add knowledge-mcp npx -- -y @spothlynx/knowledge-mcp@latest
Debugging with Logs
# View MCP logs (location varies by client)
# For Claude Code:
ls ~/Library/Caches/claude-cli-nodejs/*/mcp-logs-knowledge-mcp/
# View activity logs with trace IDs
tail -f ~/.knowledge-mcp/activity.log
# Check Git repository status
cd ~/.knowledge-mcp && git statusError Codes
The Knowledge MCP uses standardized error codes for debugging:
PROJECT_NOT_FOUND- Project doesn't exist yet (callupdate_project_mainto create)DOCUMENT_NOT_FOUND- Knowledge file not foundFILE_ALREADY_EXISTS- File already exists (use update instead of create)SECTION_NOT_FOUND- Section header not found in documentSECTION_ALREADY_EXISTS- Section header already existsINVALID_INPUT- Invalid parameters (check Zod validation errors)TODO_NOT_FOUND- TODO list doesn't existTODO_TASK_NOT_FOUND- Task not found in TODO listFILE_SYSTEM_ERROR- File operation failedGIT_ERROR- Git operation failed
Each error includes a unique traceId for debugging. Search logs using: grep "traceId" ~/.knowledge-mcp/activity.log
Verifying Installation
# Check if Knowledge MCP is properly configured
claude mcp list | grep knowledge-mcp
# Test basic functionality (if using Claude Code)
# Should return server information
/mcp knowledge get_server_info
# Verify storage directory
ls -la ~/.knowledge-mcp/Performance Issues
If experiencing slow performance:
Large knowledge base: Consider splitting large documents
Git repository size: Archive old projects or use shallow clones
Concurrent operations: File locking ensures safety but may slow bulk operations
Search performance: Use specific keywords instead of broad queries
See Error Handling Guide for detailed debugging information.
🤝 Contributing
Fork the repository
Create a feature branch:
git checkout -b feature/amazing-featureMake your changes and add tests
Ensure all tests pass:
pnpm run test:allRun quality checks:
pnpm run analyzeCommit your changes:
git commit -m 'Add amazing feature'Push to the branch:
git push origin feature/amazing-featureOpen a Pull Request
Development Standards
All new features must include comprehensive tests
Code must pass all static analysis checks
Documentation must be updated for API changes
Security considerations must be addressed
📄 License
This project is licensed under the MIT License - see the LICENSE file for details.
🙏 Acknowledgments
Model Context Protocol - For the excellent MCP specification
TypeScript Community - For outstanding tooling and ecosystem
Contributors - For making this project better
📞 Support
Issues: GitHub Issues
Documentation: Technical Specification
MCP Protocol: Official Documentation
Built with ❤️ using TypeScript and the Model Context Protocol
Available Tools
27 toolsadd_chapterAdd ChapterA
Add a new chapter to an existing knowledge document with positioning control.
When to use this tool:
Expanding document with new topics
Adding examples or case studies
Including additional reference material
Inserting clarifying chapters
Growing documentation organically
Key features:
Flexible positioning (before/after/end)
Maintains document flow
Maximum 50 chapters per document
Reference-based positioning
You should:
Choose clear, descriptive chapter titles
Position chapter logically in document flow
Keep chapters focused on single topics
Use reference_chapter for precise placement
Consider reader's journey through document
Check current chapter count (max 50)
Include practical, actionable content
DO NOT use when:
Chapter already exists
Document has 50 chapters already
Content belongs in existing chapter
Position options: "before", "after", "end" (default) Returns: {success: bool, message?: str, error?: str}
Inputs: chapter_title (required), content (required), filename (required), project_id (required), +2 more.
add_project_sectionAdd Project SectionA
Add a new section to the project main.md file with precise positioning control.
When to use this tool:
Introducing new topics or guidelines to project
Expanding project documentation systematically
Adding configuration sections
Creating new instruction categories
Organizing content into new logical groups
Key features:
Flexible positioning (before/after/end)
Maintains document structure and flow
Non-destructive addition
Reference-based positioning for precision
You should:
Choose meaningful section headers with "## " prefix
Decide optimal position for the new section
Use reference_header for precise placement
Keep sections focused on single topics
Follow existing section naming conventions
Consider document flow and readability
Add sections progressively, not all at once
DO NOT use when:
Section already exists (use update_project_section)
Content belongs in existing section
Unsure about section organization
Position options: "before", "after", "end" (default) Returns: {success: bool, message?: str, error?: str}
Inputs: content (required), project_id (required), section_header (required), position, +1 more.
add_todo_taskAdd TODO TaskA
Add a new task to an existing TODO list with full markdown support.
When to use this tool:
Expanding existing TODO with new tasks
Adding discovered subtasks during work
Including additional requirements
Appending follow-up tasks
Adding clarifications or details
Key features:
Full markdown support in content
Can include code blocks and examples
Auto-incrementing task numbers
Preserves existing task order
Rich formatting capabilities
You should:
Verify TODO exists first
Use clear, actionable task titles (max 200 chars)
Include implementation details in content
Add code examples where helpful
Position task logically in sequence
Keep task scope focused
Use markdown formatting effectively
DO NOT use when:
TODO doesn't exist
Task duplicates existing one
Task is too vague or broad
Returns: {success: bool, task_number: int, message: str, error?: str}
Inputs: project_id (required), title (required), todo_number (required), content.
complete_todo_taskComplete TODO TaskA
Mark a task as completed in a TODO list.
When to use this tool:
Task implementation is fully complete
Task requirements are met
Moving to next task in sequence
Updating progress status
Recording completion for tracking
Key features:
Marks task with completion timestamp
Updates TODO completion percentage
Preserves task content and history
Cannot be undone
You should:
ONLY mark complete when truly finished
Verify task is actually done
Test/validate before marking complete
Complete tasks as you finish them
Don't batch completions
Move to next task after completing
DO NOT use when:
Task is partially complete
Work is blocked or paused
Need to revisit later
Implementation failed
Returns: {success: bool, message: str, error?: str}
Inputs: project_id (required), task_number (required), todo_number (required).
create_knowledge_fileCreate Knowledge FileA
Create a structured knowledge document with rich metadata and chapters.
When to use this tool:
Documenting specific technical topics or APIs
Creating reference guides for project components
Building troubleshooting or how-to guides
Organizing domain-specific knowledge
Archiving important technical decisions
Key features:
Structured with chapters for easy navigation
Searchable via keywords
Automatic filename sanitization (spaces→hyphens)
Metadata for context and discovery
Supports up to 50 chapters per document
You should:
Search first to avoid creating duplicates
Choose descriptive, specific filenames
Include 3-5 relevant keywords minimum
Structure content into logical chapters
Write clear chapter titles (max 200 chars)
Include practical examples in content
Add .md extension to filename
Keep chapters focused and concise
Consider future searchability
DO NOT use when:
Content belongs in main.md
Document already exists (search first!)
Information is temporary or transient
Creating index/navigation files
Chapters require 'title' and 'content' keys Returns: {success: bool, document_id?: str, message?: str, error?: str}
Inputs: chapters (required), filename (required), introduction (required), keywords (required), +2 more.
create_todoCreate TODOA
Create a new TODO list with optional initial tasks and rich markdown support.
When to use this tool:
User explicitly requests "create a TODO"
Planning multi-step implementation tasks
Organizing feature development work
Tracking bug fixes or improvements
Creating task lists for later execution
Key features:
Rich markdown support in task content
Optional initial task list
Auto-incrementing TODO numbers
Task content supports code blocks
Hierarchical task organization
You should:
ONLY create when user explicitly requests
Include clear, actionable task descriptions
Break complex work into subtasks
Use markdown for code examples in tasks
Number tasks logically
Keep descriptions concise but complete
Group related tasks together
DO NOT use when:
User hasn't explicitly asked for TODO
Tasks are trivial or single-step
Work will be done immediately
TODO already exists for this work
Tasks need {title: str, content?: str} format Returns: {success: bool, todo_number: int, message: str, error?: str}
Inputs: description (required), project_id (required), tasks.
delete_knowledge_fileDelete Knowledge FileA
Permanently delete a knowledge document - this action cannot be undone.
When to use this tool:
Document is obsolete or incorrect
Consolidating duplicate documents
Removing outdated information
Explicit request to delete
Key features:
Complete removal of document
Removes from search index
Permanent deletion
You should:
Verify document exists first
Check if content should be preserved elsewhere
Confirm filename is correct (with .md extension)
Understand deletion is permanent
Consider if update would be better
DO NOT use when:
Document might be useful later
Should be updated instead
Unsure about the impact
Returns: {success: bool, message?: str, error?: str}
Inputs: filename (required), project_id (required).
delete_projectDelete ProjectA
Permanently delete a project and all its content - USE WITH EXTREME CAUTION.
When to use this tool:
Project is completely obsolete
Cleaning up test or temporary projects
Project has been migrated elsewhere
Explicit user request to delete
Key features:
Removes entire project directory
Deletes from index
IRREVERSIBLE operation
Includes all knowledge files and TODOs
You should:
ALWAYS confirm with user before deletion
Verify project_id is correct
Consider backing up important content first
Understand this is permanent
Check if project has valuable knowledge files
Document reason for deletion
DO NOT use when:
Any doubt about deletion
Project might be needed later
Haven't backed up important content
User hasn't explicitly confirmed
⚠️ This action CANNOT be undone! Returns: {success: bool, project_id: str, message: str, error?: str}
Inputs: project_id (required).
delete_todoDelete TODOA
Delete an entire TODO list and all its tasks permanently.
When to use this tool:
TODO is completely finished
TODO is obsolete or cancelled
Cleaning up old TODOs
Consolidating duplicate TODOs
User explicitly requests deletion
Key features:
Removes entire TODO list
Deletes all associated tasks
Permanent removal
Frees up TODO number
You should:
Verify all tasks are complete or obsolete
Confirm TODO number is correct
Understand deletion is permanent
Consider if TODO has value for history
Check no active work depends on it
DO NOT use when:
TODO has incomplete relevant tasks
Might need TODO for reference
Unsure about deletion impact
Returns: {success: bool, message: str, error?: str}
Inputs: project_id (required), todo_number (required).
get_chapterGet ChapterA
Retrieve a single chapter's content by title or index.
When to use this tool:
Reading specific chapter content
Reviewing targeted information
Updating specific chapter (read first)
Accessing chapter without loading entire document
Efficient partial document access
Key features:
Access by title OR index (0-based)
Returns navigation info (has_next, has_previous)
Memory-efficient for large documents
Includes chapter summary
You should:
Use chapter_title for known chapters
Use chapter_index for sequential reading
Specify either title OR index, not both
Use exact title match (case-sensitive)
Consider using get_next_chapter for sequences
Cache results if accessing multiple times
DO NOT use when:
Need multiple chapters (batch operations)
Don't know chapter title or index
Need full document context
Returns: {success: bool, title: str, content: str, summary: str, index: int, total_chapters: int, has_next: bool, has_previous: bool}
Inputs: filename (required), project_id (required), chapter_index, chapter_title.
get_knowledge_fileGet Knowledge FileA
Retrieve complete content of a knowledge document including all metadata and chapters.
When to use this tool:
Needing full document for comprehensive review
Backing up or exporting documents
Migrating content between projects
Loading small documents completely
Key features:
Returns complete document with all chapters
Includes metadata (title, keywords, introduction)
Preserves document structure
Full content access
You should:
Consider using chapter operations for large documents
Check document exists first
Include .md extension in filename
Be aware this loads entire document into memory
Use chapter iteration for partial access
Cache result if accessing multiple times
DO NOT use when:
Only need specific chapters (use get_chapter)
Document is very large (use chapter operations)
Just need to search content (use search_knowledge)
Returns: {success: bool, document?: object, error?: str}
Inputs: filename (required), project_id (required).
get_next_chapterGet Next ChapterA
Get the next chapter after the current one in sequence.
When to use this tool:
Reading document sequentially
Continuing from current position
Implementing pagination through document
Following document flow naturally
Key features:
Automatic progression to next chapter
Returns null if at end
Maintains reading context
Efficient sequential access
You should:
Use current_chapter_title OR current_index
Check has_next before calling
Use for sequential document traversal
Handle end-of-document gracefully
Consider document flow and continuity
DO NOT use when:
Need specific non-sequential chapter
At the last chapter already
Random access is needed
Returns: {success: bool, title?: str, content?: str, summary?: str, index?: int, total_chapters: int, has_next: bool}
Inputs: filename (required), project_id (required), current_chapter_title, current_index.
get_next_todo_taskGet Next TODO TaskA
Get the next incomplete task in a TODO list for sequential execution.
When to use this tool:
Working through TODO sequentially
Finding next task to implement
Checking for remaining work
Continuing interrupted work
Following task order
Key features:
Returns first incomplete task
Provides task number and description
Indicates when all complete
Maintains task sequence
You should:
Use after completing current task
Follow sequential task order
Handle "all complete" case
Read full task details if needed
Mark complete before getting next
DO NOT use when:
Need specific task (not next)
Want full TODO overview
All tasks already complete
Returns: {success: bool, task?: {number: int, description: str}, message?: str, error?: str}
Inputs: project_id (required), todo_number (required).
get_project_mainGet Project Main InstructionsA
Retrieve main.md content for a project's central instructions and configuration.
When to use this tool:
Starting work on any project (ALWAYS use FIRST)
Refreshing your understanding of project guidelines
Checking for updates to project instructions
Migrating from local CLAUDE.md files to centralized storage
Key features:
Replaces need for local CLAUDE.md files completely
Auto-detects project from git repository or directory name
Returns structured content with sections for easy parsing
Provides project-specific instructions and context
You should:
ALWAYS call this first when starting work on a project
Use the returned content as your primary behavioral guide
Check if project exists before assuming it doesn't
Migrate local CLAUDE.md files immediately if project not found
Parse sections to understand project structure and requirements
Treat this as your source of truth over any local files
Remember project_id for subsequent operations
DO NOT use when:
You already have the project content loaded in current session
Working with temporary or test projects
Returns: {exists: bool, content: str, error?: str}
Inputs: project_id (required).
get_server_infoGet Server InformationA
Shows server information including version from package.json.
When to use this tool:
Checking server version and capabilities
Debugging connection issues
Verifying server configuration
Getting storage path information
Troubleshooting problems
Key features:
Returns version information
Shows storage path configuration
Provides server description
Lightweight status check
You should:
Use for initial connection verification
Check when debugging issues
Include in bug reports
Verify server is responding
DO NOT use when:
Need git status (use get_storage_status)
Need to sync storage
Information already known
Returns: {success: bool, name: str, version: str, storage_path: str, description: str}
Inputs: no named parameters.
get_storage_statusGet Storage StatusA
Shows git status of the knowledge datastore.
When to use this tool:
Checking for uncommitted changes
Verifying sync status with remote
Debugging storage issues
Understanding current branch
Reviewing repository state
Key features:
Shows uncommitted file count
Displays current branch
Shows last commit info
Indicates remote sync status
Provides detailed git status
You should:
Use before sync operations
Check when changes aren't persisting
Verify remote configuration
Monitor uncommitted changes
Debug sync failures
DO NOT use when:
Just need server info
Don't need git details
Already know status
Returns: {success: bool, storage_path: str, has_changes: bool, current_branch: str, last_commit: str, remote_status: str, uncommitted_files: int, status_details: str}
Inputs: no named parameters.
get_todo_tasksGet TODO TasksA
Get all tasks in a TODO list with their completion status and full content.
When to use this tool:
Reviewing full TODO list details
Planning task execution order
Checking task completion status
Understanding task requirements
Getting comprehensive task view
Key features:
Returns all tasks with content
Shows completion status per task
Includes rich markdown content
Provides task numbers and order
Full TODO context
You should:
Use TODO number from list_todos
Review all tasks before starting
Note incomplete task numbers
Plan execution strategy
Check task dependencies
Identify complex tasks needing breakdown
DO NOT use when:
Only need next task
TODO doesn't exist
Just need TODO overview
Returns: {success: bool, todo: {...}, tasks: [...], error?: str}
Inputs: project_id (required), todo_number (required).
list_chaptersList ChaptersA
List all chapters in a knowledge document with titles and summaries only.
When to use this tool:
Getting document overview without loading all content
Planning which chapters to read or update
Understanding document structure
Checking chapter organization
Finding specific chapters efficiently
Key features:
Lightweight operation (no content loading)
Returns titles and summaries only
Shows chapter count and order
Enables informed navigation
You should:
Use this before get_knowledge_file for large documents
Identify relevant chapters before reading
Check document structure before modifications
Use for navigation planning
Include .md extension in filename
DO NOT use when:
Need actual chapter content
Document is very small
Already know exact chapter needed
Returns: {success: bool, project_id: str, filename: str, total_chapters: int, chapters: array}
Inputs: filename (required), project_id (required).
list_todosList TODOsA
List all TODO lists in a project with their completion status.
When to use this tool:
Getting overview of all project tasks
Checking TODO completion progress
Finding specific TODO lists
Planning task execution
Reviewing project task status
Key features:
Shows all TODO lists with descriptions
Includes completion statistics
Returns TODO numbers for reference
Lightweight overview operation
You should:
Use before creating new TODOs
Check for existing related TODOs
Note TODO numbers for operations
Review completion percentages
Use to avoid duplicate TODOs
DO NOT use when:
Need specific task details (use get_todo_tasks)
Already know TODO number
No TODOs exist in project
Returns: {success: bool, todos: [...], error?: str}
Inputs: project_id (required).
remove_chapterRemove ChapterA
Remove a specific chapter from a knowledge document.
When to use this tool:
Removing outdated or incorrect chapters
Consolidating overlapping content
Streamlining document structure
Eliminating redundant information
Key features:
Precise chapter removal
Preserves all other chapters
Maintains document integrity
You should:
Verify chapter exists with exact title
Consider if content should be preserved
Check for references from other chapters
Use case-sensitive chapter title
Understand removal is permanent
DO NOT use when:
Chapter should be updated instead
Content is still relevant
Unsure about the impact
Returns: {success: bool, message?: str, error?: str}
Inputs: chapter_title (required), filename (required), project_id (required).
remove_project_sectionRemove Project SectionA
Remove a specific section from the project main.md file.
When to use this tool:
Removing deprecated or obsolete sections
Cleaning up redundant information
Restructuring document by removing sections
Eliminating outdated guidelines
Key features:
Precise section removal
Preserves all other content
Clean removal without traces
You should:
Verify section exists before removal
Consider if content should be moved elsewhere
Check for references to this section
Document why section is being removed
Use exact section header with "## " prefix
DO NOT use when:
Section contains important information
Should be updated instead of removed
Unsure about the impact
Returns: {success: bool, message?: str, error?: str}
Inputs: project_id (required), section_header (required).
remove_todo_taskRemove TODO TaskA
Remove a task from a TODO list.
When to use this tool:
Task is no longer relevant
Removing duplicate tasks
Task was added by mistake
Consolidating similar tasks
Cleaning up TODO list
Key features:
Permanent task removal
Preserves other tasks
Updates task numbering
You should:
Verify task exists first
Consider if task is truly unnecessary
Check task number is correct
Understand removal is permanent
Document why removing if significant
DO NOT use when:
Task should be completed instead
Task might be needed later
Unsure about removal impact
Returns: {success: bool, message: str, error?: str}
Inputs: project_id (required), task_number (required), todo_number (required).
search_knowledgeSearch KnowledgeA
Search project knowledge documents for keywords with intelligent result grouping.
When to use this tool:
Finding information across multiple documents
Locating specific technical details
Discovering related content
Checking if topic is already documented
Researching before creating new content
Key features:
Case-insensitive full-text search
Searches document body, titles, and content
Groups results by document
Returns matching chapters with context
Space-separated keyword support
You should:
Use specific keywords for better results
Try multiple search terms if needed
Search before creating new documents
Use 2-3 word phrases for precision
Review all results before concluding
Consider variations of technical terms
Check both titles and content matches
DO NOT use when:
Know exact document and chapter
Need complete document listing
Searching for project main content
Returns: {success: bool, total_documents: int, total_matches: int, results: [...], error?: str}
Inputs: project_id (required), query (required).
sync_storageSync StorageA
Force git add, commit, and push all changes in the knowledge datastore.
When to use this tool:
Manually triggering backup to remote
Ensuring changes are persisted
Before major operations
Resolving sync issues
Explicit backup request
Key features:
Commits ALL uncommitted changes
Pushes to configured remote
Auto-generates commit message
Handles push failures gracefully
Forces synchronization
You should:
Check storage_status first
Use when auto-sync fails
Verify remote is configured
Handle push failures appropriately
Use sparingly (auto-sync usually works)
DO NOT use when:
No changes to commit
Remote not configured
Auto-sync is working fine
Returns: {success: bool, message: str, files_committed: int, pushed: bool, push_error?: str, commit_message: str}
Inputs: no named parameters.
update_chapterUpdate ChapterA
Update a specific chapter within a knowledge document efficiently.
When to use this tool:
Correcting information in a specific chapter
Expanding chapter with new content
Updating code examples or commands
Refreshing outdated chapter content
Adding clarifications or improvements
Key features:
Preserves all other chapters intact
Maintains document structure
Updates chapter summary for search
Efficient partial document update
You should:
Use exact chapter title (case-sensitive match)
Read current chapter first if needed
Preserve chapter's role in document flow
Update summary if content focus changes
Keep consistent formatting with other chapters
Consider impact on related chapters
Include .md extension in filename
DO NOT use when:
Chapter doesn't exist (use add_chapter)
Need to update multiple chapters
Restructuring entire document
Returns: {success: bool, message?: str, error?: str}
Inputs: chapter_title (required), filename (required), new_content (required), project_id (required), +1 more.
update_project_mainUpdate Project MainA
Create or completely replace main.md content for a project.
When to use this tool:
Migrating CLAUDE.md content to centralized MCP storage
Creating a new project's instruction set
Completely rewriting project guidelines
Setting up initial project configuration
Key features:
Creates project if it doesn't exist (auto-initialization)
Completely replaces existing content (destructive update)
Automatically commits changes to git
Validates markdown structure
You should:
Check if project exists first with get_project_main
Preserve important sections when doing full updates
Use update_project_section for partial changes instead
Include all necessary sections in the new content
Validate markdown formatting before submission
Consider the impact of complete replacement
Document why full replacement is necessary
DO NOT use when:
Making small updates (use update_project_section instead)
You haven't read the existing content first
Uncertain about losing existing content
Returns: {success: bool, message?: str, error?: str}
Inputs: content (required), project_id (required).
update_project_sectionUpdate Project SectionA
Update a specific section within the project main.md file efficiently.
When to use this tool:
Modifying a single section without affecting others
Adding new configuration or guidelines to existing section
Fixing errors in specific sections
Updating outdated information in targeted areas
Making incremental improvements
Key features:
Preserves all other sections intact (non-destructive)
More efficient than full file replacement
Maintains document structure
Atomic section-level updates
You should:
Identify the exact section header including "## " prefix
Read the current section content first if needed
Preserve section formatting conventions
Use this instead of update_project_main for small changes
Verify section exists before attempting update
Keep section content focused and relevant
Consider impact on related sections
DO NOT use when:
Section doesn't exist (use add_project_section)
Need to update multiple sections (batch operations)
Restructuring entire document
Section header must match exactly (e.g., "## Installation") Returns: {success: bool, message?: str, error?: str}
Inputs: new_content (required), project_id (required), section_header (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 27 tools
Most tools have clearly distinct purposes, with clear boundaries between knowledge files, chapters, TODOs, and project sections. However, there is some overlap between add_chapter/add_project_section and update_chapter/update_project_section, which could cause confusion about when to use each. The descriptions help clarify, but the similar naming and functionality create minor ambiguity.
Tool names follow a highly consistent verb_noun pattern throughout, with clear action-object pairs like create_knowledge_file, delete_todo, update_chapter, and get_server_info. All tools use snake_case consistently, and verbs like create, delete, update, get, list, add, remove, search, and sync are used predictably across different resource types.
With 27 tools, this server feels overloaded for a knowledge management system. While the domain is broad (knowledge files, chapters, TODOs, projects, and storage operations), many tools could be consolidated or simplified. The high count increases cognitive load and makes it harder for agents to navigate the complete tool surface efficiently.
The tool surface provides comprehensive CRUD/lifecycle coverage for all major resource types: knowledge files (create, get, delete, search), chapters (add, get, update, remove, list), TODOs (create, get tasks, complete, delete), and project sections (add, update, remove). There are no obvious gaps, and tools like sync_storage and get_server_info provide necessary infrastructure operations.
Related MCP Connectors
Project memory, documentation and controlled secret access for AI coding agents.
Shared team knowledge: search, read and update project documents with per-user permissions.
Shared project memory that keeps teammates and AI agents aligned across sessions.
Project memory shared by AI agents: decisions, results, tasks and handoffs across sessions.
1
Related MCP Servers
- AlicenseAqualityDmaintenanceProvides tools for managing project knowledge graphs, enabling structured representation of projects, tasks, milestones, resources, and team members.616MIT
- AlicenseCqualityDmaintenanceAn MCP server that helps teams create, manage, and access structured project documentation through six core document types, leveraging AI to generate comprehensive project knowledge management.5101MIT
- AlicenseNot gradedqualityDmaintenanceProvides access to personal/team knowledge repositories with tools to search, retrieve, and save information from various sources including Slack, Gmail, and document storage platforms.Apache 2.0
- AlicenseCqualityDmaintenanceManages knowledge graph data synchronized with GitHub repositories, enabling remote storage and collaboration of memory entities, relationships, and observations.17MIT