Provides cross-session memory and semantic search for AI coding assistants using a git-synced knowledge graph.
Also known as keshrath/agent-knowledge
- Stars
- 19
- Tools
- 6
- Downloads, 30 days
- —
- Latest version
- 3.0.0
- Last commit
- Nov 14, 2026
- License
- MIT
What is agent-knowledge MCP?
agent-knowledge provides cross-session memory and semantic search for AI coding assistants using a git-synced knowledge graph. It exposes 6 tools, such as knowledge, knowledge_search, knowledge_session.
Summary generated from the project's README
About agent-knowledge MCP server
agent-knowledge provides persistent memory and semantic search for AI coding assistants to prevent context loss between sessions. It functions as a git-synced markdown vault that stores architecture decisions, workflows, and project context, allowing information to persist across different machines and tools. The server works locally and supports major assistants including Claude Code, Cursor, Aider, Cline, and Continue.dev by automatically discovering their session files.
Users interact with the system through six specialized MCP tools such as knowledge_search, knowledge_graph, and knowledge_analyze. The server uses a hybrid search approach combining semantic vector similarity with TF-IDF keyword ranking to ensure high recall. It includes advanced features like automatic secrets scrubbing before git pushes, staleness detection based on code activity, and a knowledge-ingest skill that uses tree-sitter to extract structural information from codebases in languages like TypeScript, Python, and Rust. Developers can configure local or remote embedding providers including OpenAI, Claude, or Hugging Face.
What you can do with it
- 1Retrieve past coding decisionsAsk the assistant to find specific architectural choices or debugging insights from previous sessions.
- 2Sync knowledge across machinesMaintain a consistent project context when switching between different development environments using git.
- 3Automate codebase documentationGenerate a structured knowledge graph and entries by ingesting a local directory.
- 4Identify missing documentationFind topics or queries that have returned no results to determine what new knowledge entries should be created.
Written from the project's README. Every use case is checked against a quote from it.
How to install agent-knowledge MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall agent-knowledge MCP in Claude Code
$ claude mcp add agent-knowledge -- npx -y agent-knowledgeInstall agent-knowledge MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"agent-knowledge": {
"command": "npx",
"args": [
"-y",
"agent-knowledge"
]
}
}
}Install agent-knowledge MCP in VS Code
.vscode/mcp.json
{
"servers": {
"agent-knowledge": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"agent-knowledge"
]
}
}
}Install agent-knowledge MCP in VS Code CLI
$ code --add-mcp '{"name":"agent-knowledge","type":"stdio","command":"npx","args":["-y","agent-knowledge"]}'Install agent-knowledge MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"agent-knowledge": {
"command": "npx",
"args": [
"-y",
"agent-knowledge"
]
}
}
}Install agent-knowledge MCP in Codex
$ codex mcp add agent-knowledge -- npx -y agent-knowledgeInstall agent-knowledge MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.agent-knowledge] command = "npx" args = ["-y", "agent-knowledge"]
Install agent-knowledge MCP in Gemini CLI
$ gemini mcp add -s user agent-knowledge npx -- -y agent-knowledgeInstall agent-knowledge MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"agent-knowledge": {
"command": "npx",
"args": [
"-y",
"agent-knowledge"
]
}
}
}Started by HostedMCP on 16 Nov 2026
We ran this command for agent-knowledge 3.0.0 in an isolated container with no network and no keys. It answered and listed 6 tools.
agent-knowledge MCP tools 6
Read from the server with tools/listknowledgeKnowledge base CRUD, sync, and session-start hydration. Actions: "list" (browse entries), "read" (get entry content), "write" (create/update entry, auto git sync), "delete" (remove entry, auto git sync), "sync" (manual git pull + push), "wakeup" (return token-budgeted section-priority context bundle — identity, active_tasks, recent_decisions, known_gotchas, last_session_summary, top_weighted, semantic_fallback — call once at session start).
knowledge_searchSearch across sessions AND knowledge entries. Returns `{mode, sessions, knowledge}`. General mode (no `scope`): hybrid TF-IDF + semantic over both sources, with optional MMR diversity and category boost. Scoped mode (`scope` set): sessions-only filtered recall for a specific domain (errors, plans, configs, tools, files, decisions).
knowledge_sessionSession operations: list sessions, get a full conversation, or get a summary. Use action "list" to browse sessions, "get" to retrieve messages, "summary" for a quick overview.
knowledge_adminAdmin operations: view vector store stats, view/update configuration, rebuild embeddings, prune orphan session embeddings, or VACUUM the database. Use action "status" for index stats, "config" to view or update settings, "rebuild_embeddings" to re-embed all knowledge entries (useful when switching providers), "prune_orphans" to delete embeddings for sessions no longer present on disk, "vacuum" to reclaim free pages.
knowledge_graphKnowledge graph operations with temporal validity and code structure support. Create/remove edges, traverse via directed BFS, bulk-import code graph edges. Relationship types: related_to, supersedes, depends_on, contradicts, specializes, part_of, alternative_to, builds_on, calls, imports, inherits. Code structure types (calls/imports/inherits) are created by knowledge-ingest and use "code:" prefixed node IDs.
knowledge_analyzeAnalysis tools: find duplicates, unconnected entries, most-connected concepts (god nodes), bridge entries, knowledge gaps, zero-result search queries, stale-by-code-activity entries, or generate a compact knowledge brief. Actions: consolidate, reflect, god_nodes, bridges, gaps, brief, search_gaps, stale_by_code_activity.
| knowledge | Knowledge base CRUD, sync, and session-start hydration. Actions: "list" (browse entries), "read" (get entry content), "write" (create/update entry, auto git sync), "delete" (remove entry, auto git sync), "sync" (manual git pull + push), "wakeup" (return token-budgeted section-priority context bundle — identity, active_tasks, recent_decisions, known_gotchas, last_session_summary, top_weighted, semantic_fallback — call once at session start). | |
| knowledge_search | Search across sessions AND knowledge entries. Returns `{mode, sessions, knowledge}`. General mode (no `scope`): hybrid TF-IDF + semantic over both sources, with optional MMR diversity and category boost. Scoped mode (`scope` set): sessions-only filtered recall for a specific domain (errors, plans, configs, tools, files, decisions). | |
| knowledge_session | Session operations: list sessions, get a full conversation, or get a summary. Use action "list" to browse sessions, "get" to retrieve messages, "summary" for a quick overview. | |
| knowledge_admin | Admin operations: view vector store stats, view/update configuration, rebuild embeddings, prune orphan session embeddings, or VACUUM the database. Use action "status" for index stats, "config" to view or update settings, "rebuild_embeddings" to re-embed all knowledge entries (useful when switching providers), "prune_orphans" to delete embeddings for sessions no longer present on disk, "vacuum" to reclaim free pages. | |
| knowledge_graph | Knowledge graph operations with temporal validity and code structure support. Create/remove edges, traverse via directed BFS, bulk-import code graph edges. Relationship types: related_to, supersedes, depends_on, contradicts, specializes, part_of, alternative_to, builds_on, calls, imports, inherits. Code structure types (calls/imports/inherits) are created by knowledge-ingest and use "code:" prefixed node IDs. | |
| knowledge_analyze | Analysis tools: find duplicates, unconnected entries, most-connected concepts (god nodes), bridge entries, knowledge gaps, zero-result search queries, stale-by-code-activity entries, or generate a compact knowledge brief. Actions: consolidate, reflect, god_nodes, bridges, gaps, brief, search_gaps, stale_by_code_activity. |
Automated checks
Ran Nov 16, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablekeshrath/agent-knowledge is public and reachablegithub.com/keshrath/agent-knowledge ↗Pass
- Package names this repository as its sourceagent-knowledge names keshrath/agent-knowledge as sourcenpmjs.com/package/agent-knowledge ↗Pass
- Build provenance (Sigstore attestation)Sigstore attestation for agent-knowledgenpmjs.com/package/agent-knowledge/v/3.0.0#provenance ↗Pass
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-14github.com/keshrath/agent-knowledge ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNo popular package one edit away from agent-knowledgePass
- No critical advisory in the package or its dependenciesthe package checked; no critical advisoryosv.dev ↗Pass
- No hidden instructions to the model6 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubagent-knowledge
Cross-session memory and recall for AI coding assistants -- works with Claude Code, Cursor, OpenCode, Cline, Continue.dev, and Aider out of the box. Git-synced knowledge base, hybrid semantic+TF-IDF search, auto-distillation with secrets scrubbing.
Benchmark: R@5 = 97.2% (sparse) / 98.8% (hybrid) on longmemeval_s and 86.0% (sparse) / 88.4% (hybrid) on the harder longmemeval_m split — the public LongMemEval academic benchmark (Wu et al. 2024, ICLR 2025), full 500 questions per split, no LLM, no API key, runs entirely offline. +8.6pp to +13.2pp R@5 over the paper's official flat-bm25 baseline in apples-to-apples reproduction. Full per-category table, reproduction instructions, and paper-comparison details in bench/README.md.
In Claude Code, the agent-knowledge plugin adds the /knowledge pane: the knowledge base beside the conversation. How it works, with pictures: the user manual.

Why
AI coding sessions are ephemeral. When a session ends, everything it learned -- architecture decisions, debugging insights, project context -- is gone. The next session starts from scratch.
agent-knowledge solves this with two complementary systems:
- Knowledge Base -- a git-synced markdown vault of structured entries (decisions, workflows, project context) that persists across sessions and machines.
- Session Search -- TF-IDF ranked full-text search across session transcripts from all your coding tools, so agents can recall what happened before -- regardless of which tool was used.
Supported Tools
Sessions from all major AI coding assistants are auto-discovered -- if a tool is installed, its sessions appear automatically.
| Tool | Format | Auto-detected path |
|---|---|---|
| Claude Code | JSONL | ~/.claude/projects/ |
| Cursor | JSONL | ~/.cursor/projects/*/agent-transcripts/ |
| Codex CLI | JSONL | ~/.codex/projects/ |
| Aider | Markdown/JSONL | .aider.chat.history.md / .aider.llm.history in project dirs |
| Continue.dev | JSON | ~/.continue/projects/ |
| Cline | JSON | VS Code globalStorage saoudrizwan.claude-dev/tasks/ |
| OpenCode | SQLite | ~/.local/share/opencode/opencode.db (or $OPENCODE_DATA_DIR) |
No configuration needed. Additional session roots can be added via the AGENT_KNOWLEDGE_EXTRA_SESSION_ROOTS env var (comma-separated paths).
Features
- Host-agnostic session search -- unified search across every major AI coding assistant (Claude Code, Cursor, Codex CLI, Aider, Continue.dev, Cline, OpenCode). No host name is baked into configuration — the adapter registry probes installed host roots at startup.
- Hybrid search -- semantic vector similarity blended with TF-IDF keyword ranking
- Git-synced knowledge base -- markdown vault with YAML frontmatter, auto commit and push on writes
- Automatic staleness detection --
knowledge_analyze(action: "stale_by_code_activity")cross-references file paths mentioned in each entry body againstfilesModifiedin recent session summaries. Pairs with a symbol-presence precision layer: identifiers the entry quotes (inline backticks + fenced blocks) are checked in the touched file; if they still exist, confidence downweights ×0.3. Entries withevergreen: trueare exempt. - Search-gap tracking --
knowledge_analyze(action: "search_gaps")surfaces zero-result queries over the lastsince_days, grouped by token-Jaccard similarity. The clearest signal for "what entries should I write next?". - Section-priority context packer --
knowledge(action: "wakeup")assembles a multi-section bundle (identity→active_tasks→recent_decisions→known_gotchas→last_session_summary→top_weighted→semantic_fallback) within a token budget (default 800, override viatoken_budgetorAGENT_KNOWLEDGE_WAKEUP_BUDGET). Unused section budget redistributes to later sections. - Scored + gated promoter -- session insights promoted via a 6-signal weighted scorer with three independent gates (
minScore,minRecallCount,minUniqueQueries). Runs automatically in background, on demand viaknowledge_admin(action: "promote"), or benchable offline vianpm run bench:promote. Emits an auditable.dreams/YYYY-MM-DD.mddiary every run. - Pluggable adapter system -- add support for new tools by implementing the
SessionAdapterinterface - Embeddings -- local (Hugging Face), OpenAI, Claude/Voyage, or Gemini providers
- Fuzzy matching -- typo-tolerant search using Levenshtein distance
- 6 search scopes -- errors, plans, configs, tools, files, decisions
- 6 MCP tools -- consolidated action-based interface (
knowledge,knowledge_search,knowledge_session,knowledge_graph,knowledge_analyze,knowledge_admin) - Evergreen entries --
evergreen: truein frontmatter exempts an entry from decay in ranking AND makes it append-only under promotion. The/knowledgepane marks them. - Author attribution -- optional
author: <string>frontmatter, kept with the entry and returned by the REST API. - Code graph resolution --
calls,imports,inheritsedge types for code structure; directed BFS traversal (outbound/inbound/both);bulk_linkfor efficient ingestion;unlink_by_originfor clearing stale code edges before re-ingest;code:prefixed node IDs distinguish code from knowledge - Temporal knowledge graph -- edges support
valid_from/valid_tovalidity windows;as_ofqueries return point-in-time snapshots;invalidateaction marks facts as ended without deleting them - Hybrid scoring boosts -- proper-noun and temporal-proximity boosts on top of TF-IDF + semantic blend, capped at +66.7%, short-circuit when no signals are present
- Category as boost (not filter) -- opt into
category_mode: "boost"so a wrong category guess down-ranks instead of discarding the right answer - Verbatim session indexing -- per-message chunks (≥30 chars) embedded into the vector store so raw conversation is retrievable; toggle with
AGENT_KNOWLEDGE_INDEX_VERBATIM=false - Configurable git URL --
knowledge_admin(action: "config")for runtime setup, persisted at XDG/AppData location - Cross-machine persistence -- knowledge syncs via git, sessions read from local storage of each tool
/knowledgepane in Claude Code -- browse and search the knowledge base beside the conversation (agent-knowledge plugin)- Secrets scrubbing -- API keys, tokens, passwords, private keys automatically redacted before git push
- Knowledge graph -- relationship edges between entries (related_to, supersedes, depends_on, contradicts, specializes, part_of, alternative_to, builds_on) with BFS traversal
- Confidence/decay scoring -- entries scored by access frequency and recency; auto-promotion from candidate to established to proven
- Memory consolidation -- TF-IDF duplicate detection on write (warns of similar entries) plus
knowledge_analyze(action: "consolidate")for batch dedup scanning - Reflection cycle --
knowledge_analyze(action: "reflect")surfaces unconnected entries and generates structured prompts for the agent to identify new graph connections - Auto-linking on write -- new entries automatically linked to top-3 similar existing entries when cosine similarity > 0.7
- Confidence metadata — entries tagged
extracted(user-written) orinferred(auto-distilled, 0.85× search rank multiplier);confidence_scorefield carries the model's certainty 0-1 - Knowledge analysis —
knowledge_analyzeactionsgod_nodes(most-connected entries),bridges(cross-category connectors),gaps(isolated entries) - Knowledge brief —
knowledge_analyze(action: "brief")returns a cached ~200 token summary (core concepts, active projects, recent decisions, stale and gap counts) for session-start orientation - Edge provenance — graph edges track
origin(manual, auto-link, distill, reflect) so analysis can distinguish user judgment from automated heuristics - Deterministic pre-extraction in distillation — session summaries now include git commits, error patterns, URLs accessed, and packages changed extracted via regex from bash/tool output (no LLM cost)
- Freshness metadata on every search hit — every knowledge result carries
freshness: { body_age_days, last_accessed, access_count, verified_at, verification_age_days, evergreen }. Agent reads the trust signal and decides; we impose no policy demotion. - Per-category decay windows — the "Unused" filter and bytype chart honor per-category thresholds (projects 180d, people 365d, decisions 90d, workflows 60d, notes 30d) so identity-shaped content doesn't look stale just because it isn't re-read weekly.
- Lifecycle hooks —
SessionStartauto-wakeup + ingest-freshness check,UserPromptSubmitfirst-prompt targeted injection,PreCompactmemory-flush nudge + distill,SessionEnddistill. Six hook scripts total, all fail-open, each toggleable via anAGENT_KNOWLEDGE_*env var. Seedocs/HOOKS.md. - Replaces host auto-memory — on hosts with a per-session memory system (Claude Code's
~/.claude/projects/*/memory/, similar in other IDEs), route durable user facts and feedback to agent-knowledge instead. Auto-memory is machine-local and invisible to other machines; agent-knowledge is git-synced, cross-machine, searchable, and surfaces in wakeup. See the Claude Code integration note indocs/USER-MANUAL.md.
Codebase Ingestion
The knowledge-ingest skill populates or updates the knowledge base from a codebase directory. It uses tree-sitter for zero-token structural extraction (classes, functions, imports, call graphs, rationale comments), then clusters files into subsystems and creates knowledge entries + graph edges via existing MCP tools. Subsequent runs are incremental — only changed files are reprocessed.
/knowledge-ingest ./my-project
Uses the Agent Skills standard — works with Claude Code, OpenCode, Cursor, Codex CLI, and Gemini CLI. See Ingestion Guide for details.
Supported languages: TypeScript, JavaScript, Python, Go, Rust, Java, C, C++.
Quick Start
Install from npm
npm install -g agent-knowledge
Or clone from source
git clone https://github.com/keshrath/agent-knowledge.git
cd agent-knowledge
npm install && npm run build
Option 1: MCP server (for AI agents)
Add to your MCP client config (Claude Code, Cline, etc.):
{
"mcpServers": {
"agent-knowledge": {
"command": "npx",
"args": ["agent-knowledge"]
}
}
}
The first MCP process also serves a local REST API on 127.0.0.1:3423 (what the hooks, the /knowledge pane and agent-tasks call); when it exits, another running session takes the port over.
See Setup Guide for client-specific instructions (Claude Code, Cursor, Windsurf, OpenCode).
Option 2: Claude Code plugin
claude plugin marketplace add keshrath/agent-knowledge
claude plugin install agent-knowledge@agent-knowledge
The plugin brings the MCP server, the knowledge-ingest skill and the /knowledge pane (Claude Code 2.1.289+).
MCP Tools (6)
Knowledge Base
| Tool | Action | Description | Parameters |
|---|---|---|---|
knowledge |
list |
List entries by category and/or tag | category?, tag? |
read |
Read a specific entry | path (required) |
|
write |
Create/update entry (auto git sync) | category, filename, content (all required) |
|
delete |
Delete an entry (auto git sync) | path (required) |
|
sync |
Manual git pull + push | -- | |
wakeup |
Return L0 identity + L1 top-weighted entries (token-budgeted) | token_budget?, category? |
Search
| Tool | Description | Parameters |
|---|---|---|
knowledge_search |
General hybrid TF-IDF + semantic (no scope) |
query, project?, role?, max_results?, ranked?, semantic?, category?, category_mode?, mmr?, mmr_lambda?, explain? |
Scoped session-only recall (when scope set) |
query, scope, project?, max_results? |
Response shape: {mode: "general" | "scoped", sessions, knowledge}. Scoped mode returns knowledge: [] by design.
Scopes: errors, plans, configs, tools, files, decisions, all.
Search knobs:
mmr: trueapplies Maximal Marginal Relevance re-ranking (kills near-duplicate clusters in top-K).mmr_lambda0-1, default 0.7.category_mode: "boost"(default) gives matching-category entries a 1.25× score multiplier instead of dropping non-matches. Pass"filter"for hard-filter behavior.explain: trueattachesscore_components: {bm25, decay, maturity, confidence, category_boost, mmr_penalty}to every knowledge hit.
Sessions
| Tool | Action | Description | Parameters |
|---|---|---|---|
knowledge_session |
list |
List sessions with metadata | project? |
get |
Retrieve full session conversation | session_id, project?, include_tools?, tail? |
|
summary |
Session summary (topics, tools, files) | session_id, project? |
Knowledge Graph
| Tool | Action | Description | Parameters |
|---|---|---|---|
knowledge_graph |
link |
Create/update edge between entries | source, target, rel_type, strength? |
unlink |
Remove edges between entries | source, target, rel_type? |
|
invalidate |
Mark edges as expired (set valid_to) | source, target, rel_type?, valid_to? |
|
list |
List edges | entry?, rel_type?, as_of? |
|
traverse |
Directed BFS traversal from an entry | entry, depth?, direction?, rel_type?, as_of? |
|
bulk_link |
Batch-create edges (code graph ingestion) | edges (array of {source, target, rel_type, strength?, origin?}) |
|
unlink_by_origin |
Delete all edges by origin | origin |
Knowledge types: related_to, supersedes, depends_on, contradicts, specializes, part_of, alternative_to, builds_on
Code structure types: calls, imports, inherits
Traverse directions: outbound (source→target), inbound (target→source), both (default, undirected)
Analysis
| Tool | Action | Description | Parameters |
|---|---|---|---|
knowledge_analyze |
consolidate |
Find near-duplicate entries | category?, threshold? |
reflect |
Find unconnected entries for linking | category?, max_entries? |
|
god_nodes |
Most-connected entries (degree centrality) | top_n? |
|
bridges |
Cross-category connectors (betweenness) | top_n? |
|
gaps |
Isolated entries (0-1 edges) by maturity | max_entries? |
|
brief |
Cached ~200 token knowledge base summary | -- |
Admin
| Tool | Action | Description | Parameters |
|---|---|---|---|
knowledge_admin |
status |
Vector store statistics | -- |
config |
View or update configuration | git_url?, memory_dir?, auto_distill? |
|
rebuild_embeddings |
Re-embed all knowledge entries (useful on provider switch) | -- | |
prune_orphans |
Delete embeddings for sessions no longer on disk | vacuum?, force_vacuum? |
|
vacuum |
Reclaim free pages in the vector store | -- | |
promote |
Scored + gated promoter | promote_mode? (apply|explain), min_score?, min_recall_count?, min_unique_queries? |
Scored promoter
Every project-level candidate is scored on six signals (relevance 0.30, frequency 0.24, query-diversity 0.15, recency 0.15, consolidation 0.10, conceptual-richness 0.06) and gated on minScore ≥ 0.5, minRecallCount ≥ 2, minUniqueQueries ≥ 2. All three gates must pass. Background auto-promotion is controlled by the same auto_distill config flag; invoke on demand with knowledge_admin(action: "promote").
promote_mode: "explain"(default) — score + gate candidates, write diary, DO NOT touch the KB.promote_mode: "apply"— promote candidates that pass, write diary, git-commit.- Every run drops
~/agent-knowledge/.dreams/YYYY-MM-DD.mdwith per-candidate signal breakdowns and gate outcomes. The.-prefixed dir is git-tracked but excluded from list/search. - Grounded rehydration: a candidate is skipped if its source session file no longer exists on disk (prevents promoting deleted content).
- Entries with
evergreen: truefrontmatter are never overwritten by promotion — activity is appended.
Write-bench harness: npm run bench:promote — offline replay with auto-labeling by "referenced in later sessions". Compares gated promoter to a naive "ship all" baseline, reports precision / recall / F1. Use it to gate signal-weight or threshold changes before rolling them out.
REST API
Loopback only (127.0.0.1), JSON only. Every request goes through a guard: a foreign Host or any Origin header gets 403, a request body must be application/json. A :path with a slash is sent encoded (notes%2Fx.md).
| Method | Endpoint | Caller | Description |
|---|---|---|---|
| GET | /health |
pane, hooks | Status, version, entry count |
| GET | /api/overview |
/knowledge pane |
Counts, categories, recent events |
| GET | /api/knowledge?category=&tag= |
pane | List entries with their scoring |
| GET | /api/knowledge/search?q=&max_results= |
pane, opencode plugin | Search the knowledge base |
| GET | /api/knowledge/:path |
pane | Read one entry |
| GET | /api/knowledge/:path/links |
pane | The entry's graph edges, each with the other end's title |
| DELETE | /api/knowledge/:path |
pane | Delete an entry (git synced) |
| POST | /api/knowledge |
agent-tasks KnowledgeBridge | Write an entry (full write pipeline) |
| POST | /api/knowledge/sync |
pane | git pull + push |
| GET | /api/analysis |
pane | Hubs and isolated entries |
| GET | /api/sessions?limit=&offset=&project= |
pane | Sessions, paged: { sessions, total } |
| GET | /api/sessions/search?q=&role= |
pane | Search sessions |
| GET | /api/sessions/:id/summary |
pane | Session summary |
| POST | /api/events |
sessionend-distill hook |
A receipt the pane shows |
agent-knowledge MCP questions
How do I add agent-knowledge MCP to Claude Code?
Run claude mcp add agent-knowledge -- npx -y agent-knowledge in your terminal. Add --scope user to make it available in every project.
How do I add agent-knowledge MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What tools does agent-knowledge MCP provide?
It exposes 6 tools, including knowledge, knowledge_search, knowledge_session, knowledge_admin, knowledge_graph.
What AI coding assistants are supported?
It works out of the box with Claude Code, Cursor, OpenCode, Cline, Continue.dev, and Aider.
Can I use it offline?
Yes, the benchmark runs entirely offline without requiring an LLM or an API key.
How is the knowledge base synchronized across different machines?
The knowledge base is a git-synced markdown vault that persists across sessions and machines.