Skip to main content
Retrieve and the drop-in proxy both ship with sensible defaults, but “sensible” isn’t always right for your data. This guide is a symptom-to-fix map for the knobs that actually move recall quality.

”It’s returning duplicates of the same fact”

This is by design, and there’s a knob for it. Anona keeps two layers (raw fact memories and consolidated note memories synthesized from them), and by default (prefer_observations: true) a note replaces the facts it was built from, so you see one distilled result instead of the same content several times. If you’re still seeing what looks like duplication, you’re probably retrieving with prefer_observations: false (or an old space that predates consolidation catching up). Leave it at the default unless you specifically need the raw evidence behind a synthesis:

“It’s returning too little” / “missing an obvious memory”

Check these in order:
  1. Is min_score filtering it out? This is the first thing to check, because almost any floor is a high one. In the default accurate mode relevance_score is close to two-valued: a near-verbatim match scores around 1.1, and everything else — including a correct answer phrased differently from the query — scores around 0.0001 or less. Very little lands in between, so any floor between those two values keeps near-verbatim matches only. A floor also drops results without shrinking limit, so it returns fewer than you asked for with nothing to say it did. Omit it.
  2. Is a scope key excluding it? A scoped query (user_id/agent_id/session_id) returns only memories written under that exact scope, never unscoped ones, never another scope’s. If the memory was written without a scope and you’re querying with one, it won’t come back. See Scoping.
  3. Is limit too low? Default is 10. Raise it (limit / top_k, up to 100) if the memory exists but is being cut off by rank.
  4. Is it filtered by memory_type or tags? Both narrow the result set; drop them to confirm the memory shows up unfiltered, then add them back deliberately.
  5. Is the memory in a different space from the one you searched? No amount of tuning finds a memory that is somewhere else — the space you named is the whole search. If you are not sure which space holds the answer, use route: "auto" and read the searched array in the response to see where it looked. A question whose answer genuinely spans two spaces — the charge in one, the account it landed on in another — needs more than one space searched.

”It’s returning too much” / “the wrong things are ranking high”

  1. Lower limit. This is the lever for precision vs. breadth, because results come back ranked and the ones you do not want are at the bottom. Reach for limit (or top_k) rather than min_score: as above, the score is close to two-valued, so min_score is a switch for “near-verbatim only” rather than a dial you can trim with. Set it only when that switch is what you want — and never to a round number like 0.1 or 0.5 picked to shave off the weakest results, which drops every paraphrase match instead. See relevance_score.
  2. Add memory_type or tags filters if you know which kind of memory you actually want (e.g. memory_type: ["fact"] to skip synthesized notes and summaries).
  3. Check you’re on mode: "accurate", not "fast". fast skips the neural rerank pass and ranks on retrieval fusion alone: faster, but lower precision. It trades exactly the quality you’re trying to improve.

”The proxy is injecting too much / too little context into the model”

This is the chat/responses/messages proxy, not raw retrieve, so the knobs are the memory tunables, not retrieve parameters: Set these once as space defaults (PUT /v1/spaces/{space_id}/chat-settings) instead of a header on every call if the whole space should behave differently. Resolution order is body → header → space default → platform default, so a space default is a safe place to change behavior without touching call sites. See Migrating to the drop-in proxy.

”I want the model to see the memories exactly, not rely on the proxy’s injection”

Build the prompt yourself with format: "block" on retrieve, which returns a ready-to-paste string with the token budget already applied:
context_max_tokens drops whole memories, lowest-ranked first, until the block fits, and text is never truncated mid-sentence. results is still returned alongside the block, so you get both for one round trip.

”Recall is too slow”

Latency-sensitive path (an agent loop, autocomplete-style lookups)? Set mode: "fast" on retrieve, which skips the neural cross-encoder rerank and ranks on retrieval fusion alone. Accept the precision tradeoff deliberately, and don’t set it globally as a default without checking result quality first.

Quick reference

Next steps

Retrieve API

Full parameter and response reference.

Chat API: memory tunables

Every proxy tunable, body and header form.