SDKs · Node.js

Node.js Memory Client

Build against the ten public promise-based memory methods, their exported TypeScript types, and explicit project and end-user scope.

Configure the client

client.ts

import { MemorySyncClient } from "memorysync-sdk";

const client = new MemorySyncClient({
  apiKey: process.env.MEMORYSYNC_API_KEY!,
  baseUrl: "https://api.memorysync.io",
  projectId: process.env.MEMORYSYNC_PROJECT_ID!,
  endUserId: "usr_7f3a9c2e",
});

Field	Required	Purpose
`apiKey`	Yes	Server-side memory API credential.
`baseUrl`	Yes	MemorySync HTTPS base URL.
`projectId`	By application scope	Selects the trusted project context.
`endUserId`	For user-scoped memory calls	Stable opaque application-user identifier.
`timeoutMs`	No	Request timeout in milliseconds; defaults to 30000.
`fetch`	No	Inject a compatible fetch implementation when required.

All memory methods

Method	Returns	Use
`add(request)`	`Promise<AddResponse>`	Store one memory candidate.
`bulkAdd(items, options?)`	`Promise<BulkAddResponse>`	Submit 1–50 items and inspect each outcome.
`query(request)`	`Promise<QueryResponse>`	Retrieve a result window.
`get(memoryId)`	`Promise<MemoryRecord>`	Read one known record.
`update(memoryId, request)`	`Promise<MemoryRecord>`	Replace supported descriptive fields.
`forget(memoryIds, reason?)`	`Promise<number[]>`	Remove selected records and inspect confirmed IDs.
`summarize(request)`	`Promise<MemoryRecord>`	Create a summary record.
`compose(request)`	`Promise<ComposeResponse>`	Receive a composed prompt and usage fields.
`exportAll()`	`Promise<ExportResponse>`	Read the authenticated principal export.
`createRelation(fromId, request)`	`Promise<RelationRecord>`	Create a documented record relationship.

Narrow AddResponse

add-memory.ts

const result = await client.add({
  text: "The user prefers dark mode.",
  source: "settings",
  metadata: { screen: "appearance" },
});

if ("status" in result && result.status === "skipped") {
  console.log("not created", result.reason);
} else {
  console.log("created", result.id, result.text);
}

Reconcile every bulk item

bulk-add.ts

const response = await client.bulkAdd([
  { text: "The launch is Friday.", tags: ["plan"] },
  { text: "The release needs legal approval.", tags: ["constraint"] },
]);

for (const item of response.results) {
  console.log(item.index, item.status, item.memoryIds, item.reason);
}

Retrieve and maintain records

retrieve-and-update.ts

const response = await client.query({
  query: "What constraints apply to the launch?",
  k: 5,
  filters: { tags: ["constraint"] },
});

for (const memory of response.memories) {
  const current = await client.get(memory.id);
  const updated = await client.update(current.id, {
    tags: ["constraint", "reviewed"],
  });
  console.log(updated.id, updated.tags);
}

Authorize destructive operations

forget.ts

const requestedIds = [101, 102];
const deletedIds = await client.forget(requestedIds, "user_request");

const confirmedIds = new Set(deletedIds);
if (requestedIds.some((id) => !confirmedIds.has(id))) {
  console.log("Reconcile the IDs that were not confirmed");
}

Reference and safety

Memory API Reference

See operation fields and successful response variants.

Types & Errors

Narrow unions and typed failures.

Memory Contract

Understand customer-visible record fields.

Retrieval Contract

Consume candidate results safely.

← Previous

Quickstart

Types & Errors