Power your agent
คำสั่งของผู้เผยแพร่เอง ไม่ใช่เอนด์พอยต์ของ PlugMCP
Host a copy with our keys and logs.
uvx loreconvo==0.11.0Claude Code ไม่มีลิงก์ติดตั้งสำหรับคำสั่งแบบโลคัล ให้คัดลอกคำสั่งด้านล่างแล้วรันในเทอร์มินัล
LORECONVO_PRO=<secret> claude mcp add labyrinth-analytics-loreconvo -- uvx loreconvo==0.11.0รันในเทอร์มินัล
{ "mcpServers": { "labyrinth-analytics-loreconvo": { "command": "uvx", "args": [ "loreconvo==0.11.0" ], "env": { "LORECONVO_PRO": "<secret>" } } }}claude_desktop_config.json
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.
เปิดจากผู้เผยแพร่
Your memory follows your identity, not your tool — with your consent.
LoreConvo is the only AI memory that carries your context across Claude Code, Cowork, Codex, Cursor, and Hermes Agent. One install, one memory, everywhere you code.
Install directly from Claude Code's plugin marketplace, or via PyPI:
Cross-surface persistent memory for AI sessions
uvx --from loreconvo[server] loreconvoLoreConvo works across Claude Code, Cowork, Cursor, Codex, and Hermes -- the same memory layer, no matter which client you reach for. When you switch mid-project, your context travels with you automatically.
Most tools wall off memory by machine or workspace. LoreConvo stores everything locally in a SQLite database you own, and surfaces it wherever you are. Capture happens two ways: explicitly via the save tools, or automatically at session end if you install the optional hooks. Either way, you can inspect, edit, or delete any memory at any time.
LoreConvo puts you in control: automatic capture only runs if you choose to install the session hooks, every save is inspectable, and you can delete any memory at any time.
Every memory shows you exactly where it came from — which surface captured it, when, what project context it belongs to, and which skill generated it. No mystery. Full provenance.
LoreConvo stores everything in a SQLite database on your own machine. Your data stays local unless you explicitly enable optional AI summarization (off by default) by setting LORECONVO_ANTHROPIC_API_KEY, which sends a transcript excerpt or summary to the Anthropic API using that key. LoreConvo never reads the generic ANTHROPIC_API_KEY. No cloud accounts. No vendor with access to your session history.
Your sessions live in ~/.loreconvo/sessions.db -- a file you own, can back up, and can delete whenever you want.
LoreConvo captures two types of memory for each session:
Together these give Claude a structured, searchable record of your project's history, not just a pile of chat transcripts.
LoreConvo's FTS5 search is benchmarked against a 60-session synthetic corpus (6 topic areas, 36 labeled queries).
Compound token expansion (camelCase / snake_case query preprocessing) lifts Recall@5 by +35.7 pp on queries using technical identifiers like autoSave, pipeline_tracker, and get_context_for.
One command to install:
bash install.sh
This creates a virtual environment, installs dependencies, and verifies everything works. No system Python changes, no manual pip commands.
Using the Claude Agent SDK directly? git clone the public repo and point the SDK's local-directory plugin loader at it -- the repo root is a self-contained plugin directory (.claude-plugin/plugin.json + .mcp.json). No separate SDK-installable bundle exists or is needed.
Start a session with the plugin loaded:
claude --plugin-dir /path/to/loreconvo
Or load it inside an existing session:
/plugin add /path/to/loreconvo
Replace /path/to/loreconvo with wherever you saved the source folder.
After making code changes, use /reload-plugins to refresh without restarting.
Once loaded, Claude has access to all 40 LoreConvo MCP tools automatically. Ask Claude to "save this session" or "recall what we discussed about X" and it will use the tools on its own.
loreconvo source folderImportant: Shared Database Access
Cowork runs in a sandboxed VM and can't see your Mac's filesystem by default. To read sessions saved by Claude Code, ask Claude in Cowork:
"Mount my ~/.loreconvo folder"
Once mounted, Cowork reads and writes to the same database as Claude Code. Sessions saved in Code appear instantly in Cowork.
Chat doesn't support plugins, so LoreConvo provides a one-command bridge. Run this in your terminal:
bash export-to-chat.sh
This exports your last session and copies it to your clipboard (macOS). Switch to Chat and paste (Cmd+V). Chat instantly has the context from your Code or Cowork session.
To search for a specific session:
bash export-to-chat.sh "tax prep"
The core value of LoreConvo is that context persists across Claude surfaces automatically. Here is the full chain:
Claude Code (~/.claude/settings.json via `claude mcp add`)
|-- SessionEnd hook --> auto_save.py --> ~/.loreconvo/sessions.db
|-- SessionStart hook <-- auto_load.py <-+
|
Cursor (.cursor/mcp.json) <--MCP-----+
Codex (~/.codex/config.toml) <--MCP-+
Hermes Agent (~/.hermes/config.yaml) <-MCP-+
Cowork (MCP-native execution env) <--+
All surfaces: save_session / get_recent_sessions / search_sessions
Claude Chat (web)
|-- export-to-chat.sh --> clipboard --> paste into Chat
Claude Code is the primary surface. The hooks run automatically:
auto_save.py captures the conversation and saves a structured summary (decisions, artifacts, open questions, tags) to the local SQLite database.auto_load.py queries the database, scores recent sessions by signal quality, and injects the most relevant context into the session as system context. Sessions with open questions and decisions score highest; low-signal sessions are filtered out. It also indexes any MEMORY.md found in the project directory (see MEMORY.md Auto-Indexing below).Cursor connects via .cursor/mcp.json in the project root -- the same MCP protocol as Claude Code. See INSTALL.md for setup details.
OpenAI Codex connects via ~/.codex/config.toml using a [mcp_servers.<name>] section. See INSTALL.md for setup details.
Hermes Agent connects via ~/.hermes/config.yaml under the mcp_servers: key. See INSTALL.md for setup details.
Claude Chat (web) does not support plugins. The export-to-chat.sh script bridges the gap: it exports your most recent session to your clipboard so you can paste it directly into Chat. This gives Chat the same context that Code would have loaded automatically.
The result: when you switch surfaces mid-project, you never have to re-explain what you were doing.
LoreConvo works through MCP tools when they are available and falls back to bundled scripts automatically when they are not. Your sessions are safe regardless of MCP status -- the same save, search, and recall operations work either way. You do not need to configure anything; the plugin skill handles the switch silently.
LoreConvo projects are persistent workspaces -- every session, decision, and artifact from your work on a project is searchable from any Claude surface.
# Create a project workspace
create_project("my-api", "REST API project", expected_skills=["openapi", "python"])
# Add persistent project instructions (optional)
create_project(
"my-api",
description="REST API project",
instructions="Python 3.10+, SQLite only. No cloud dependencies. Deploy via Docker."
)
# See recent sessions, skill usage, and open questions for the project
get_project("my-api")
# Search scoped to the project
search_sessions("auth design", project="my-api")
Project Instructions (optional): When you create a project, you can store persistent instructions or constraints that Claude will see at session start. This is useful for enforcing project-wide standards without repeating them in every CLAUDE.md file. Instructions are displayed in the auto-load context before recent session summaries.
Used with LoreDocs, LoreConvo forms a portable project workspace for all of Claude -- session memory AND structured knowledge, entirely on your machine. Where cloud AI workspaces tie you to one ecosystem, the Lore pair works across every Claude surface you already use.
If your project has a MEMORY.md file, LoreConvo automatically indexes it at every session start. The contents become searchable alongside your regular sessions via search_sessions.
This means Claude can recall project conventions, team notes, or architectural decisions from MEMORY.md without you having to mention them. Search results from MEMORY.md are tagged memory_md and have source='file_memory' so you can tell them apart from regular session entries.
Which directory is scanned?
By default, LoreConvo scans the directory where Claude Code is running (the current working directory). To point it at a different directory, pass LORECONVO_PROJECT_PATH as an env flag in your claude mcp add --scope user command:
"--env=LORECONVO_PROJECT_PATH=/Users/YOUR_USERNAME/projects/my_project"
Replace YOUR_USERNAME and my_project with your actual values. Use the full absolute path -- do not use ~ or $HOME.
Filtering MEMORY.md entries in search results
To include MEMORY.md entries in a search, use search_sessions normally -- they appear automatically. To see only MEMORY.md entries, filter by tag:
"Search LoreConvo sessions tagged memory_md for 'database conventions'."
The index is updated each time a session starts (idempotent -- no duplicates accumulate).
After installing, verify LoreConvo is working by asking Claude:
"Run
get_recent_sessionsand show me the results."
If you see a list of sessions (or an empty list if this is your first time), LoreConvo is connected. If you get an error about missing tools, re-run bash install.sh and reload the plugin.
For hooks verification (Claude Code only):
"Check if LoreConvo auto-loaded any context at the start of this session."
If the SessionStart hook is working, Claude will have received context from your recent sessions automatically.
For the best experience, add the following snippet to your ~/.claude/CLAUDE.md (global) or your project's CLAUDE.md. This tells Claude how to use LoreConvo consistently across sessions.
## LoreConvo (persistent session memory)
At session start:
1. Call `get_recent_sessions` to check for recent context relevant to the current work.
2. Use this context to avoid re-explaining things already discussed in prior sessions.
During the session:
- If important decisions are made or domain knowledge is shared, note it for the session summary.
At session end:
- Call `save_session` with a summary of what was accomplished, key decisions, open questions,
and any artifacts created. Use appropriate tags (e.g., project name, surface).
For Cowork users: Cowork does not run hooks automatically. Add instructions to call get_recent_sessions at session start and save_session at session end in your project CLAUDE.md. See COWORK_RESTORE.md for details.
LoreConvo is local-first and free to use. Pro ($8/mo) removes the session limit and unlocks LLM-quality summaries, hybrid retrieval search, and cross-product linking. Everything runs on your machine on either plan -- Pro adds no cloud component.
Free tier search: keyword (FTS5) + recency ordering. Pro tier search: hybrid retrieval -- vector (BGE-small-en-v1.5), BM25 full-text, and recency reranking combined via RRF fusion. Finds sessions by meaning, not just keywords.
Check your current tier and usage with get_tier. Activate a Pro license with
vault_set_tier.
save_session call requiredron-bot:sql)search_sessionsLORECONVO_ANTHROPIC_API_KEY. A daily cap (LORECONVO_SUMMARIZER_DAILY_CAP, default 100) prevents runaway API spend. Pro tier only.get_related_sessions automatically discovers sessions with similar content using BGE-small-en-v1.5 embeddings (cosine >= 0.75). Up to 10 bidirectional auto-links per save, same-project scoped. Free tier gets keyword co-occurrence links. Set LORECONVO_EMBEDDING_LINKS=0 to disable embedding links.get_docs_for_session and session_link_doc. Requires both LoreConvo Pro and LoreDocs Pro.core, memory, graph, agents, admin) with the configure_tools tool or LORECONVO_TOOL_GROUPS. All groups are on by default. See Tool Groups.Free - 50 sessions
Pro - $8/month
After checkout, your license key is emailed automatically to the address you used at checkout, usually within a few minutes. Questions: [email protected].
LoreConvo provides 40 MCP tools that Claude calls automatically during sessions. The table below shows the most commonly used ones -- see MCP Tool Catalog for the complete reference.
mcp and click (auto-installed by install.sh)LoreConvo is local-first. All data lives in ~/.loreconvo/sessions.db on your machine.
~/.loreconvo/sessions.db. No cloud storage. Override the path with the LORECONVO_DB environment variable.LORECONVO_ANTHROPIC_API_KEY, which sends a bounded transcript excerpt or summary to the Anthropic API under that key. Every summarization path (background summaries (Pro), post-turn capture (Pro), and save_session(summarize=True)) uses only this key; the generic ANTHROPIC_API_KEY is never read. Leave it unset and everything stays local.delete_session or remove the database file manually. No automatic expiry.Full privacy policy: https://labyrinthanalyticsconsulting.com/privacy
MCP tools not showing up in Claude Code?
Make sure you ran bash install.sh first. The .venv must exist with dependencies installed.
"No module named 'mcp'" error?
The .mcp.json points to .venv/bin/python3 inside the plugin folder. If you moved the folder, re-run bash install.sh.
Cowork can't see sessions saved in Code? Ask Claude to "mount my ~/.loreconvo folder" so Cowork can access the shared database.
If the MCP server is unreachable (e.g., in scheduled tasks or automation scripts), scripts/save_to_loreconvo.py provides the same core operations directly against the SQLite database.
# Save a session
python scripts/save_to_loreconvo.py \
--title "Daily QA run" \
--surface "qa" \
--summary "Ran full test suite. All passing." \
--tags '["qa", "automated"]'
# Read recent sessions
python scripts/save_to_loreconvo.py --read --limit 5
# Filter by surface
python scripts/save_to_loreconvo.py --read --surface code --limit 3
# Search sessions
python scripts/save_to_loreconvo.py --search "tax pipeline"
The script auto-discovers the database at ~/.loreconvo/sessions.db (or pass --db-path explicitly). It generates proper UUIDs and writes the same schema as the MCP save_session tool.
configure_tools tool, the
LORECONVO_TOOL_GROUPS environment variable, or a tool_groups setting in
~/.loreconvo/config.json. Changes apply after a restart. By default every
group stays on, so nothing changes unless you opt in.LORECONVO_ANTHROPIC_API_KEY. They never started on databases set up by the
normal install, so sessions kept their quick heuristic summary. If you set
that key on Pro (for example only for summarize=True), LoreConvo will now
also send new session text to the Anthropic API in the background to write
summaries, up to 100 a day by default (LORECONVO_SUMMARIZER_DAILY_CAP).
Unset the key to keep everything local.~/.loreconvo/sessions.db now holds
every session on its own, so copying that one file to another machine brings
them with it. Previously, sessions saved through the MCP server could stay in
a side file (sessions.db-wal), so a copy of sessions.db alone could arrive
empty. If LoreConvo is still running or was force-killed, copy the
sessions.db-wal file too.--search
and --read hide external-tool and expired sessions by default (on
--search, add --include-external or --include-expired to show them),
--project now actually filters --search and --read (it was accepted
and ignored; --inspect now rejects it with an error instead), --expires-at clear removes an expiry, and the script no
longer erases the record that session-saving hooks are failing.python -m loreconvo.cli stats now shows whether hook saves are failing,
like the get_stats tool.save_session with summarize=True) and turn capture
now use only LORECONVO_ANTHROPIC_API_KEY. Earlier versions also picked up
a general ANTHROPIC_API_KEY set for other tools, which could send session
text to the Anthropic API when you had not configured LoreConvo to do so.
If you use either feature, set LORECONVO_ANTHROPIC_API_KEY. Without it,
LoreConvo stays local-only.See the full changelog for the complete release history.
Business Source License 1.1 (BSL 1.1) - Labyrinth Analytics Consulting
Free for personal/non-commercial use (up to 50 sessions). Commercial use requires a paid license. Converts to Apache 2.0 on 2030-03-31. See LICENSE for details.
mcp-name: io.github.labyrinth-analytics/loreconvo
Cross-surface persistent memory for AI sessions
{ "mcpServers": { "labyrinth-analytics-loreconvo": { "command": "uvx", "args": [ "loreconvo==0.11.0" ], "env": { "LORECONVO_PRO": "<secret>" } } }}เครื่องมือ
ยังไม่มีรายการเครื่องมือ เซิร์ฟเวอร์แบบรีโมตจะได้รายการหลังการตรวจสอบสถานะครั้งแรก
FAQ
คัดลอกคอนฟิก stdio สำหรับ Cursor, Claude Desktop, Claude Code หรือ VS Code ได้ในหน้านี้ คอนฟิกนี้ใช้การติดตั้งของผู้เผยแพร่ ไม่ใช่พร็อกซีของ PlugMCP
ผู้เผยแพร่ระบุตัวแปรสภาพแวดล้อมเหล่านี้: LORECONVO_PRO
Loreconvo ทำงานแบบโลคัลผ่าน stdio
ตรวจสอบล่าสุดเมื่อ 2026-10-28 Cross-surface persistent memory for AI sessions