← Back to directory
C

CKB

Community
Know your code. Change it safely. Ship with confidence.
GitHub source repository ↗
★ 108 Stars Category · Dev Tools Popular Source revision 041d5ddb7429
43FMRS · D
Reliability
5/20
Security and permissions
8/20
Maintenance
6/20
Documentation
12/20
Setup experience
12/20

CKB is a feature-rich code intelligence MCP server offering a comprehensive toolset (80+) covering navigation, impact analysis, architecture, security, ownership, and quality. Its compound operations and presets significantly reduce AI token consumption. The main strengths are static analysis and multi-language support, though quality varies (Go best, PHP experimental). It requires indexing, which can become stale, and does not handle dynamic behavior. Overall, it is highly useful for refactoring, review, and AI-assisted development, but be mindful of static analysis limitations and index maintenance.

Read the FMRS scoring method →

CKB (Code Knowledge Backend) transforms your codebase into a queryable knowledge base. It provides 80+ MCP tools, CLI, and HTTP API for symbol navigation, impact analysis, architecture mapping, dead code detection, secret scanning, code ownership, and more. Leveraging SCIP indexes, LSP, Git, and optional LIP semantic embeddings, it offers precise code intelligence for AI assistants or as a backend for CI/CD and custom tooling. It features compound operations like explore, understand, and prepareChange that reduce AI tool calls by 60-70%, and presets that cut token usage by up to 77%. CKB has tiered language support, with Go, TypeScript, JavaScript, and Python being best.

Tools

explore
Area exploration: symbols, dependencies, hotspots
understand
Symbol deep-dive: refs, callers, explanation
prepareChange
Pre-change analysis: impact, tests, risk
batchGet
Fetch up to 50 symbols at once
batchSearch
Run up to 10 searches at once
searchSymbols
Semantic search for symbols
findReferences
Find all references to a symbol
callGraph
Generate call graph
traceUsage
Trace usage of a symbol
findEntrypoints
Find code entrypoints
impactAnalysis
Analyze impact scope of changes
riskScore
Compute risk score
affectedTests
Identify affected tests
compareAPI
Compare API backward compatibility
blastRadius
Determine blast radius
architecture
Get architecture overview
moduleOverview
Get module overview
adrs
Retrieve architecture decision records
dependencyGraph
Generate dependency graph
explainOrigin
Explain origin of a symbol
findDeadCode
Detect dead code
couplingAnalysis
Analyze coupling
complexity
Compute code complexity
hotspots
Identify hotspot areas
ownership
Find code ownership
reviewerSuggestions
Suggest reviewers
driftDetection
Detect ownership drift
detectSecrets
Detect exposed secrets
scanCredentials
Scan for credentials
securitySensitive
Identify security-sensitive code
docSymbols
Doc-symbol linking
docStaleness
Check doc staleness
docCoverage
Doc coverage metrics
federation
Cross-repo queries
openTelemetry
OpenTelemetry integration
observedUsage
Observed usage in production
streamReferences
Stream references
streamSearch
Stream search results
expandToolset
Dynamically expand toolset

Setup

Options: 1) npm (recommended): npm install -g @tastehub/ckb; 2) Homebrew (macOS/Linux): brew tap SimplyLiz/ckb && brew install ckb; 3) Build from source: git clone https://github.com/SimplyLiz/CodeMCP.git && cd CodeMCP && go build -o ckb ./cmd/ckb. After installation, run ckb init in your project directory, optionally ckb index to generate SCIP index, then ckb setup to connect Claude Code. You can also manually add npx @tastehub/ckb mcp to your MCP config.

claude_desktop_config.json
{
  "mcpServers": {
    "ckb": {
      "command": "npx",
      "args": [
        "@tastehub/ckb",
        "mcp"
      ]
    }
  }
}

Fit and risk

Best for

  • Developers using AI assistants who want them to have precise code awareness
  • Teams with large codebases needing efficient navigation
  • Anyone doing refactoring who wants to understand impact
  • Code reviewers who need the full picture of changes
  • Tech leads tracking architectural health over time

Not for

  • Dynamic dispatch or runtime behavior analysis (use a debugger)
  • Generated code that isn't indexed
  • Code generation, linting, or formatting
  • Cross-repo calls (use federation for this)

Required permissions

  • Read access to codebase files and git history
  • Generate and maintain SCIP indexes (local files)
  • Execute the MCP server process via stdio
  • Optionally create API tokens for authentication when using the index server
  • Optional network access for HTTP API server

Risks and side effects

  • SCIP indexes may become stale, leading to inaccurate references or impact analysis
  • Indexing large codebases can be time and disk intensive
  • Dynamic or reflective code may be misanalyzed
  • Requires installing SCIP indexers, and language support quality varies
  • Inputs are not sanitized, so verify outputs

Troubleshooting

  1. Run `ckb status` to check system health
  2. Run `ckb doctor --tier standard` to check language tools
  3. If index is outdated, run `ckb index` or use `ckb mcp --watch` for auto-refresh
  4. For TypeScript monorepos, may need `--infer-tsconfig` flag
  5. C/C++ requires `compile_commands.json`
  6. For best search quality, install LIP daemon manually: `cargo install lip-cli` and start with `lip daemon --socket ~/.local/share/lip/lip.sock`

Use cases

Semantic code navigation in AI-assisted development (Claude Code, Cursor, etc.)
Impact analysis and risk scoring before refactoring
Identifying affected tests to narrow down test runs
Code ownership tracking and reviewer suggestions via CODEOWNERS and git blame
Dead code detection and tech debt tracking
Secret scanning and credential detection for security
Architecture mapping and module understanding
CI/CD integration for PR review and quality gates

Supported clients

Claude DesktopFull support
Claude CodeFull support
CursorFull support
WindsurfFull support
VS CodeFull support
OpenCodeFull support
GrokFull support