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 RailwayMemory 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 RailwayDocker
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 bundleGoogle Cloud
Terraform and Helm for GKE, applied with your own authenticated gcloud. No
cloud credentials go into the wizard.
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 bundleEach 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:
cd deploy/dockerMEMORY_BASE_DOMAIN=memory.example.com \ADMIN_EMAIL=you@example.com \ACME_EMAIL=you@example.com \./install.shinstall.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:
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.
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.
task-board is a good first install: a
board-enabled Task type, a task-worker agent with its workflow skill, and
one example task.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.
app.<your-domain>) and go to MCP Sharing.memory_* tools and can search the graph.{ "mcpServers": { "memory": { "type": "http", "url": "https://api.<your-domain>/api/mcp", "headers": { "X-Project-ID": "<project-id>", "X-API-Key": "<scoped-token>" } } }}# 1. install the CLI (adds ~/.memory/bin to PATH)curl -fsSL https://raw.githubusercontent.com/emergent-company/emergent.memory/main/deploy/install-cli.sh | bash
# 2. sign in to this instance — the browser opens, the session is savedmemory login --server https://api.<your-domain>
# 3. check what the CLI can see, then ask the graph a questionmemory projects listmemory query "what have we decided about pricing?"memory login opens the browser and stores an OAuth session, which is the right choice when one sign-in should cover several projects. For CI, skip the browser with memory set-token <token> or a MEMORY_PROJECT_TOKEN environment variable — theCLI referencehas the full credential resolution order.
Mint a token in Project settings → API tokens → Create token, or from the CLI withmemory projects create-token --project <name>. The token is scoped to the project and shown once.
# the token is shown once, at creation — keep it in an environment variableexport MEMORY_TOKEN=emt_...export MEMORY_PROJECT=<project-id>
curl -s https://api.<your-domain>/api/blueprints \ -H "Authorization: Bearer $MEMORY_TOKEN" \ -H "X-Project-ID: $MEMORY_PROJECT"Send X-Project-ID on every project-scoped call;Authorization: Bearer and X-API-Key are both accepted. The same credentials reach the MCP endpoint athttps://api.<your-domain>/api/mcp.