Transient Recall — Quick start
Transient Recall is a free, self-hosted MCP service. It gives AI agents persistent context across sessions via structured checkpoints stored in a local Postgres database.
This guide is contract-first and focuses on stable MCP setup and workflow behavior.
When to use TI vs TR
| Use case | Best fit |
|---|---|
| Document Q&A with citations and evidence checks | Transient Intelligence (TI) |
| Cross-session continuity, handoffs, blockers, next actions | Transient Recall (TR) |
| Best end-to-end developer workflow | Use TI for evidence + TR for continuity |
Prerequisites
Docker (Desktop or CLI). A supported MCP client: Cursor, Claude Desktop, or any MCP-compatible tool.
Step 1 — Install
bash <(curl -fsSL https://transientintelligence.com/install/recall)
Pulls and starts the pinned TR Docker image with Postgres, runs database migrations, and prints ready-to-paste blocks for Cursor MCP config and the continuity rule.
Step 2 — Configure your MCP client
Use the printed MCP config in your client settings, then reload MCP servers. Cursor is shown below as a concrete example.
{
"mcpServers": {
"transient-recall-local": {
"url": "http://localhost:8090/mcp",
"headers": {
"x-tr-subject": "local-dev-user",
"x-tr-tenant": "public",
"x-tr-project": "my-project"
}
}
}
}Set x-tr-project to your repo or project name. This scopes all checkpoints to that project.
Set x-tr-project to a stable key (for example my-team-history) and keep it unchanged across restarts. Continuity restore depends on the exact identity tuple: x-tr-tenant, x-tr-subject, and x-tr-project.
Using Claude Desktop? Follow the dedicated setup guide: Claude Desktop Setup.
Step 3 — Add continuity instructions
Paste the block below into your coding agent (Cursor, Copilot, Windsurf, Claude, etc.). The agent will create rule files in .cursor/rules/ (or your tool's equivalent rules path). This ensures your AI resumes at session start and checkpoints with git metadata.
[INSTALL TR RULES] Create these two files in the workspace root. Path: .cursor/rules/ (or your IDE's equivalent rules directory).
FILE 1: .cursor/rules/tr-continuity.mdc
---
description: Transient Recall - automatic resume and checkpoint for workflow continuity
alwaysApply: true
---
# TR Continuity (automatic)
**First action every conversation:** Call `tr_resume(project)` and `tr_status(project)` immediately. Use workspace folder name as project (for example `my-team-history` in shared repos). If `reminder_due` is true, call `tr_checkpoint` before doing anything else.
**Checkpoint automatically** — call `tr_checkpoint` when:
- You complete a task or reach a task boundary
- You make a significant decision
- You resolve or add a blocker
- You switch to a new goal or topic
- Before your final response, if you changed blockers/next_actions/decisions
**High-value payload contract for each checkpoint:**
- `current_goal`: one clear sentence of the objective now
- `context_capsule`: concise "what changed + why"
- `decision_rationale`: reason for the chosen approach
- `next_actions`: explicit next 1-3 actions
- `files_touched` and `code_refs`: include when code or files changed
**Session cadence (always):**
- Start: `tr_resume` + `tr_status`, then set/confirm current goal
- Mid-session: checkpoint at meaningful decision boundaries
- End-session: checkpoint with blockers and next actions before final response
**Do not skip:** Checkpoint before replying if state changed. Resume at session start. This is automatic workflow continuity.
---
FILE 2: .cursor/rules/tr-checkpoint-git-enrich.mdc
---
description: Enrich TR checkpoints with git state (commit_sha, branch, files_touched)
globs:
alwaysApply: true
---
# TR Checkpoint Git Enrichment
When calling `tr_checkpoint` (or `tr_auto_checkpoint` with `repo_state`), **always run git in the workspace first** and pass the results into the work_packet. TR runs in Docker and cannot access your filesystem—enrichment is client-side only.
## Before checkpointing
Run these in the relevant workspace root (e.g. the repo you're working in):
git rev-parse --short HEAD
git rev-parse --abbrev-ref HEAD
git log -1 --pretty=%s
git diff --cached --name-only; git diff --name-only
## Pass into tr_checkpoint work_packet
- `commit_sha`: output of `git rev-parse --short HEAD`
- `commit_subject`: output of `git log -1 --pretty=%s`
- `files_touched`: combined staged + unstaged file names (from `git diff --cached --name-only` and `git diff --name-only`), capped at ~60
- Include `branch` in `context_capsule` if useful, e.g. "On branch fix/install-recall. Commit abc123: Add deployment mode patch."
## Example
{
"project": "Transient_Recall_API",
"work_packet": {
"current_goal": "...",
"context_capsule": "On branch main. Commit abc1234: Fix auth_header for set -u.",
"commit_sha": "abc1234",
"commit_subject": "fix: auth_header unbound variable under set -u",
"files_touched": ["scripts/install-artifact.sh", "app/install/recall/route.ts"]
}
}
## Multi-workspace
If multiple repos are open, run git in each and use the primary repo's data for the checkpoint, or the repo that matches the `project` name.Step 4 — Checkpoint
Ask your AI: "Call tr_checkpoint with my current goal: getting TR set up and running."
TR stores your goal, context, and session state in Postgres.
Step 5 — Resume next session
At the start of any future session, ask: "Call tr_resume for project: my-project"
TR returns your last checkpoint — goal, decisions, files, blockers, next actions — and your AI picks up from there.
Repository indexing (historical + live)
TR supports two continuity paths:
- Live continuity: ongoing
tr_checkpointcalls from your AI (via the rules in Step 3). - Historical indexing: backfill past commits into the same project stream using the TR Docker image.
Run backfill from your repo directory. The TR image includes the backfill script. Use --idempotency_scope=repo when combining multiple repos into one project.
docker run --rm \
-v "${PWD}:/repo" \
-e TR_MCP_BASE_URL="http://host.docker.internal:8090" \
ghcr.io/james-transient/transient-recall-api:v0.1.0 \
node scripts/backfill-commits.mjs \
--project="my-team-history" \
--all_history=true \
--idempotency_scope=repo \
--repo_root="/repo"On Linux, add --add-host=host.docker.internal:host-gateway if host.docker.internal is unavailable.
Core MCP tools
| Tool | What it does |
|---|---|
| tr_checkpoint | Save current goal, decisions, context, and blockers |
| tr_resume | Load the latest context pack for a project |
| tr_status | Check system health and checkpoint stats |
| tr_timeline | Browse checkpoint events by project and date |
| tr_projects | List recent projects and suggest best match for your workspace |
| tr_search_checkpoints | Search checkpoints by keyword with optional project/time filters |
| tr_blockers | View open blockers for a project |
| tr_graph_view | View the knowledge graph for a project |
| tr_graph_diff | See what changed between checkpoints |
Verify it is running
curl http://localhost:8090/healthz
# {"status":"ok"}Troubleshooting
TR not showing in MCP tools
Reload MCP servers in your client after applying config updates. If still missing, verify the MCP URL and port match your running TR stack.
Port 8090 already in use
Re-run the installer with TR_PORT=8091 (e.g. TR_PORT=8091 bash <(curl ...)) and update the MCP config URL to http://localhost:8091/mcp.
Lost context after Docker restart
As long as you have not run docker compose down -v, your Postgres volume is intact. If resume still looks empty, verify you are using the exact same x-tr-tenant, x-tr-subject, and x-tr-project values as before restart.
