Pensieve: A Local Dashboard for Inspecting and Governing LLM Memory

What Pensieve Does and Does Not Do

Pensieve manages external structured memory: records you import or create, stored in a local JSON file. It does not intercept or access model weights, internal attention states, or the built-in memory systems of ChatGPT, Claude, or Claude Code. The README makes this explicit: the shipped adapters use Pensieve's own repository and do not automatically read or modify private memories in other services.

The application addresses a specific gap: when an LLM assistant uses memory to shape its answers, users typically have no visibility into what was retained, what was retrieved for a given query, or how the memory affected the response. Pensieve gives users a local interface to observe all three, using a mock retrieval model rather than live API calls for most operations.

The core capabilities the README lists are observability (what is in the store and what surfaced for a query), portability (import from JSON or text, export to JSON or text), and user control (edit content, pin records, soften their influence, hide them, confirm deletion).

Getting Started with Pensieve

Pensieve requires Node.js 22.18 or later. The README says Node 22 LTS is used in CI. Starting a local instance takes four commands:

git clone https://github.com/DrJonaC/Pensieve.git
cd Pensieve
npm ci
npm run dev

Opening http://127.0.0.1:3000/memories starts you on the memory management page. A new library begins with bundled sample memories, so there is something to explore immediately. No API key is required for memory management or for the Mock query mode.

For Live mode, which sends filtered queries and selected memory context to an actual LLM, create a .env.local file in the project root with an OpenAI API key:

OPENAI_API_KEY=your_api_key_here

The README says to restart the server after changing server configuration, and warns never to commit .env.local. A production build is available with npm run build followed by npm run start.

Both the dev and production commands bind to the loopback address 127.0.0.1. The README describes Pensieve as a single-user application and explicitly warns against exposing it publicly without access controls. For remote access on a public server, the README recommends SSH port forwarding.

The default memory store is data/pensieve-memory-records.json. The PENSIEVE_DATA_DIR environment variable can relocate runtime data including governance reports.

How Retrieval and the Surface Model Work

Pensieve's retrieval uses a local lexical vector index built from the current set of records. It does not call an external embedding service. The index is rebuilt from current records each time, and records that are hidden or deleted are excluded from retrieval. Edits to a record replace its indexed content.

The /surface-model route provides Mock and Live query modes. In Mock mode, no API call is made; Pensieve uses its local retrieval model to show which records would surface for a query and in what rank order. In Live mode, the filtered query and selected memory context are sent to the OpenAI Responses API, and the answer is shown alongside the explanation and a simulated heatmap.

The heatmap is an illustrative local surface, not measured model attention. The README is direct about this: model-generated explanations are interpretations, not proof of causal attribution. This is an important limitation for anyone who wants to use Pensieve to verify exactly which memory caused a specific response. The tool shows what was available and what was ranked highly; it cannot show what the model actually weighted internally.

Retrieval ranking uses modifiers beyond raw lexical similarity. Priority keywords, themes, and governance state (pinned, softened, hidden) all affect how records rank. The /user-view route shows priority keywords and themes derived from the current record set.

Memory Management: Import, Edit, and Governance

The /memories route is the main management interface. The workflow is import, preview, confirm, manage, and export. Imports can be versioned JSON files or plain text, and the import process shows a preview of additions, duplicates, and conflicts before applying changes. Imports merge by default without silently overwriting conflicts.

Once records are in the store, the management interface supports editing content and keywords, pinning records, softening their influence, hiding them temporarily, and confirming deletion. These changes affect actual retrieval: a hidden record does not appear in results, and a pinned record ranks higher.

Governance reports record desired state as JSON manifests with verification receipts. The README describes this as tracking what changes were requested and whether they were applied, which is relevant for auditing whether memory governance decisions had their intended effect.

Export produces JSON or plain text. JSON exports preserve source metadata, timestamps, and governance state. Text exports store records as supplied, one non-empty line per memory. Neither format is advertised as a native ChatGPT or Claude backup format.

Credential filtering replaces recognized credential formats, private keys, and selected server-secret values with [REDACTED:...] placeholders in model input, generated text, reports, and errors. The README describes this as best-effort, not a complete secret detector.

Limitations and Privacy Constraints

The privacy section of the README lists the most important limitations directly. Raw memories, source records, exports, and backups are unencrypted local files. Deletion removes the active record but not every historical backup, which means deleted records may persist in backup files. Existing exposed keys must be rotated because Pensieve's redaction covers the active pipeline, not historical storage.

The WebUI has no encrypted transport. The README explicitly warns that in public network environments, HTTPS or SSH tunneling is required; running the service on a public IP without one of those is documented as unsafe.

Native write-back to host memory systems (ChatGPT, Claude, Claude Code) is listed as future work in the README. The plugin system is a preview rather than a production-ready host-memory connection. The /plugin route provides a host-adapter preview, but the README notes this is not a native host-memory connection.

A semantically stronger alternative for memory retrieval is a vector embedding service, which Pensieve explicitly does not use. The trade-off is that Pensieve requires no external API for memory operations, which preserves privacy and offline capability, but lexical retrieval may miss semantic matches that an embedding model would catch. The README lists semantic embedding providers as future work.

Testing, Maintenance, and License

The README reports that the migration and privacy update passed 72 unit tests, 4 package-policy checks, strict TypeScript compilation, and a production build. Browser suites cover memory management, localization, and credential redaction using an isolated library and synthetic data. The test command is npm test; type checking runs with npm run typecheck.

The repository had its last push on 2026-09-16, twelve days before the review date. It is not archived. There are no GitHub releases; the package.json version is 0.1.0, indicating the project is at an early release stage.

The tech stack is Next.js 15, React 19, TypeScript 5.8, Tailwind CSS 3.4, and the OpenAI SDK for the optional Live mode. The MIT license permits free use, modification, and distribution.

Editorial conclusion

Pensieve suits individual developers and researchers who want a local tool to inspect, organize, and experiment with structured AI memory without sending records to an external service. It does not connect natively to ChatGPT, Claude, or Claude Code memories and is explicit about this boundary. Before deploying it beyond a single machine, read the privacy documentation carefully: the default store is an unencrypted local JSON file, deletion removes the active record but not historical backups, and the WebUI transport is unencrypted. The project has no GitHub releases; check the package.json version and the commit history to track the current state.

Frequently asked questions

Official sources

1. DrJonaC/Pensieve on GitHub
2. Issues
3. License: MIT
4. README