mrkeyoor.com_
Tue 01 Sept 17:39 UTC
LLM Toolsevaluationupdated 26 Aug 2026

opencode-mem review

OpenCode Memory is a plugin that gives the OpenCode coding agent searchable memory across sessions. It stores project decisions, prior fixes, prompts, and a user-preference profile in local libSQL shards, then injects relevant items into later chats.

+79stars / 7d
Verdict

Our run installed 128 packages and 510 MB, then the build failed and 9 tests failed, so this commit is a trial candidate rather than a default recommendation. The migration safeguards and local libSQL design are thoughtful, and 435 tests did pass. Use it if OpenCode is already your daily agent and memory loss is costly, but pin the version, keep the UI on loopback, and watch database growth before trusting months of history.

We ran it

Lab card: what happened when we ran opencode-memScreenshot of opencode-mem (github.com/tickernelz/opencode-mem)
Install✓ · 58s128 packages · 510 MB
Build✗ · 8s
Tests✗ · 332s435 passed · 9 failed · 1 skipped of 444 (bun test)
Repo226 files~35,195 lines of source · 3.2 MB · 3 CI workflows · tests dir

Answers from our run

Does opencode-mem build from source?

Dependencies installed in 58 seconds (128 packages), and the build failed. We cloned commit d1d0eb0 into a clean Debian container with 3 CPUs and no project-specific setup.

Do opencode-mem's tests pass?

Not all of them: 435 of 444 passed and 9 failed when we ran the project's own test command (bun test). Some failures need services or credentials a bare container does not have.

Who should not use opencode-mem?

Users who do not want conversation content sent to another model: automatic capture and profile learning require an AI provider, even though manual memory operations can stay local.

What are the alternatives to opencode-mem?

Mem0, Supermemory, Claude Context. Our run installed 128 packages and 510 MB, then the build failed and 9 tests failed, so this commit is a trial candidate rather than a default recommendation.

Setup2/5One config entry for users, but our build and 9 tests failed
Docs5/5Storage, migration, providers, security, and recovery are specific
Community4/5v2.25.0 and active fixes landed in August 2026
Maturity3/5Good safeguards, with measured failures and index growth risk

Who it’s for

OpenCode users who repeatedly return to the same repositories and lose context between sessions.
Developers who want local vector storage with optional local embeddings.
Teams willing to inspect and delete captured memories instead of treating extraction as infallible.
Users who need project-level search, export, import, and recovery across moved working directories.

Who it’s NOT for

Users who do not want conversation content sent to another model: automatic capture and profile learning require an AI provider, even though manual memory operations can stay local.
Large high-dimensional stores without disk tests: issue 277 reports a 542 MB shard for about 656 memories using 2,048-dimensional embeddings.
Anyone expecting a clean source build on the measured commit: our build could not resolve React, Vite, Tailwind, clsx, and related web packages.
Teams requiring a green default suite before adoption: our run had 9 failed tests, 1 skipped test, and a timeout.
Users likely to expose the web UI casually: the README requires an API token for non-loopback binding and separately documents Basic Auth.

Setup reality

Our sandbox installed 128 Bun packages in 58 seconds and used 510 MB on disk. The build failed in 8 seconds because TypeScript could not find React, Vite, Tailwind, clsx, tailwind-merge, and related declarations. Tests failed after 332 seconds: 435 passed, 9 failed, and 1 skipped.

Normal installation is one OpenCode config entry. The default local embedding model downloads on first use; automatic capture needs an OpenCode, Anthropic, OpenAI, or compatible provider capable of structured output. Remote embeddings require an API URL and key.

The checkout had 226 files, about 35,195 source lines, 3 CI workflows, no Dockerfile, and a tests directory. Intel Mac local embeddings use a documented older ONNX Runtime pin, while remote embeddings avoid that native path.

Memory is retrieved by project instead of pasted into every prompt

OpenCode Memory stores durable facts in local Turso/libSQL databases and uses native vector indexes to find relevant entries. Project memories can hold decisions, failed approaches, or recurring bug patterns. A separate user profile summarizes preferences across projects. The plugin can inject a small number of matches into the first message or during compaction, leaving stable rules in AGENTS.md where every agent should see them.

Manual tools cover add, search, list, forget, profile, export, import, and shard migration. Automatic capture runs after a session becomes idle and asks a configured model to extract technical context. Users can browse the combined prompt and memory timeline in a web interface on port 4747. This is more inspectable than an invisible summary, though the usefulness still depends on what the extraction model chooses to save.

Automatic capture sends context to the provider you configure

Search, manual additions, and listing can work without an auto-capture provider. Automatic extraction and profile learning cannot. The recommended setup points at a provider and model already available in OpenCode; a fallback can call an OpenAI-compatible service. Local embeddings use @huggingface/transformers and download the chosen model on first use, while remote embeddings need a URL, model name, and Bearer key.

This split is good for privacy decisions. Embeddings may stay on the machine while a conversation summary still goes to Anthropic, OpenAI, or another configured model. Teams should identify which text each background request sends and whether source code, customer data, or secrets can enter it. Disabling automatic capture keeps manual memory useful and offers a safer evaluation path before any provider policy is accepted.

What happened when we ran it

Our run cloned commit d1d0eb0 into a fresh unprivileged Node 22 container with 3 CPUs, 8 GB of RAM, and no secrets. Bun installed 128 packages in 58 seconds and used 510 MB on disk. The build then failed with exit 1 after 8 seconds. TypeScript could not resolve React, React DOM, Vite, Tailwind's Vite plugin, clsx, tailwind-merge, JSX runtime, or the CSS side-effect import.

Tests also exited 1 after 332 seconds. Bun reported 435 passing tests, 9 failures, 1 skipped test, 1 error, and 1,075 expectations across 71 files. The tail says one test exceeded its 5,000 ms timeout. It does not identify all 9 causes in the supplied lines, so the result supports no broader diagnosis. A large green majority still leaves the default command red.

The 3.2 MB checkout contained 226 files and roughly 35,195 lines of source. Our scan found 3 CI workflow files, no Dockerfile, and a tests directory. That contrasts with the local failure and suggests platform or dependency-path differences deserve investigation. It does not make the sandbox result disappear: contributors on this measured setup could install, but they could neither produce the build nor finish with a passing suite.

Migration favors recovery over an in-place gamble

The storage design takes model and path changes seriously. Legacy SQLite shards are backed up before conversion, progress is tracked per shard, and a global marker appears only after verification. Lock files block concurrent migrations and writes during sensitive operations. If embedding dimensions become incompatible, writes stop instead of quietly mixing vectors with different shapes. The web UI can build and verify a replacement before swapping it into place.

Moving a repository can change its identity and leave the old shard orphaned. The plugin can list shards, preview a migration, move by old path or hash, and retain timestamped backups. Export and import support cross-machine transfers, with embeddings recomputed under the destination model. Export files are plaintext and can include memory text, identity data, repository URLs, and absolute paths, so they need the same handling as source-bearing backups.

Nested repositories can share one logical memory by placing an .opencode-mem-project marker at the workspace root. That is useful for Android-style or multi-repo trees, but it widens retrieval scope deliberately. Put the marker only where every child repository is allowed to share context, since project boundaries are part of the privacy model as well as search quality.

DiskANN growth can turn hundreds of memories into hundreds of megabytes

Issue 277 reports that version 2.22.2 produced a 542 MB shard for about 656 memories with 2,048-dimensional embeddings. The reporter attributes 98% of the file to 2 DiskANN shadow tables and says a tuned index rebuild reduced the shard to 73.3 MB. The issue says the behavior likely extends through v2.25.0, but it remains a reporter's finding rather than a fix shipped in the reviewed release.

That report is specific enough to test. Create a disposable shard with your chosen dimensions, add a representative number of memories, inspect file growth, and verify retrieval before committing. Smaller default embeddings may behave differently. Changing the model or dimensions can also trigger re-embedding, so record the model, dimensions, memory count, and database size as the store grows. Local does not automatically mean small or maintenance-free.

Loopback is the safe default for the memory browser

The web server defaults to 127.0.0.1. Binding to 0.0.0.0 or another non-loopback address requires an API token for /api/* calls, and the README also documents Basic Auth for the UI. Secrets can come from environment variables or protected files rather than literal config. These controls matter because the timeline can reveal prompts, project decisions, user preferences, and paths.

Release v2.25.0 arrived on 2026-08-25, the same day as the last repository push, and GitHub listed 8 open issues and pull requests combined. Its release notes include data-integrity, ANN query-plan, Windows locking, provider-error, and orphaned-memory fixes. That is useful maintenance on the risky parts of the product. It also argues for pinning: memory storage deserves staged upgrades and a checked backup, even when migration code promises recovery.

Alternatives

ProjectWhat it isPick it when
Mem0 gh↗A general memory layer for agents and applications with hosted and self-managed paths.pick this instead when memory belongs in an application or several agent clients, not only OpenCode.
SupermemoryA broader memory and retrieval service for AI applications and personal context.pick this instead when documents and cross-application memory matter more than a local OpenCode plugin.
Claude ContextA codebase retrieval tool that exposes semantic search to Claude Code through MCP.pick this instead when the goal is current-code retrieval in Claude Code rather than learned session memory.

What people are saying

  1. [github-trending] tickernelz/opencode-mem

Sources

  1. OpenCode Memory README
  2. OpenCode Memory v2.25.0 release
  3. DiskANN shard growth issue 277
  4. OpenCode Memory issues and pull requests

More llm tools reviews

rig · open-knowledge · graphiti · cve-mcp-server · minimind · SillyTavern · the whole board →