DEV Community: imper

I built a local-first memory service so my coding agent stops forgetting between sessions

imper — Sun, 30 Aug 2026 03:23:32 +0000

My coding agent was very good at solving a problem and very bad at remembering that it had. Every session started clean. Which port the local service listens on, why we went with one crate instead of another, the fix for a race we had already chased twice: I typed all of it again, in a slightly different order, most days.

Each harness has some answer to this. pi has its own store, Claude Code has another, Codex keeps transcripts. None of them hand anything to the next one, so the memory lives wherever you happened to be working that week.

I wanted one place to keep it, on my machine, that any of them could ask. That turned into memnest.

One service, several front doors

memnest is a single Rust binary listening on 127.0.0.1:3111. One address serves both an HTTP API and a Streamable HTTP MCP endpoint.

http://127.0.0.1:3111        HTTP API
http://127.0.0.1:3111/mcp    MCP endpoint

Each harness exposes different extension points, so the wiring differs while the store and the tool contract stay identical:

Harness	Prompt-time recall	Memory tools	Transcript capture
pi	Autocontext, from the extension	Registered by the extension	`memnest watch`
Claude Code	`memnest hook` on `UserPromptSubmit`	MCP	`memnest watch`
Codex	`memnest hook` on `UserPromptSubmit`	MCP	`memnest watch`
Other MCP clients	Depends on the client	MCP	Not applicable

Point any MCP client at it and you are done:

{
  "mcpServers": {
    "memnest": { "url": "http://127.0.0.1:3111/mcp" }
  }
}

Streamable HTTP is the recommended transport because every client then shares one server and one data directory. stdio works, but only when that single process owns the store. A second writer on the same data directory is rejected rather than allowed to race the indexes.

No LLM anywhere in the loop

Nothing in memnest calls a model API. Embeddings run locally with intfloat/multilingual-e5-base, and there is no summarization step between what you saved and what comes back.

That was a deliberate choice, and it cost something. LLM summarization would compress a long transcript into something denser and probably rank better. It would also mean that reading my own notes depends on someone else's uptime, someone else's pricing, and a paraphrase I never reviewed. A memory that quietly rewrites what you told it is worse than a memory that occasionally returns too much.

So there are two kinds of records, kept apart. Things you save on purpose (decisions, preferences, corrections) and redacted conversation text, kept verbatim. Both are searchable, neither is rewritten.

SQLite is the truth, the indexes are opinions

The store is SQLite. Next to it sit a Tantivy BM25 index and an HNSW vector index, and both are derived state that can be thrown away and rebuilt.

That distinction is what makes the write path recoverable. A write inserts the record and an index job in the same transaction, then builds both indexes, then clears the job. If the process dies halfway, the job is still there at startup and the write is replayed. The failure mode is a few seconds of extra work on boot, not a memory that exists in the database and cannot be found by search.

Why two indexes and not one

This is the part I would argue about with someone.

BM25 finds an exact token. Ask it for 3111 or a crate name and it lands on the right record. Ask it for the same idea in different words and it shrugs.

Vector similarity does the opposite. It handles the paraphrase and drifts away from the literal string you actually typed, which is exactly the case where you knew the answer and just wanted it back.

You cannot tell which one you need until the query arrives, and by then the write is long done. So a write pays for both, and a read merges the two rankings with reciprocal rank fusion at k=60, then reranks with MMR at lambda=0.5 so five near-identical memories do not fill the whole result.

Scope narrows before any of that runs: the current directory's workspace plus a shared playbook scope for rules that hold everywhere. Project memory does not leak sideways.

What I measured, including what I threw away

The benchmarks doc has a public fixture of 22 documents and 46 hand-labelled Korean queries, 41 with a relevant document and 5 deliberately with none.

Current hybrid search gets recall@1 of 0.976 on it. Two ideas that looked good did not ship.

A CJK 2-to-3-character ngram tokenizer took partial-term lexical recall from 0.167 to 1.000 on an isolated 5,000-document probe. On the real 46-query fixture it changed nothing, at 2.94 times the index size and roughly 50 times the lexical query cost. Every language pays that, and the measured gain on representative queries was zero, so it stays off behind a flag.

A jina-reranker-v2-base-multilingual cross-encoder took Precision@1 from 0.200 to 1.000 on five known rank errors. It also wanted 1.1 GB of model cache and 35 seconds of warm initialization for a service meant to answer a prompt hook in milliseconds. Also off.

Both are written down with their numbers rather than quietly dropped, because "we tried it and here is what it cost" is the part I always want from someone else's repo and rarely get.

The honest weak spot is candidate rejection. Recall@1 is 0.976, but no-result accuracy is 0.200: four of the five queries that should return nothing still return a low-confidence memory. Good retrieval and bad abstention is a real failure mode for an agent, because a confidently irrelevant memory in the prompt is worse than an empty one. That is what I am working on next.

Secrets do not go in the searchable store

Credentials live in an AES-256-GCM vault behind separate tools, not in anything the search path can reach. Credential-shaped text is redacted on the way in, so a token pasted into a conversation does not quietly become a searchable record.

Install

Linux x86_64 and aarch64 can install a release without a Rust toolchain. The script verifies the archive checksum, installs the binary, registers a user systemd service, and checks its health.

curl -fsSL https://raw.githubusercontent.com/Blue-B/memnest/main/core/scripts/install.sh \
  -o /tmp/memnest-install.sh
bash /tmp/memnest-install.sh --user

Read the script before you run it. Windows and WSL have their own scripts in the same directory, and building from source needs Git and a 2024-edition Rust toolchain.

Starting the service downloads nothing. The embedding model arrives on the first operation that needs it, so the first write or first search is slower than the rest. memnest --warmup-embedding pays that up front.

MIT licensed. The repo is at github.com/Blue-B/memnest, and I would rather hear where the design is wrong than where it is fine.

I stopped spawning a second Pi just to switch sessions

imper — Sun, 23 Aug 2026 14:23:00 +0000

I use the Pi coding agent from several project folders. After a while, pi --resume became a long list of sessions with similar first prompts. I kept reopening the wrong one.

I made pisesh to add the things I wanted in that list: favorites, search, custom names, a current-project view, and optional title generation. It is a single Node script with no runtime dependencies.

The first `/sesh` implementation

The first version took a direct route. It paused Pi's TUI, opened the pisesh picker, then started another Pi process for the selected session.

That was useful because leaving the child process returned me to the original session. It also meant the process tree looked like this:

Pi session A
  pisesh
    Pi session B

The nested process eventually became the problem. Tools were running in session B, but anything watching the outer Pi process could still see session A as idle. The terminal looked right while the runtime lifecycle was wrong.

Switching the existing runtime

Pi already exposes ctx.switchSession() to extensions. In pisesh 0.3.0, the picker no longer starts Pi when it was opened through /sesh.

The picker writes one small JSON selection to a private file descriptor. It includes the absolute session path and the selected model behavior. The extension reads that result and asks Pi to switch the current runtime:

Pi session A
  /sesh picker
  ctx.switchSession(sessionB)
Pi session B

Standalone pisesh still starts pi --session, so the shell command keeps its old behavior. Only the extension path changed.

There were two details I did not want to lose. Enter still resumes with the current default model and thinking level, while o restores the values recorded in the selected session. Interrupted tool calls are also repaired before the handoff when Pi would otherwise load an incomplete transcript.

Install

pi install npm:pisesh

Then run /sesh inside Pi. The package is MIT licensed and works on Node 18 or newer.

Repo: https://github.com/Blue-B/pisesh

영상 하나 던지면 번역된 자막이 생기는 오픈소스 앱 WhisperSubTranslate v2.0 (whisper.cpp + 로컬 LLM)

imper — Sat, 23 May 2026 14:09:21 +0000

외국어 영상 볼 때 자막 없으면 답답하죠. 저도 그랬습니다.

그래서 WhisperSubTranslate 만들었습니다. 영상 파일 하나 던지면 whisper.cpp가 음성 추출하고, 번역 엔진이 SRT 자막으로 만들어줍니다. 클라우드 업로드 없고, 계정도 필요 없습니다.

엔진 선택 가능:

MyMemory (무료, 키 불필요, 일일 제한 있음)
DeepL / OpenAI / Gemini (본인 키 사용)
로컬 LLM (HY-MT GGUF 모델, 완전 오프라인) — v2.0 주요 기능

실제로 잘 되는 것들:

긴 영상도 배치 큐로 처리
폴더 드래그 앤 드롭
GPU 있으면 CUDA 가속, 없으면 CPU 폴백
SRT 출력 → VLC, mpv, Plex 등에서 바로 사용

안 되는 것 (솔직히):

영상에 박힌 자막 추출은 안 됨. 음성에서 새로 만드는 방식입니다
실시간 마이크 입력은 아직 지원 안 함

한국어 포함 14개 언어, whisper.cpp 기준 100+ 소스 언어 지원합니다. Windows 포터블 빌드 + Linux/macOS 소스 빌드.

오픈소스 (GPL-3.0): https://github.com/Blue-B/WhisperSubTranslate

/disconnect for opencode — a tiny TUI plugin I wish existed before I made it

imper — Mon, 18 May 2026 17:23:30 +0000

I use opencode as my daily TUI coding agent. It's good. But there's one thing that kept biting me.

When you want to remove a single provider — say you rotated a key and want the old entry gone — opencode doesn't ship a clean way to do it. The choices are:

Re-auth every provider from scratch
Open ~/.local/share/opencode/auth.json in vim and pray the trailing comma survives

I did option 2 maybe four times before I got annoyed enough to write a plugin.

What I built

opencode plugin opencode-tui-utils

Then inside the TUI:

/disconnect

It opens opencode's own provider picker — the same dialog component the rest of the TUI already uses — so it doesn't feel like a bolted-on script. You pick the provider you want gone, confirm, done.

Token values are never printed. Only provider names and auth types are shown, so you can run it in a recorded session without paranoia.

The other commands

Since I was writing the plugin loader anyway, I added the three other slash commands I kept wanting:

/lsp-toggle — flip LSP on/off without restarting the TUI
/websearch-toggle — same for web search
/tool-status — print what's currently enabled

The toggle commands update your shell profile and prompt for a restart, which matches opencode's existing pattern for launch-gated flags.

Why a plugin instead of a fork

opencode's plugin system is just JSON: drop the package into ~/.config/opencode/tui.json under "plugin", restart, the slash command shows up in the palette next to the built-ins. No fork to maintain, no rebase pain when opencode updates.

This also means adding command #5 is mechanical — there's a shared API wrapper and the loader handles registration. If you've got a slash command you keep missing in opencode, there's a "command ideas up for grabs" section in CONTRIBUTING.md.

Where to find it

Repo: https://github.com/Blue-B/opencode-tui-utils
npm: opencode-tui-utils
License: MIT
Inspired by opencode issue #10494, where someone had asked for the disconnect flow

Built by @Blue-B — happy to take feedback, especially from anyone using opencode in a workflow I haven't thought of.

One install command wires 8 CLI coding agents to a shared stealth Chromium

imper — Mon, 18 May 2026 16:58:37 +0000

I use a bunch of CLI coding agents — Claude Code, Codex CLI, pi, opencode, Gemini CLI, Kiro, Amp, Crush — and every one of them shipped its own headless Chromium that gets blocked by basic bot checks (navigator.webdriver, missing plugins, the usual headless fingerprints).

The fix itself isn't novel. Patched stealth Chromium has existed for years. The annoying part is wiring it into each agent — every one wants its config in a different file:

Claude Code → CLAUDE.md
Codex CLI / opencode → AGENTS.md
Gemini CLI → GEMINI.md
Kiro → .kiro/steering/
Amp / Crush → their own dotfiles

…and all of them need to point at the same browser binary.

So I spent a weekend writing a one-command installer that does the wiring:

git clone https://github.com/Blue-B/browser-harness-kit
cd browser-harness-kit
bash install.sh

It detects which of the 8 agents you have installed, writes the right rule file for each, and creates a shared ~/.playwright/cli.config.json so they all hit the same stealth Chromium through pi-playwright as the CLI runner.

Result

Every agent drives a real headed Chromium that passes:

navigator.webdriver check
plugin / mimeType length checks
window.chrome shape
full bot.sannysoft.com matrix

Screenshot of the pass matrix and verify output are in the README.

What it isn't

This repo is integration glue only. It does NOT bundle or redistribute:

[CloakBrowser]https://www.reddit.com/r/SideProject/comments/1tgrmo3(https://github.com/CloakHQ/CloakBrowser) — the actual stealth Chromium build (linked, not bundled)
Playwright + pi-playwright — the runner
The 8 agents themselves — each lives at its own home

Just the wiring between them, so I don't have to redo it on every fresh box.

Why I'm sharing it

I wrote this for my own setup. After the third time pasting the same config snippets into a new machine I figured someone else would save a weekend.

Repo: https://github.com/Blue-B/browser-harness-kit
Tested on WSL2 + Ubuntu 24.04 + Node 22
License: MIT
Reddit discussion: https://www.reddit.com/r/SideProject/comments/1tgrmo3

Happy to take feedback, or PRs adding adapters for CLI agents I haven't covered. If your agent reads from yet another rule file, drop an issue.

Built by @Blue-B — find more side projects on my GitHub.

Building an offline subtitle extractor with whisper.cpp and Electron

imper — Sun, 08 Mar 2026 02:37:46 +0000

I watch a lot of foreign language content - anime, K-dramas, tech talks - and getting subtitles was always a pain. Upload to a random website, hit the daily limit, try another one, or install Python and figure out whisper's CLI.

So over the past few months I've been building a desktop app that handles the whole pipeline locally.

What it does

You drop a video file in, pick a whisper model size, and it spits out an SRT subtitle file. Optionally you can translate the subtitles using one of several engines.

The speech-to-text runs via whisper.cpp so everything stays on your machine. No uploads, no API calls for the transcription part. If you have an NVIDIA GPU it automatically uses CUDA, otherwise it falls back to CPU - this was one of the trickier parts to get right.

Tech decisions

I went with Electron + Node.js because:

Cross-platform (though I'm mainly targeting Windows right now)
Easy to bundle whisper.cpp binaries and ffmpeg
The UI is just HTML/CSS/JS so iteration is fast

For whisper.cpp integration, the app spawns it as a child process with the right flags depending on whether CUDA is available. Model files (GGML format) auto-download on first run into a local _models/ folder.

Translation engines

Translation is optional. Currently supported:

MyMemory - free, no API key, ~50K chars/day
DeepL - free tier 500K chars/month, needs API key
OpenAI GPT - paid, good quality for nuanced translations
Gemini - Google's API, generous free tier

The app chunks subtitle text and sends it in batches to avoid rate limits. Each engine has its own quirks with language codes so there's a mapping layer.

v1.4.0 changes

Just pushed the latest update which adds:

Automatic GPU/CPU fallback detection
Bundled ffprobe-static (no more separate ffmpeg install)
Better DeepL language code mapping

Try it out

It's packaged as a portable .exe - no install needed, just extract and run.

GitHub: WhisperSubTranslate
License: GPL-3.0

If you're working on something similar or have suggestions, I'd love to hear about it.

DEV Community: imper

I built a local-first memory service so my coding agent stops forgetting between sessions

One service, several front doors

No LLM anywhere in the loop

SQLite is the truth, the indexes are opinions

Why two indexes and not one

What I measured, including what I threw away

Secrets do not go in the searchable store

Install

I stopped spawning a second Pi just to switch sessions

The first /sesh implementation

Switching the existing runtime

Install

영상 하나 던지면 번역된 자막이 생기는 오픈소스 앱 WhisperSubTranslate v2.0 (whisper.cpp + 로컬 LLM)

/disconnect for opencode — a tiny TUI plugin I wish existed before I made it

What I built

The other commands

Why a plugin instead of a fork

Where to find it

One install command wires 8 CLI coding agents to a shared stealth Chromium

Result

What it isn't

Why I'm sharing it

Building an offline subtitle extractor with whisper.cpp and Electron

What it does

Tech decisions

Translation engines

v1.4.0 changes

Try it out

The first `/sesh` implementation