Mmcp.market

LoreConvo MCP server

by labyrinth-analytics·io.github.labyrinth-analytics/loreconvo·v0.10.12
No reviews yet

Local-first persistent session memory for Claude Code and other agents. SQLite + FTS5, no cloud.

B80/100grade B
Write a reviewInstall
What users say
No reviews yet
Be the first
Safety scan
B80/100

full report

Adoption
Growing

10 stars140 downloads/wk

Reviews

Write one

Nobody has reviewed LoreConvo yet.

If you have run it, two minutes of your experience saves the next person an afternoon.

LoreConvo tools (40, 5 write)

write = sends, deletes, buys or posts

Read from the package source without running it. The installed server may list more.

  • configure_agent_context

    Store or update a named topic configuration for an agent.

  • consolidate_memorieswrite action

    Run memory consolidation for a project to build a structured digest.

  • create_projectwrite action

    Create or update a project definition.

  • export_for_anthropic

    Export LoreConvo sessions to Anthropic managed-agents memory format. Pro only.

  • export_sessions

    Export portable session records to JSON or JSONL for migration.

  • get_anti_patterns

    Retrieve sessions marked as anti-patterns.

  • get_context_for

    Get relevant session context for a topic.

  • get_docs_for_session

    Return LoreDocs documents cross-linked to a LoreConvo session. Pro tier only.

  • get_dream_log

    Return recent consolidation log entries for transparency and diagnostics.

  • get_memory_digest

    Retrieve the current memory digest for a project without re-running consolidation.

  • get_project

    Get project details including recent sessions and skill usage stats.

  • get_recent_sessions

    Get recent session summaries.

  • get_related_sessions

    Find sessions related to a given session by co-occurrence and embedding. Pro only.

  • get_server_info

    Return MCP compatibility status for this LoreConvo server.

  • get_session

    Get full details of a specific session.

  • get_skill_history

    Get all sessions that used a specific skill.

  • get_stats

    Return a usage dashboard: session counts by surface, project, and tag; storage metrics (DB size, estimated tokens stored); and the 5 most recent sessions.

  • get_tier

    Return the current LoreConvo license tier and status.

  • graph_session_map

    Render a Mermaid knowledge-graph neighborhood around a session or project.

  • import_sessions

    Import sessions from a LoreConvo export file (JSON or JSONL).

  • inject_agent_context

    Return targeted session context for an agent at session start.

  • inspect_sessions

    Inspect stored sessions: list, filter, or get full detail for one session.

  • link_sessions

    Link two related sessions.

  • list_projects

    List all defined projects with session counts.

  • loreconvo_onboard

    Set up or update your LoreConvo workspace configuration.

  • pin_session

    Pin or unpin a session to exclude it from automated cleanup.

  • query_memory_items

    Query structured memory items by type, project, status, and recency.

  • rebuild_index

    Rebuild the LanceDB semantic search index from all stored sessions. Pro only.

  • save_memory_item

    Save a structured memory item: a decision, open question, or artifact.

  • save_session

    Save a session summary to persistent memory.

  • search_sessions

    Search session memory by keyword, with optional filters.

  • session_link_docwrite action

    Create a manual cross-product link from a LoreConvo session to a LoreDocs doc.

  • set_session_expiry

    Set or clear an expiry date on a session.

  • tag_as_anti_pattern

    Mark an existing session as an anti-pattern. Idempotent.

  • tag_session

    Tag a session with a persona for filtered recall.

  • transition_memory_item

    Move a memory item through its lifecycle.

  • untag_anti_patternwrite action

    Remove an anti-pattern tag from a session. Idempotent.

  • update_memory_itemwrite action

    Correct a memory item's title, body, tags, or metadata, or move it between projects.

  • vault_set_tier

    Activate a tier (free or pro) for LoreConvo.

  • vault_suggest

    Get proactive context suggestions based on your session history.

Public scan report

scanner v0.1.9 · 2026-09-25 · same rubric, same numbers if you re-run it

no findings
  • Code scan24 source files scanned25/25
  • –Live reliabilityno gateway calls yet and no remote to proben/a
  • –Tool poisoningtools not inspected (local package is not executed); not countedn/a
  • Auth qualitystatic API keys via environment variables6/15
  • Maintenancelast push 0 days ago15/15
  • Maintainer identityregistry namespace matches repository owner6/10
Overall 80/100. Components that don't apply are left out of the denominator. Any critical finding is an F.RubricAppeal a findingJSON

What the publisher says

From the LoreConvo repository's README, as published. We do not edit it. Read it on GitHub

LoreConvo v0.10.12

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: uvx loreconvo

Why LoreConvo?

Works wherever you work

LoreConvo 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.

You control what gets saved

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.

Your memory stays on your machine

LoreConvo stores everything in a SQLite database on your own machine. Your data stays local unless you explicitly enable the optional AI summarization feature (Pro, off by default), which sends a transcript excerpt to the Anthropic API using your own 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.

Structured memory, not raw transcripts

LoreConvo captures two types of memory for each session:

  • Episodic memory: what happened -- summaries, artifacts created, open questions left behind
  • Semantic memory: what was decided -- stable conclusions about the project that persist across sessions

Together these give Claude a structured, searchable record of your project's history, not just a pile of chat transcripts.

Recall Benchmark

LoreConvo's FTS5 search is benchmarked against a 60-session synthetic corpus (6 topic areas, 36 labeled queries).

Compound token expansion (camelCase / snakecase query preprocessing) lifts Recall@5 by +35.7 pp on queries using technical identifiers like autoSave, pipelinetracker, and getcontextfor.

Full benchmark report | Reproduce

Quick Start

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.

Using LoreConvo

Claude Code (Terminal)

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 39 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.

Shortened. The full README is on GitHub.

Nothing above is checked by us. What we check is on the safety report.

Install directly

claude mcp add loreconvo -- uvx loreconvo
Add to Cursor

LoreConvo: common questions

Is LoreConvo MCP server safe?
Mostly: it is graded B (80/100). Read the LoreConvo safety report
How do I install LoreConvo?
It runs on your machine. Copy the Claude Code, Claude Desktop or Cursor config from the install section.
Does LoreConvo need an API key?
Yes. The registry entry asks for LORECONVO_PRO.
Is LoreConvo maintained?
The last commit was in the last day (2026-09-25). The latest release is v0.10.12.
What can I use instead of LoreConvo?
Servers from other publishers that do the same job: Remem MCP server, memo MCP server and remem-mcp — Local-first MCP Memory + CodeGraph + Wiki MCP server. Compare all LoreConvo alternatives.

Alternatives to LoreConvo

Same job from other publishers: the closest match first, then the best rated.

All LoreConvo alternatives →
  • Remem
    Local-first automatic memory for Claude Code and Codex: capture, distill, recall from SQLite.
    B
  • memo
    Memory for AI agents — MLX (Apple Silicon) or CPU (Linux), sqlite-vec + BM25, zero cloud.
    A
  • remem-mcp — Local-first MCP Memory + CodeGraph + Wiki
    Local-first memory for AI coding agents. Memory + CodeGraph + Wiki in one SQLite file.
    B
  • KEPTA — Agent Memory
    Local memory for AI agents. One SQLite file on your machine — no cloud, no account.
    A
  • Local Memory
    Persistent local AI memory. SQLite + FTS5 + vector search, knowledge graph. No cloud, no API keys.
    A
LoreConvo vs RememLoreConvo vs memoLoreConvo vs remem-mcp — Local-first MCP Memory + CodeGraph + Wiki

More from labyrinth-analytics →