Chronicler — self-hosted AI roleplay client with long-term memory
A local-first alternative to SillyTavern, RisuAI, and Faraday, built around memory that survives long campaigns.
Power your agent
पब्लिशर का इंस्टॉल। PlugMCP एंडपॉइंट नहीं।
Host a copy with our keys and logs.
रजिस्ट्री में अभी कोई पैकेज्ड रिलीज़ नहीं है। रिपॉज़िटरी का README देखें.
रिमोट URL या आपकी मशीन पर कमांड? दोनों इंस्टॉल में क्या अंतर है
PlugMCP पर चलाएँ
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
लॉन्चपब्लिशर से
A local-first alternative to SillyTavern, RisuAI, and Faraday, built around memory that survives long campaigns.
Self-hosted AI roleplay client with memory that survives long campaigns — tiered canon/heuristic/reflex writes, retrieval-time privacy ACL for group chats, native MCP tool support.
Chronicler is an open-source, self-hosted AI roleplay and character-chat app you run on your own machine with docker compose up. It imports the community v2/v3 character card format (chub.ai-compatible), talks to any OpenAI-compatible LLM — Ollama, OpenAI, Anthropic, OpenRouter, llama.cpp, vLLM, nano-gpt — and remembers what matters about every character across every session, automatically and locally, without sending anything to a cloud.
The problem with existing RP clients isn't the UI — it's that memory falls apart after a few sessions. Chronicler is built on a persistent cognitive memory engine (YantrikDB) with a strict three-tier write contract that keeps canon clean and accumulates real continuity over hundreds of hours.
What you get that other clients don't: verified long-term memory instead of a rolling summary · per-memory visible_to ACL so characters can't recall secrets they were never told · a prompt inspector showing exactly what was sent and why · native MCP support (tools, resources, prompts) · an extension SDK on npm.
Looking for a SillyTavern alternative with real memory · an AI companion that remembers across sessions · a local/offline character chat app · long-term memory for LLM roleplay · an MCP-native chat client? That's what this is.
Fastest — one file, no clone:
curl -O https://raw.githubusercontent.com/yantrikos/chronicler/main/docker-compose.yml
docker compose up -d
open http://localhost:3001
Docker pulls both published images (~500 MB total) from GitHub Container Registry and starts the stack. First boot waits ~60s for YantrikDB to finish loading its embedding model.
Or clone for development:
git clone https://github.com/yantrikos/chronicler && cd chronicler
docker compose up -d
docker compose up prefers the published image; if you modify the source and run docker compose build, it rebuilds locally and your image replaces the pulled one.
Both are multi-platform (linux/amd64 + linux/arm64) and rebuilt on every push to main via .github/workflows/docker-images.yml. Semver tags (v0.1.0, etc.) publish stable versions as they're cut.
qwen2.5:7b). Measured 2026-08-04: at 1.5B the extractor cannot reliably follow fact-attribution rules and will write the user's facts as facts about the character — e.g. storing "Ren's birthday is April 2nd" when April 2nd is yours and the character merely repeated it back. 7B and 9B attribute correctly. A structural filter catches the worst artifacts regardless of model, but it cannot repair a confidently mis-attributed fact.passive lets the character take initiative when urges accumulate and you've been idleFirst-run flow:
Almost always the model connection, not the app. When a reply fails Chronicler shows a red bar near the top of the chat saying why; the usual causes:
"doesn't have " — the model name in Settings isn't installed on that Ollama. Run ollama pull <model> in a terminal, or pick one you have (ollama list). The first-run wizard now checks this for you.
"Couldn't reach …" — Chronicler can't connect to the address in Settings. If Chronicler runs in Docker, localhost means the container itself: use http://host.docker.internal:11434 for an Ollama on the same machine. On Linux, also start Ollama with OLLAMA_HOST=0.0.0.0 so it listens beyond loopback (the bundled docker-compose.yml maps host.docker.internal for you; re-pull it if you copied an older one).
"rejected the credentials" — the API key in Settings is wrong or expired.
The dots spin for a long time, then you get "spent its whole reply budget thinking" (or, on an older version, nothing at all) — a reasoning model (Qwen3 / 3.5 / 3.8, DeepSeek-R1, gpt-oss…) used its whole token budget thinking and wrote no reply. Turn thinking off for that provider: Settings → Providers → "turn thinking off". The switch differs by server, so Chronicler sends the right one:
Measured on one machine with qwen3.5:4b: thinking left on used all 1,024 tokens and returned no text after ~21 s; with it off the reply arrived in ~1.5 s.
A slow machine: replies cut short or "dropped" — Chronicler waits up to 10 minutes for a model to start answering and 3 minutes of silence mid-reply (set CHRONICLER_LLM_TIMEOUT_MS / CHRONICLER_LLM_IDLE_MS on the chronicler service to change them). A smaller model, or thinking off, is usually the real fix. Pressing Stop now also stops the model.
A big model feels slow, and the next reply lags — after every reply Chronicler also runs background calls (memory extraction, the scene board, the ledger, the story summary) on the same model unless you assign another. On a small model that is a couple of seconds; on a big one it is most of a minute (measured on an M4 Pro with qwen3.8 27B at ~5 tokens/s: ~35–60 s of background work per turn, versus ~8 s on qwen3.5:4b). Your next message now goes first — background calls wait for it, are cancelled the moment you send, and retried afterwards — but the work itself still takes that long, so Settings → "use a small model for background tasks" (shown when your chat model is large) assigns a small fast one. It needs enough memory to keep both models loaded; if Ollama has to swap them each swap costs a few seconds. Also, generation speed is the model's own: qwen3.8 27B ran ~5 tok/s here against ~37–58 tok/s for the 4B/9B.
Reply cut off mid-sentence, a background task that never finishes, or the model forgets older context — these are limits you can change. Settings → Providers → "sampling & limits (advanced)" sets a model's max reply tokens and, for Ollama, its context window; Settings → Advanced — limits lists everything else with its default and an explanation: the prompt budget (how much memory and scene text goes into each prompt), how many tokens each background task may write (fact extraction, scene board, ledger, story summary, recap, audits…), how long to wait for a model's first word and for a silent stream, and the background scheduler. Leave a field empty to use the default; out-of-range values are corrected for you. Keep prompt budget + reply length below the model's context window — Settings warns when they don't fit.
Not sure which models you have — in Settings → Providers press load models from this server (Ollama, vLLM, llama.cpp, LM Studio, OpenRouter, OpenAI, Anthropic, Gemini) and click one.
You get a strange placeholder like "(stays in character, does not invent anything not in canon)" — you chose "Skip" in the wizard, so the built-in mock provider is answering. Add a real provider in Settings → Providers.
visible_to ACL. In a group scene, a character physically cannot recall a secret they weren't told — the retrieval layer filters before ranking. Not prompt-engineered, not relying on the model's discretion.character_book entries are honored with full trigger semantics (keys + secondary keys + selective + constant + position + insertion_order + case sensitivity) AND supplemented by semantic recall. Retires the brittle keyword-only mechanic without breaking compatibility.<canon> and <scene> as real, do not reference prior events not in those sections." Combined with the visibility ACL, the model cannot invent memory it wasn't given.skill_substrate entries — but only after an LLM verifier passes on each candidate, biased toward rejection. Skills surface back into future prompts when relevant, score +1 / −1 from user reactions (regenerate / edit / delete vs accept and move on), and transition through candidate → active → suppressed → archived based on accumulated outcomes. There's a "Character development" tab next to "Memory" with approve / disable / archive controls; the local override always wins over the derived state. See docs/LCDB-v0.md for the ablation harness that proves the contract holds.active into a 5th state, core_trait — always-on identity facets like "Adira is fundamentally guarded with strangers" that inject into every system prompt unconditionally, alongside a periodically-generated first-person self-model ("I am Adira. I'm a wandering musician…"). The Identity inspector makes all of it auditable. Status, stated plainly: the substrate and a cross-model benchmark harness both ship, but the benchmark does not yet demonstrate model-independent character — mean trait adherence was 0.275, and the run had no control arm. An earlier README claimed "σ=0.087 moderate model-independence"; that was computed on a blended score and is retracted. The gap where the core-trait verifier rejected almost every real trait was found and fixed on 2026-09-29 (it accepted 0–2 of 8 test patterns; it now accepts 5–6 of 8 with no false accepts among 26 negatives — see IDENTITY-LAYER.md), but promotion still needs days of accumulated evidence and the layer has not yet been shown end to end on real play. A separate consistency audit (Settings → More → Check character consistency) measures drift from the character card directly. Treat this as research in progress, not a working feature. See the thesis and the corrected results.All of the above is verified by automated tests: three-day-continuity, auto-promote, secret-stays-private, session-replay, lorebook, extract, skill-former, skill-outcomes, lcdb-v0, mcp-connectivity, core-trait-promoter, self-model-generator, identity-aggregator, cross-model-benchmark. Everything green.
For a head-to-head comparison against SillyTavern, RisuAI, and AgnAistic, see docs/COMPARISON.md. Headline:
Because the above is wasted if you can't actually RP:
**bold**, *italic*, code, block quotes, lists.docker compose pull
docker compose up -d
Pulls the latest published images and restarts. Your memory DB persists in the named volume (chronicler-memory) across restarts.
/api/mcp/* to YantrikDB, routes POST /api/llm to configured providers (keeps API keys host-side, no browser CORS)/api/chat with think: false support) + OpenAI-compatible + Anthropic native; streaming on all threeSee docs/ADR-001-stack.md for why web+Docker over native (yes, we pivoted from Tauri).
┌─── browser (React + TS) ──────────────────────────┐
│ ChatPane SessionList MemoryInspector │
│ Settings PromptInspector │
└───────────────────────────┬───────────────────────┘
│ fetch
▼
┌─── Node proxy (same origin) ──────────────────────┐
│ /api/mcp/* → transparent reverse proxy │
│ POST /api/llm → { target_url, method, headers, │
│ body } → upstream provider │
│ / /index.html → serves dist/ │
└──┬─────────────────────┬──────────────────────────┘
│ │
▼ ▼
┌─────────────┐ ┌──────────────┐
│ YantrikDB │ │ any LLM │
│ (docker │ │ (Ollama / │
│ service) │ │ Anthropic / │
│ │ │ OpenAI API) │
└─────────────┘ └──────────────┘
chronicler/
server/index.mjs Node proxy + static
src/
lib/
yantrikdb/ typed MCP client + conventions
orchestrator/ per-turn pipeline, compose, write, extract, scene,
auto-promote, lorebook scanner, anti-confabulation
cards/ v2/v3 parser + decomposition
providers/ OpenAI-compat / Anthropic / Ollama / Mock
session/ lifecycle, store, markdown export
recap/ previously-on generator
instrumentation/ promotion + session logs (redacted by default)
components/
Chat/ ChatPane with recap + swipes + toolbar
Inspector/ MemoryInspector + PromptInspector
Sessions/ SessionList
Settings/ SettingsPanel
App.tsx
Dockerfile web build + runtime
yantrikdb.Dockerfile yantrikdb-mcp image with CPU-only torch
docker-compose.yml both services wired
docs/
ADR-001-stack.md why web+Docker
ADR-002-memory-conventions.md the three-tier write contract
DOGFOOD.md pre-launch testing protocol
PATTERN.md the reusable memory pattern (standalone read)
tests/ 53 test suites, all required to ship
127.0.0.1 by default. Remote access requires you to remove that binding yourself and add an auth layer in front (Tailscale / Caddy).CHRONICLER_VERBOSE_LOGS=1.visible_to ACLs and pre-ranking retrieval filters — verified by tests/secret-stays-private.test.ts.npm install
# frontend dev with HMR (expects API sidecar on :3001)
npm run dev
# second terminal: API sidecar
npm run dev:server
# full prod-mode run
npm run build && npm start
# 53-suite test run (pure TS, no services required)
npm test
# live MCP integration smoke (requires compose stack running)
npm run test:integration
docs/ADR-002 for why this is a soft-suggestion-only featureChronicler is the roleplay client. The memory underneath it is a separate stack you can use on its own:
pip install yantrikdb-mcp). This is what Chronicler's docker-compose runs.MIT — see LICENSE.
Chronicler talks to YantrikDB over
its MCP server (the default in docker-compose.yml). The engine is Apache-2.0
as of 2026-08-18, so both sides of that boundary are permissive and nothing
here imposes obligations on your own code or a service you host.
Companion read: docs/PATTERN.md — a standalone write-up of the memory architecture, useful if you're building anything that needs a trustworthy memory layer on top of a language model.
Self-hosted AI roleplay client with memory that survives long campaigns — tiered canon/heuristic/reflex writes, retrieval-time privacy ACL for group chats, native MCP tool support.
टूल
अभी टूल सूची नहीं है। रिमोट सर्वर को पहले हेल्थ चेक के बाद सूची मिलती है।
FAQ
इस पेज पर Cursor, Claude Desktop, Claude Code या VS Code के लिए stdio कॉन्फ़िग कॉपी करें। यह पब्लिशर का इंस्टॉल इस्तेमाल करता है, PlugMCP प्रॉक्सी नहीं।
इस रिकॉर्ड में कोई ज़रूरी एनवायरनमेंट वेरिएबल दर्ज नहीं है।
Chronicler stdio पर लोकल चलता है।
पिछली जाँच 2026-10-28 को हुई। Self-hosted AI roleplay client with memory that survives long campaigns — tiered canon/heuristic/reflex writes, retrieval-time privacy ACL for group chats, native MCP tool support.