MemFront keeps the next likely context hot, so realtime agents do not wait on memory search after the prompt arrives. Predict-first staging returns compact `.ndp` handles in the fast path; full context and Reasoning are pulled only when needed.
Reactive retrieval waits for a query. Predict-first memory watches trajectory and stages the context most likely to matter next.
The `.ndp` format moves memory as handles, previews, terms, scores, and storage keys. Full context is pulled only after the kernel selects it.
Predict, Memory, and Hydration stay cheap. Reasoning adds the LLM answer layer only when the customer needs final QA.
You ask → it searches → returns. That's RAG with a nicer name. Mem0, Zep, MemGPT, LangMem, OpenAI Memory, Claude Memory — all the same pattern.
MemFront does something different: it watches behavioral signal — what sessions you've had, what topics are trending, what past conversations are about to become relevant — and pre-stages them before you ask.
from ndpa import Client
# Initialize once
c = Client(api_key="ndpa_...", platform="myapp")
# Log every turn
c.log_turn(session_id, "user", user_msg)
c.log_turn(session_id, "assistant", reply)
# Stage likely memory before the next query lands
stage = c.stage(session_id, k=5)
# Memory returns handles/previews, not full raw transcripts
matches = c.get_predictions(session_id, query=user_msg)
keys = [m["storage_key"] for m in matches["predictions"]]
# Hydrate full context only when needed
context = c.hydrate(keys)Pre-Query Hit Rate measures predict-forward memory. Given only the user's prior session trajectory — no current question, no explicit input — can the system stage the right past context that will become relevant for their next session?
Vector DBs and embedding-based memory systems can't be scored on this. They require an explicit query. PQHR is the metric for voice AI, ambient assistants, and agentic loops. It measures a category reactive memory systems do not benchmark.
| Predictor | pqhr@1 | pqhr@3 | pqhr@5 | Notes |
|---|---|---|---|---|
| Random baseline | 0.205 | 0.505 | 0.687 | sanity check |
| Recency-only | 0.209 | 0.503 | 0.680 | bar to beat |
| MemFront fixed multi-signal | — | — | 0.846 | W=7 public |
| MemFront adaptive multi-signal ★ | — | — | 0.859 | W=10 public |
18,773 samples · 500 synthetic users · LongMemEval public dataset · BM25 is the labeler (defines truth), not a competitor · BoW cosine is the predictor · fully reproducible
Honest note: random@5 is 68.7% on this synthetic corpus because each user's candidate pool is small (~30–40 past convs). The launch claims are fixed W=7 multi-signal PQHR@5 at 84.6% and adaptive W=10 public PQHR@5 at 85.9%.
MemFront reports each layer with its own metric: PQHR for Predict, hit@K for Memory, latency/storage for Hydration, and E2E LLM judge for Reasoning.
| Layer | Metric | Verified result | What it means |
|---|---|---|---|
| Predict | PQHR@5 | 85.9% | adaptive W=10 public; fixed W=7 is 84.6% |
| Memory | LongMemEval retrieval@5 | 90.6% | latest metadata-only run |
| Memory | LoCoMo retrieval@5 | 85.1% | latest local metadata-only run |
| Hydration | local-FS raw context fetch | 0.49ms | local API p50; p95 0.88ms; not QA |
| Reasoning | LongMemEval-S E2E LLM judge | 85.2% | current repaired full run; optional answer layer |
Most competing systems publish full-stack QA accuracy, not retrieval hit@K. MemFront does not compare its retrieval hit@K to competitor QA numbers.
* Predict latency is staged/warm latency. Cold non-staged requests are measured separately and should not be described as the fast path.
Reproduce: python3 -m eval.metadata_retrieval_eval --benchmark longmemeval · python3 -m eval.locomo_runner · python3 -m eval.compare_latency --profile staged
Every turn is queued locally so capture does not block generation.
Compact top terms, previews, handles, timestamps, and storage keys stay hot in Postgres.
Recency + frequency + topic overlap. Behavioral signal, no LLM in path.
Top-K predictions returned. Inject into system prompt before generation.
Drop MemFront into any AI product. The SDK is platform-agnostic. Works with Claude, GPT, Gemini — or any LLM.
Use the layers you need. Measure each one with the right metric.
Stages likely context before the current query exists.
Searches hot metadata and returns ranked handles, previews, and scores.
Fetches raw context only after Predict or Memory selects the handle.
Runs LLM QA over selected hydrated memory. BYOK or hosted billing.
Four separately metered layers. Predict, Memory, and Hydration stay low-cost; Reasoning is premium because it can call an LLM.
Get early access to predict-first memory for voice agents, chat products, and AI apps that need context ready before the next prompt lands.
No credit card required to start. MIT licensed. Self-hostable.