Skip to main content
Glama
Kratos MCP
by ceorkm

Kratos MCP

Ultra-Lean Memory System for AI Coding Tools

npm version License: MIT MCP Compatible TypeScript

Never explain your codebase again. Let AI remember everything.


Kratos has evolved. This repo is now legacy.

github.com/ceorkm/kratos-cli

Kratos is now a standalone CLI — faster, lighter, works with ANY AI agent.

No MCP overhead. No vendor lock-in. Just memory that works.

Star the new repo

npx kratos-memory

Claude Code, Codex, Cursor, Cline — anything that runs Bash.

Your existing memories work instantly. Same ~/.kratos/ storage, same SQLite format.

Go to Kratos CLI >


Related MCP server: mcp-memento

Why Kratos?

After building 30+ production apps with AI, we discovered a critical problem: AI tools forget everything between sessions. You explain your architecture, your patterns, your decisions—and tomorrow, you explain it all again.

Kratos MCP solves this with an ultra-lean memory system that gives AI perfect recall of your project—with minimal context overhead.

Features

100% Project Isolation

Each project gets its own SQLite database. No cross-contamination. Ever.

Zero Configuration

Auto-detects projects via git, package.json, or directory structure. Just install and code.

Ultra-Lean Architecture

Just 12 essential tools. 64% smaller context footprint than competitors.

Universal Protocol

Works with Claude, Cursor, Windsurf, Continue—any MCP-compatible tool.

Installation

# Install globally
npm install -g kratos-mcp

# Or run directly with npx (no installation required)
npx kratos-mcp

# Or install as a dependency
npm install kratos-mcp

Quick Start

1. Configure Your AI Tool

Add to your Claude Desktop config file:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Windows: %APPDATA%\Claude\claude_desktop_config.json

  • Linux: ~/.config/claude/claude_desktop_config.json

{
  "mcpServers": {
    "kratos": {
      "command": "npx",
      "args": ["--yes", "kratos-mcp@latest"]
    }
  }
}

Or if you have it installed globally:

{
  "mcpServers": {
    "kratos": {
      "command": "kratos-mcp",
      "args": []
    }
  }
}

Run this command in your terminal:

claude mcp add kratos -- npx --yes kratos-mcp@latest

Or for global installation:

# First install globally
npm install -g kratos-mcp@latest

# Then add to Claude Code
claude mcp add kratos -- kratos-mcp

Add to .cursor/mcp_config.json in your project root:

{
  "mcpServers": {
    "kratos": {
      "command": "npx",
      "args": ["--yes", "kratos-mcp@latest"]
    }
  }
}

Kratos works with any tool supporting the Model Context Protocol. The general format is:

{
  "command": "npx",
  "args": ["kratos-mcp"]
}

Compatible with: Windsurf, Cline, BoltAI, Augment Code, Roo Code, Zencoder, Amazon Q, Qodo Gen, JetBrains AI, Warp, Opencode, Continue.dev, Zed, and more!

Check your tool's documentation for specific MCP server configuration location.

2. Start Using Kratos

// Your AI now remembers:
// - Your authentication patterns
// - Your API structure
// - Your component architecture
// - Your coding standards
// - Every decision you've made

Available Tools

Kratos provides 12 ultra-lean tools optimized for minimal context consumption:

Memory Management (7 tools)

Tool

Description

memory_save

Store important project knowledge with tags, paths, and importance levels

memory_search

Smart semantic search with debug mode and path matching

memory_ask

Natural language queries about your memories

memory_get_recent

Get recently created memories with filtering

memory_get

Retrieve a specific memory by ID

memory_get_multiple

Bulk retrieve multiple memories

memory_forget

Delete a memory by ID

Security (1 tool)

Tool

Description

security_scan

Scan text for PII and secrets before saving

Project Management (3 tools)

Tool

Description

project_switch

Switch between different projects

project_current

Get current active project info

change_storage_path

Dynamically change storage location with automatic data migration

System (1 tool)

Tool

Description

system_status

Get system status and memory statistics

How It Works

AI Tool ──► Kratos MCP ──► Project Detection ──► SQLite + FTS5 ──► Perfect Context
  • SQLite + FTS5: Lightning-fast full-text search

  • Smart Scoring: Path matching + recency + importance

  • Auto-detection: Git, package.json, or directory-based

  • Secure: All data stays local, no external calls

  • Lean: Only 4 core components, minimal memory footprint

Performance

Metric

Value

Context Overhead

64% smaller than v3

Memory Retrieval

< 10ms

Project Switch

< 100ms

Storage Overhead

~2MB per project

Data Storage

~/.kratos/
├── projects/
│   ├── project-id-1/
│   │   └── memories.db          # SQLite database with FTS5
│   └── project-id-2/
│       └── memories.db
└── global/
    └── global.db                # Shared knowledge (optional)

Use change_storage_path to move data to custom locations like /opt/kratos or .kratos for per-project storage.

Example Usage

// Save a memory
await memory_save({
  summary: "JWT auth implementation",
  text: "We use httpOnly cookies with refresh tokens...",
  tags: ["auth", "security"],
  paths: ["src/middleware/auth.ts"],
  importance: 5
});

// Search memories
await memory_search({
  q: "authentication",
  k: 5,
  debug: true
});

// Ask natural language questions
await memory_ask({
  question: "How does our auth system work?",
  limit: 10
});

Contributing

git clone https://github.com/ceorkm/kratos-mcp.git
npm install
npm run build
npm run dev

License

MIT


Built for developers who value their time.

Report Bug · Request Feature

Available Tools

12 tools
change_storage_pathB

Dynamically change where Kratos stores data (with automatic migration)

Inputs: newPath (required), migrate, backup.

memory_askC

Ask questions about your memories using natural language

Inputs: question (required), limit.

memory_forgetB

Delete a memory by ID

Inputs: id (required).

memory_getB

Get a specific memory by ID with full text

Inputs: id (required).

memory_get_multipleB

Get multiple memories by IDs with full text (bulk operation)

Inputs: ids (required).

memory_get_recentB

Get recent memories from active project

Inputs: k, path_prefix, include_expired.

memory_saveC

Save a memory document to the active project

Inputs: summary (required), text (required), tags, paths, +2 more.

project_currentA

Get current active project

Inputs: no named parameters.

project_switchC

Switch to a different project

Inputs: project_path (required).

security_scanB

Scan text for PII and secrets

Inputs: text (required), redact.

system_statusA

Get system status and statistics

Inputs: no named parameters.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    B3.4/5.0

    Scored across 12 tools

    Disambiguation4/5

    Most tools have distinct purposes, but memory_get and memory_get_multiple are closely related, and memory_ask could be conflated with memory_search if not careful. Overall, boundaries are clear.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern in snake_case, making them predictable and easy to navigate.

    Tool Count5/5

    With 12 tools, the set is well-scoped for a memory and project management system, neither too sparse nor overwhelming.

    Completeness3/5

    Missing a memory update tool and project listing capability. The set covers core CRUD for memories but lacks lifecycle operations for projects and explicit memory updates.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides AI coding assistants with persistent project memory to retain architectural decisions, code patterns, and domain knowledge across sessions. It stores data locally in a SQLite database, allowing agents to remember, recall, and manage project-specific context using full-text search.
      3 npm
      Apache 2.0
    • A
      license
      A
      quality
      B
      maintenance
      Provides AI coding assistants with persistent memory storage using a local SQLite database. Enables tools to remember project details, notes, and relationships across sessions to maintain context and reduce repetitive explanations.
      17
      4
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides a local long-term memory layer for AI coding tools like Cursor and Claude Code, enabling cross-session, cross-tool sharing of project facts, user preferences, decisions, and workflows.
      11 npm
      2
      MIT