Skip to main content
Lerim includes a local web dashboard for session analytics, memory browsing, and runtime status. The dashboard runs alongside the daemon and API server.

​
Accessing the dashboard

When running via Docker (recommended), the dashboard is automatically available: 
lerim up
# Dashboard at http://localhost:8765
Or run standalone without Docker: 
lerim serve
# Then open http://127.0.0.1:8765
The dashboard is served by lerim serve (or lerim up for Docker). No separate server needs to be started.

​
Get the URL

Print the dashboard URL: 
lerim dashboard
Output: 
Dashboard: http://localhost:8765
The dashboard is served by `lerim serve` (or `lerim up` for Docker).

​
Custom host and port

Change the bind address in your config (~/.lerim/config.toml): 
[server]
host = "0.0.0.0"
port = 9000
Or override when starting: 
lerim serve --host 0.0.0.0 --port 9000
Then access at: http://localhost:9000

​
Dashboard tabs

The dashboard has five main sections:

​
Overview

High-level metrics and charts showing:
  • Sessions processed — Total agent conversations indexed
  • Messages exchanged — User and assistant messages across all sessions
  • Tools called — Agent tool invocations (file reads, commands, etc.)
  • Errors encountered — Extraction failures and runtime errors
  • Token usage breakdown — Tokens consumed by model and role
  • Activity by day and hour — Session frequency heatmaps
  • Model usage distribution — Which LLMs are being used (OpenRouter, OpenAI, Anthropic)
Metrics update in real-time as new sessions are synced and memories are extracted.

​
Runs

Searchable session list (50 per page) with status and metadata:
  • Session run ID
  • Coding agent (Claude Code, Cursor, Codex, OpenCode)
  • Timestamp
  • Status (processed, failed, queued)
  • Message count
  • Project association
Click any run to open a full-screen chat viewer showing the complete conversation. 
Agent: Claude Code ▼
Filters apply to the session list and update dynamically.

​
Memories

Library and editor for memory records:
  • Browse all memories — Decisions and learnings extracted from sessions
  • Filter by type — Decision or learning
  • Filter by tags — Tags assigned during extraction
  • Filter by confidence — Confidence score (0.0 to 1.0)
  • Inspect individual memories — View full content with frontmatter
  • Edit memories — Modify title, body, kind, confidence, and tags directly

​
Memory card example

📋 Decision: Auth pattern - bearer tokens
Confidence: 0.9 | Tags: auth, api, security
Created: 2026-02-15 | Source: claude-abc123

We chose bearer tokens over session cookies because our API is stateless.
JWTs are issued on login with a 7-day expiration.

[Edit] [View File] [Archive]
Edits in the dashboard modify the underlying markdown files. Changes are saved to disk immediately.

​
Pipeline

Sync and maintain status:
  • Extraction queue state — Sessions pending, processing, or completed
  • Latest extraction report — Summary of last sync run
    • Sessions indexed
    • Memories extracted
    • Errors encountered
  • Recent sync timestamps — When sync last ran and next scheduled run
  • Recent maintain timestamps — When maintenance last ran

​
Queue status example

Queue:
- Pending: 5
- Processing: 1
- Completed: 147

Last sync: 2 minutes ago
Next sync: in 8 minutes

Last maintain: 15 minutes ago
Next maintain: in 45 minutes
The Pipeline tab is useful for troubleshooting sync issues or monitoring extraction progress.

​
Settings

Dashboard-editable configuration:
  • Server settings — Poll interval, sync window, max sessions
  • Model role configuration — Which LLMs to use for extraction, synthesis, etc.
  • Tracing toggle — Enable OpenTelemetry tracing for debugging
Changes are saved to ~/.lerim/config.toml immediately.

​
Example settings

[daemon]
sync_interval_minutes = 10
maintain_interval_minutes = 60
sync_window_days = 7
sync_max_sessions = 50

[models]
lead.provider = "openrouter"
lead.model = "x-ai/grok-4.1-fast"

extract.provider = "openrouter"
extract.model = "openai/gpt-5-nano"

[tracing]
enabled = false
Changes to config require a server restart to take effect:
lerim down
lerim up

​
Top bar filters

The dashboard includes global filters in the top bar:
  • Agent filter — Show data for specific platforms (Claude, Codex, Cursor, OpenCode)
  • Scope filter — Switch between project-level and global data
These filters update:
  • Overview metrics and charts
  • Run listings in the Runs tab
  • Memory counts in the Memories tab

​
HTTP API

The dashboard is built on top of Lerim’s JSON API. Key endpoints:
EndpointMethodDescription
/api/healthGETHealthcheck for container monitoring
/api/statusGETRuntime state (agents, memory count, queue)
/api/askPOSTLLM-synthesized query
/api/syncPOSTTrigger sync cycle
/api/maintainPOSTTrigger maintenance
/api/memoriesGETList all memories
/api/searchPOSTKeyword search memories
You can query these endpoints directly: 
curl http://localhost:8765/api/status | jq
curl -X POST http://localhost:8765/api/sync -H "Content-Type: application/json" -d '{"force": false}'
The thin CLI commands (lerim ask, lerim sync, etc.) are HTTP clients that forward to these endpoints.

​
Dashboard features

​
Session chat viewer

Click any session in the Runs tab to open a full-screen viewer:
  • Complete conversation history
  • User and assistant messages
  • Tool calls and results
  • Timestamps and metadata
  • Syntax highlighting for code blocks

​
Memory editor

From the Memories tab, click [Edit] on any memory:
  • Edit title
  • Edit body (markdown supported)
  • Change primitive type (decision/learning)
  • Adjust confidence score
  • Modify tags
  • Update kind (insight, procedure, friction, pitfall, preference)
Changes save to the markdown file immediately.

​
Live metrics

The Overview tab shows live metrics:
  • Total sessions indexed
  • Messages per day
  • Token usage by model
  • Activity heatmaps
Metrics refresh when you navigate between tabs or apply filters.

​
Notes and limitations

  • The dashboard is read-only for run content — you can view sessions but not modify them
  • Memory edits go through the Memories tab edit interface
  • Graph Explorer code exists in the project but is currently hidden in the UI
  • When running via Docker, the dashboard is served by the lerim serve process alongside the daemon loop and HTTP API

​
Troubleshooting

The server might not be running.Solution: Start Lerim:
lerim up        # Docker
lerim serve     # Native
Check status:
lerim status
If it’s running, verify the port:
lerim dashboard
No sessions have been synced yet.Solution: Run an initial sync:
lerim sync
Or wait for the automatic daemon cycle (default: every 10 minutes).
The dashboard may need a refresh to show updates.Solution: Refresh the page or navigate between tabs to force a data reload.
Another service is using port 8765.Solution: Change the port in config:
[server]
port = 9000
Then restart:
lerim down
lerim up

​
Next steps

Build docs developers (and LLMs) love

Get started for freeTalk to us