agent-knowledge
This MCP server exposes a git-synced knowledge base plus session recall and graph/analysis/admin tools for AI coding assistants.
Create, read, list, delete, sync, and wake up knowledge entries with token-budgeted context.
Search across sessions and knowledge using hybrid TF-IDF + semantic search, scoped recall, MMR, category boost/filter, and score explanations.
List, retrieve, and summarize session transcripts, optionally filtering by project or including tool calls.
Manage a temporal knowledge graph with typed edges, code-structure edges, BFS traversal, bulk linking, invalidation, and origin-based cleanup.
Run analysis for duplicates, unconnected entries, god nodes, bridges, gaps, search gaps, stale-by-code-activity, and compact briefs.
Administer vector store/config: status, git URL/memory dir/auto-distill config, rebuild embeddings, prune orphans, vacuum, and promote candidates.
Uses Hugging Face embedding models (local or API) to generate semantic embeddings that power hybrid search and memory ranking.
Uses OpenAI's embedding API to produce semantic embeddings for knowledge entries and session data, enhancing search relevance and retrieval.
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., "@agent-knowledge search my sessions for the fix to the pagination bug"
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.
agent-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.
Related MCP server: Memory-MCP
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 |
|
Cursor | JSONL |
|
Codex CLI | JSONL |
|
Aider | Markdown/JSONL |
|
Continue.dev | JSON |
|
Cline | JSON | VS Code globalStorage |
OpenCode | SQLite |
|
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
SessionAdapterinterfaceEmbeddings -- 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 knowledgeTemporal knowledge graph -- edges support
valid_from/valid_tovalidity windows;as_ofqueries return point-in-time snapshots;invalidateaction marks facts as ended without deleting themHybrid 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 answerVerbatim session indexing -- per-message chunks (≥30 chars) embedded into the vector store so raw conversation is retrievable; toggle with
AGENT_KNOWLEDGE_INDEX_VERBATIM=falseConfigurable git URL --
knowledge_admin(action: "config")for runtime setup, persisted at XDG/AppData locationCross-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 scanningReflection cycle --
knowledge_analyze(action: "reflect")surfaces unconnected entries and generates structured prompts for the agent to identify new graph connectionsAuto-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-1Knowledge 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 orientationEdge provenance — graph edges track
origin(manual, auto-link, distill, reflect) so analysis can distinguish user judgment from automated heuristicsDeterministic 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-projectUses 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-knowledgeOr clone from source
git clone https://github.com/keshrath/agent-knowledge.git
cd agent-knowledge
npm install && npm run buildOption 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-knowledgeThe 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 |
|
| List entries by category and/or tag |
|
| Read a specific entry |
| |
| Create/update entry (auto git sync) |
| |
| Delete an entry (auto git sync) |
| |
| Manual git pull + push | -- | |
| Return L0 identity + L1 top-weighted entries (token-budgeted) |
|
Search
Tool | Description | Parameters |
| General hybrid TF-IDF + semantic (no |
|
Scoped session-only recall (when |
|
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 |
|
| List sessions with metadata |
|
| Retrieve full session conversation |
| |
| Session summary (topics, tools, files) |
|
Knowledge Graph
Tool | Action | Description | Parameters |
|
| Create/update edge between entries |
|
| Remove edges between entries |
| |
| Mark edges as expired (set valid_to) |
| |
| List edges |
| |
| Directed BFS traversal from an entry |
| |
| Batch-create edges (code graph ingestion) |
| |
| Delete all edges by 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 |
|
| Find near-duplicate entries |
|
| Find unconnected entries for linking |
| |
| Most-connected entries (degree centrality) |
| |
| Cross-category connectors (betweenness) |
| |
| Isolated entries (0-1 edges) by maturity |
| |
| Cached ~200 token knowledge base summary | -- |
Admin
Tool | Action | Description | Parameters |
|
| Vector store statistics | -- |
| View or update configuration |
| |
| Re-embed all knowledge entries (useful on provider switch) | -- | |
| Delete embeddings for sessions no longer on disk |
| |
| Reclaim free pages in the vector store | -- | |
| Scored + gated promoter |
|
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 |
| pane, hooks | Status, version, entry count |
GET |
|
| Counts, categories, recent events |
GET |
| pane | List entries with their scoring |
GET |
| pane, opencode plugin | Search the knowledge base |
GET |
| pane | Read one entry |
GET |
| pane | The entry's graph edges, each with the other end's title |
DELETE |
| pane | Delete an entry (git synced) |
POST |
| agent-tasks KnowledgeBridge | Write an entry (full write pipeline) |
POST |
| pane | git pull + push |
GET |
| pane | Hubs and isolated entries |
GET |
| pane | Sessions, paged: |
GET |
| pane | Search sessions |
GET |
| pane | Session summary |
POST |
|
| A receipt the pane shows |
Architecture
graph LR
subgraph Storage
KB[(Knowledge Base<br/>~/agent-knowledge<br/>Git Repository)]
end
subgraph Session Sources
CC[(Claude Code<br/>JSONL)]
CU[(Cursor<br/>JSONL)]
OC[(OpenCode<br/>SQLite)]
CL[(Cline<br/>JSON)]
CD[(Continue.dev<br/>JSON)]
AI[(Aider<br/>MD / JSONL)]
end
subgraph agent-knowledge
KM[Knowledge Module<br/>store / search / git]
AD[Session Adapters<br/>auto-discovery]
SE[Search Engine<br/>TF-IDF + Fuzzy]
DS[REST API<br/>127.0.0.1:3423]
MCP[MCP Server<br/>stdio]
end
subgraph Clients
AG[Agent Sessions]
PN["/knowledge pane<br/>hooks, agent-tasks"]
end
KB <-->|git pull/push| KM
CC --> AD
CU --> AD
OC --> AD
CL --> AD
CD --> AD
AI --> AD
AD --> SE
KM --> MCP
SE --> MCP
KM --> DS
SE --> DS
MCP --> AG
DS --> PNKnowledge Graph
Entries and code symbols can be connected via typed, weighted edges stored in a dedicated edges SQLite table. Eleven relationship types are supported — 8 for knowledge edges and 3 for code structure:
Knowledge: related_to, supersedes, depends_on, contradicts, specializes, part_of, alternative_to, builds_on
Code structure: calls, imports, inherits
knowledge_graph(action: "link")creates or updates an edge (with optional strength 0-1)knowledge_graph(action: "unlink")removes edges (optionally filtered by type)knowledge_graph(action: "list")lists edges for an entry or relationship typeknowledge_graph(action: "traverse")performs directed BFS traversal from a starting entry. Supportsdirection(outbound,inbound,both) andrel_typefilterknowledge_graph(action: "bulk_link")batch-creates edges in a single transaction (for code graph ingestion)knowledge_graph(action: "unlink_by_origin")deletes all edges with a specific origin (for clearing stale code edges before re-ingest)
Code Graph
Code structure edges are created by the knowledge-ingest skill during codebase ingestion. They use code: prefixed node IDs:
code:src/auth/middleware.ts # file node
code:src/auth/middleware.ts::validateToken # symbol nodeQuery examples:
# Who calls validateToken?
knowledge_graph({ action: "traverse", entry: "code:src/auth.ts::validateToken", direction: "inbound", rel_type: "calls", depth: 3 })
# What breaks if I change this function?
knowledge_graph({ action: "traverse", entry: "code:src/auth.ts::validateToken", direction: "inbound", rel_type: "calls", depth: 5 })
# Combined: callers + knowledge context (decisions, design rationale)
knowledge_graph({ action: "traverse", entry: "code:src/auth.ts::validateToken", depth: 2 })Auto-linking
When knowledge with action: "write" creates or updates an entry, it automatically finds the top-3 most similar existing entries via cosine similarity and creates related_to edges for any pair scoring above 0.7.
Confidence & Decay Scoring
Each knowledge entry has a confidence score tracked in the entry_scores SQLite table. Search results are ranked using:
finalScore = baseRelevance * 0.5^(daysSinceLastAccess / 90) * maturityMultiplierEntries mature automatically based on access count:
Stage | Accesses | Multiplier |
| < 5 | 0.5x |
| 5-19 | 1.0x |
| 20+ | 1.5x |
Frequently accessed entries rise in search rankings; stale entries decay over time.
Search Capabilities
TF-IDF Ranking -- results scored by term frequency-inverse document frequency. Rare terms boost relevance. Global index cached for 60 seconds.
Fuzzy Matching -- Levenshtein edit distance with sliding window. Configurable threshold (default 0.7).
Scoped Recall via knowledge_search with the scope parameter:
Scope | Matches |
| Stack traces, exceptions, failed commands |
| Architecture, TODOs, implementation steps |
| Settings, env vars, configuration files |
| MCP tool calls, CLI commands |
| File paths, modifications |
| Trade-offs, rationale, choices |
Integrations
REST Write Endpoint
POST /api/knowledge accepts { category, filename, content } and runs the full write pipeline: git pull → file write → embedding index → auto-link → git push → duplicate check. Returns { path, autoLinks?, duplicateWarnings?, git } with status 201.
This enables HTTP-based writes from other services without an MCP connection.
agent-tasks KnowledgeBridge
agent-tasks has a built-in KnowledgeBridge that auto-pushes learning and decision artifacts to agent-knowledge on task completion. Entries land in decisions/ with frontmatter tags (agent-tasks, project name, artifact type), are auto-indexed with embeddings, and auto-linked to similar entries. No configuration needed: while any session runs agent-knowledge, its REST API on 127.0.0.1:3423 answers.
Testing
npm test # 604 tests across 39 files
npm run test:watch # Watch mode
npm run lint # ESLint on src/ and tests/
npm run typecheck # tsc --noEmit
npm run check # typecheck + lint + format + testEnvironment Variables
All env vars live under the AGENT_KNOWLEDGE_* prefix. No host name is baked in — the adapter registry auto-detects installed AI coding hosts (.claude, .cursor, .codex, .aider, .continue, OpenCode) without configuration.
Core
Variable | Default | Description |
|
| Git-synced knowledge base directory |
| -- | Git remote URL (auto-clones if dir missing) |
|
| Auto-distill session insights into the knowledge base |
|
| Index raw session message chunks into the vector store so conversation is retrievable later. Set |
| (platform config) | Override the primary host data root. Leave unset in the common case — adapters auto-detect every well-known host root under |
| -- | Extra session directories, comma-separated. Added to whatever auto-detection finds. |
|
| Local REST API port (the |
|
| REST bind address |
Embeddings
Variable | Default | Description |
|
|
|
|
| TF-IDF vs semantic blend weight ( |
| -- | Override provider default model |
|
| Seconds before unloading the local model ( |
| (auto) | ONNX / OMP thread count for the local provider |
API keys
Project-scoped overrides win over the standard keys. Set either; the scoped form lets you run agent-knowledge with a different key than the rest of your environment.
Variable | Fallback | Description |
|
| OpenAI embeddings |
|
| Claude / Voyage embeddings |
|
| Gemini embeddings |
Hooks
Variable | Default | Description |
|
| Auto-inject a |
|
| Tokens for the wakeup bundle |
|
| Run a targeted |
|
| Tokens for first-prompt injection (clamp |
|
| Max knowledge hits attached to the first prompt (clamp |
|
| Before pre-compaction, nudge the agent to save context via |
External tool overrides
Variable | Default | Description |
|
| Override where OpenCode's session DB lives (OpenCode's own env, honored by our adapter) |
Documentation
Setup Guide — installation, client setup (Claude Code, OpenCode, Cursor, Windsurf), hooks, skills
Ingestion Guide — codebase ingestion skill, tree-sitter extraction, incremental updates
Architecture — source structure, design principles, database schema
Hooks — the Claude Code lifecycle hooks
License
Available Tools
6 toolsknowledgeA
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).
Inputs: action (required), tag, path, content, +5 more.
knowledge_adminB
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.
Inputs: action (required), vacuum, git_url, min_score, +6 more.
knowledge_analyzeA
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.
Inputs: action (required), top_n, category, min_count, +5 more.
knowledge_graphB
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.
Inputs: action (required), as_of, depth, edges, +9 more.
knowledge_searchA
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).
Inputs: query (required), mmr, role, scope, +8 more.
knowledge_sessionA
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.
Inputs: action (required), tail, limit, offset, +3 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 6 tools
Each tool targets a distinct functional domain: CRUD operations, cross-source search, session management, admin/maintenance, graph relationships, and analysis/insights. The action-based sub-operations are clearly scoped, and there is no meaningful overlap between tools.
All tool names follow the consistent pattern `knowledge_<verb_noun>` using snake_case throughout. The naming convention is uniform, with descriptive suffixes (search, session, admin, graph, analyze) that clearly differentiate purposes.
Six tools is an ideal count for a knowledge-management server. Each tool encapsulates a distinct set of related operations (CRUD, search, sessions, admin, graph, analysis), providing comprehensive functionality without overwhelming the agent.
The toolset covers the full lifecycle of a knowledge base: creating/reading/updating/deleting entries, searching across sessions and entries, managing session history, performing administrative tasks (embeddings, vacuum), maintaining knowledge graph relationships, and deriving analytical insights. No obvious gaps exist; even advanced features like bulk graph import and orphan pruning are included.
Related MCP Connectors
Shared memory for coding agents. Stop re-explaining your codebase every session.
Memory for AI agent teams across tools, sessions, repositories, and teammates.
Shared, permission-aware memory for teams and their AI: recall, save, and keep knowledge current.
Persistent engineering memory designed to follow developers across coding agents.
Related MCP Servers
AlicenseNot gradedqualityCmaintenanceProvides persistent memory for AI coding assistants, storing and retrieving architectural decisions, patterns, and solutions across sessions using semantic search, while also offering git integration for commit messages and code expertise mapping.MIT- AlicenseAqualityDmaintenanceProvides persistent memory for AI agents using hybrid search (vector embeddings + BM25) with neural reranking, enabling storage and retrieval of insights, debugging solutions, and patterns across coding sessions.8MIT
- AlicenseNot gradedqualityDmaintenanceProvides AI coding assistants with persistent, context-rich memory of a codebase, including documentation and git history, enabling recall across sessions.105Apache 2.0
- AlicenseNot gradedqualityBmaintenanceProvides persistent, searchable memory and knowledge capture for AI-assisted development, enabling agents to retain decisions, bugs, and patterns across sessions and projects.265 PyPIMIT