Skip to main content
Glama

Knownbase MCP Server

Persistent, searchable project memory for AI agents, over the Model Context Protocol.

Knownbase is a hosted MCP server that gives AI coding agents (Claude, Cursor, ChatGPT, Claude Code, Windsurf, and any other MCP-compatible client) a place to read and write durable notes, decisions, and handoffs that live outside your git history: the working memory an agent otherwise loses the moment a session ends.

This repository documents the /mcp endpoint: how to connect, what tools it exposes, and how authentication works. There is no local install: Knownbase is a remote, streamable-HTTP MCP server, so connecting is just pointing your client at a URL.

https://knownbase.dev/mcp

The problem this solves

AI agents are stateless between sessions. Every new chat, every new terminal, every restarted IDE window starts from zero. The agent re-reads your code but has no memory of why things are the way they are:

  • Architecture decisions and the tradeoffs behind them

  • Debugging trails ("we tried X, it didn't work because Y")

  • Conventions and gotchas that aren't obvious from the code itself

  • Task handoffs between sessions, or between you and a teammate's agent

  • Anything you don't want cluttering git history but still need the agent to know

Without a memory layer, you end up re-explaining the same context every session, or the agent re-discovers (and re-breaks) the same thing twice. Knownbase gives the agent a workspace it can search and write to directly, so that memory persists and compounds instead of resetting.

Related MCP server: memory-vault

Quick start

  1. Create a free workspace at knownbase.dev (no card required).

  2. Connect your MCP client to https://knownbase.dev/mcp; see docs/CONNECTING_CLIENTS.md for exact steps per client (Claude, Claude Code, ChatGPT, Cursor, and generic MCP clients).

  3. Authenticate with either a static API key or OAuth 2.1 (most clients auto-discover OAuth); see docs/AUTHENTICATION.md.

  4. Start a task with get_context to load what's already known, write durable knowledge with remember, and fall back to search_notes / get_note / upsert_note for direct control. Full tool reference: docs/TOOLS.md.

What it exposes

Tool

Purpose

list_projects

List project categories and note counts in the workspace

get_context

One-call project orientation: constraints, decisions, status, open items, and recent changes, ranked and packed to a token budget

search_notes

Search by text, project, tag, status, or last-modified date (keyword; semantic search is coming soon, and semantic: true falls back to keyword until then)

get_note

Read one note in full, with its links/backlinks

get_notes

Batch-read up to 50 notes in one call

remember

Store a durable fact/decision/constraint in one call: derives the title, checks for duplicates or contradictions, reports what it did

checkpoint

Close a work session as structured durable state: summary, decisions, discoveries, open items, next actions

get_changes_since

Resume from another agent, session, or machine via an opaque cursor, without reloading the project

upsert_note

Create a note, or partially update an existing one

patch_note

Change part of a body (append, prepend, or literal find-and-replace) without resending it

delete_note

Soft-delete (trash) a note

list_note_revisions

List a note's saved prior versions

get_note_revision

Read the full body of one historical revision

workspace_info / usage_summary

Plan, limits, usage, and this key's own access scope

rename_project

Bulk-rename a project across every note

rename_tag

Bulk-rename or remove a tag across every note

backup_project

Export full content of one project inline, for backup/portability

Notes also carry optional typed, temporal metadata (decision / fact / constraint / …, plus a current / superseded / disputed lifecycle) that get_context ranks and filters on. See Typed, temporal memory in the tool reference.

Full parameter-level reference, including the lean-by-default response shapes designed to save agent tokens, is in docs/TOOLS.md.

Why a remote, hosted MCP server

Every note is scoped to your own workspace; nothing is shared across tenants. Full-text search runs server-side, so agents get results without loading your entire notes corpus into context. Semantic (meaning-based) search is coming soon: search_notes already accepts semantic: true and falls back to keyword search until it is available, and workspace_info reports plan.semanticSearch so an agent can check first. Notes are versioned (every edit snapshots a revision) and soft-deleted (trash, not permanently gone), so an agent's write is never a one-way door.

Repository contents

This repository documents a hosted service; it does not contain the Knownbase server's source code. Found an issue with these docs, or a mismatch with actual server behavior? Please open an issue or email hello@knownbase.dev.

License

Documentation in this repository is MIT licensed. Use of the Knownbase service itself is governed by its Terms of Service.

Tool Schema Changelog

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

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      Provides persistent memory for AI coding agents via MCP, enabling teams to share and recall facts across sessions. Automatically captures, classifies, and curates knowledge from supported transcript sources.
      18
      34 npm
      1
      AGPL 3.0
    • A
      license
      A
      quality
      B
      maintenance
      Provides cross-session persistent memory for coding agents via MCP tools to store, retrieve, and manage notes with hybrid keyword/semantic search and automatic deduplication.
      8
      298 npm
      MIT
    • A
      license
      Not graded
      quality
      A
      maintenance
      Enables AI agents to capture, classify, synthesize, and retrieve persistent shared knowledge from sources such as Obsidian, code, transcripts, bookmarks, and sessions. It provides token-efficient search, context briefings, and tiered memory through MCP and REST APIs.
      10 npm
      MIT
    • A
      license
      Not graded
      quality
      A
      maintenance
      Gives AI agents persistent, shared memory by ingesting notes, code, transcripts, and session captures, then serving token-optimized context and hybrid keyword/semantic search over MCP and REST. Agents can classify, promote, and synthesize stored material so each session builds on prior work instead of starting from zero.
      10 npm
      MIT