Transient

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 caseBest fit
Document Q&A with citations and evidence checksTransient Intelligence (TI)
Cross-session continuity, handoffs, blockers, next actionsTransient Recall (TR)
Best end-to-end developer workflowUse 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

Terminal
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.

mcp.json
{
  "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.

Paste to your AI agent
[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_checkpoint calls 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.

Backfill (run from your repo)
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

ToolWhat it does
tr_checkpointSave current goal, decisions, context, and blockers
tr_resumeLoad the latest context pack for a project
tr_statusCheck system health and checkpoint stats
tr_timelineBrowse checkpoint events by project and date
tr_projectsList recent projects and suggest best match for your workspace
tr_search_checkpointsSearch checkpoints by keyword with optional project/time filters
tr_blockersView open blockers for a project
tr_graph_viewView the knowledge graph for a project
tr_graph_diffSee what changed between checkpoints

Verify it is running

Terminal
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.