MCP Tools Reference

Recordari exposes its functionality through MCP tools. Your agent uses them automatically when you give it natural language instructions - you don't call tools directly. This page covers what each tool does and gives you example prompts that work well.

Starting a session

Orient

Loads context from a domain at the start of a session. This is the first thing you should ask your agent to do when beginning work on a project. It returns a summary of recent activity, important decisions, and active threads - everything the agent needs to be useful immediately.

"Orient on the recordari-web domain."

"Before we start, orient on the payments domain."

When you already know what you'll be working on, name the topic so your agent gets memories semantically matched to that purpose rather than a generic "most significant" slice:

"Before we start, orient on the recordari-web domain for the docs gap review."

"Orient on payments — we're debugging the Stripe webhook handler today."

If orient reports stale memories in a domain, ask your agent to run a stale audit before filing anything new there:

"Orient on recordari-web — if anything looks stale, run a stale audit before we file new memories."

By default, orient shows your own recent activity. On shared domains, the digest also surfaces contradictions involving your memories and memories of yours that someone superseded — your agent uses these to flag disagreements you may not know about. See When memories disagree.

On shared domains, ask for the whole team's view when you need domain-wide context:

"Orient on payments — show me everyone's recent activity, not just mine."

"Before we start, orient on recordari-web scoped to my work from this week."

Filing memories

Remember

Stores a piece of information as a node in the graph. Say what was decided in your own words — you don't need a special phrase. Your agent can usually infer why it matters from context, and will ask if the reasoning isn't clear.

"File a memory that we're switching from REST to GraphQL."

"Remember that the deploy environment requires Node 20 — the CI image needs updating before we ship the new build step."

"Make sure you capture why this decision was made, not just what was decided."

When you have several things to file at once, ask your agent to handle them in one go:

"File all three of those decisions and link each one to related memories."

Memory types

When filing, your agent categorises each memory by type. Getting the type right makes search, trust ranking, and audits much more useful:

The most common mistake is filing an observation as a decision. If you checked something and found a result, that's a finding; the choice you made because of it is a separate decision.

"File a finding that load tests showed Redis latency spikes above 200ms — that's evidence, not a decision yet."

"File a decision that we're switching to Redis for session storage. Connect it to the load-test finding — the finding is evidence, the decision is the choice."

Revise

Updates an existing memory when something has changed.

• Corrections (same claim, better wording) — revise in place
• Substantive changes (different claim) — your agent supersedes the old memory: a new node is created, the predecessor is archived, and a supersedes edge records why

You can revise your own memories freely. Changing someone else's human-owned memory requires Editor or Owner role. Substantive changes on foreign nodes use supersede with a required reason and confirmation; minor fixes (tags, dates) can still be revised in place. See When memories disagree for the full walkthrough.

"Revise the memory about our auth approach - we've moved from JWTs to sessions."

"Update the deployment memory: we've migrated off Heroku, we're on Fly.io now."

When several memories need updating together, batch the revisions:

"Revise all three deployment memories — we've moved everything to Fly.io."

Finding memories

Search

Finds memories by meaning, not just keywords. Useful when you want to check what the agent already knows about a topic, or when you're not sure whether something has been filed.

"Search your memory for anything about the payment integration."

"What do you know about the database migration plan?"

For precise lookups by identifier - a ticket number, a branch name, a specific error code - add "use exact matching" to your prompt. Without it, semantic search may rank conceptually similar results above the exact string you're looking for.

"Search memory for 'PROJ-431' - use exact matching."

Recall

Retrieves the full content of a specific memory by its ID. Useful when you have an ID from a previous session and want everything on record about that node.

"Recall node abc-1234."

Recent

Returns memories that have been touched most recently - filed, revised, or connected. A quick way to catch up on what's been happening in a domain.

"What are the most recently updated memories in the recordari domain?"

Connecting memories

Connect

Creates a labelled relationship between two nodes. Relationships make the graph navigable - when an agent orients, it can follow connections to pull in related context automatically.

"Connect the auth decision to the session handling memory."

"Link the deployment memory to the CI configuration memory - they're directly related."

The most common failure mode is filing a memory and forgetting to link it - an unlinked memory can only be found by direct search. Make linking part of the same action:

"Save that decision and link it to anything related in memory."

Relationships have types that tell your agent how two memories relate:

• General link — two things are associated (default)
• Depends on — one memory has a hard prerequisite on another
• Contradicts — two memories make conflicting claims. Your agent should surface these to you rather than pick a winner silently
• Resolved — records how a contradiction was settled after you've decided. Settling a pair that involves someone else's human-owned memory requires Editor role and override ceremony

Your agent typically discovers contradictions during orient (via the digest's owned-contradiction list) or while filing — not because you asked for a scan. See When memories disagree.

"Connect the auth decision to the session handling memory — it depends on that approach."

"We reconciled the deployment conflict — record how we resolved it after I decide."

When several connections need wiring at once:

"Connect all four of those new memories to the architecture decision."

Disconnect

Removes a relationship between two nodes. Use this when a connection was made in error or is no longer meaningful.

"Remove the connection between the auth node and the legacy API node."

Suggest connections

Asks Recordari to look for memories that should probably be linked but aren't yet. Useful after a burst of new memories, or when you want to check whether the graph is well-connected.

"Are there any memories that should be connected but aren't?"

"Suggest connections for recent memories about the checkout flow."

Why connected

Explains the reasoning behind a specific relationship - what was the agent thinking when it made this connection?

"Why are these two nodes connected?"

Trace

Finds the connection path between two specific memories - how they're linked, directly or through others in between. Useful for confirming whether (and how) two decisions are actually related, not just that they sound related.

"Trace the connections between the database schema decision and the API rate-limiting decision."

Refining

Alias

Registers a short, memorable alternate name for a domain, so you can refer to it without typing the full name every time. Also resolves an alias back to its domain, or removes one.

"Add an alias 'pg' for the backend-api domain."

"What domain does 'pg' point to?"

Significance

Ranks memories by importance, combining two signals: decisions you've explicitly put a date on (so they show up on the project timeline), and memories the graph is currently, structurally leaning on the most. Good for finding decisions that deserve a place on the timeline but never got one, or ones that were flagged important once but nothing live depends on anymore.

"What are the most significant memories in the payments domain?"

"Any decisions that used to be marked important but nothing depends on now?"

There is also a trust mode that ranks memories by epistemic trust — how much weight to give each memory based on its type (decisions rank higher than assumptions) and whether unresolved contradictions affect it. Useful when several memories touch the same topic and you want to know which ones to treat as most reliable:

"Which memories in the payments domain should I treat as most trustworthy?"

"Rank auth-related memories by trust — I want to know what's solid vs speculative."

To make a memory significant in the first place, ask your agent to date it when filing or revising - for example: "That's a real decision, not just a note - put today's date on it."

Organising

Domains

Lists all the domains in your workspace. A domain is a named collection of memories - usually one per project or team.

"What domains do we have in this workspace?"

Rename domain

Renames an existing domain.

"Rename the old-payments domain to payments-v2."

Maintenance

Forget

Archives a single memory node - a reversible soft-delete, not a permanent one (see Restore, below). Your agent should confirm with you before forgetting anything; it shouldn't act on a passing remark. The action is recorded in the admin portal audit log on plans that include it.

"Forget the memory about the old Redis caching approach - it's been replaced."

When several outdated memories should be archived together:

"Forget all the superseded Redis caching memories — we've fully moved to the new approach."

Restore

Brings back a node that was archived - whether by an explicit forget or automatically due to age or low access frequency. Archive nodes still count against your plan's archive limit, not your live limit.

"Restore the node about the original API design - we're revisiting it."

Forget all

Archives every memory in a domain at once - the same reversible soft-delete as a single forget, just applied in bulk. Your agent should confirm with you first, since it affects the whole domain in one go.

"Clear all memories from the scratch-pad domain."

Insight

Graph audit

Inspects the health of your knowledge graph. This is not the compliance audit log - that lives in the admin portal.

Four modes:

• orphans - memories with no connections
• stale - drift candidates (contradictions, superseded labels, duplicates, stale open questions, old transient memories)
• conflicts - semantically close memory pairs worth reviewing. Recordari surfaces candidates, not confirmed contradictions — your agent decides whether to connect, revise, or escalate
• archived - list archived memories (only call forget or restore on listed items after explicit confirmation)

Optional filters: domain, limit, tags, node_kind. In stale mode, memory_id restricts results to the neighbourhood of that memory.

"Run an orphan audit on the payments domain."

"Check for stale memories in recordari-web before we file anything new."

"Run a conflicts audit on the recordari domain — anything semantically close I should review?"

History

Shows the change history for a specific memory node - what it looked like when it was first filed, and every revision since.

"Show me the history of the database schema decision."

Visualise

Returns a representation of the memory graph - nodes and their connections - that can be rendered as a diagram.

"Visualise the memory graph for the checkout domain."

Key phrases at a glance