Skip to content

Self-hosted

Memory installs into the platform you already run. Pick a target below — every one of them is a page in the same installer — then the last four steps are identical whatever you chose.

The figures are Railway’s: it is the only target with a wizard of its own. The other three hand you a script to review and run.

Railway

OAuth into your Railway workspace. The installer creates the project, its five services and a bucket, then bootstraps the identity provider — nothing to install.

Deploy on Railway

Docker

A single-host Docker Compose stack you run yourself. The wizard hands you a reviewable script; it generates the secrets and bootstraps Zitadel on the host.

Configure the Docker bundle

Google Cloud

Terraform and Helm for GKE, applied with your own authenticated gcloud. No cloud credentials go into the wizard.

Configure the GKE bundle

AWS

Terraform and Helm for EKS, applied with your own authenticated AWS CLI. The same bundle shape, with advanced settings if you need them.

Configure the EKS bundle

Each of those links opens the installer in a new tab, so this page stays behind it.

Target What you bring
Railway A Railway account with permission to create projects in the workspace you pick, and room for five services and one bucket
Docker A Linux host with Docker Engine and Compose v2, ports 80 and 443 reachable from the internet, and openssl, curl, jq installed. Start at 8 GB RAM / 4 vCPU
Google Cloud A project and a region, with gcloud, terraform and helm authenticated on the machine you apply from
AWS An account and a region, with the AWS CLI, terraform and helm authenticated on the machine you apply from

The Railway card takes you to Railway’s consent screen first. The installer needs workspace:admin so it can create the project, its services and its bucket; you can revoke that access later in Railway account settings.

Back in the wizard, choose the workspace that should own the deployment. The Admin email becomes the first platform superadmin: it defaults to the account you signed in with, it can be changed, and it is how you will sign in afterwards.

If email delivery is not configured yet, leave Skip email for now checked and add SMTP later from Settings → Platform email. Until then Zitadel verification, password reset and 2FA emails, and Memory invitations, do not work.

Click deploy and the installer creates the Railway project, deploys the published template and bootstraps Zitadel. It takes about fifteen to twenty minutes, mostly waiting, and the page polls its own progress — you can leave it open.

The success card holds Open Memory and the temporary admin password, printed once. Copy the password now: nothing will show it again.

The Docker page asks for three values — the base domain, the admin email and an ACME email for the TLS certificate — and answers with a downloadable script. It takes no cloud credentials and executes nothing; you review it and run it on the host:

Terminal window
cd deploy/docker
MEMORY_BASE_DOMAIN=memory.example.com \
ADMIN_EMAIL=you@example.com \
ACME_EMAIL=you@example.com \
./install.sh

install.sh generates .env with fresh database, Zitadel, object-store and application secrets, brings up Postgres, SeaweedFS, the extraction worker, Zitadel, the server and the web UI behind Caddy, and bootstraps Zitadel. Caddy obtains the certificates once the three DNS records resolve to the host.

The temporary admin password is written to deploy/docker/admin-credentials.env — the script does not print it. Email is skipped by the bundle; configure SMTP after your first sign-in.

The GCP page asks for the base domain, the project id and a region (default europe-west1), and returns a GKE bundle: Terraform for the cluster and its dependencies, Helm for the Memory stack. It asks for no cloud credentials — you apply it with your own authenticated gcloud, terraform and helm, then open app.<domain>.

The AWS page is the same shape for EKS: base domain and region, plus an Advanced AWS settings section for anything the defaults do not cover. It returns a Terraform + Helm bundle you apply with your authenticated AWS CLI, and then you open app.<domain>.

Every target ends here. Open app.<domain> — or, on Railway, the hostname the success card links to — and sign in with the admin address you chose. Where the temporary password comes from depends on the target: Railway prints it once on the success card, Docker writes it to deploy/docker/admin-credentials.env, and the cloud bundles name the file in their own output.

Sign-in runs through the bundled Zitadel, so you will be asked for the admin address and the temporary password, then walked through two things that exist only for the first account:

  • 2-Factor Setup — enroll an authenticator or skip it for now. Skipping is allowed, and you can enroll later from your profile.
  • A forced password change — set a real password. The temporary one stops working here.

You land on the projects page, as a superadmin of an instance that is now yours.

A project is the workspace everything else lives in: graph objects, documents, chat sessions, agents, branches. It belongs to an organization, and you can be a member of several.

  1. Select New project.
  2. Give it a name and, optionally, a purpose — one sentence describing what knowledge it holds. The purpose is passed to AI features as context, so a real sentence beats a label.
  3. Leave automatic extraction on if you want every uploaded document mined for objects and relationships. Each upload can override it.

An empty project has no object types, so the first thing to add is a domain model. Do not build it by hand — install a blueprint, which bundles object and relationship types, agent definitions, skills and seed data, and applies them in one action.

  1. Open the project and go to Blueprints.
  2. Pick one from the registry. task-board is a good first install: a board-enabled Task type, a task-worker agent with its workflow skill, and one example task.
  3. Select Install. The blueprint’s types appear in the schema, its seed objects land in the graph, and the badge on the blueprint row reads Installed.

Everything a blueprint created is owned by that blueprint, so Uninstall removes exactly what it added and leaves the rest of the project alone. Built-in blueprints are immutable — fork one with New version to change it.

You now have a project with a working model. Three ways in, same credentials, and you only need one of them.

Every option authenticates as the same project and reaches the same graph, so pick the one that fits where the client runs: an MCP client reads and writes the graph as tools, the CLI is for a terminal or a script, and the REST API is for anything else.

Memory is itself an MCP server, so an AI client — Claude, Cursor, OpenCode — reads the graph directly, as tools, with no code in between.

  1. Open the project in Memory (app.<your-domain>) and go to MCP Sharing.
  2. Select Create a share, name the recipient and choose read-only or read-write. Memory mints a token scoped to that share.
  3. Copy the install link or the JSON config the dialog shows. The link is private — it carries the token.
  4. Paste the config into the client's MCP settings and restart it. The client lists the memory_* tools and can search the graph.
Claude Desktop — claude_desktop_config.json
{
"mcpServers": {
"memory": {
"type": "http",
"url": "https://api.<your-domain>/api/mcp",
"headers": {
"X-Project-ID": "<project-id>",
"X-API-Key": "<scoped-token>"
}
}
}
}
  • Knowledge Graph — objects, relationships, search and traversal.
  • Agents — scheduled and event-driven work over the graph.
  • Data Sources — pull external systems in and keep them in sync.
  • Deploy on Railway — the same install, with every screen and every prerequisite spelled out.