mcpField
M
MCP KnowledgeBase Server

MCP KnowledgeBase Server

Local
github.com/mbcrawfoDatabases7Updated 75w ago

About MCP KnowledgeBase Server

MCP KnowledgeBase Server lets LLMs save conversational memories in SQLite and retrieve them with full-text search. It also includes a prompt for guiding memory use.

Key features

  1. 01Store memories in SQLite
  2. 02Search memories with full-text search
  3. 03Includes a memory-use prompt
  4. 04Configure database path and filename

Use cases

  1. 01Save conversation details for later retrieval
  2. 02Find earlier memories with full-text search

MCP support

The MCP server lets LLMs store and search memories, and includes a prompt that guides memory use.

Configuration

Local server config is the same for every client. Copy it into your client’s MCP config file.

mcp.json · Universal config
{
"mcpServers": {
"KnowledgeBaseServer": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"mbcrawfo/knowledge-base-server"
]
}
}
}
Run commanddocker run -i --rm mbcrawfo/knowledge-base-server

Local servers need a runtime on your machine (e.g. Node.js 18+). Config file locations differ by client; see your client’s docs.

Packages
ocimbcrawfo/knowledge-base-server

Tools

No tool list yet

Local servers expose tools only once running on your machine, and the maintainer has not provided a tool list.

Details

From the project README

MCP KnowledgeBase Server

Docker Image Version Build Status

A Model Context Protocol (MCP) server that allows LLMS to store memories during a conversation and search them later. Memories are stored in a SQLite database, and its full text search features power the memory search.

Usage

Two environment variables control the location and filename of the database.

DATABASE_NAME: Use the default location, but a custom db filename. For example, my_custom_db.sqlite.

DATABASE_PATH: Specify the fully path to the db file (ignores DATABASE_NAME). For example, /Users/your_name/.db/my_db.sqlite.

Docker

When using docker you must create a persistent volume to store the database (advanced users can mount a folder from their file system, if desired). Run docker volume create knowledgebase to set it up, then configure the server in your claude_desktop_config.json as below.

If you want to use a custom database file with docker you must use DATABASE_PATH and pass it to the docker command using the --env arg. For example (place these strings in the args array of the config, before the image name), "--env", "DATABASE_PATH=/db/my_db.sqlite".

{
  "mcpServers": {
    "knowledgebase": {
      "command": "docker",
      "args": [
        "run",
        "--interactive",
        "--rm",
        "--volume", "knowledgebase:/db",
        "mbcrawfo/knowledge-base-server"
      ]
    }
  }
}

Run locally with dotnet cli
  1. You will need the .Net 9 SDK.
  2. Clone this repository.
  3. Navigate to the repo in your terminal and run dotnet build.
  4. Add the config below to claude_desktop_config.json (if you get errors, try specifying the full path to the dotnet cli).

When running locally the default database location is in your Application Data directory.

{
  "mcpServers": {
    "knowledgebase": {
      "command": "dotnet",
      "args": [
        "run",
        "--project", "/full/path/to/repo/src/KnowledgeBaseServer/KnowledgeBaseServer.csproj",
        "--no-restore",
        "--no-build"
      ]
    }
  }
}

Prompts

The server includes a "General Memory Usage" prompt to tell the LLM how to use memory. However you may wish to use a custom prompt to be more specific to your usage.

Development

You can use the app with the --init-db parameter to create or upgrade databases for testing. From the KnowledgeBaseServer project directory, run dotnet run -- --init-db /path/to/db.sqlite.

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.