Epitome

Epitome provides a portable, shared memory layer for AI agents, giving every assistant a persistent memory of you. It unifies memory across tools and platforms while offering per-user privacy, consent controls, and an auditable history, so your memories travel with your agents wherever you host them.

How to use

You connect an AI agent to a central memory layer that stores your data in a per-user, schema-isolated PostgreSQL setup. Your agents can read your profile, remember preferences, and access a knowledge graph to improve responses. Use the MCP URL provided by your hosted or self-hosted instance to link your agents, then supply your API key to authorize requests.

How to install

Prerequisites: you need a machine with Docker and Docker Compose installed, plus git for cloning the repository if you choose the self-hosted path.

# Self-hosted deployment
git clone https://github.com/gunning4it/epitome.git
cd epitome
cp .env.example .env    # edit with your credentials
docker compose up -d

# Access the app at http://localhost:5173 and sign in with Google or GitHub OAuth

Connect an AI Agent

Before connecting, obtain your API key from Settings → API Keys in the dashboard. Use the key to authorize MCP requests in your agent configuration.

{
  "mcpServers": {
    "epitome": {
      "url": "https://epitome.fyi/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Self-hosted vs hosted connection

Hosted instances provide a quick start: sign up, copy your MCP URL from settings, and connect an AI agent to begin memory sharing immediately.

Self-hosted deployments require running the server locally or in your environment. Use the Docker Compose setup above to start the services, then connect your agent to the local MCP endpoint.

What you can do with Epitome

Epitome exposes nine MCP tools for reading and writing your memory, performing memory searches, managing tables, querying a knowledge graph, and more. These tools enable structured memory management, profile updates, and cross-agent memory sharing.

Architecture overview

Each user gets a separate PostgreSQL schema to ensure strict data isolation. A streamable HTTP MCP interface connects to a memory-optimized backend, which includes a knowledge graph and an audit log to record access and changes.

Security and privacy

You own your data. Per-user schema isolation ensures data separation, not just row-level security. You control what each agent can read or write, and every access is logged in an append-only audit log. The system is GDPR-ready, with options to export or delete data at any time.

Notes on tools and usage

The MCP server includes multiple tools described in the tool reference. While you don’t need to understand every tool upfront, you can gradually explore profile read/write, memory search, table CRUD, and knowledge graph queries to build rich, cross-agent memory experiences.

Troubleshooting tips

If you encounter connection issues, verify your MCP URL and API key, ensure the server is running, and check per-user schema isolation settings. Review the append-only audit log to understand access patterns and permissions.

Available tools

profile_read

Read user profile fields used in the memory layer.

profile_write

Write or update user profile fields in the memory store.

memory_search

Search memory using semantic queries across the shared memory.

table_crud

Create, read, update, and delete structured data tables within the personal database.

knowledge_graph_query

Query the knowledge graph to retrieve entities and relationships.

consent_audit

Manage per-agent consent rules and audit access to data.