TypeScript SDK

npm install @anona-labs/memory

import { Anona } from "@anona-labs/memory";

const anona = new Anona({ apiKey: process.env.ANONA_API_KEY! });

await anona.record({ spaceId: "support", content: "Alice is a senior engineer at Google" });

const results = await anona.retrieve({ spaceId: "support", query: "Where does Alice work?" });
console.log(results[0]?.content);

const anona = new Anona({
  apiKey: "anona_live_YOUR_KEY",
  baseUrl: "https://api.anonalabs.com", // optional, this is the default
  timeoutMs: 30_000,                    // optional, per attempt — this is the default
  maxRetries: 2,                        // optional — this is the default; 0 turns retrying off
});

const anona = new Anona({ apiKey: "...", fetch: myInstrumentedFetch });

const memory = await anona.record({
  spaceId: "support",
  content: "Alice works at Google and specializes in distributed systems",
  userId: "alice_123",
  tags: ["work"],
  metadata: { source: "crm" },
});
console.log(memory.memory_id);

// Only Alice's memories
const results = await anona.retrieve({
  spaceId: "support",
  query: "Where does Alice work?",
  userId: "alice_123",
});

const batch = await anona.recordBatch({
  spaceId: "support",
  items: [{ content: "Bob works in Berlin" }, { content: "Carol joined in March" }],
});
console.log(batch.job_id, batch.accepted);

const results = await anona.retrieve({
  spaceId: "support",
  query: "Where does Alice work?",
  limit: 10,
});

for (const r of results) {
  console.log(r.content, r.relevance_score);
  // A `note` names the facts it was synthesized from. Empty on a `fact`,
  // which is the evidence itself.
  for (const sourceId of r.source_ids) {
    console.log("  built from", sourceId);
  }
}

const results = await anona.retrieve({
  spaceId: "support",
  query: "what is left to do",
  tagGroups: [
    { or: [{ tags: ["project:alpha"] }, { tags: ["project:beta"] }] },
    { not: { tags: ["status:archived"] } },
  ],
});

const res = await anona.retrieveReceipt({
  spaceId: "support",
  query: "who is on call for billing?",
  receiptDetail: "full",
});

console.log(res.memories.map((m) => m.content));

const receipt = await anona.getReceipt(res.receipt_id!);
for (const cut of receipt.excluded) {
  console.log(cut.reason, cut.detail);
}

const verdict = await anona.explain(res.receipt_id!, "mem_abc123");

verdict.outcome;  // "included" | "excluded" | "not_retrieved"
verdict.stage;    // "retrieval" | "fusion" | "rerank", when excluded
verdict.arms;     // { semantic: 812, keyword: null, ... }

const answer = await anona.reason({
  spaceId: "support",
  query: "What have we learned about Alice's career?",
});
console.log(answer.insights);

const profile = await anona.getUserProfile({ spaceId: "support", userId: "alice_123" });
console.log(profile.memory_count, profile.last_active);

// Prompt-ready instead of a list
const { context } = await anona.getUserProfile({
  spaceId: "support",
  userId: "alice_123",
  format: "block",
  contextMaxTokens: 500,
});

const answer = await anona.askAboutUser({
  spaceId: "support",
  userId: "alice_123",
  query: "How does she prefer to be contacted?",
});
console.log(answer.insights, answer.model);

// Fix the content
await anona.updateMemory({
  spaceId: "support",
  memoryId: "mem_1",
  text: "Alice moved to Berlin in March",
});

// Retire it. Reversible, unlike deleteMemory
await anona.updateMemory({
  spaceId: "support",
  memoryId: "mem_1",
  state: "invalidated",
  reason: "superseded by a later correction",
});

const { history } = await anona.getMemoryHistory({ spaceId: "support", memoryId: "mem_1" });

for (const entry of history) {
  console.log(entry.changed_at, entry.previous_content);
}

import { readFile } from "node:fs/promises";

const upload = await anona.uploadFiles({
  spaceId: "support",
  files: [{ data: await readFile("handbook.pdf"), filename: "handbook.pdf" }],
  tags: ["hr", "policy"],
});
console.log(upload.job_ids);

import { openai } from "@ai-sdk/openai";
import { generateText, wrapLanguageModel } from "ai";
import { Anona } from "@anona-labs/memory";
import { anonaMemory } from "@anona-labs/memory/vercel";

const anona = new Anona({ apiKey: process.env.ANONA_API_KEY! });

const model = wrapLanguageModel({
  model: openai("gpt-4o"),
  middleware: anonaMemory({ client: anona, spaceId: "support", limit: 8 }),
});

const { text } = await generateText({ model, prompt: "How should I contact Alice?" });

import { Agent, run } from "@openai/agents";
import { Anona } from "@anona-labs/memory";
import { anonaTools } from "@anona-labs/memory/openai-agents";

const anona = new Anona({ apiKey: process.env.ANONA_API_KEY! });

const agent = new Agent({
  name: "support",
  tools: anonaTools({ client: anona, spaceId: "support" }),
});

await run(agent, "What do you know about Alice?");

import { Anona, AnonaError } from "@anona-labs/memory";

try {
  await anona.retrieve({ spaceId: "support", query: "Where does Alice work?" });
} catch (error) {
  if (error instanceof AnonaError) {
    console.error(error.statusCode, error.code, error.requestId);
  }
}

// Backend route
app.post("/api/memories/search", async (req, res) => {
  const results = await anona.retrieve({
    spaceId: req.body.spaceId,
    query: req.body.query,
  });
  res.json(results);
});