GoodMemory
Language: English | 简体中文
GoodMemory is a memory layer for AI products and coding agents.
> Release source: this source targets the 0.8.3 stable release.
> Registry commands require goodmemory@0.8.3 to be published. The release
> workflow verifies npm latest and the already published GitHub assets
> against the locally prepared manifest; it does not rebuild or publish.
It gives chat apps, copilots, and agent hosts a durable user/project memory loop:
write selected facts, retrieve the right context, inject it into the next turn,
audit what happened, and delete it when it is wrong.
GoodMemory is not an LLM, agent framework, vector database, or generic RAG
system. It is the product memory layer between your app or installed agent host
and the model runtime.
What You Get
- Durable memory API:
remember,recall,buildContext,feedback,forget,
exportMemory,importMemory, anddeleteAllMemory. - Installed agent memory for Codex and Claude Code through
goodmemory setup,
managed hooks, installed Codex pre-action,goodmemory status, read-only
MCP, and opt-in writeback. - Public write customization with
GoodMemoryConfig.remember,
RememberProfile,rememberRules,RememberInput.annotations, and named
extractor ids. - Package exports for
goodmemory,goodmemory/ai-sdk,goodmemory/host,
andgoodmemory/httpthrough compileddistartifacts and TypeScript
declarations. - Local-first storage: Bun gets durable SQLite by default; explicit Postgres,
injected adapters, and embedding providers can be added when needed. - Evaluation and release evidence paths for deterministic tests, live evals,
provider-backed evals, package smoke tests, and quality gates.
OpenAI Build Week 2026
Pre-existing foundation. GoodMemory existed before OpenAI Build Week. The
pre-event foundation already included the core memory API, local
SQLite/Postgres storage, installed-host integration, and the local Inspector.
The hackathon entry is the work added after the submission period opened on
July 13, 2026, not the entire repository.
Added during Build Week. Dated commits completed and published v0.6.0,
strengthened generalized retrieval and iterative-recall verification, added
claim-source provenance coverage, hardened installed-host canaries and leakage
audits, and expanded the controlled Codex coding-effect evaluation path. Review
the pre-event-to-Build-Week diff
and its dated commit history for the exact boundary.
How Codex and GPT-5.6 were used. Codex with GPT-5.6 was the primary
implementation and verification environment: exploring the repository,
implementing and reviewing changes, writing regression tests, reproducing
installed-host behavior, and exercising the release and coding-effect evidence
paths. GPT-5.6 also powers disclosed non-judge model calls in current evaluation
profiles; public-claim paths either use deterministic scoring or keep the judge
independent from the answer model.
Run and verify. After publication, install 0.8.3 from the registry and inspect
its local memory surface:```bash
npm install -g goodmemory@0.8.3
goodmemory setup --host codex
goodmemory status codex --workspace-root .
goodmemory inspector serve
Verify the repository from source with `bun install --frozen-lockfile`,
`bun test`, and `bun run typecheck`. See the
Devpost submission and
public demo video.
**Claim boundary:** the submission demonstrates durable cross-session memory,
governed writeback, recall evidence, and inspection/deletion infrastructure. It
does not claim that GoodMemory has already proven an improvement in Codex
coding outcomes; that paired hidden-test evaluation remains an active,
fail-closed evidence track.
## Start Here: Codex Or Claude Code```bash
npm install -g goodmemory@0.8.3
goodmemory setup
No account or hosted service is required. GoodMemory stores memory locally in
SQLite by default, wires lifecycle hooks plus read-only MCP inspection, and
keeps durable writeback opt-in. Verify the installation with
goodmemory status.
Using another MCP client or integrating an application? Choose an integration
path.
Benchmark Results
GoodMemory separates current-production claims, versioned historical evidence,
and internal research. A number may enter the current-claims table only after
gate:public-benchmark-claim --strict validates a committed declaration for
the current package version: complete coverage, executionFailures: 0, a
no-memory baseline, deterministic scoring or an independent judge, verified
dataset source and license, and a reproducible run (commit + command + package
version). No end-to-end benchmark runner is allowlisted today, so promotion is
unavailable for both current and historical rows. Stored-answer rescores and
legacy presentation projections cannot open that boundary or supply README
score and disclosure fragments as self-attestation.
GoodMemory 0.8.3 has no current or versioned historical benchmark claim.
The retained v0.7.3 LoCoMo projection is not end-to-end runner evidence, so
it is an internal diagnostic. The v0.6.0
LoCoMo, BEAM, and MemoryAgentBench measurements and ImplicitMemBench are also
internal diagnostics under the same fail-closed boundary.
LongMemEval is withdrawn pending a clean rerun: the historical rules-only path
used answer annotations, and the later label-free path exposed raw
answer_* session IDs to retrieval and the reader. ImplicitMemBench's
retry-merged result remains internal evidence because it does not replace a
monolithic fresh run. HaluMem, MemGym, and MINTEval remain release evidence
rather than public benchmark claims.
No benchmark result is currently presented as measured on 0.8.3.
Versioned evidence
No end-to-end benchmark runner is currently allowlisted for versioned evidence.
No benchmark result currently qualifies as versioned historical evidence.
The retained v0.7.3 LoCoMo projection remains available in the repository for
audit, but it is not shipped as a verified package artifact and cannot authorize
a public or versioned claim. Old artifacts will not be retrofitted; a future
producer and its verifier must be implemented together before promotion opens.
Where both are available, a row reports two tracks. The
strict track is deterministic or judge-free — a hard lower bound no LLM
judge can inflate. The second track re-judges the same stored answers (not
regenerated) under a benchmark-source or industry-standard prompt. Numerical
comparability is claimed only when the pinned evaluator model and remaining
benchmark configuration also match. Every per-protocol detail is recorded in
the linked declarations.
The LongMemEval declaration is now paused_boundary, not historical evidence.
Its old numeric artifacts remain only to preserve the audit trail. They must
not be quoted as GoodMemory results until an opaque-session-id, label-free full
rerun replaces them; see the
withdrawal declaration.
The v0.6.0 BEAM, MemoryAgentBench, and LoCoMo measurements remain internal
diagnostics. They do not pass the empty end-to-end runner allowlist, so they are
not versioned historical evidence.
The ImplicitMemBench Full-300 stored-answer rescore uses the canonical zero-failure
run-phase61-full300-rerun-20260706-codex-current answers, then re-scores the
same stored answers with gpt-5.4 (sourceAnswersUnchanged: true). The judge is
cross-version but the same GPT family as the gpt-5.5 answer model, not a
cross-family judge. The recorded score is 0.691 (207.35/300) versus an
upstream-chat baseline of 0.400 (120/300), with 530 judge-required row
decisions across the baseline and GoodMemory arms; deterministic
structured_first_action rows are carried forward rather than judged. The
older same-model diagnostic score was 0.708 and is not the recorded result. The
freshest clean answer-regeneration drift check after recent code changes scored
0.6895 with executionFailures: 0; it shows current checkout drift, not a
replacement for the stored-answer comparability artifact. Its measured sources do
not independently expose both package version and commit at explicit JSON paths,
so the result is paused as an internal diagnostic and is not versioned historical
evidence. Dataset CC BY 4.0, fetched at eval time, never vendored.
Internal diagnostics (not public claims)
LongMemEval's first current-recall assembly development slice is superseded:
although its reader context hid raw session IDs, the memory-builder boundary
still received gold-bearing session IDs and turn markers. A stricter v2
protocol now removes answers, question type, answer markers, and raw session
identities before memory construction. Its development slice must be rerun on
a clean commit before the still-sealed holdout can be opened; no LongMemEval
claim is restored. ImplicitMemBench's explicit retry-merged check reaches
0.6923666667 with zero failures, but it is not a replacement monolithic fresh
Full-300 run. Both therefore remain outside the current-claims table. The
underlying reports live under gitignored reports/ and are reproducible from
the recorded commands.
Use task-board/00-README.txt for execution order
and
docs/GoodMemory-Current-Status-and-Evidence.md
for claim boundaries.
Choose Your Integration Path
GoodMemory has three primary product entry points. They are not the only APIs:
lower-level surfaces such as goodmemory/host, custom stores, eval tooling, and
runtime helpers support these paths. They are the README-level ways to decide
how to start.
Autonomous agent? Start here
If you are an agent that wants to give yourself durable memory, match one path
and run it. Machine-readable versions of this tree live in
llms.txt and
.well-known/goodmemory.json (a deployed bridge
also serves the descriptor at /.well-known/goodmemory.json).
- You are, or run inside, Claude Code or Codex →
npm install -g goodmemory@0.8.3 && goodmemory setup. Unsure what is already
wired? Rungoodmemory adopt(add--jsonfor a machine-readable plan): it
inspects.claude/,.codex/, and existing MCP config, then prints the exact
next command for your environment. - You speak MCP (Cursor, Windsurf, Cline, Claude Desktop, Gemini CLI,
OpenCode, or a custom client) → add the
standalone MCP server; the two tools you need
aregoodmemory_get_context(recall) andgoodmemory_remember(opt-in write). - You are a framework agent or a backend → call the
HTTP bridge: hosted atgoodmemory.vibenest.net
or self-hosted withgoodmemory-http-bridge --recommended(or
GOODMEMORY_PROFILE=agent-recommended goodmemory-http-bridge); Python callers
usepip install goodmemory-client.
The prose paths below expand each option.
1. Build Memory Into An Agent, Chatbox, Or Copilot
Use this when you own the product server and the model call. Install
goodmemory in your Node/Bun service, create one memory instance, and pass a
stable scope such as userId, workspaceId, sessionId, and optionally
agentId.
The request flow is:
- Before the model call, run
recall()for the current scope and query. - Run
buildContext()to turn recall hits into a prompt fragment. - Call your model with that memory context.
- After the response, write selected signals with
memory.jobs.enqueueRemember()
orremember(). - Use
feedback(), targetedreviseMemory(),forget(), andexportMemory()
for correction, deletion, and user audit;importMemory()restores an
export or ingests a directory of Markdown pages asnotememories.
If your server already uses Vercel AI SDK, use goodmemory/ai-sdk to wrap
generateText() or streamText() instead of hand-wiring the whole loop. Start
with App Quickstart, then read
AI SDK Adapter if you use AI SDK.
2. Add Memory To Codex Or Claude Code
Use this when you want an installed coding agent to remember project and user
context without changing the agent itself. Install the global CLI and run
goodmemory setup.
The installed-host flow is:
session-startinjects a session brief;user-prompt-submitinjects
per-prompt context (relevance-gated on fresh installs so low-signal prompts
stay clean).- The Claude Code
Stophook captures each turn from the session transcript
(transcript_path) into governed writeback candidates — bounded, redacted,
never raw transcripts; for Codex,goodmemory codex writeback --from-rollout
feeds the newest session rollout through the same pipeline. - Codex
pre-tool-usecan deny or redirect risky Bash through
goodmemory codex actionon the same installed config and storage path. - MCP gives trace, context, stats, and artifact inspection; the
goodmemory_rememberwrite tool is opt-in viamcp.allowWrite(or
goodmemory enable --mcp-allow-write). - Writeback stays
offfor scripted installs; interactive install and
goodmemory setup --recommended(one consent prompt) enableselective
durable writes — auditable viawriteback inspect, reversible via
writeback forget --event-id. - Fresh installs start on the measured BM25 hybrid retrieval tier with a
1024-token session brief and 512-token gated prompt injection;goodmemory statusshows the retrieval tier, capture proof-of-life, and injection
telemetry. OptionalsharedAgentsconfig lets one host read the other
host's records (writes stay attributed).
Start with Quickstart: Codex Or Claude Code Memory.
Use Installed Host Writeback when you are ready to
review or enable writes.
3. Deploy GoodMemory As A Backend Memory-Layer Service
Use this when another backend should call GoodMemory as a service, especially
when the product backend is Python/FastAPI or when a product such as OneLife
should keep memory server-side instead of bundling GoodMemory into a mobile or
browser client.
Deploy the packaged goodmemory-http-bridge in a Node/Bun sidecar. Your backend
then calls:
/memory/recall-contextbefore its own model call/memory/rememberafter a user-confirmed or product-approved signal/memory/feedbackfor procedural corrections/memory/exportand/memory/forgetfor audit and deletion/memory/revisefor targeted correction by explicit memory id/memory/importfor restoring an export or ingesting Markdown pages
Your service still owns auth, product policy, UI, and model orchestration.
GoodMemory owns memory storage, recall, context assembly, write governance, and
audit/export/delete behavior. Start with
Python/FastAPI HTTP Bridge — the official Python
client (pip install goodmemory-client) and a hosted bridge instance at
goodmemory.vibenest.net are documented there — then check
Runtime And Storage for SQLite/Postgres choices.
During a model turn, GoodMemory does four jobs:
- Resolve memory for the current
scope. - Build a prompt-ready context fragment.
- Record selected post-response signals when your app or host allows it.
- Provide audit, correction, export, and deletion paths for user control.
Your app or installed agent still owns auth, UI, model calls, and product
policy. GoodMemory owns the memory loop and storage boundary.
Install
These commands target GoodMemory 0.8.3 after publication. Use the pinned registry
commands below for reproducible installs.
Use the global CLI when you want memory enhancement inside installed coding
agents:```bash
npm install -g goodmemory@0.8.3
goodmemory setup
goodmemory status
Use the package dependency when you are building an application:```bash
npm install goodmemory@0.8.3
If you want to type goodmemory directly, install the global CLI.
A project-local npm install goodmemory@0.8.3 does not put goodmemory on your shell PATH.
Use npx goodmemory, npm exec -- goodmemory, or ./node_modules/.bin/goodmemory
from that project instead.```bash
npx goodmemory -V
Bun consumers can install it directly:```bash
bun add goodmemory@0.8.3
Tarball verification for this release source:```bash
npm install ./goodmemory-0.8.3.tgz
The installed CLI is Bun-backed for non-version commands. The package bin is
Node-safe for `goodmemory -V` and `goodmemory --version`; other commands
delegate to Bun.
## Quickstart: Codex Or Claude Code Memory
For most users, the first useful path is installed-host memory.```bash
npm install -g goodmemory@0.8.3
goodmemory setup
goodmemory status
goodmemory setup detects Codex and Claude Code, installs managed host wiring,
and asks for:
- host:
codex,claude, or both detected hosts - activation: global, current workspace, or manual opt-in
- GoodMemory user id
- optional Postgres storage
- optional embedding provider
- optional LLM extraction provider
- writeback mode:
off,observe,review, orselective
Interactive setup defaults to global activation with workspace-derived
isolation and recommends selective for new host configs so high-signal writes
start working immediately with audit and undo. Choose review when you want
Inspector approval before durable writes. Existing host configs keep their
current writeback mode when the interactive prompt default is accepted.
Scripted installs stay safe with --json or --no-interactive.
Skipping provider setup is valid: GoodMemory still works with local SQLite and
rules-only extraction.
Useful commands:```bash
goodmemory setup --host codex
goodmemory status codex --workspace-root .
goodmemory enable codex --workspace-root . --writeback observe
goodmemory enable codex --workspace-root . --writeback selective
goodmemory disable codex --workspace-root .
goodmemory uninstall codex
The installed host path has four pieces:
- Managed pre-action for Codex: `pre-tool-use` can deny or redirect risky Bash
and `goodmemory codex action` executes the vetted first step on the same
installed config, storage, provider, and scope path used by recall and
writeback.
- Recall injection: `session-start` and `user-prompt-submit` hooks call
`recall()` plus `buildContext()` and fail open if config, parsing, or storage
is unavailable.
- Deep inspection: `goodmemory mcp serve --host codex` and `goodmemory-mcp
--host codex` expose read-only context, trace, stats, and artifact tools.
- Optional writeback: `session-stop` and explicit writeback commands can turn
selected after-response signals into durable memory.
## Standalone MCP For Any Client
Hosts without a managed install path (Cursor, Windsurf, Cline, Claude Desktop,
Gemini CLI, OpenCode, or your own MCP client) can run the same MCP server in
standalone mode — no `goodmemory setup`, no host config files. Scope and
storage come from flags/env; the served surface is the same 8 read-only tools,
plus an opt-in governed write tool:```json
{
"mcpServers": {
"goodmemory": {
"command": "goodmemory-mcp",
"args": ["--standalone", "--user-id", "YOUR_USER_ID"]
}
}
}
Equivalent invocation: goodmemory-mcp --standalone --user-id (requires
Bun on PATH; GOODMEMORY_USER_ID works as the flag's env fallback).
--allow-write (or GOODMEMORY_MCP_ALLOW_WRITE=1) registers
goodmemory_remember, which writes through the normal governed remember
pipeline, and goodmemory_write_note, which stores an authored page (prose or
Markdown, up to 8 KB) verbatim as a note and supersedes it by title on
rewrite. Agent-tagged memories written by installed hosts stay private to
their agent; add --agent-id codex plus the shared --storage-url to opt into
reading an installed host's store. Full flag/env matrix, scope notes, and
per-host recipes:
docs/GoodMemory-Standalone-MCP-Setup-Guide.md
(Cursor ·
Gemini CLI ·
OpenCode).
Installed Host Writeback
Installed Host Writeback is opt-in. Runtime config defaults and new scripted
installs remain off unless the user explicitly chooses a writeback mode.
Existing configs keep their current writeback mode when no explicit override is
provided. New interactive installs recommend selective so high-signal writes
start working immediately with audit and undo; choose review when you want
Inspector approval before durable writes.
Use observe before selective:```bash
goodmemory enable codex --writeback observe
goodmemory codex writeback --json
goodmemory enable codex --writeback review
goodmemory inspector serve
goodmemory enable codex --writeback selective
goodmemory codex writeback --json
`goodmemory inspector serve` opens the built-in local React console for users
and scopes, categorized memory and supersession history, candidate decisions,
recall evidence traces, and audit events. The startup token is passed in a URL
fragment, cleared immediately into session storage, and sent only as a Bearer
header. Revision and destructive actions require confirmation, ETags, and
idempotency keys. See
Inspector And Admin API.
Writeback rules:
- `off`: no after-response memory extraction.
- `observe`: store local bounded/redacted candidate previews for review without
raw transcripts or durable memory writes.
- `review`: queue bounded/redacted candidates for Inspector approval; no durable
memory is written until an operator approves a candidate.
- `selective`: write selected candidates through the public `remember` surface.
- Raw transcripts are not persisted as memory.
- Assistant-originated durable memory is blocked unless the host confirms or
verifies it and the active profile allows it.
- `remember: "never"` masks annotated content before deterministic, custom, or
assisted extraction.
Audit and undo:```bash
goodmemory codex writeback inspect --json
goodmemory codex writeback forget --event-id <event-id> --review-outcome false_write
The audit ledger stores bounded redacted candidate previews, candidate keys,
typed linked record ids, status, reasons, host, mode, timestamps,
scope/session digests, and optional manual review metadata. It does not store
raw host payloads. forget --event-id deletes linked memory/evidence records
through public forget() before marking durable audit events forgotten; for
observe-only events it marks the candidate dismissed without calling
forget().
Claude Code has deterministic CLI parity for hook and writeback commands;
Codex is the canonical live-evidence path.
Scripted Host Install
Use goodmemory install when you want a fully non-interactive setup:```bash
goodmemory install codex \
--user-id <user-id> \
--activation-mode global \
--writeback observe \
--storage-provider postgres \
--storage-url "postgres://user:pass@host:5432/goodmemory" \
--embedding-provider openai \
--embedding-model text-embedding-3-small \
--embedding-api-key <key> \
--llm-provider openai \
--llm-model gpt-4o-mini \
--llm-api-key <key> \
--no-interactive
Managed config lives under `~/.goodmemory/.json`. Re-running install with
provider flags updates the same config and keeps MCP/hook registration
idempotent. Package uninstall does not delete `~/.goodmemory`, repo-local
`.goodmemory`, local SQLite files, or remote Postgres data. Use
`goodmemory uninstall ` to remove managed host wiring, and use
`goodmemory forget ...` or explicit storage deletion to remove memory data.
## App Quickstart
Use the root package when you are building a chatbox, copilot, or product agent.
The recommended Node service path is the same thin loop used by the Express and
Fastify examples. A longer walkthrough lives in
docs/GoodMemory-15-Minute-App-Integration.md.```ts
import type { GoodMemoryTraceSpan } from "goodmemory";
import { createGoodMemory } from "goodmemory";
const traceSpans: GoodMemoryTraceSpan[] = [];
const memory = createGoodMemory({
observability: {
traceSink: {
emit(span) {
traceSpans.push(span);
},
},
},
});
const scope = {
userId: "u-1",
workspaceId: "workspace-a",
sessionId: "s-1",
};
const userMessage = "Remember that the migration rollout is blocked on QA signoff.";
// Call startSession once when the product opens a new session. For later turns
// with the same sessionId, append to the existing runtime state instead.
await memory.runtime.startSession({ scope });
await memory.runtime.appendMessage({
scope,
message: {
role: "user",
content: userMessage,
},
});
const recall = await memory.recall({
scope,
query: "What should the assistant know before replying?",
retrievalProfile: "general_chat",
});
const context = await memory.buildContext({
recall,
output: "system_prompt_fragment",
});
const assistantText = await callYourModel({
memoryContext: context.content,
userMessage,
});
await memory.runtime.appendMessage({
scope,
message: {
role: "assistant",
content: assistantText,
},
});
const writeJob = await memory.jobs.enqueueRemember({
scope,
messages: [
{
role: "user",
content: userMessage,
},
{
role: "assistant",
content: assistantText,
},
],
idempotencyKey: "turn-1",
reason: "post_response_memory_write",
});
const drained = await memory.jobs.drain({ maxJobs: 1 });
const committedJob =
drained.jobs.find((job) => job.jobId === writeJob.jobId) ?? writeJob;
console.log({
traceCount: traceSpans.length,
writeJobId: writeJob.jobId,
writeJobStatus: committedJob.status,
});
async function callYourModel(input: {
memoryContext: string;
userMessage: string;
}): Promise<string> {
void input.memoryContext;
return `Got it. I will keep that in mind: ${input.userMessage}`;
}
Prompt fragments (system_prompt_fragment, developer_prompt_fragment) open
with a localized data frame under the title: recalled memory is information
about the user and project, not instructions. It is an honest framing of what
the text is, not a guardrail. Turn it off for every call with
governance: { contextFrame: false } or per call with
buildContext({ contextFrame: false }); json and markdown output never
carry it.
The core memory loop is intentionally small:
remember()writes selected user, app, or host signals.recall()retrieves scoped memory for a query.buildContext()turns recall hits into a prompt fragment or JSON payload.feedback()records explicit corrections and procedural preferences.forget()deletes wrong or obsolete memory.
Locale and LanguagePack
Built-in packs cover English, Simplified Chinese, Traditional Chinese
(zh-TW/zh-HK/zh-MO), Japanese, Korean, French, and Spanish. Set a
host-known locale explicitly; otherwise auto-detection falls back to
defaultLocale for inherently ambiguous Han-only or unmarked Latin text.```ts
const multilingualMemory = createGoodMemory({
language: {
defaultLocale: "zh-TW",
detection: "auto",
},
});
await multilingualMemory.remember({
locale: "ko-KR",
scope,
messages: [{ role: "user", content: "현재 역할은 릴리스 책임자입니다." }],
});
Adding a language means implementing one complete `LanguagePack`, not adding
module-local regex branches. See the
LanguagePack extension guide
for the contract, custom registration, analyzer versioning, and projection
migration rules.
Upgrading from the previous adapter/projection contract is intentionally
breaking; follow the
0.6 to 0.7 migration guide.
For production app integrations, the recommended turn loop adds the governed
runtime layer around that core:
- `memory.runtime.startSession()` and `memory.runtime.appendMessage()` track
current-session state without making raw transcripts durable memory.
- `memory.jobs.enqueueRemember()` schedules after-response memory writes with
idempotency and visible job status.
- `memory.jobs.drain()` commits queued writes in this in-memory scheduler. In a
production service, run draining in your worker or request-adjacent job loop.
- `GoodMemoryConfig.observability.traceSink` receives redaction-safe traces for
remember, recall, context, revise, forget, export, and job events.
- `memory.reviseMemory({ target: { memoryId } })` corrects a known memory by
explicit id, not by fuzzy text selection.
- `exportMemory()` gives the user an audit/export path. Its `pages/` bundle is
a memoryfield-compatible directory of note pages with a SHA-256 manifest.
- `memory.importMemory({ source })` re-imports that export by id or ingests
pages as `note` memories; `expectedSha256` pins the input before any write.
- `governance.fileMirror: { root, scope }` keeps a read-only copy of that
export bundle on disk after every durable write inside `scope` (debounced,
atomic directory swap). One root serves one durable scope; the mirror is a
projection: it is never read back and never fails a write.
Runtime archive persistence is off by default. If you call
`memory.runtime.endSession({ scope, archive: "off" })`, session state is
cleared without writing an archive. If you opt into archive persistence, keep it
summary-only and never treat raw transcripts as the default memory source.
For server integrations, start with the thin examples:
examples/express-chat-server.ts or
examples/fastify-chat-server.ts.
For Python/FastAPI backends, use the packaged `goodmemory-http-bridge` path
described below.
## Opt-In Recall Tuning: Generalized Fusion, Multi-Hop, Optional Embeddings, And Conversational Extraction
The knobs below are optional and conservative by design. Default recall is
single-pass and rules-only, and default extraction is unchanged; nothing happens
unless you opt in. The recommended preset has a provider-free local path;
embedding and extraction providers add optional channels but are not required.
### One-flag recommended retrieval preset
`retrieval.preset: "recommended"` enables generalized retrieval and conditional
conversational extraction with one flag:```ts
const memory = createGoodMemory({
retrieval: { preset: "recommended" },
});
When active it (a) indexes memory-, field-, and sentence-granularity recall
documents, (b) fuses BM25, direct entity adjacency, and any available neural
…(正文过长,页面只展示前面部分,完整内容见仓库)
