Skip to main content
Glama

Slate

Shared blackboard MCP server. Multiple agents can write and read the same facts without you copying context between them.

What it does

Slate is a small, self-hosted MCP server. One agent writes a fact. Another agent queries it. There is no central orchestrator. The shared state is one SQLite file.

Related MCP server: kepta

Tools

Tool

Description

write

Store a fact (text, optional tags, optional TTL)

query

Search facts by keyword or tags

list

List recent facts

delete

Delete a fact by id

A fact's text is at most 16000 characters. A fact has at most 16 tags. ttl_hours is a whole number from 1 to 8784 (about one year). Omit it to keep the fact until it is deleted. list and query return at most 100 rows. Expired facts disappear from both, and the next write removes them from the file.

Quick start

Requires Python 3.13 and uv.

uv run slate

uv run slate-mcp starts the same server. The default transport is stdio, which is what Claude Code and Cursor launch themselves.

The database file defaults to $HOME/.slate/slate.db. Override it with SLATE_DB.

SLATE_DB=/absolute/path/slate.db uv run slate

Clients

Point every client at the same SLATE_DB and the same checkout. Use absolute paths. A desktop app often does not inherit your shell PATH.

Claude Code

Project scope is .mcp.json in the project you are working in. User scope is the mcpServers object in ~/.claude.json.

{
  "mcpServers": {
    "slate": {
      "type": "stdio",
      "command": "/absolute/path/to/uv",
      "args": ["run", "--directory", "/absolute/path/to/slate-mcp", "slate"],
      "env": {
        "SLATE_DB": "/absolute/path/.slate/slate.db"
      }
    }
  }
}

Approve the server with /mcp in Claude Code the first time you use a project .mcp.json.

Cursor

Global config is ~/.cursor/mcp.json. Project config is .cursor/mcp.json.

{
  "mcpServers": {
    "slate": {
      "type": "stdio",
      "command": "/absolute/path/to/uv",
      "args": ["run", "--directory", "/absolute/path/to/slate-mcp", "slate"],
      "env": {
        "SLATE_DB": "/absolute/path/.slate/slate.db"
      }
    }
  }
}

Restart Cursor after saving the file. A write from one client is then visible to a query from the other, because both processes open the same file.

Optional SSE

Stdio is the normal setup. SSE is for a long-running process on the machine that holds the database.

uv run slate --transport sse --host 127.0.0.1 --port 8765

Claude Code:

{
  "mcpServers": {
    "slate": {
      "type": "sse",
      "url": "http://127.0.0.1:8765/sse"
    }
  }
}

Cursor:

{
  "mcpServers": {
    "slate": {
      "url": "http://127.0.0.1:8765/sse"
    }
  }
}

Docker

The image is meant for a small ARM board such as a Pironman 5 (8 GB RAM, local SSD). The base image is multi-arch. Compose caps the container at 256 MB and half a CPU. The SQLite file lives on a bind mount, default ./.slate-data, which is gitignored.

Stdio, for a client that spawns the container:

docker compose --profile stdio run --rm -i slate

SSE on localhost only:

docker compose --profile sse up -d --build

That publishes 127.0.0.1:8765 and listens on port 8765 inside the container. To share the host database with uv run slate clients, point the mount at the same directory:

SLATE_DATA="$HOME/.slate" docker compose --profile sse up -d --build

The container starts as root only long enough to make /data private, then the server runs as uid 1000.

Security

Slate has no authentication. It is a local blackboard for agents you already trust.

  • Stdio is not a network service. Your MCP client starts the process.

  • The database file is created mode 0600. Its directory is mode 0700 when that directory is not a shared system path such as your home directory or /tmp.

  • Do not commit the database. It can contain anything an agent wrote. It is not a password store.

  • SSE defaults to 127.0.0.1. The Docker publish line is also localhost-only. Anyone who can open the port can read, write, and delete every fact. Do not publish it on 0.0.0.0.

  • Tool arguments are length-checked, and SQL values are bound parameters.

Tests

uv run pytest

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
      Not graded
      quality
      D
      maintenance
      Local, cross-agent memory for AI coding agents using a single SQLite file, enabling persistent sessions and durable facts shared across multiple MCP-compatible tools.
      10 npm
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Local memory for AI agents in one SQLite file on your own machine. Facts carry a validity window and a confidence score, so an outdated one is superseded and downweighted rather than deleted, and retrieval fuses BM25, vector similarity and a knowledge graph.
      4
      Business Source 1.1
    • A
      license
      A
      quality
      C
      maintenance
      Lets AI clients store, retrieve, update, and forget long-term facts in a local SQLite database with deterministic lexical search, sharing the same memory across multiple clients without relying on model APIs or embedding services.
      7
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Enables AI agents to persist facts with tags, sources, and importance in a local SQLite database, retrieve them through hybrid BM25 plus embedding search weighted by retention decay, link or supersede related entries, and review everything in a read-only visual dashboard showing the memory graph and timeline.
      6
      MIT