LaPis

Persistent memory for the Pi coding agent. LaPis gives Pi a local memory layer for decisions, bugfixes, patterns, indexed code, indexed docs, and session context.

It runs as one Pi extension plus one local Node.js backend. Storage is SQLite by default at ~/.pi/memory/memory.db; there are no cloud dependencies and no API keys.

Architecture

LaPis is a modular monolith: one installable extension with clear internal ownership between Pi adapters, CLI routing, feature services, and shared platform/storage code. The extension calls the backend through in-process dispatch() when possible, with child-process fallback for streaming operations such as indexing.

Module boundaries

Memory lifecycle

For dependency rules and module ownership details, see docs/ARCHITECTURE.md and docs/MODULE_MAP.md.

Install

pi install git:github.com/GeneGulanesJr/LaPis

Restart Pi and memory auto-wires on session start. Use pi update --extensions to keep it up to date.

LaPis does not install npm dependencies at runtime. If you are running from a local clone or developing the extension, install dependencies explicitly:

npm install

What It Does

• Remembers across sessions - decisions, bugfixes, patterns, discoveries, and constraints persist.
• Auto-injects context - new sessions start with relevant memories loaded.
• Indexes code - web-tree-sitter parses JS/TS/TSX/Go/Python/Rust/SQL for semantic code lookup and analysis.
• Indexes docs - Markdown sections, links, glossary terms, and code examples become searchable.
• Tracks trust - memories linked to changed code lose confidence; stable linked code recovers trust.
• Deduplicates memory - similar saves are merged or flagged before they clutter recall.
• Manages workspaces - project isolation is explicit through create/list/archive workflows.
• Cleans stale memory - the Dream Cycle removes superseded, never-useful, and replaced memories based on quality signals.

Benchmarks

Token Efficiency

The wire format (wire-format.js) uses compact encoding to reduce the token footprint of analysis responses inside Pi's context window. The benchmark runs real CLI commands against indexed repos, passes output through compactResponse(), and compares byte sizes.

Run it with:

node bench/bench-tokens.js

Latest local run: May 24, 2026, with fresh reindexes for both repos. call-hierarchy and blast-radius were skipped because the benchmark could not select a representative symbol with callers.

Percentage Saved per Tool

Tool	LaPis / PiMemoryExtension	PCBuilder
importance	21%	24%
hotspots	0%	0%
dead-code	44%	50%
coupling	37%	40%
extraction	23%	22%
import-graph	18%	20%
cycles	0%	0%
overall	40%	49%

Total Savings

	LaPis / PiMemoryExtension	PCBuilder
Repo size	292 files / 6,913 symbols	171 files / 207,599 symbols
Raw JSON	692.6 KB	36.7 MB
Compact format	417.5 KB	18.5 MB
Bytes saved	275.1 KB	18.1 MB
Tokens saved	~80,500 tokens	~5,436,007 tokens

See bench/README.md for benchmark usage and interpretation notes.

Paired Memory

The paired benchmark measures whether memory helps by running the same task twice: once with LaPis disabled and once with LaPis active. It is an internal regression and directional benchmark, not a comprehensive external evaluation. It is designed to catch regressions in LaPis behavior; it should not be read as a claim about typical real-world usage, where prompts, repositories, model behavior, provider cache state, and tool choices vary.

Run it with:

npm run bench:pi-paired

Latest run: bench/results/pi-paired-2026-05-24T14-47-20-651Z/report.json

Metric	Memory On	Without Memory	Savings
Facts correct	18/18	18/18	no loss
Active tokens	3,192	42,954	-92.6%
Wall time	~86s	~233s	-63.1%
Tool calls	6	49	-87.8%
Failed tools	0	4	-100%

Per-category Breakdown

Category	Facts (on)	Tokens (on)	Savings
prior-decision	3/3	128	99.0%
bug-history	3/3	603	94.2%
staleness	3/3	426	94.2%
navigation	3/3	72	99.0%
negative-control	6/6	1,963	65.7%

What Each Category Tests

Category	What it tests
prior-decision	Recalls an architectural decision and its rationale, then names the current module involved.
bug-history	Recalls why a fix exists, including the historical failure mode that is not obvious from the final code alone.
staleness	Checks whether LaPis warns that an indexed code view may be stale and should be verified or reindexed before trust.
navigation	Uses memory to jump to the likely hook/module and confirm where extension wiring lives.
negative-control	Asks current-source questions that should not need memory facts; memory-on should route cheaply to code lookup instead of adding overhead.

Memory-on achieved perfect accuracy with 92.6% fewer active tokens overall. Memory-dependent tasks saved 94.2-99.0% active tokens in this run.

The paired benchmark also reports behavior counters. In the latest run, memory-on used 6 total tools, 4 code-oriented tools, 4 memory tools, 12 assistant turns, and 0 failed tools. These counters help distinguish real memory regressions from normal provider cache and latency variance. The negative-control tasks are current-source questions; they should avoid memory facts and route quickly through memory-code search plus targeted reads when code verification is needed.

Requirements

• Node.js
• @libsql/client for async local SQLite/libSQL access
• No Python dependency
• No API keys or cloud services

Documentation

• CONTRIBUTING.md - contributor workflow and checks.
• docs/ARCHITECTURE.md - architecture overview and dependency rules.
• docs/MODULE_MAP.md - module ownership and entry points.
• docs/COMMANDS.md - command reference.
• docs/CONFIGURATION.md - config file and stored data.
• docs/DREAM_CYCLE.md - stale-memory cleanup behavior.

License

MIT