> ## Documentation Index
> Fetch the complete documentation index at: https://docs.anonalabs.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Use Cases

> Every recipe, searchable — from a support bot that knows each customer to a data-subject deletion runbook.

export const UseCaseIndex = () => {
  const MIRROR = "https://github.com/anonalabs/Anona-Memory-SDK/blob/main/examples/";
  const GROUPS = ["All", "Personal", "Build", "Support", "Research", "Team", "Governance", "Frameworks"];
  const RECIPES = [{
    title: "Remember the people you meet",
    description: "Who they are, what they're working on, what they said last time \u2014 without keeping a CRM you'll never update.",
    group: "Personal",
    tags: ["mcp", "people", "personal-crm", "profiles"],
    href: "/use-cases/remember-people",
    script: null,
    buildsOn: []
  }, {
    title: "Keep your own promises",
    description: "What you said you'd do, who you said it to, and which ones you quietly dropped.",
    group: "Personal",
    tags: ["mcp", "commitments", "temporal", "personal"],
    href: "/use-cases/keep-your-promises",
    script: null,
    buildsOn: []
  }, {
    title: "Think out loud, keep the thought",
    description: "Say it into your phone on the walk home. It arrives as memory you can question later.",
    group: "Personal",
    tags: ["voice", "audio", "notes", "multimodal"],
    href: "/use-cases/think-out-loud",
    script: null,
    buildsOn: ["document_qa.py"]
  }, {
    title: "Stop re-solving the same bug",
    description: "The fix you found in March, surfaced in September \u2014 before you start debugging, not after.",
    group: "Personal",
    tags: ["mcp", "debugging", "skills", "coding-agent"],
    href: "/use-cases/stop-resolving-the-same-bug",
    script: null,
    buildsOn: []
  }, {
    title: "The three calls you actually need",
    description: "Record what happened, retrieve what matters, reason across it. Almost every integration is these three.",
    group: "Build",
    tags: ["core", "quickstart"],
    href: "/use-cases/the-three-calls",
    script: "memory_basics.py",
    buildsOn: []
  }, {
    title: "One line, keep your OpenAI SDK",
    description: "Point a stock OpenAI client at Anona. Every call recalls what matters and stores what is new. No rewrite.",
    group: "Build",
    tags: ["proxy", "openai", "migration", "drop-in"],
    href: "/use-cases/drop-in-proxy",
    script: "drop_in_proxy.py",
    buildsOn: []
  }, {
    title: "Chat with your documents",
    description: "Upload a file, wait for extraction, ask. Uploads land in the same space as everything else you recorded.",
    group: "Build",
    tags: ["documents", "upload", "rag", "pdf"],
    href: "/use-cases/chat-with-your-documents",
    script: "document_qa.py",
    buildsOn: []
  }, {
    title: "Turn a meeting recording into memory",
    description: "Drop in the audio. It comes back as transcribed, searchable memory nobody had to write up.",
    group: "Build",
    tags: ["audio", "meetings", "multimodal", "transcription"],
    href: "/use-cases/meeting-recording-to-memory",
    script: null,
    buildsOn: ["document_qa.py", "background_ingestion.py"]
  }, {
    title: "Backfill a year of history",
    description: "Queue the writes, keep serving, poll for the outcome. A blocking record waits on an LLM call; this does not.",
    group: "Build",
    tags: ["batch", "async", "jobs", "backfill"],
    href: "/use-cases/backfill-history",
    script: "background_ingestion.py",
    buildsOn: []
  }, {
    title: "Know the moment ingestion finishes",
    description: "Webhooks instead of polling, plus the per-space defaults that stop you resending the same options.",
    group: "Build",
    tags: ["webhooks", "events", "settings"],
    href: "/use-cases/events-not-polling",
    script: "webhooks_and_settings.py",
    buildsOn: []
  }, {
    title: "Support agent that knows each customer",
    description: "One space serves every customer. Scoping keeps their histories apart, so nobody is told someone else's story.",
    group: "Support",
    tags: ["scoping", "support", "saas", "isolation"],
    href: "/use-cases/support-agent-per-customer",
    script: "support_bot_scoping.py",
    buildsOn: []
  }, {
    title: "Everything you know about one user",
    description: "Two calls turn scoped writes into a profile, and a question you can ask about that person alone.",
    group: "Support",
    tags: ["profiles", "personalization", "scoping"],
    href: "/use-cases/one-user-profile",
    script: "user_profiles.py",
    buildsOn: []
  }, {
    title: "Support memory the whole team shares",
    description: "What one agent learns on a ticket, the next one already knows \u2014 across reps, shifts and organisations.",
    group: "Support",
    tags: ["sharing", "team", "support", "roles"],
    href: "/use-cases/shared-team-support-memory",
    script: null,
    buildsOn: ["support_bot_scoping.py", "multi_agent_shared_space.py"]
  }, {
    title: "Tutor that remembers the learner",
    description: "Progress, sticking points and preferences that persist between sessions, months apart.",
    group: "Support",
    tags: ["education", "tutoring", "profiles", "temporal"],
    href: "/use-cases/tutor-that-remembers",
    script: null,
    buildsOn: ["user_profiles.py", "time_travel.py"]
  }, {
    title: "Who your agent keeps meeting",
    description: "Extraction names the people, companies and systems in every memory. Read the graph it has been building.",
    group: "Research",
    tags: ["graph", "entities"],
    href: "/use-cases/entity-graph",
    script: "knowledge_graph.py",
    buildsOn: []
  }, {
    title: "What was true back then",
    description: "Every memory carries two clocks. Filter on when things happened, not just when you stored them.",
    group: "Research",
    tags: ["temporal", "as-of", "history", "audit"],
    href: "/use-cases/what-was-true-back-then",
    script: "time_travel.py",
    buildsOn: []
  }, {
    title: "Competitive intelligence that accumulates",
    description: "Press releases, pricing changes and job postings become a position you can query, not a folder nobody reads.",
    group: "Research",
    tags: ["competitive", "temporal", "monitoring"],
    href: "/use-cases/competitive-intelligence",
    script: null,
    buildsOn: ["time_travel.py", "knowledge_graph.py"]
  }, {
    title: "Financial analyst across quarters",
    description: "Ask what changed between Q2 and Q4 and get an answer grounded in what was said at the time.",
    group: "Research",
    tags: ["finance", "temporal", "analysis"],
    href: "/use-cases/financial-analyst",
    script: null,
    buildsOn: ["time_travel.py", "memory_basics.py"]
  }, {
    title: "Contract and policy memory",
    description: "Which clause, in which agreement, agreed when \u2014 with the provenance to prove where the answer came from.",
    group: "Research",
    tags: ["legal", "documents", "provenance"],
    href: "/use-cases/contract-and-policy-memory",
    script: null,
    buildsOn: ["document_qa.py", "context_receipts.py"]
  }, {
    title: "A briefing that keeps itself current",
    description: "Ask a standing question once. It rewrites its own answer as new memories arrive, and tells you when it is stale.",
    group: "Research",
    tags: ["models", "briefing", "synthesis"],
    href: "/use-cases/self-refreshing-briefing",
    script: null,
    buildsOn: ["memory_basics.py"]
  }, {
    title: "Two agents, one space",
    description: "Shared knowledge with per-agent working sets, so a handoff carries everything the next agent needs.",
    group: "Team",
    tags: ["multi-agent", "handoff", "scoping"],
    href: "/use-cases/two-agents-one-space",
    script: "multi_agent_shared_space.py",
    buildsOn: []
  }, {
    title: "Memory for your coding agent",
    description: "Architecture decisions, past fixes and house conventions that survive the end of the session.",
    group: "Team",
    tags: ["coding-agent", "mcp", "skills", "claude-code"],
    href: "/use-cases/memory-for-your-coding-agent",
    script: null,
    buildsOn: ["memory_basics.py", "multi_agent_shared_space.py"]
  }, {
    title: "Onboarding agent for new hires",
    description: "New starters ask the questions they are embarrassed to ask, and get answers from your real docs.",
    group: "Team",
    tags: ["onboarding", "internal", "documents"],
    href: "/use-cases/onboarding-agent",
    script: null,
    buildsOn: ["document_qa.py", "memory_basics.py"]
  }, {
    title: "Search across everything the company knows",
    description: "One question, answered from the documents, decisions and conversations you have already fed it.",
    group: "Team",
    tags: ["internal-search", "knowledge-base", "documents"],
    href: "/use-cases/company-wide-search",
    script: null,
    buildsOn: ["document_qa.py", "memory_basics.py"]
  }, {
    title: "Incident copilot that has read every postmortem",
    description: "The last four times this broke, what fixed it, and who knew \u2014 surfaced while it is still broken.",
    group: "Team",
    tags: ["incident", "ops", "postmortem"],
    href: "/use-cases/incident-copilot",
    script: null,
    buildsOn: ["document_qa.py", "time_travel.py"]
  }, {
    title: "Account memory that outlives the rep",
    description: "Stakeholders, commitments and objections stay with the account when the person handling it changes.",
    group: "Team",
    tags: ["sales", "crm", "accounts", "handoff"],
    href: "/use-cases/account-memory",
    script: null,
    buildsOn: ["support_bot_scoping.py", "user_profiles.py"]
  }, {
    title: "Candidate memory across interviewers",
    description: "Every interviewer sees what the others already covered, so the fourth conversation is not the first one again.",
    group: "Team",
    tags: ["recruiting", "hiring", "scoping"],
    href: "/use-cases/candidate-memory",
    script: null,
    buildsOn: ["support_bot_scoping.py", "knowledge_graph.py"]
  }, {
    title: "Why the answer used what it used",
    description: "A receipt for every retrieval: what entered the prompt, what was cut, and which of four reasons cut it.",
    group: "Governance",
    tags: ["receipts", "audit", "debugging", "compliance"],
    href: "/use-cases/why-the-answer-used-what-it-used",
    script: "context_receipts.py",
    buildsOn: []
  }, {
    title: "Correct a memory without losing the record",
    description: "Supersede what turned out to be wrong, with the reason attached and the old version still readable.",
    group: "Governance",
    tags: ["correction", "audit", "history", "compliance"],
    href: "/use-cases/correct-a-memory",
    script: null,
    buildsOn: ["memory_basics.py", "time_travel.py"]
  }, {
    title: "Delete a user's memories, provably",
    description: "A data-subject request answered end to end: find everything about one person, export it, remove it, show your work.",
    group: "Governance",
    tags: ["gdpr", "dsr", "deletion", "compliance"],
    href: "/use-cases/delete-a-users-memories",
    script: null,
    buildsOn: ["support_bot_scoping.py", "user_profiles.py"]
  }, {
    title: "Cut the bill without cutting recall",
    description: "Cap what memory is allowed to spend of your prompt, and measure what the provider's cache gave back.",
    group: "Governance",
    tags: ["cost", "tokens", "prompt-cache", "budget"],
    href: "/use-cases/cut-the-bill",
    script: null,
    buildsOn: ["drop_in_proxy.py", "memory_basics.py"]
  }, {
    title: "Prove the memory is earning its place",
    description: "Run the same questions with memory on and off, and keep the number instead of the impression.",
    group: "Governance",
    tags: ["evaluation", "ab-test", "quality"],
    href: "/use-cases/prove-memory-helps",
    script: null,
    buildsOn: ["drop_in_proxy.py", "memory_basics.py"]
  }, {
    title: "Choose the model a space thinks with",
    description: "Fourteen models, priced per operation. Pin a cheap one to a noisy space and a strong one to the space that matters.",
    group: "Governance",
    tags: ["models", "cost", "reason-settings", "catalog"],
    href: "/use-cases/choose-the-model",
    script: null,
    buildsOn: []
  }, {
    title: "Teach it your vocabulary",
    description: "Your domain has words that mean something specific. Extraction can be told, once, per space.",
    group: "Build",
    tags: ["extraction", "domain", "tuning", "settings"],
    href: "/use-cases/teach-it-your-vocabulary",
    script: null,
    buildsOn: []
  }, {
    title: "Browse what it knows",
    description: "Page through the memories themselves \u2014 no query, no ranking. The view that answers 'what did it actually store?'",
    group: "Build",
    tags: ["browse", "list", "documents", "debugging"],
    href: "/use-cases/browse-what-it-knows",
    script: null,
    buildsOn: []
  }, {
    title: "One space or many?",
    description: "The decision you make once, early, and cannot cheaply undo. Here is how to make it right.",
    group: "Build",
    tags: ["spaces", "architecture", "isolation", "lifecycle"],
    href: "/use-cases/one-space-or-many",
    script: null,
    buildsOn: []
  }, {
    title: "Give the space a mission",
    description: "Tell it what it is for, and how skeptical to be. It changes what gets kept and how it is read back.",
    group: "Research",
    tags: ["profile", "disposition", "mission", "tuning"],
    href: "/use-cases/give-the-space-a-mission",
    script: null,
    buildsOn: []
  }, {
    title: "A shelf of standing questions",
    description: "Not one self-updating briefing \u2014 a dozen, listed, edited, cleared and retired as the work moves.",
    group: "Research",
    tags: ["models", "briefing", "lifecycle", "synthesis"],
    href: "/use-cases/a-shelf-of-standing-questions",
    script: null,
    buildsOn: []
  }, {
    title: "Stop a runaway import",
    description: "You queued fifty thousand rows from the wrong table. Here is the kill switch, and the cleanup.",
    group: "Build",
    tags: ["jobs", "cancel", "cleanup", "webhooks"],
    href: "/use-cases/stop-a-runaway-import",
    script: null,
    buildsOn: []
  }, {
    title: "Take everything with you",
    description: "A full export of a space \u2014 every memory and entity \u2014 as a file you hold. No SDK method; three HTTP calls.",
    group: "Governance",
    tags: ["export", "portability", "backup", "rest"],
    href: "/use-cases/take-everything-with-you",
    script: null,
    buildsOn: []
  }, {
    title: "LangChain and LangGraph",
    description: "One middleware, and every turn is recalled and stored. Nothing else in the chain changes.",
    group: "Frameworks",
    tags: ["langchain", "langgraph", "middleware"],
    href: "/integrations/langchain",
    script: "langchain_agent.py",
    buildsOn: []
  }, {
    title: "CrewAI",
    description: "Memory as tools the crew can call, with the prompt wording that makes them call it.",
    group: "Frameworks",
    tags: ["crewai", "tools", "multi-agent"],
    href: "/integrations/crewai",
    script: "crewai_crew.py",
    buildsOn: []
  }, {
    title: "LlamaIndex",
    description: "LlamaIndex flushes a turn only when its own buffer overflows, so the last turn needs an explicit capture.",
    group: "Frameworks",
    tags: ["llamaindex"],
    href: "/integrations/llamaindex",
    script: "llamaindex_agent.py",
    buildsOn: []
  }, {
    title: "Google ADK",
    description: "ADK automates neither direction: load_memory gives the model a search tool, a callback stores the turn.",
    group: "Frameworks",
    tags: ["google", "adk"],
    href: "/integrations/google-adk",
    script: "google_adk_agent.py",
    buildsOn: []
  }, {
    title: "Microsoft Agent Framework",
    description: "One context provider, and every turn is recalled and stored.",
    group: "Frameworks",
    tags: ["microsoft", "agent-framework"],
    href: "/integrations/microsoft-agent-framework",
    script: "ms_agent_framework.py",
    buildsOn: []
  }, {
    title: "AWS Strands",
    description: "Memory exposed as tools, with the prompt text that tells the model when to reach for them.",
    group: "Frameworks",
    tags: ["aws", "strands", "tools"],
    href: "/integrations/strands",
    script: "strands_agent.py",
    buildsOn: []
  }];
  const ACTIVE = "#ce3430";
  const BORDER = "rgba(128, 128, 128, 0.38)";
  const wrap = {
    margin: "1.5rem 0"
  };
  const searchBox = {
    width: "100%",
    padding: "0.625rem 0.75rem",
    borderRadius: "0.5rem",
    border: "1px solid " + BORDER,
    background: "transparent",
    color: "inherit",
    fontFamily: "inherit",
    fontSize: "0.9375rem"
  };
  const chipRow = {
    display: "flex",
    flexWrap: "wrap",
    gap: "0.5rem",
    margin: "0.75rem 0 0.25rem"
  };
  const chip = {
    padding: "0.3125rem 0.75rem",
    borderRadius: "999px",
    border: "1px solid " + BORDER,
    background: "transparent",
    color: "inherit",
    font: "inherit",
    fontSize: "0.8125rem",
    cursor: "pointer"
  };
  const chipOn = {
    ...chip,
    background: ACTIVE,
    borderColor: ACTIVE,
    color: "#fff"
  };
  const grid = {
    display: "grid",
    gridTemplateColumns: "repeat(auto-fill, minmax(17rem, 1fr))",
    gap: "0.875rem",
    marginTop: "1rem"
  };
  const CARD_BORDER = "rgba(128, 128, 128, 0.28)";
  const CARD_BORDER_HOVER = "rgba(128, 128, 128, 0.7)";
  const card = {
    border: "1px solid " + CARD_BORDER,
    cursor: "pointer",
    transition: "border-color 120ms ease",
    borderRadius: "0.75rem",
    padding: "0.9375rem 1rem",
    display: "flex",
    flexDirection: "column",
    gap: "0.4375rem"
  };
  const tagPill = {
    fontSize: "0.6875rem",
    padding: "0.125rem 0.4375rem",
    borderRadius: "0.25rem",
    border: "1px solid " + BORDER,
    opacity: 0.7
  };
  const descStyle = {
    margin: 0,
    fontSize: "0.8125rem",
    opacity: 0.8,
    lineHeight: 1.5
  };
  const tagRow = {
    display: "flex",
    flexWrap: "wrap",
    gap: "0.25rem",
    marginTop: "auto",
    paddingTop: "0.375rem"
  };
  const linkReset = {
    fontWeight: 600,
    fontSize: "0.9375rem",
    textDecoration: "none",
    borderBottom: "none"
  };
  const haystackOf = r => (r.title + " " + r.description + " " + r.group + " " + r.tags.join(" ")).toLowerCase();
  const openCard = event => {
    if (event.target.closest && event.target.closest("a")) return;
    const href = event.currentTarget.getAttribute("data-uc-href");
    if (href) window.location.href = href;
  };
  const hoverOn = event => {
    event.currentTarget.style.borderColor = CARD_BORDER_HOVER;
  };
  const hoverOff = event => {
    event.currentTarget.style.borderColor = CARD_BORDER;
  };
  const applyFilter = () => {
    const root = document.getElementById("anona-use-cases");
    if (!root) return;
    const input = root.querySelector("[data-uc-search]");
    const q = (input && input.value || "").toLowerCase().trim();
    const group = root.getAttribute("data-uc-group") || "All";
    let shown = 0;
    root.querySelectorAll("[data-uc-card]").forEach(el => {
      const matchesGroup = group === "All" || el.getAttribute("data-uc-of") === group;
      const matchesText = q === "" || (el.getAttribute("data-uc-hay") || "").indexOf(q) !== -1;
      const ok = matchesGroup && matchesText;
      el.style.display = ok ? "flex" : "none";
      if (ok) shown += 1;
    });
    const empty = root.querySelector("[data-uc-empty]");
    if (empty) empty.style.display = shown === 0 ? "block" : "none";
    const count = root.querySelector("[data-uc-count]");
    if (count) count.textContent = shown + (shown === 1 ? " use case" : " use cases");
  };
  const selectGroup = event => {
    const root = document.getElementById("anona-use-cases");
    if (!root) return;
    const picked = event.currentTarget.getAttribute("data-uc-chip");
    root.setAttribute("data-uc-group", picked);
    root.querySelectorAll("[data-uc-chip]").forEach(button => {
      const on = button.getAttribute("data-uc-chip") === picked;
      button.setAttribute("aria-pressed", on ? "true" : "false");
      button.style.background = on ? ACTIVE : "transparent";
      button.style.borderColor = on ? ACTIVE : BORDER;
      button.style.color = on ? "#fff" : "inherit";
    });
    applyFilter();
  };
  return <div id="anona-use-cases" data-uc-group="All" style={wrap}>
      <label htmlFor="anona-use-case-search" style={{
    display: "block",
    fontWeight: 600,
    marginBottom: "0.5rem"
  }}>
        Search use cases
      </label>

      <input id="anona-use-case-search" type="search" data-uc-search="" placeholder="receipts, scoping, upload, handoff…" style={searchBox} onInput={applyFilter} />

      <div style={chipRow} role="group" aria-label="Filter by category">
        {GROUPS.map(g => <button key={g} type="button" data-uc-chip={g} aria-pressed={g === "All" ? "true" : "false"} style={g === "All" ? chipOn : chip} onClick={selectGroup}>
            {g}
          </button>)}
      </div>

      <p style={{
    margin: "0.5rem 0 0",
    fontSize: "0.8125rem",
    opacity: 0.7
  }}>
        <span data-uc-count="">{RECIPES.length + " use cases"}</span>
        {" · every one is a script our CI runs"}
      </p>

      <div style={grid}>
        {RECIPES.map(r => <div key={r.title} data-uc-card="" data-uc-of={r.group} data-uc-hay={haystackOf(r)} data-uc-href={r.href || MIRROR + r.script} style={card} onClick={openCard} onMouseEnter={hoverOn} onMouseLeave={hoverOff}>
            <a href={r.href || MIRROR + r.script} style={linkReset}>
              {r.title}
            </a>

            <p style={descStyle}>{r.description}</p>

            <div style={tagRow}>
              {r.tags.map(t => <span key={t} style={tagPill}>
                  {t}
                </span>)}
            </div>

          </div>)}
      </div>

      <p data-uc-empty="" style={{
    display: "none",
    margin: "1.25rem 0 0",
    fontSize: "0.875rem",
    opacity: 0.75
  }}>
        Nothing matches that. Clear the search, or tell us what you were looking
        for at <a href="mailto:support@anonalabs.com">support@anonalabs.com</a> —
        a miss here is a recipe we should write.
      </p>
    </div>;
};

The [Guides](/guides/tuning-recall) explain how a knob works. These explain how
to build the thing you came here to build.

**Every recipe is anchored to code you can run.** Many are a complete program
in the SDK repository — clone it, set a key, run it.

The rest are recombinations rather than new mechanisms: a support workflow is
scoping plus sharing, a financial analyst is temporal filtering plus reason.
Those carry no script of their own, and the rule they follow instead is that
**every call they show appears in one that does** — each names the scripts it
was built from, so you can run the mechanism before you trust the recipe.

<UseCaseIndex />

## Every recipe

Each one is a written walkthrough — the scenario, the steps, how to check it
worked, and the mistakes worth avoiding.

**Personal**

* [Remember the people you meet](/use-cases/remember-people) — Who they are, what they're working on, what they said last time — without keeping a CRM you'll never update.
* [Keep your own promises](/use-cases/keep-your-promises) — What you said you'd do, who you said it to, and which ones you quietly dropped.
* [Think out loud, keep the thought](/use-cases/think-out-loud) — Say it into your phone on the walk home. It arrives as memory you can question later.
* [Stop re-solving the same bug](/use-cases/stop-resolving-the-same-bug) — The fix you found in March, surfaced in September — before you start debugging, not after.

**Build**

* [The three calls you actually need](/use-cases/the-three-calls) — Record what happened, retrieve what matters, reason across it. Almost every integration is these three.
* [One line, keep your OpenAI SDK](/use-cases/drop-in-proxy) — Point a stock OpenAI client at Anona. Every call recalls what matters and stores what is new. No rewrite.
* [Chat with your documents](/use-cases/chat-with-your-documents) — Upload a file, wait for extraction, ask. Uploads land in the same space as everything else you recorded.
* [Turn a meeting recording into memory](/use-cases/meeting-recording-to-memory) — Drop in the audio. It comes back as transcribed, searchable memory nobody had to write up.
* [Backfill a year of history](/use-cases/backfill-history) — Queue the writes, keep serving, poll for the outcome. A blocking record waits on an LLM call; this does not.
* [Know the moment ingestion finishes](/use-cases/events-not-polling) — Webhooks instead of polling, plus the per-space defaults that stop you resending the same options.
* [Teach it your vocabulary](/use-cases/teach-it-your-vocabulary) — Your domain has words that mean something specific. Extraction can be told, once, per space.
* [Browse what it knows](/use-cases/browse-what-it-knows) — Page through the memories themselves — no query, no ranking. The view that answers 'what did it actually store?'
* [One space or many?](/use-cases/one-space-or-many) — The decision you make once, early, and cannot cheaply undo. Here is how to make it right.
* [Stop a runaway import](/use-cases/stop-a-runaway-import) — You queued fifty thousand rows from the wrong table. Here is the kill switch, and the cleanup.

**Support**

* [Support agent that knows each customer](/use-cases/support-agent-per-customer) — One space serves every customer. Scoping keeps their histories apart, so nobody is told someone else's story.
* [Everything you know about one user](/use-cases/one-user-profile) — Two calls turn scoped writes into a profile, and a question you can ask about that person alone.
* [Support memory the whole team shares](/use-cases/shared-team-support-memory) — What one agent learns on a ticket, the next one already knows — across reps, shifts and organisations.
* [Tutor that remembers the learner](/use-cases/tutor-that-remembers) — Progress, sticking points and preferences that persist between sessions, months apart.

**Research**

* [Who your agent keeps meeting](/use-cases/entity-graph) — Extraction names the people, companies and systems in every memory. Read the graph it has been building.
* [What was true back then](/use-cases/what-was-true-back-then) — Every memory carries two clocks. Filter on when things happened, not just when you stored them.
* [Competitive intelligence that accumulates](/use-cases/competitive-intelligence) — Press releases, pricing changes and job postings become a position you can query, not a folder nobody reads.
* [Financial analyst across quarters](/use-cases/financial-analyst) — Ask what changed between Q2 and Q4 and get an answer grounded in what was said at the time.
* [Contract and policy memory](/use-cases/contract-and-policy-memory) — Which clause, in which agreement, agreed when — with the provenance to prove where the answer came from.
* [A briefing that keeps itself current](/use-cases/self-refreshing-briefing) — Ask a standing question once. It rewrites its own answer as new memories arrive, and tells you when it is stale.
* [Give the space a mission](/use-cases/give-the-space-a-mission) — Tell it what it is for, and how skeptical to be. It changes what gets kept and how it is read back.
* [A shelf of standing questions](/use-cases/a-shelf-of-standing-questions) — Not one self-updating briefing — a dozen, listed, edited, cleared and retired as the work moves.

**Team**

* [Two agents, one space](/use-cases/two-agents-one-space) — Shared knowledge with per-agent working sets, so a handoff carries everything the next agent needs.
* [Memory for your coding agent](/use-cases/memory-for-your-coding-agent) — Architecture decisions, past fixes and house conventions that survive the end of the session.
* [Onboarding agent for new hires](/use-cases/onboarding-agent) — New starters ask the questions they are embarrassed to ask, and get answers from your real docs.
* [Search across everything the company knows](/use-cases/company-wide-search) — One question, answered from the documents, decisions and conversations you have already fed it.
* [Incident copilot that has read every postmortem](/use-cases/incident-copilot) — The last four times this broke, what fixed it, and who knew — surfaced while it is still broken.
* [Account memory that outlives the rep](/use-cases/account-memory) — Stakeholders, commitments and objections stay with the account when the person handling it changes.
* [Candidate memory across interviewers](/use-cases/candidate-memory) — Every interviewer sees what the others already covered, so the fourth conversation is not the first one again.

**Governance**

* [Why the answer used what it used](/use-cases/why-the-answer-used-what-it-used) — A receipt for every retrieval: what entered the prompt, what was cut, and which of four reasons cut it.
* [Correct a memory without losing the record](/use-cases/correct-a-memory) — Supersede what turned out to be wrong, with the reason attached and the old version still readable.
* [Delete a user's memories, provably](/use-cases/delete-a-users-memories) — A data-subject request answered end to end: find everything about one person, export it, remove it, show your work.
* [Cut the bill without cutting recall](/use-cases/cut-the-bill) — Cap what memory is allowed to spend of your prompt, and measure what the provider's cache gave back.
* [Prove the memory is earning its place](/use-cases/prove-memory-helps) — Run the same questions with memory on and off, and keep the number instead of the impression.
* [Choose the model a space thinks with](/use-cases/choose-the-model) — Fourteen models, priced per operation. Pin a cheap one to a noisy space and a strong one to the space that matters.
* [Take everything with you](/use-cases/take-everything-with-you) — A full export of a space — every memory and entity — as a file you hold. No SDK method; three HTTP calls.

## Running any of them

```bash theme={null}
git clone https://github.com/anonalabs/Anona-Memory-SDK.git
cd Anona-Memory-SDK

export ANONA_API_KEY=anona_live_YOUR_KEY
export ANONA_SPACE_ID=my-space          # optional, each script has a default

python examples/memory_basics.py
```

<Tip>
  **Run any script twice.** Each one asks two questions in a row where the
  second is only answerable from what the first stored. On the second run the
  opening question is answerable too, because the first run's memories are
  already in the space. That difference is the whole product.
</Tip>

## What if my case isn't here

Tell us at [support@anonalabs.com](mailto:support@anonalabs.com). A gap in this
list is a recipe we should write, and we would rather hear it from you than
guess.

The building blocks underneath every recipe are the same three calls —
[`record`](/api-reference/memories), [`retrieve`](/api-reference/retrieve) and
[`reason`](/api-reference/reason) — so if you can describe your case in terms of
what to store and what to ask, you can usually assemble it from
[Record, retrieve, reason](https://github.com/anonalabs/Anona-Memory-SDK/blob/main/examples/memory_basics.py)
plus one other recipe.

## A question we get asked, answered here

**"Where is the self-hosting guide?"** There isn't one, and that is a product
decision rather than an omission. Anona holds the model credentials so that you
never have to provision, rotate or pay for them, and so that a model change is
something we ship rather than something you migrate. That is the trade: you
cannot run Anona on your own hardware, and in exchange there is no inference
bill, no key rotation and no capacity planning on your side.

If you need memory inside your own network, say so — it is the single most
useful thing you can tell us about your requirements.