Skip to content
Back to search

ckb

Code intelligence for AI assistants - MCP server, CLI, and HTTP API with symbol navigation, impact analysis, and architecture mapping

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/SimplyLiz/ckb with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/SimplyLiz/ckb'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/simplyliz--ckb/badge.svg)](/listings/simplyliz--ckb)

HTML

<a href="/listings/simplyliz--ckb"><img src="/api/listings/simplyliz--ckb/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Option 1: npm (Recommended)

# Install globally
npm install -g @tastehub/ckb

# Or run directly with npx (no install needed)
npx @tastehub/ckb init

Option 2: Homebrew (macOS/Linux)

brew install simplyliz/ckb/ckb

> Use the fully-qualified name. Homebrew 6.0 requires third-party taps to be trusted before it loads them; installing this way grants that trust for this one formula. Tapping first and installing by short name fails with `Refusing to load formula ... from untrusted tap`.

Option 3: Build from Source

git clone https://github.com/SimplyLiz/CodeMCP.git
cd CodeMCP
go build -o ckb ./cmd/ckb

Setup

# 1. Initialize in your project
cd /path/to/your/project
ckb init   # or: npx @tastehub/ckb init

# 2. Generate SCIP index (optional but recommended)
ckb index  # auto-detects language and runs appropriate indexer

# 3. Connect to Claude Code
ckb setup  # creates .mcp.json automatically

# Or manually:
claude mcp add --transport stdio ckb -- npx @tastehub/ckb mcp

**Token efficiency shown at startup:**

CKB MCP Server v9.3.1
  Active tools: 25 / 110 (22%)
  Estimated context: ~4k tokens
  Preset: core

Now Claude can answer questions like: - *"What calls the HandleRequest function?"* - *"How is ProcessPayment reached from the API?"* - *"What's the blast radius if I change UserService?"* - *"Who owns the internal/api module?"* - *"Is this legacy code still used?"*

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 666 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # CKB — Code Knowledge Backend
  2. **Know your code. Change it safely. Ship with confidence.**
  3. [![npm version](https://img.shields.io/npm/v/@tastehub/ckb.svg)](https://www.npmjs.com/package/@tastehub/ckb)
  4. [![Website](https://img.shields.io/badge/website-codeknowledge.dev-teal.svg)](https://codeknowledge.dev)
  5. [![Documentation](https://img.shields.io/badge/docs-codeknowledge.dev-blue.svg)](https://codeknowledge.dev/docs)
  6. [![MCP Badge](https://lobehub.com/badge/mcp/simplyliz-codemcp)](https://lobehub.com/mcp/simplyliz-codemcp)
  7. [![LIP](https://img.shields.io/crates/v/lip-cli.svg?label=LIP&color=orange)](https://crates.io/crates/lip-cli)
  8. [![LIP docs](https://img.shields.io/badge/LIP-docs-blue.svg)](https://lip-sigma.vercel.app/docs)
  9. CKB transforms your codebase into a queryable knowledge base. Ask questions, understand impact, find owners, detect dead code—all through CLI, API, or AI assistants.
  10. > Think of it as a senior engineer who knows every line of code, every decision, and every owner—available 24/7 to answer your questions.
  11. ---
  12. ## Instant Answers to Hard Questions
  13. | Question | Without CKB | With CKB |
  14. |----------|-------------|----------|
  15. | "What breaks if I change this?" | Grep and hope | Precise blast radius with risk score |
  16. | "Who should review this PR?" | Guess from git blame | Data-driven reviewer suggestions |
  17. | "Is this code still used?" | Delete and see what breaks | Confidence-scored dead code detection |
  18. | "What tests should I run?" | Run everything (30 min) | Run affected tests only (2 min) |
  19. | "How does this system work?" | Read code for hours | Query architecture instantly |
  20. | "Who owns this code?" | Search CODEOWNERS manually | Ownership with drift detection |
  21. | "Are there exposed secrets?" | Manual grep for patterns | Automated scanning with 26 patterns |
  22. ---
  23. ## What You Can Do
  24. 🔍 **Understand** — Semantic search, call graphs, usage tracing, architecture maps
  25. ⚡ **Analyze** — Impact analysis, risk scoring, hotspot detection, coupling analysis
  26. 🛡️ **Protect** — Affected test detection, breaking change warnings, PR risk assessment
  27. 🔐 **Secure** — Secret detection, credential scanning, security-sensitive code identification
  28. 👥 **Collaborate** — Ownership lookup, reviewer suggestions, architectural decisions (ADRs)
  29. 📊 **Improve** — Dead code detection, tech debt tracking, documentation coverage
  30. 🚀 **Compound Operations** — Single-call tools (`explore`, `understand`, `prepareChange`) reduce AI tool calls by 60-70%
  31. 🔗 **Integrate** — CLI, HTTP API, MCP for AI tools, CI/CD pipelines, custom scripts
  32. ---
  33. ## Try It Now
  34. ```bash
  35. # See what's risky in your codebase
  36. ckb hotspots --format=human
  37. # Check what changed and what might break
  38. ckb diff-summary --format=human
  39. # Scan for exposed secrets
  40. ckb audit --format=human
  41. # Check architecture at a glance
  42. ckb arch --format=human
  43. # Check system status
  44. ckb status
  45. ```
  46. ---
  47. ## Works Everywhere
  48. | AI Assistants | CI/CD | Your Tools |
  49. |---------------|-------|------------|
  50. | Claude Code, Cursor, Windsurf, VS Code, Grok | GitHub Actions, GitLab CI | CLI, HTTP API, Scripts |
  51. **83% token reduction** with smart presets—load only the tools you need.
  52. ```bash
  53. # One command to connect to Claude Code
  54. ckb setup
  55. ```
  56. > **Building your own tools?** Use CKB as a backend via CLI, HTTP API, or MCP. See the **[Integration Guide](https://github.com/SimplyLiz/CodeMCP/wiki/Integration-Guide)** for examples in Node.js, Python, Go, and shell scripts.
  57. ---
  58. ## Learn More
  59. | Resource | Description |
  60. |----------|-------------|
  61. | 📖 **[Features Guide](https://github.com/SimplyLiz/CodeMCP/wiki/Features)** | Complete feature list with examples |
  62. | 💬 **[Prompt Cookbook](https://github.com/SimplyLiz/CodeMCP/wiki/Prompt-Cookbook)** | Real prompts for real problems |
  63. | 🔌 **[Integration Guide](https://github.com/SimplyLiz/CodeMCP/wiki/Integration-Guide)** | Use CKB in your own tools and scripts |
  64. | ⚡ **[Impact Analysis](https://github.com/SimplyLiz/CodeMCP/wiki/Impact-Analysis)** | Blast radius, affected tests, PR risk |
  65. | 🔧 **[CI/CD Integration](https://github.com/SimplyLiz/CodeMCP/wiki/CI-CD-Integration)** | GitHub Actions, GitLab CI templates |
  66. ---
  67. ## Quick Start
  68. ### Option 1: npm (Recommended)
  69. ```bash
  70. # Install globally
  71. npm install -g @tastehub/ckb
  72. # Or run directly with npx (no install needed)
  73. npx @tastehub/ckb init
  74. ```
  75. ### Option 2: Homebrew (macOS/Linux)
  76. ```bash
  77. brew install simplyliz/ckb/ckb
  78. ```
  79. > Use the fully-qualified name. Homebrew 6.0 requires third-party taps to be trusted before it loads them; installing this way grants that trust for this one formula. Tapping first and installing by short name fails with `Refusing to load formula ... from untrusted tap`.
  80. ### Option 3: Build from Source
  81. ```bash
  82. git clone https://github.com/SimplyLiz/CodeMCP.git
  83. cd CodeMCP
  84. go build -o ckb ./cmd/ckb
  85. ```
  86. ### Setup
  87. ```bash
  88. # 1. Initialize in your project
  89. cd /path/to/your/project
  90. ckb init # or: npx @tastehub/ckb init
  91. # 2. Generate SCIP index (optional but recommended)
  92. ckb index # auto-detects language and runs appropriate indexer
  93. # 3. Connect to Claude Code
  94. ckb setup # creates .mcp.json automatically
  95. # Or manually:
  96. claude mcp add --transport stdio ckb -- npx @tastehub/ckb mcp
  97. ```
  98. **Token efficiency shown at startup:**
  99. ```
  100. CKB MCP Server v9.3.1
  101. Active tools: 25 / 110 (22%)
  102. Estimated context: ~4k tokens
  103. Preset: core
  104. ```
  105. Now Claude can answer questions like:
  106. - *"What calls the HandleRequest function?"*
  107. - *"How is ProcessPayment reached from the API?"*
  108. - *"What's the blast radius if I change UserService?"*
  109. - *"Who owns the internal/api module?"*
  110. - *"Is this legacy code still used?"*
  111. ## Why CKB?
  112. | Without CKB | With CKB |
  113. |-------------|----------|
  114. | AI greps for patterns | AI navigates semantically |
  115. | "I found 47 matches for Handler" | "HandleRequest is called by 3 routes via CheckoutService" |
  116. | Guessing at impact | Knowing the blast radius with risk scores |
  117. | Reading entire files for context | Getting exactly what's relevant |
  118. | "Who owns this?" → search CODEOWNERS | Instant ownership with reviewer suggestions |
  119. | "Is this safe to change?" → hope | Hotspot trends + impact analysis |
  120. ## Three Ways to Use It
  121. | Interface | Best For |
  122. |-----------|----------|
  123. | **[MCP](https://github.com/SimplyLiz/CodeMCP/wiki/MCP-Integration)** | AI-assisted development — Claude, Cursor, Windsurf, VS Code, OpenCode, Grok |
  124. | **[CLI](https://github.com/SimplyLiz/CodeMCP/wiki/User-Guide)** | Quick lookups from terminal, scripting |
  125. | **[HTTP API](https://github.com/SimplyLiz/CodeMCP/wiki/API-Reference)** | IDE plugins, CI integration, custom tooling |
  126. ## How Indexing Works
  127. CKB uses **SCIP indexes** to understand your code. Think of it like a database that knows where every function is defined, who calls it, and how everything connects.
  128. ### The Basics
  129. ```bash
  130. # 1. Generate an index (auto-detects language)
  131. ckb index
  132. # 2. Check if your index is fresh
  133. ckb status
  134. ```
  135. Without an index, CKB still works using tree-sitter parsing (basic mode), but with an index you get:
  136. - Cross-file references ("who calls this function?")
  137. - Precise impact analysis
  138. - Call graph navigation
  139. ### Language Support
  140. Not all languages are equal. CKB classifies languages into **quality tiers** based on indexer maturity:
  141. | Tier | Quality | Languages |
  142. |------|---------|-----------|
  143. | **Tier 1** | Full support, all features | Go |
  144. | **Tier 2** | Full support, minor edge cases | TypeScript, JavaScript, Python |
  145. | **Tier 3** | Basic support, call graph may be incomplete | Rust, Java, Kotlin, C++, Ruby, Dart |
  146. | **Tier 4** | Experimental | C#, PHP |
  147. **Key limitations:**
  148. - **Incremental indexing** is Go-only. Other languages require full reindex.
  149. - **TypeScript monorepos** may need `--infer-tsconfig` flag
  150. - **C/C++** requires `compile_commands.json`
  151. - **Python** works best with activated virtual environment
  152. Run `ckb doctor --tier standard` to check if your language tools are properly installed.
  153. See **[Language Support](https://github.com/SimplyLiz/CodeMCP/wiki/Language-Support)** for indexer installation, known issues, and the full feature matrix.
  154. ### Keeping Your Index Fresh
  155. Your index becomes stale when you make commits. CKB offers several ways to stay current:
  156. | Method | Command | When to Use |
  157. |--------|---------|-------------|
  158. | Manual | `ckb index` | One-off updates, scripts |
  159. | Watch mode | `ckb index --watch` | Auto-refresh during development |
  160. | MCP watch | `ckb mcp --watch` | Auto-refresh in AI sessions |
  161. | CI webhook | `POST /api/v1/refresh` | Trigger from CI/CD |
  162. **Quick start for AI sessions:**
  163. ```bash
  164. ckb mcp --watch # Auto-reindexes every 30s when stale
  165. ```
  166. **Check staleness:**
  167. ```bash
  168. ckb status
  169. # Shows: "5 commits behind HEAD" or "Up to date"
  170. ```
  171. For Go projects, CKB uses **incremental indexing**—only changed files are processed, making updates fast.
  172. See the **[Index Management Guide](https://github.com/SimplyLiz/CodeMCP/wiki/Index-Management)** for complete documentation.
  173. ## Features
  174. | Feature | Description |
  175. |---------|-------------|
  176. | [**Compound Operations**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#compound-operations) | `explore`, `understand`, `prepareChange` — single-call tools that reduce AI overhead by 60-70% |
  177. | [**Code Navigation**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#code-navigation--discovery) | Semantic search, call graphs, trace usage, find entrypoints |
  178. | [**Impact Analysis**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#impact-analysis--safety) | Blast radius, risk scoring, affected tests, breaking changes (`compareAPI`) |
  179. | [**Architecture**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#architectural-understanding) | Module overview, ADRs, dependency graphs, explain origin |
  180. | [**Ownership**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#ownership--review) | CODEOWNERS + git blame, reviewer suggestions, drift detection |
  181. | [**Code Quality**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#code-quality--risk) | Dead code detection (`findDeadCode`), coupling analysis, complexity |
  182. | [**Security**](https://github.com/SimplyLiz/CodeMCP/wiki/Security) | Secret detection, credential scanning, allowlists |
  183. | [**Documentation**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#documentation-intelligence) | Doc-symbol linking, staleness detection, coverage metrics |
  184. | [**Multi-Repo**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#multi-repo--federation) | Federation, API contracts, remote index serving |
  185. | [**Runtime**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#runtime-intelligence) | OpenTelemetry integration, observed usage, production dead code |
  186. | [**Streaming**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#streaming) | SSE streaming for `findReferences`, `searchSymbols` with real-time progress |
  187. | [**Automation**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#automation--cicd) | Daemon mode, watch mode, webhooks, incremental indexing |
  188. 📖 **[Full Features Guide](https://github.com/SimplyLiz/CodeMCP/wiki/Features)** — Detailed documentation with examples
  189. 📋 **[Changelog](https://github.com/SimplyLiz/CodeMCP/blob/main/CHANGELOG.md)** — Version history
  190. ## PR Review
  191. CKB review runs 21 quality checks in 5 seconds — secrets, breaking changes, dead code, complexity, test gaps, bug patterns, and more. Zero tokens, zero API calls.
  192. When your AI assistant (Claude Code, Cursor, Windsurf) reviews a PR, it calls CKB first and gets structured analysis in ~1k tokens. Then it only reads the files that matter — saving **50-80% of tokens** on large PRs.
  193. ```bash
  194. ckb review --base=main # Human-readable review
  195. ckb review --base=main --ci # CI mode (exit codes)
  196. ckb review --base=main --post=123 # Post as PR comment
  197. ```
  198. Works in CI without any LLM:
  199. ```yaml
  200. - run: npx @tastehub/ckb review --base=main --ci --format=sarif > review.sarif
  201. ```
  202. | | Without CKB | With CKB |
  203. |---|---|---|
  204. | LLM tokens on 100-file PR | ~200k | ~50k |
  205. | Files LLM reads | all | ~10 (CKB-flagged) |
  206. | Secrets/breaking/dead-code checked | no | yes (all files) |
  207. 📖 [**How it helps AI review**](docs/marketing/ckb-review/how-it-helps-llm.md) · [**Benchmarks**](docs/marketing/ckb-review/benchmarks.md) · [**CI Integration**](docs/marketing/ckb-review/ci-integration.md) · [**Quickstart**](docs/marketing/ckb-review/quickstart.md)
  208. ## CLI
  209. ```bash
  210. ckb status # System health (with remediation suggestions)
  211. ckb search Handler # Find symbols
  212. ckb diff-summary # Analyze what changed
  213. ckb hotspots # Risky areas
  214. ckb arch # Architecture overview
  215. ckb ownership # File/path ownership
  216. ckb mcp # Start MCP server
  217. ```
  218. **Compound Operations (via MCP):**
  219. ```bash
  220. # These tools combine multiple queries into single calls
  221. explore # Area exploration: symbols, dependencies, hotspots
  222. understand # Symbol deep-dive: refs, callers, explanation
  223. prepareChange # Pre-change analysis: impact, tests, risk
  224. batchGet # Fetch up to 50 symbols at once
  225. batchSearch # Run up to 10 searches at once
  226. ```
  227. 📖 **[User Guide](https://github.com/SimplyLiz/CodeMCP/wiki/User-Guide)** — All CLI commands and options
  228. ## HTTP API
  229. ```bash
  230. # Start the HTTP server
  231. ckb serve --port 8080
  232. # Example calls
  233. curl http://localhost:8080/health
  234. curl http://localhost:8080/status
  235. curl "http://localhost:8080/search?q=NewServer"
  236. curl http://localhost:8080/architecture
  237. curl "http://localhost:8080/ownership?path=internal/api"
  238. curl http://localhost:8080/hotspots
  239. # Index Server Mode (v7.3) - serve indexes to remote clients
  240. ckb serve --port 8080 --index-server --index-config config.toml
  241. # Index server endpoints
  242. curl http://localhost:8080/index/repos
  243. curl http://localhost:8080/index/repos/company%2Fcore-lib/meta
  244. curl "http://localhost:8080/index/repos/company%2Fcore-lib/symbols?limit=100"
  245. curl "http://localhost:8080/index/repos/company%2Fcore-lib/search/symbols?q=Handler"
  246. # Upload endpoints (with compression + auth)
  247. curl -X POST http://localhost:8080/index/repos \
  248. -H "Content-Type: application/json" \
  249. -H "Authorization: Bearer ckb_xxx" \
  250. -d '{"id":"my-org/my-repo","name":"My Repo"}'
  251. gzip -c index.scip | curl -X POST http://localhost:8080/index/repos/my-org%2Fmy-repo/upload \
  252. -H "Content-Encoding: gzip" \
  253. -H "Authorization: Bearer ckb_xxx" \
  254. --data-binary @-
  255. # Token management (index server admin)
  256. ckb token create --name "ci-upload" --scope upload # Create API key
  257. ckb token list # List all tokens
  258. ckb token revoke ckb_xxx # Revoke a token
  259. ckb token rotate ckb_xxx # Rotate (new secret, same ID)
  260. ```
  261. ## MCP Integration
  262. CKB works with any MCP-compatible AI coding tool.
  263. <details>
  264. <summary><strong>Claude Code</strong></summary>
  265. ```bash
  266. # Auto-configure for current project
  267. npx @tastehub/ckb setup
  268. # Or add globally for all projects
  269. npx @tastehub/ckb setup --global
  270. ```
  271. Or manually add to `.mcp.json`:
  272. ```json
  273. {
  274. "mcpServers": {
  275. "ckb": {
  276. "command": "npx",
  277. "args": ["@tastehub/ckb", "mcp"]
  278. }
  279. }
  280. }
  281. ```
  282. </details>
  283. <details>
  284. <summary><strong>Cursor</strong></summary>
  285. Add to `~/.cursor/mcp.json` (global) or `.cursor/mcp.json` (project):
  286. ```json
  287. {
  288. "mcpServers": {
  289. "ckb": {
  290. "command": "npx",
  291. "args": ["@tastehub/ckb", "mcp"]
  292. }
  293. }
  294. }
  295. ```
  296. </details>
  297. <details>
  298. <summary><strong>Windsurf</strong></summary>
  299. Add to `~/.codeium/windsurf/mcp_config.json`:
  300. ```json
  301. {
  302. "mcpServers": {
  303. "ckb": {
  304. "command": "npx",
  305. "args": ["@tastehub/ckb", "mcp"]
  306. }
  307. }
  308. }
  309. ```
  310. </details>
  311. <details>
  312. <summary><strong>VS Code</strong></summary>
  313. Add to your VS Code `settings.json`:
  314. ```json
  315. {
  316. "mcp": {
  317. "servers": {
  318. "ckb": {
  319. "type": "stdio",
  320. "command": "npx",
  321. "args": ["@tastehub/ckb", "mcp"]
  322. }
  323. }
  324. }
  325. }
  326. ```
  327. </details>
  328. <details>
  329. <summary><strong>OpenCode</strong></summary>
  330. Add to `opencode.json` in project root:
  331. ```json
  332. {
  333. "mcp": {
  334. "ckb": {
  335. "type": "local",
  336. "command": ["npx", "@tastehub/ckb", "mcp"],
  337. "enabled": true
  338. }
  339. }
  340. }
  341. ```
  342. </details>
  343. <details>
  344. <summary><strong>Grok</strong></summary>
  345. ```bash
  346. # Auto-configure for current project
  347. npx @tastehub/ckb setup --tool=grok
  348. # Or add globally
  349. npx @tastehub/ckb setup --tool=grok --global
  350. ```
  351. Or manually add to `.grok/settings.json` (project) or `~/.grok/user-settings.json` (global):
  352. ```json
  353. {
  354. "mcpServers": {
  355. "ckb": {
  356. "name": "ckb",
  357. "transport": "stdio",
  358. "command": "npx",
  359. "args": ["@tastehub/ckb", "mcp"]
  360. }
  361. }
  362. }
  363. ```
  364. </details>
  365. <details>
  366. <summary><strong>Claude Desktop</strong></summary>
  367. Claude Desktop doesn't have a project context, so you must specify the repository path.
  368. **Automatic setup** (recommended):
  369. ```bash
  370. cd /path/to/your/repo
  371. ckb setup --tool=claude-desktop
  372. ```
  373. **Manual configuration** — add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
  374. ```json
  375. {
  376. "mcpServers": {
  377. "ckb": {
  378. "command": "npx",
  379. "args": ["-y", "@tastehub/ckb", "mcp"],
  380. "env": {
  381. "CKB_REPO": "/path/to/your/repo"
  382. }
  383. }
  384. }
  385. }
  386. ```
  387. The `CKB_REPO` environment variable tells CKB which repository to analyze. Claude Desktop can only work with one repository at a time.
  388. </details>
  389. <details>
  390. <summary><strong>Windows</strong></summary>
  391. Use `cmd /c` wrapper in any config above:
  392. ```json
  393. {
  394. "mcpServers": {
  395. "ckb": {
  396. "command": "cmd",
  397. "args": ["/c", "npx", "@tastehub/ckb", "mcp"]
  398. }
  399. }
  400. }
  401. ```
  402. </details>
  403. <details>
  404. <summary><strong>Presets (Token Optimization)</strong></summary>
  405. CKB exposes 110+ tools, but most sessions only need a subset. Use presets to reduce token overhead by up to 77%:
  406. ```bash
  407. # List all available presets with tool counts and token estimates
  408. ckb mcp --list-presets
  409. # Default: core preset (25 essential tools)
  410. ckb mcp
  411. # Workflow-specific presets
  412. ckb mcp --preset=core # 25 tools - search, explain, impact (default)
  413. ckb mcp --preset=review # 42 tools - core + diff, ownership, PR review
  414. ckb mcp --preset=refactor # 42 tools - core + coupling, dead code
  415. ckb mcp --preset=federation # 46 tools - core + cross-repo
  416. ckb mcp --preset=docs # 34 tools - core + doc-symbol linking
  417. ckb mcp --preset=ops # 43 tools - core + jobs, webhooks, metrics
  418. ckb mcp --preset=full # 110 tools - complete feature set
  419. ```
  420. In MCP config:
  421. ```json
  422. {
  423. "mcpServers": {
  424. "ckb": {
  425. "command": "npx",
  426. "args": ["@tastehub/ckb", "mcp", "--preset=review"]
  427. }
  428. }
  429. }
  430. ```
  431. The AI can dynamically expand the toolset mid-session using the `expandToolset` tool.
  432. </details>
  433. ## Under the Hood
  434. CKB orchestrates multiple code intelligence backends, using whatever is available and stacking their strengths — more backends running means richer answers:
  435. - **Cartographer** — Fast structural analysis (architecture, dependencies, blast-radius, coupling, directory rollup) that needs **no index** and works the moment CKB is installed. Compiled into the binary, so it ships in the npm and Homebrew builds by default.
  436. - **SCIP** — Precise, pre-indexed symbol data for exact definitions, references, and call graphs (run `ckb index`)
  437. - **LSP** — Real-time language server queries
  438. - **Git** — Blame, history, churn analysis, ownership
  439. - **LIP** — Semantic embedding daemon for nearest-neighbour search and re-ranking. Runs as a **separate, optional daemon** — install and start it alongside CKB.
  440. Results are merged intelligently and compressed for LLM context limits. Every backend except Git is optional; CKB degrades gracefully to whatever is present.
  441. > **LIP enhances semantic search, PR novelty detection, test discovery, file boundary analysis, and architecture coupling signals.** When LIP is running alongside CKB, search quality improves significantly — especially for natural-language queries that don't match symbol names literally. See [Hybrid Retrieval](https://github.com/SimplyLiz/CodeMCP/wiki/Hybrid-Retrieval) for details, or the [LIP documentation](https://lip-sigma.vercel.app/docs).
  442. Persistent knowledge survives across sessions:
  443. - **Module Registry** — Boundaries, responsibilities, tags
  444. - **Ownership Registry** — CODEOWNERS + git-blame with time decay
  445. - **Hotspot Tracker** — Historical snapshots with trend analysis
  446. - **Decision Log** — ADRs with full-text search
  447. ## Who Should Use CKB?
  448. - **Developers using AI assistants** — Give your AI tools superpowers
  449. - **Teams with large codebases** — Navigate complexity efficiently
  450. - **Anyone doing refactoring** — Understand impact before changing
  451. - **Code reviewers** — See the full picture of changes
  452. - **Tech leads** — Track architectural health over time
  453. ## Limitations (Honest Take)
  454. **CKB excels at:**
  455. - Static code navigation—finding definitions, references, call graphs
  456. - Impact analysis for safe refactoring
  457. - Ownership lookup (CODEOWNERS + git blame)
  458. - Architecture and module understanding
  459. **CKB won't help with:**
  460. - Dynamic dispatch / runtime behavior (use debugger)
  461. - Generated code that isn't indexed
  462. - Code generation, linting, or formatting
  463. - Cross-repo calls (use [federation](https://github.com/SimplyLiz/CodeMCP/wiki/Federation) for this)
  464. > CKB is static analysis, not magic. Always verify critical decisions by reading the actual code.
  465. 📖 **[Practical Limits](https://github.com/SimplyLiz/CodeMCP/wiki/Practical-Limits)** — Full guide on accuracy, blind spots, and when to trust results
  466. ## Documentation
  467. See the **[Full Documentation Wiki](https://github.com/SimplyLiz/CodeMCP/wiki)** for:
  468. - [Quick Start](https://github.com/SimplyLiz/CodeMCP/wiki/Quick-Start) — Step-by-step installation
  469. - [Prompt Cookbook](https://github.com/SimplyLiz/CodeMCP/wiki/Prompt-Cookbook) — Real prompts for real problems
  470. - [Language Support](https://github.com/SimplyLiz/CodeMCP/wiki/Language-Support) — SCIP indexers and support tiers
  471. - [Practical Limits](https://github.com/SimplyLiz/CodeMCP/wiki/Practical-Limits) — Accuracy notes, blind spots
  472. - [User Guide](https://github.com/SimplyLiz/CodeMCP/wiki/User-Guide) — CLI commands and best practices
  473. - [Index Management](https://github.com/SimplyLiz/CodeMCP/wiki/Index-Management) — How indexing works, auto-refresh methods
  474. - [Incremental Indexing](https://github.com/SimplyLiz/CodeMCP/wiki/Incremental-Indexing) — Fast index updates for Go projects
  475. - [Doc-Symbol Linking](https://github.com/SimplyLiz/CodeMCP/wiki/Doc-Symbol-Linking) — Symbol detection in docs, staleness checking
  476. - [Authentication](https://github.com/SimplyLiz/CodeMCP/wiki/Authentication) — API tokens, scopes, rate limiting
  477. - [MCP Integration](https://github.com/SimplyLiz/CodeMCP/wiki/MCP-Integration) — Claude Code setup, 110+ tools
  478. - [API Reference](https://github.com/SimplyLiz/CodeMCP/wiki/API-Reference) — HTTP API documentation
  479. - [Daemon Mode](https://github.com/SimplyLiz/CodeMCP/wiki/Daemon-Mode) — Always-on service with scheduler, webhooks
  480. - [Configuration](https://github.com/SimplyLiz/CodeMCP/wiki/Configuration) — All options including MODULES.toml
  481. - [Architecture](https://github.com/SimplyLiz/CodeMCP/wiki/Architecture) — System design and components
  482. - [Security](https://github.com/SimplyLiz/CodeMCP/wiki/Security) — Secret detection, credential scanning
  483. - [Telemetry](https://github.com/SimplyLiz/CodeMCP/wiki/Telemetry) — Runtime observability, dead code detection
  484. - [Federation](https://github.com/SimplyLiz/CodeMCP/wiki/Federation) — Cross-repository queries
  485. - [CI/CD Integration](https://github.com/SimplyLiz/CodeMCP/wiki/CI-CD-Integration) — GitHub Actions, PR analysis
  486. ## Requirements
  487. **Using npm (recommended):**
  488. - Node.js 16+
  489. - Git
  490. **Building from source:**
  491. - Go 1.21+
  492. - Git
  493. **Optional (for enhanced analysis):**
  494. - SCIP indexer for your language (scip-go, scip-typescript, etc.) — run `ckb index` to auto-install
  495. - [LIP v2.3+](https://lip-sigma.vercel.app) semantic embedding daemon (requires Rust/cargo) — strongly recommended for best search quality ([docs](https://lip-sigma.vercel.app/docs), [crates.io](https://crates.io/crates/lip-cli)):
  496. ```bash
  497. cargo install lip-cli
  498. lip daemon --socket ~/.local/share/lip/lip.sock
  499. ```
  500. ## License
  501. **Free for:**
  502. - Personal use
  503. - Open source projects
  504. - Startups & small businesses under $25k annual revenue
  505. **Commercial license required** for organizations with $25k+ annual revenue. See [pricing](https://codeknowledge.dev/pricing) for Team and Enterprise plans, or [LICENSE](LICENSE) for full terms.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.