RL4 MCP Tools for Cursor IDE: The Complete Reference (14 Tools)

Why MCP Changes Everything for Cursor IDE

The Model Context Protocol (MCP) lets Cursor IDE call external tools natively — no copy-paste, no manual steps. RL4 exposes 14 MCP tools that give your AI assistant direct access to your development history, search capabilities, and context management.

Instead of describing your project to Cursor, your AI reads your actual history. Instead of manually generating snapshots, Cursor triggers them for you.

Here's every MCP tool RL4 provides, what it does, and when to use it.

Setup: Enable RL4 MCP in Cursor

Before using any tool, add RL4's MCP server to your Cursor configuration:

1. Open Cursor Settings → MCP
2. RL4 registers automatically when you install the extension
3. Verify: you should see "rl4" in your MCP servers list with a green status

Once connected, Cursor's AI can call any of these tools directly in your conversations.

Category 1: Snapshot & Lifecycle Tools

1. `run_snapshot`

What it does: Triggers a full headless snapshot — scans all chat sources (Cursor + Claude Code), builds the evidence pack, and returns a structured "Continue Development" prompt.

When to use it:

• Start of a new session ("What was I working on?")
• Before a handoff to another developer
• Before switching LLMs
• Weekly project review

Example prompt in Cursor:

Run a snapshot to see what I've been working on this week

What you get back: A structured prompt with activity summary, recent decisions, active files, and suggested next steps — ready for Phase 1-4 processing.

2. `finalize_snapshot`

What it does: Cleans up temporary files created during a snapshot (`.rl4/last_final_prompt.txt` and `.rl4/.headless_result.json`).

When to use it: After you've processed a snapshot and updated your timeline/skills. This is Phase 3 of the snapshot protocolsnapshot protocol/cursor/blog/create-first-ai-snapshot-tutorial.

Example prompt in Cursor:

Finalize the snapshot — we're done processing

Category 2: Read Structured History

3. `get_evidence`

What it does: Returns the full evidence pack — facts, sessions, and activity data from `.rl4/evidence.md`.

When to use it:

• Deep-dive into what happened in a project
• Verify claims or decisions
• Audit trail review

4. `get_timeline`

What it does: Returns the project timeline — a forensic, append-only journal from `.rl4/timeline.md`.

When to use it:

• Understand project evolution chronologically
• Find when a specific change was made
• Review the narrative arc of development

5. `get_decisions`

What it does: Returns structured decisions from `decisions.jsonl` — each with intent, chosen option, and confidence gate.

When to use it:

• Recall why a specific architectural choice was made
• Review all decisions before a major refactor
• Onboard someone to the project's decision history

Example prompt in Cursor:

Show me all architectural decisions we made for the auth system

Category 3: Search & RAG Tools

These are the most powerful tools — they let you ask questions about your development history instead of reading through everything manually.

6. `search_context`

What it does: RAG-powered search across all RL4 data (evidence, timeline, decisions, chat, CLI history). Uses BM25 + RRF (Reciprocal Rank Fusion) for relevance ranking.

Filters available:

• `source`: "evidence" | "timeline" | "decisions" | "chat" | "cli"
• `tag`: "FIX" | "UI" | "ARCH" | "DOCS" | "CLI" | "GIT"
• `date_from` / `date_to`: ISO date range
• `file`: Filter by file path substring
• `limit`: Max chunks to return (1-20)

Example prompt in Cursor:

Search my context for anything related to the authentication refactor last week

7. `rl4_ask`

What it does: Natural language Q&A over your development history — like Perplexity, but for your codebase. Returns cited answers with sources.

When to use it:

• "Why did we choose PostgreSQL over MongoDB?"
• "What files were involved in the payment integration?"
• "When did we last refactor the API layer?"

Example prompt in Cursor:

Ask rl4: Why did we switch from REST to GraphQL?

What makes it special: `rl4_ask` understands intent (why/how/what/when), extracts entities (files, dates, tags), expands synonyms, and boosts recent results. Every answer includes citations back to the source.

8. `search_chats`

What it does: Searches specifically through your Cursor chat history (`chat_history.jsonl`). Returns chunks with thread ID and date citations.

When to use it:

• "Did I discuss the caching strategy with Cursor?"
• Find a specific conversation you remember having
• Locate code suggestions from previous chats

9. `search_cli`

What it does: Searches your CLI command history (`cli_history.jsonl`) — captures shell commands (git, npm, cargo, docker, make) with exit codes, duration, and output previews.

When to use it:

• "What git commands did I run yesterday?"
• "Did the build pass last time?"
• "What Docker containers did I start?"

Example prompt in Cursor:

Search CLI history for failed npm builds this week

Category 4: Workspace Management

10. `list_workspaces`

What it does: Lists all your RL4 workspaces synced to Supabase cloud. Returns workspace ID, name, snapshot count, and last active date.

When to use it:

• See all your projects with RL4 history
• Find a workspace to load context from
• Check which projects have recent activity

11. `set_workspace`

What it does: Sets the active workspace for all subsequent tool calls. Use `"current"` for the local `.rl4/` folder, or a workspace ID from `list_workspaces` for cloud data.

When to use it:

• Switch between projects without changing directories
• Load context from a different project into current session
• Cross-reference decisions between workspaces

Category 5: Content Store & Recovery

12. `get_content_store_index`

What it does: Returns the file index mapping file paths to SHA-256 checksums. This is the backbone of RL4's Content StoreContent Store/cursor/blog/recover-lost-cursor-conversations — every file version is stored as an immutable blob.

When to use it:

• See which files have been captured
• Get checksums for specific file versions
• Prepare for file content recovery

13. `read_rl4_blob`

What it does: Reads the content of a stored file by its SHA-256 checksum. Combined with `get_content_store_index`, this lets you reconstruct any captured file version.

When to use it:

• Recover a file you accidentally deleted
• Compare current code with a previous version
• Reconstruct files in a clean repo

Example workflow:

1. get_content_store_index → find checksum for src/auth.ts
2. read_rl4_blob(checksum) → get the file content
3. Write it back to disk

Category 6: Quality & Safety

14. `rl4_guardrail`

What it does: Validates queries and responses against RL4's quality rules. For queries: checks non-empty, max 2000 chars. For responses: checks max 100K chars and requires at least one citation.

When to use it:

• Before `rl4_ask` to validate the query
• After `rl4_ask` to ensure the response has proper citations
• Enforce proof-backed answers in your workflow

Quick Reference Table

| Tool | Category | Use Case |

|------|----------|----------|

| `run_snapshot` | Lifecycle | Generate context snapshot |

| `finalize_snapshot` | Lifecycle | Clean up after snapshot |

| `get_evidence` | Read | Full evidence pack |

| `get_timeline` | Read | Project timeline journal |

| `get_decisions` | Read | Structured decisions |

| `search_context` | Search | RAG search across all data |

| `rl4_ask` | Search | Natural language Q&A with citations |

| `search_chats` | Search | Search chat history |

| `search_cli` | Search | Search CLI command history |

| `list_workspaces` | Workspace | List cloud workspaces |

| `set_workspace` | Workspace | Switch active workspace |

| `get_content_store_index` | Recovery | File-to-checksum mapping |

| `read_rl4_blob` | Recovery | Read stored file content |

| `rl4_guardrail` | Quality | Validate queries/responses |

Common Workflows

Morning Standup (2 minutes)

1. run_snapshot → get activity summary
2. Phase 1: review what happened
3. Phase 2: update timeline
4. finalize_snapshot → clean up

"What did we decide about X?"

1. rl4_ask("Why did we choose X over Y?")
2. get_decisions → verify with structured data

Recover a Lost File

1. get_content_store_index → find the file checksum
2. read_rl4_blob(checksum) → retrieve content
3. Write to disk

Cross-Project Context

1. list_workspaces → see all projects
2. set_workspace(other_project_id)
3. search_context("auth implementation")
4. set_workspace("current") → back to local

What's Next

These 14 MCP tools turn Cursor IDE from a code editor into a context-aware development environment. Your AI doesn't just generate code — it understands your project's history, decisions, and evolution.

Start with `run_snapshot` to capture your first context, then explore `rl4_ask` to search your history. Learn more about creating your first snapshotcreating your first snapshot/cursor/blog/create-first-ai-snapshot-tutorial or why automated context beats manual noteswhy automated context beats manual notes/cursor/blog/why-rl4-over-manual-summaries.

**Try RL4 for Cursor IDE**Try RL4 for Cursor IDE/cursor/form — 14 MCP tools that give your AI assistant perfect memory. Install in 2 minutes, context in 5.