SDK · TypeScript

Give your TypeScript app a memory.

Keep useful context between requests and conversations. The Minds TypeScript SDK connects your application to a dedicated Mind for memory, data storage, search, and connected knowledge.

Start free Read the docs

TypeScript · a memory request

Good context. A clear interface.

An example request on the left. Useful context on the right.

TS recall.ts ×

server / memory

src › memory › recall.ts

01const request = {02  name: "recall",03  arguments: {04    query: "What release schedule did we choose?",05    limit: 5,06  },07 } as const;08 09const output = await response.json();10if (output.is_error) throw new Error("Recall failed");11console.log(output.result.memories);

APPLICATION CONTEXTReceived

resultObject

↳ memoriesArray

0 · memory

content: “We chose weekly releases.”
memory_type: semantic
tags: ["launch-review"]

READY FOR THE NEXT REQUEST

Weekly releases.
The earlier decision stays in context.

Put the decision back into the work.

Use the returned content to inform your application’s next response. The retrieval is an explicit part of your workflow.

Choose a chapter to explore

Example HTTP payload and response. Keep credentials on your server; the complete authenticated request is below.

Capabilities

Start with a memory. Build from there.

Save a project decision, retrieve it when it matters, and add it to the context your agent uses. More specialized clients give you access to the rest of Akasha as your application grows.

Save and recall context.

Store a note with its source, then search for relevant memories when the next request arrives.

Fit your JavaScript project.

Use ESM imports or CommonJS with shipped TypeScript definitions. The package supports Node.js 18 and later.

Show responses as they arrive.

Read generated text in chunks with native async iteration when using the model-generation client.

Know what a call returns.

Typed methods and response shapes help you discover the API in your editor and catch integration mistakes while you build.

Connect to your Mind.

Provide your instance URL and access token. Keep credentials in your server environment when building a web application.

Go beyond plain text.

Work with stored records, vector search, and graph relationships as part of the same application.

Memory request example

Find the context behind a decision.

This TypeScript HTTP example searches existing memories on a Mind with MCP enabled. Set AKASHA_URL to the instance endpoint, AKASHA_TOKEN to your access token, and AKASHA_CAPABILITY to a signed credential with memory-read permission.

exampletypescript

const response = await fetch(
  new URL("/v1/mcp/tools/call", process.env.AKASHA_URL),
  {
    method: "POST",
    headers: {
      Authorization: "Bearer " + process.env.AKASHA_TOKEN,
      "X-Akasha-Capability": process.env.AKASHA_CAPABILITY!,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      name: "recall",
      arguments: { query: "What release schedule did we choose?", limit: 5 },
    }),
  },
);
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");
console.log(output.result.memories);

Specs

What ships in the package.

At a glance

Package: @minds-sdk/typescript
Node.js: 18+
Formats: ESM · CommonJS
Memory tools: remember · recall · forget
Types: first-class, .d.ts shipped

Keep exploring

Python SDK

Bring Minds into Python scripts and applications.

MCP Server

Connect compatible assistants to memory through MCP.

Reasoning

Explore how stored knowledge can guide an agent’s reasoning.

Make your next request more informed.

Connect your TypeScript application to a Mind and give it useful context to return to.

Start free Talk to sales