Agent integrations · MCP

Give your assistant a memory.

Keep project decisions, preferences, and useful notes available beyond a single conversation. Minds connects to compatible assistants through the Model Context Protocol (MCP), a standard for giving AI access to tools and data.

Start free Connect your assistant

Model Context Protocol

A tool call. A more informed answer.

Example

You

What release schedule did we choose?

TOOL CALLrecall

{
  "name": "recall",
  "arguments": {
    "query": "What release schedule did we choose?",
    "limit": 5
  }
}

RESPONSE EXCERPTresult.memories[0]

id: example-memory-01
content: The team chose weekly releases after the launch review.
memory_type: episodic
tags: ["release-plan"]

You chose weekly releases. That decision is saved from the launch review.

POST/v1/mcp/tools/callAuthorized instance connection

Put the returned context to work.

The assistant uses the recalled record in its response. Stored knowledge survives beyond the current conversation.

Choose a chapter to explore

Example tool exchange with sample memories. The HTTP response is shortened to show the returned context.

Memory in the conversation

Save what matters. Bring it back when needed.

An assistant can save a decision as you make it, look it up in a later conversation, and remove a note that is no longer useful. Your assistant chooses when to call each memory tool; what it saves and retrieves depends on your integration.

Keep the useful context.

The remember tool saves a note with its source and tags. A project decision can stay connected to the meeting or document it came from.

Pick up where you left off.

The recall tool searches stored memories for relevant context. Ask what changed, what was decided, or what a customer prefers.

Retire an outdated note.

The forget tool removes selected memories with a stated reason and returns an audit reference. Keep a record of why a note was removed.

Build your own integration

Add memory actions to your agent.

This HTTP example saves a sample note, searches for it, and then requests its removal. Use a Mind with MCP enabled. Set AKASHA_URL to its endpoint, AKASHA_TOKEN to your access token, and AKASHA_CAPABILITY to a signed credential with permission for these actions.

See an example tool exchange

Illustrated workflowConversation → tool

In the conversation

You

Remember what changed in Q3.

Agent

I’ll store the note with its source and tags.

The conversation calls a tool.

rememberMemory tool

Tool callJSON request

{
  "name": "remember",
  "arguments": {
    "content": "Q3 revenue dipped after the channel mix shifted.",
    "context": {
      "source": "finance-review",
      "tags": [
        "q3",
        "revenue"
      ]
    }
  }
}

POST/v1/mcp/tools/call

Sample resultoutput.result fields

{
  "stored": true,
  "memory_id": "mem_sample_01",
  "was_duplicate": false
}

Same tool. Same memory.

A memory ID connects the stored note to the next call.

Memory tools · TypeScript HTTPtypescript

const endpoint = new URL("/v1/mcp/tools/call", process.env.AKASHA_URL);

async function callMemory(name: string, args: Record<string, unknown>) {
  const response = await fetch(endpoint, {
    method: "POST",
    headers: {
      Authorization: "Bearer " + process.env.AKASHA_TOKEN,
      "X-Akasha-Capability": process.env.AKASHA_CAPABILITY!,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ name, arguments: args }),
  });
  if (!response.ok) throw new Error("Memory request failed: " + response.status);
  const output = await response.json();
  if (output.is_error) throw new Error("Memory tool failed");
  return output.result;
}

const stored = await callMemory("remember", {
  content: "Example: The team chose weekly releases after a launch review.",
  context: { source: "website-example", tags: ["release-plan"] },
});

const recalled = await callMemory("recall", {
  query: "What release schedule did we choose?", limit: 5,
});
console.log(recalled.memories);

const removed = await callMemory("forget", {
  memory_ids: [stored.memory_id],
  reason: "Remove the example note after this demonstration",
});
console.log(removed.audit_id);

Developer reference

Explore the memory tools.

Core memory actions

Call a tool: POST /v1/mcp/tools/call
remember: Save content with optional source and tags
recall: Search using a question and optional filters
forget: Remove selected memories with a reason
Discover tools: POST /v1/mcp/tools/list

Inspection and deletion options

reflect: Review stored memories around a topic
introspect: Inspect memory-system information
Request shape: Tool name and arguments
forget.reason: required · audit_id returned
forget.mode: soft (default) · hard

Keep exploring

TypeScript SDK

Build memory tools into your own TypeScript application.

Memory

See how Minds keeps events, knowledge, and procedures.

Cognitive Cycle

See how an agent can use memory while it plans and acts.

Keep the context. Continue the conversation.

Connect your assistant to Minds, save a useful note, and ask for it in your next conversation.

Start free Talk to sales