Bietet eine lokale, persistente Session-Memory für AI Agents mittels SQLite und FTS5, um den Kontext über verschiedene Coding-Umgebungen hinweg zu bewahren.
Auch bekannt als labyrinth-analytics/loreconvo
- Stars
- 12
- Tools
- 42
- Downloads, 30 Tage
- 1.049
- Neueste Version
- 0.11.0
- Letzter Commit
- 6. Nov. 2026
- Lizenz
- —
Was ist LoreConvo MCP?
Bietet eine lokale, persistente Session-Memory für AI Agents mittels SQLite und FTS5, um den Kontext über verschiedene Coding-Umgebungen hinweg zu bewahren. Er stellt 42 Tools bereit, etwa save_session, get_recent_sessions, get_session.
Zusammenfassung generiert aus dem README des Projekts
Über LoreConvo MCP server
LoreConvo bietet eine Local-first Memory-Schicht, die es AI Agents ermöglicht, den Kontext über verschiedene Coding-Umgebungen hinweg beizubehalten. Anstatt auf ein einzelnes Tool beschränkt zu sein, folgen dir dein Session-Verlauf, deine Entscheidungen und deine Projekt-Artifacts zwischen Clients wie Claude Code, Cursor, Codex, Cowork und Hermes Agent.
Nutzer können den Server via PyPI oder direkt über den Claude Code Plugin Marketplace installieren. Während die Daten in einer sessions.db Datei auf deinem Rechner bleiben, kannst du optional eine AI-Summarization aktivieren, indem du einen LORECONVO_ANTHROPIC_API_KEY bereitstellst. Das System nutzt FTS5-Suche mit Compound Token Expansion, um die Trefferquote bei technischen Identifikatoren wie snake_case oder camelCase Variablen zu verbessern. Dieses Setup stellt sicher, dass dein Projektkontext automatisch verfügbar ist, wenn du von einem terminalbasierten Agent zu einer Desktop-App wechselst, ohne dass du deine Arbeit erneut erklären musst.
Was du damit machen kannst
- 1Kontext über verschiedene IDEs hinweg beibehaltenEin Entwickler kann von der Nutzung von Claude Code im Terminal zu Cursor in einer GUI wechseln, ohne den Projektverlauf zu verlieren.
- 2Session-Dokumentation automatisierenDu kannst Hooks einrichten, um Summaries, Artifacts und offene Fragen automatisch zu erfassen, wenn eine Coding-Session endet.
- 3Technische Projekt-Identifikatoren durchsuchenEin AI Agent kann spezifische Code-Elemente mithilfe von fortgeschrittener Search-Preprocessing präzise finden.
- 4Projekt-Dokumentation automatisch indizierenDer Server kann eine MEMORY.md Datei in eine durchsuchbare Knowledge Base für deinen AI Agent verwandeln.
Geschrieben aus dem README des Projekts. Jeder Use Case wurde gegen ein Zitat daraus geprüft.
So installierst du LoreConvo MCP
Formate geprüft am 10. Nov. 2026Zu Cursor hinzufügenZu Goose hinzufügenLoreConvo MCP in Claude Code installieren
$ claude mcp add --env 'LORECONVO_PRO=<YOUR_LORECONVO_PRO>' loreconvo -- uvx --from 'loreconvo[server]' loreconvoLoreConvo MCP in Cursor installieren
~/.cursor/mcp.json
{
"mcpServers": {
"loreconvo": {
"command": "uvx",
"args": [
"--from",
"loreconvo[server]",
"loreconvo"
],
"env": {
"LORECONVO_PRO": "<YOUR_LORECONVO_PRO>"
}
}
}
}LoreConvo MCP in VS Code installieren
.vscode/mcp.json
{
"servers": {
"loreconvo": {
"type": "stdio",
"command": "uvx",
"args": [
"--from",
"loreconvo[server]",
"loreconvo"
],
"env": {
"LORECONVO_PRO": "<YOUR_LORECONVO_PRO>"
}
}
}
}LoreConvo MCP in VS Code CLI installieren
$ code --add-mcp '{"name":"loreconvo","type":"stdio","command":"uvx","args":["--from","loreconvo[server]","loreconvo"],"env":{"LORECONVO_PRO":"<YOUR_LORECONVO_PRO>"}}'LoreConvo MCP in Claude Desktop installieren
claude_desktop_config.json
{
"mcpServers": {
"loreconvo": {
"command": "uvx",
"args": [
"--from",
"loreconvo[server]",
"loreconvo"
],
"env": {
"LORECONVO_PRO": "<YOUR_LORECONVO_PRO>"
}
}
}
}LoreConvo MCP in Codex installieren
$ codex mcp add loreconvo --env 'LORECONVO_PRO=<YOUR_LORECONVO_PRO>' -- uvx --from 'loreconvo[server]' loreconvoLoreConvo MCP in Codex config.toml installieren
~/.codex/config.toml
[mcp_servers.loreconvo] command = "uvx" args = ["--from", "loreconvo[server]", "loreconvo"] [mcp_servers.loreconvo.env] LORECONVO_PRO = "<YOUR_LORECONVO_PRO>"
LoreConvo MCP in Gemini CLI installieren
$ gemini mcp add -s user -e 'LORECONVO_PRO=<YOUR_LORECONVO_PRO>' loreconvo uvx -- --from 'loreconvo[server]' loreconvoLoreConvo MCP in Gemini settings.json installieren
~/.gemini/settings.json
{
"mcpServers": {
"loreconvo": {
"command": "uvx",
"args": [
"--from",
"loreconvo[server]",
"loreconvo"
],
"env": {
"LORECONVO_PRO": "<YOUR_LORECONVO_PRO>"
}
}
}
}Von HostedMCP gestartet am 16. Nov. 2026
Wir haben diesen Befehl für loreconvo 0.11.0 in einem isolierten Container ohne Netzwerk und ohne Schlüssel ausgeführt. Er hat geantwortet und 42 Tools gelistet.
LoreConvo MCP tools 42
Vom Server mit tools/list gelesensave_sessionSave a session summary to persistent memory. Call this at the end of a session or when the user requests /bridge save. Captures decisions, artifacts, skills used, and open questions for recall in future sessions. Args: title: Short descriptive title for the session surface: Where this session ran - 'cowork', 'code', or 'chat' summary: 2-3 paragraph narrative summary of what happened. Capped at 15000 chars. decisions: List of key decisions made during the session. Each item capped at 2000 chars. artifacts: List of files created or modified open_questions: Unresolved questions to carry forward. Each item capped at 2000 chars. tags: Freeform tags for categorization skills_used: Skills that were invoked during this session project: Project name if part of a defined project start_date: ISO 8601 start time (defaults to now) end_date: ISO 8601 end time session_id: Optional session ID to enable deduplication with the auto-save hook. If a session with this ID already exists (e.g., auto-saved at session end), the record is updated with the richer manual metadata. Artifacts from the existing record are preserved when the caller does not supply artifacts. If omitted, a new UUID is generated (existing behavior). external_tool_session: Set True when saving a session generated by an external tool (e.g., Anthropic Managed Agents). Flagged sessions are excluded from auto-load and search by default to prevent context contamination. Override exclusion with include_external=True on search, or set LORECONVO_EXTERNAL_TOOL_EXCLUSION=0 to disable globally. reasoning_notes: Optional free-form text capturing the reasoning chain or thought process behind decisions. Blank or None leaves the field empty. Capped at 15000 chars. summarize: If True and LORECONVO_ANTHROPIC_API_KEY is set, send the summary to Claude API (Haiku) for compression before saving. Opt-in only; defaults to False. Falls back to the raw summary on any API error or if the key is absent. See INSTALL.md Privacy Note.
get_recent_sessionsGet recent session summaries. Use to see what work was done recently, optionally filtered by project or skill. Args: limit: Max sessions to return (default 10) days_back: How far back to look (default 30 days) project: Filter to sessions in this project skill: Filter to sessions that used this skill
get_sessionGet full details of a specific session. Args: session_id: The UUID of the session to retrieve
search_sessionsSearch session memory by keyword, with optional filters. Use to find sessions where a topic was discussed, a decision was made, or a specific skill/project was involved. Args: query: Search keywords (matched against title, summary, decisions). Short alphabetic tokens (<=10 chars) are prefix-matched automatically. Append `*` to force prefix matching on longer terms (e.g., "consolid*"). persona: Filter to sessions tagged with this persona (supports prefix matching) tags: Filter to sessions with any of these tags skills: Filter to sessions that used any of these skills project: Filter to sessions in this project limit: Max results (default 10) include_external: If True, include sessions flagged as external_tool_session. Default False. Can also be enabled globally via LORECONVO_EXTERNAL_TOOL_EXCLUSION=0. semantic: If True, use LanceDB hybrid (vector + BM25) search instead of FTS5. Pro tier only. Falls back to FTS5 if index not built yet; run rebuild_index to build it after first Pro activation. Semantic search is designed for topical discovery -- finding sessions about a concept even when exact keywords differ. For known-item lookup (you know specific words that appeared in a session), FTS5 (semantic=False) gives higher recall because it matches exact tokens. A probe over 7,500 sessions found FTS5 recall at 9-10/10 vs semantic 1/10 for known-item queries, which is expected: BGE-small embeddings + RRF equal-weight fusion + recency decay all bias toward topical relevance over exact-match. Use semantic=True when you want "sessions about X"; use semantic=False when you want "sessions containing word Y". include_expired: If True, include sessions whose expires_at is in the past. Default False (expired sessions are hidden from search). after: Optional ISO 8601 UTC instant (e.g. "2026-07-06T00:00:00Z"). Only sessions started at or after this instant are returned. before: Optional ISO 8601 UTC instant. Only sessions started strictly before this instant are returned. To answer a question like "what did I work on last week", resolve the range yourself -- you know the user's local date, the server does not -- and pass the two instants. Do not put date words in `query`; they are matched as literal keywords, not parsed.
get_context_forGet relevant session context for a topic. Use at the start of a session to load prior decisions and context about a topic. Returns the most relevant session excerpts. Args: topic: The topic to find context for (e.g., 'K-1 parser', 'rental insurance') max_results: Max excerpts to return (default 5) include_external: If True, include sessions flagged as external_tool_session. Default False. semantic: If True, use LanceDB hybrid search (Pro only). Falls back to FTS5 if index not yet built.
configure_agent_contextStore or update a named topic configuration for an agent. Args: agent_name: Canonical agent name (^[a-z][a-z0-9-]{1,63}$). project: Project name matching sessions.project (^[a-z_][a-z0-9_]{0,63}$). topics: Non-empty list of topic strings; max 10; each max 200 chars. Replaces all existing topics for this (agent_name, project) pair. max_results_per_topic: Sessions returned per topic search. 1-10. enabled: Set False to disable injection without deleting the config. retire: Set True to soft-retire this config (status='retired'). inject_agent_context treats a retired config like enabled=0. Any write with retire=False reactivates a previously retired config (reflected in the response's reactivated_retired_config).
inject_agent_contextReturn targeted session context within project for an agent at session start. If topics is provided (non-empty, len<=10), it overrides stored config. If topics is None, stored config is used. If topics=[], has_config reflects stored state; no injection runs. Returns status in {"ok", "partial", "warning", "error"}. Branch on status first; treat "warning" as skipped (not success), not as a synonym for "ok" -- a caller that only checks `status != "error"` will silently treat skipped or empty injection as success.
tag_sessionTag a session with a persona for filtered recall. Supports hierarchical personas (e.g., 'ron-bot:sql' matches 'ron-bot' queries). Args: session_id: Session to tag persona_name: Persona identifier (e.g., 'ron-bot', 'ron-bot:sql', 'tax-prep') relevance_note: Optional note about why this session is relevant to the persona
link_sessionsLink two related sessions. Args: from_id: Source session ID to_id: Target session ID link_type: Relationship type - 'continues', 'related', or 'supersedes'
get_related_sessionsFind sessions related to a given session by co-occurrence and embedding. Pro only. Returns co-occurrence links (shared_term_count >= 1) and embedding-based semantic links (shared_term_count=0 sentinel). Co-occurrence results rank above embedding results when sorting by shared_term_count DESC. Response version=2 signals the new format with link_type field. Args: session_id: UUID of the session to find related sessions for limit: Max results to return (default 10, max 50) min_shared_terms: Minimum shared keywords required (default 3)
graph_session_mapRender a Mermaid knowledge-graph neighborhood around a session or project. Exactly one of session_id/project selects the seed. Traversal is a bounded, read-only BFS over session_links (undirected) plus each admitted session's attribute leaves (project/skill/persona/tag). Pro tier adds derived (co-occurrence/embedding) and doc (LoreDocs cross-link) edges, seed-only. Every emitted label is restricted to a fixed character allowlist so no title/tag/skill text can alter the diagram's structure. Args: session_id: UUID of the seed session. Exactly one of session_id/project required. project: name of the seed project. Exactly one of session_id/project required. depth: number of BFS expansion hops over link edges, clamped [0, 3] max_nodes: node budget (sessions + attribute leaves), clamped [1, 200] Returns a dict with version, seed, seed_found, mermaid, nodes, edges, truncated, nodes_emitted, nodes_available, edges_emitted, nodes_dropped_by_kind, edges_dropped_by_kind, frontier_session_ids, edge_kinds_included, edge_kinds_omitted -- or {"error": {...}} on a validation failure or an unavailable database.
rebuild_indexRebuild the LanceDB semantic search index from all stored sessions. Pro only. Starts the rebuild in a background thread and returns immediately with a status handle. The server remains responsive to other calls while the rebuild runs. Call rebuild_index_status() to track progress. The first run downloads BAAI/bge-small-en-v1.5 (~130MB; cached afterwards). Expect roughly 3-10 minutes per thousand sessions depending on hardware. A rebuild already in progress returns status 'busy' with the current progress percentage. Returns: - {'status': 'started', 'message': '...'} when a new rebuild begins - {'status': 'busy', 'message': '...', 'progress_pct': N} when one is already running - {'error': '...'} when the tier is Free
| save_session | Save a session summary to persistent memory. Call this at the end of a session or when the user requests /bridge save. Captures decisions, artifacts, skills used, and open questions for recall in future sessions. Args: title: Short descriptive title for the session surface: Where this session ran - 'cowork', 'code', or 'chat' summary: 2-3 paragraph narrative summary of what happened. Capped at 15000 chars. decisions: List of key decisions made during the session. Each item capped at 2000 chars. artifacts: List of files created or modified open_questions: Unresolved questions to carry forward. Each item capped at 2000 chars. tags: Freeform tags for categorization skills_used: Skills that were invoked during this session project: Project name if part of a defined project start_date: ISO 8601 start time (defaults to now) end_date: ISO 8601 end time session_id: Optional session ID to enable deduplication with the auto-save hook. If a session with this ID already exists (e.g., auto-saved at session end), the record is updated with the richer manual metadata. Artifacts from the existing record are preserved when the caller does not supply artifacts. If omitted, a new UUID is generated (existing behavior). external_tool_session: Set True when saving a session generated by an external tool (e.g., Anthropic Managed Agents). Flagged sessions are excluded from auto-load and search by default to prevent context contamination. Override exclusion with include_external=True on search, or set LORECONVO_EXTERNAL_TOOL_EXCLUSION=0 to disable globally. reasoning_notes: Optional free-form text capturing the reasoning chain or thought process behind decisions. Blank or None leaves the field empty. Capped at 15000 chars. summarize: If True and LORECONVO_ANTHROPIC_API_KEY is set, send the summary to Claude API (Haiku) for compression before saving. Opt-in only; defaults to False. Falls back to the raw summary on any API error or if the key is absent. See INSTALL.md Privacy Note. | |
| get_recent_sessions | Get recent session summaries. Use to see what work was done recently, optionally filtered by project or skill. Args: limit: Max sessions to return (default 10) days_back: How far back to look (default 30 days) project: Filter to sessions in this project skill: Filter to sessions that used this skill | |
| get_session | Get full details of a specific session. Args: session_id: The UUID of the session to retrieve | |
| search_sessions | Search session memory by keyword, with optional filters. Use to find sessions where a topic was discussed, a decision was made, or a specific skill/project was involved. Args: query: Search keywords (matched against title, summary, decisions). Short alphabetic tokens (<=10 chars) are prefix-matched automatically. Append `*` to force prefix matching on longer terms (e.g., "consolid*"). persona: Filter to sessions tagged with this persona (supports prefix matching) tags: Filter to sessions with any of these tags skills: Filter to sessions that used any of these skills project: Filter to sessions in this project limit: Max results (default 10) include_external: If True, include sessions flagged as external_tool_session. Default False. Can also be enabled globally via LORECONVO_EXTERNAL_TOOL_EXCLUSION=0. semantic: If True, use LanceDB hybrid (vector + BM25) search instead of FTS5. Pro tier only. Falls back to FTS5 if index not built yet; run rebuild_index to build it after first Pro activation. Semantic search is designed for topical discovery -- finding sessions about a concept even when exact keywords differ. For known-item lookup (you know specific words that appeared in a session), FTS5 (semantic=False) gives higher recall because it matches exact tokens. A probe over 7,500 sessions found FTS5 recall at 9-10/10 vs semantic 1/10 for known-item queries, which is expected: BGE-small embeddings + RRF equal-weight fusion + recency decay all bias toward topical relevance over exact-match. Use semantic=True when you want "sessions about X"; use semantic=False when you want "sessions containing word Y". include_expired: If True, include sessions whose expires_at is in the past. Default False (expired sessions are hidden from search). after: Optional ISO 8601 UTC instant (e.g. "2026-07-06T00:00:00Z"). Only sessions started at or after this instant are returned. before: Optional ISO 8601 UTC instant. Only sessions started strictly before this instant are returned. To answer a question like "what did I work on last week", resolve the range yourself -- you know the user's local date, the server does not -- and pass the two instants. Do not put date words in `query`; they are matched as literal keywords, not parsed. | |
| get_context_for | Get relevant session context for a topic. Use at the start of a session to load prior decisions and context about a topic. Returns the most relevant session excerpts. Args: topic: The topic to find context for (e.g., 'K-1 parser', 'rental insurance') max_results: Max excerpts to return (default 5) include_external: If True, include sessions flagged as external_tool_session. Default False. semantic: If True, use LanceDB hybrid search (Pro only). Falls back to FTS5 if index not yet built. | |
| configure_agent_context | Store or update a named topic configuration for an agent. Args: agent_name: Canonical agent name (^[a-z][a-z0-9-]{1,63}$). project: Project name matching sessions.project (^[a-z_][a-z0-9_]{0,63}$). topics: Non-empty list of topic strings; max 10; each max 200 chars. Replaces all existing topics for this (agent_name, project) pair. max_results_per_topic: Sessions returned per topic search. 1-10. enabled: Set False to disable injection without deleting the config. retire: Set True to soft-retire this config (status='retired'). inject_agent_context treats a retired config like enabled=0. Any write with retire=False reactivates a previously retired config (reflected in the response's reactivated_retired_config). | |
| inject_agent_context | Return targeted session context within project for an agent at session start. If topics is provided (non-empty, len<=10), it overrides stored config. If topics is None, stored config is used. If topics=[], has_config reflects stored state; no injection runs. Returns status in {"ok", "partial", "warning", "error"}. Branch on status first; treat "warning" as skipped (not success), not as a synonym for "ok" -- a caller that only checks `status != "error"` will silently treat skipped or empty injection as success. | |
| tag_session | Tag a session with a persona for filtered recall. Supports hierarchical personas (e.g., 'ron-bot:sql' matches 'ron-bot' queries). Args: session_id: Session to tag persona_name: Persona identifier (e.g., 'ron-bot', 'ron-bot:sql', 'tax-prep') relevance_note: Optional note about why this session is relevant to the persona | |
| link_sessions | Link two related sessions. Args: from_id: Source session ID to_id: Target session ID link_type: Relationship type - 'continues', 'related', or 'supersedes' | |
| get_related_sessions | Find sessions related to a given session by co-occurrence and embedding. Pro only. Returns co-occurrence links (shared_term_count >= 1) and embedding-based semantic links (shared_term_count=0 sentinel). Co-occurrence results rank above embedding results when sorting by shared_term_count DESC. Response version=2 signals the new format with link_type field. Args: session_id: UUID of the session to find related sessions for limit: Max results to return (default 10, max 50) min_shared_terms: Minimum shared keywords required (default 3) | |
| graph_session_map | Render a Mermaid knowledge-graph neighborhood around a session or project. Exactly one of session_id/project selects the seed. Traversal is a bounded, read-only BFS over session_links (undirected) plus each admitted session's attribute leaves (project/skill/persona/tag). Pro tier adds derived (co-occurrence/embedding) and doc (LoreDocs cross-link) edges, seed-only. Every emitted label is restricted to a fixed character allowlist so no title/tag/skill text can alter the diagram's structure. Args: session_id: UUID of the seed session. Exactly one of session_id/project required. project: name of the seed project. Exactly one of session_id/project required. depth: number of BFS expansion hops over link edges, clamped [0, 3] max_nodes: node budget (sessions + attribute leaves), clamped [1, 200] Returns a dict with version, seed, seed_found, mermaid, nodes, edges, truncated, nodes_emitted, nodes_available, edges_emitted, nodes_dropped_by_kind, edges_dropped_by_kind, frontier_session_ids, edge_kinds_included, edge_kinds_omitted -- or {"error": {...}} on a validation failure or an unavailable database. | |
| rebuild_index | Rebuild the LanceDB semantic search index from all stored sessions. Pro only. Starts the rebuild in a background thread and returns immediately with a status handle. The server remains responsive to other calls while the rebuild runs. Call rebuild_index_status() to track progress. The first run downloads BAAI/bge-small-en-v1.5 (~130MB; cached afterwards). Expect roughly 3-10 minutes per thousand sessions depending on hardware. A rebuild already in progress returns status 'busy' with the current progress percentage. Returns: - {'status': 'started', 'message': '...'} when a new rebuild begins - {'status': 'busy', 'message': '...', 'progress_pct': N} when one is already running - {'error': '...'} when the tier is Free |
Alle 42 Tools anzeigenWeniger Tools anzeigen
rebuild_index_statusReturn the current status of a background semantic-index rebuild. Call after rebuild_index() to monitor progress. Returns 'idle' when no rebuild has been started or the last rebuild has finished. Returns: - {'status': 'idle', 'message': '...'} - {'status': 'running', 'phase': '...', 'progress': N, 'total': N, 'progress_pct': N, 'elapsed_s': N.N} - {'status': 'complete', 'message': '...', 'indexed': N, 'total_in_db': N, 'exclusions': {reason: count}, 'elapsed_s': N.N} - {'status': 'error', 'message': '...'}
get_projectGet project details including recent sessions and skill usage stats. Args: project_name: The project identifier
list_projectsList all defined projects with session counts.
create_projectCreate or update a project definition. Projects group related sessions and can auto-associate based on skill usage. All changes to project instructions are logged for audit purposes. Args: name: Project identifier (e.g., 'secret-agent-man', 'project-ron') description: What this project is about expected_skills: Skills typically used in this project's sessions default_persona: Auto-tag new sessions with this persona instructions: Optional project-wide instructions or constraints session_id: Optional session ID for audit trail (typically provided by MCP context)
loreconvo_onboardSet up or update your LoreConvo workspace configuration. Call this once after installing LoreConvo to get a recommended setup. Call again any time to add projects or agents, or to regenerate your reference doc. Creates: - Project registrations for each project listed - A config file at ~/.loreconvo/onboard_config.json - A reference doc (markdown) in the response -- paste it into your CLAUDE.md or a LoreDocs vault so your AI assistant can apply your conventions consistently Args: name: Your workspace or team name (e.g. 'Labyrinth Analytics') projects: Snake_case project identifiers (e.g. ['side_hustle', 'finance']) agents: Agent names that will tag sessions (e.g. ['ron', 'meg']) tag_style: 'simple' (status + priority) or 'detailed' (adds effort, scout-run markers, date tag guidance) Surfaces: code (Claude Code), cowork (Claude.ai Projects), chat (Claude.ai chat), codex (Codex CLI). Custom values are allowed for other tools. Agent identity: use tags=['agent:name'] -- not the surface field.
get_skill_historyGet all sessions that used a specific skill. Useful for understanding how often a skill is used and in what contexts. Args: skill_name: The skill to look up (e.g., 'rental-property-accounting') days_back: How far back to search (default 90 days)
vault_suggestGet proactive context suggestions based on your session history. Analyzes recent sessions and surfaces: - Sessions with unresolved open questions that need follow-up - Sessions with key decisions worth reviewing before starting new work - Skill gaps: skills expected by a project but not used recently Use at the start of a session to find the most valuable prior context, or when you're unsure what to work on next. When `project` is given and the initial window returns no suggestions but the project still has sessions, the window is expanded progressively (30, 90, 365, then all-time days) so older unresolved work is surfaced instead of returning an empty result. The response metadata reports the effective window (`days_back`), and -- when the window was expanded -- `window_expanded`, `expanded_to_days`, `initial_days_back`, and an `expansion_note`. An empty result with `project` set therefore means the project genuinely has no suggestions (no open questions, no >=2-decision sessions, no skill gaps) at any window, not merely that the default window was too narrow. Args: project: Filter suggestions to this project persona: Filter to sessions tagged with this persona (prefix matching) days_back: How far back to look (default 14 days) limit: Max suggestions to return (default 5)
get_tierReturn the current LoreConvo license tier and status. Use this to confirm whether the Pro license key is loaded and valid. Returns a dict with keys: is_pro -- bool, True if Pro tier is active mode -- "licensed" | "dev_bypass" | "free" | "invalid_key" product -- product name from the license payload (if licensed) exp -- expiry date or "never" (if licensed) email -- customer email (if licensed and present) error -- error message (if mode is "invalid_key") upgrade_url -- Stripe checkout link (present when not already Pro)
vault_set_tierAktionActivate a tier (free or pro) for LoreConvo. Pro tier removes the free-tier session limit (default: 50 sessions). After purchasing a Pro license, set LORECONVO_PRO=<your-license-key> in your environment and restart the server, then call this tool with tier='pro' to confirm Pro is active. Reverting to tier='free' re-enables limits (existing sessions are preserved -- only new saves are blocked once the limit is hit).
export_sessionsExport portable session records to JSON or JSONL for migration. Exports matching session fields, skills, tags, and artifacts. Links and independent structured memory items are outside this export. Use output_path to write to a file; omit it to receive the data inline. Use import_sessions to load the exported file. Args: output_path: File path to write export (e.g. '/tmp/loreconvo_export.json'). If omitted, data is returned inline. project: Export only sessions from this project. tags: Export only sessions that have any of these tags. days_back: Limit to sessions from the last N days. Omit for all time. limit: Max sessions to export (default 1000). format: 'json' (array wrapped in metadata) or 'jsonl' (one session per line).
export_for_anthropicExport LoreConvo sessions to Anthropic managed-agents memory format. Pro only. Produces a JSON file in 'anthropic-memory-v1' format, suitable for import into Anthropic managed-agents memory stores. Only non-periodic, non-file-memory sessions are exported (contamination control). NOTE: Field mapping is preliminary pending Anthropic beta API schema stabilization. Cassandra will signal when the schema is stable. Save the output and validate against Anthropic docs before submitting to a managed-agents memory store. Args: output_path: File path to write the export. If omitted, data is returned inline. project: Export only sessions from this project. session_ids: List of specific session UUIDs to export. Overrides project filter. days_back: Limit to sessions from the last N days.
import_sessionsImport sessions from a LoreConvo export file (JSON or JSONL). Reads an export created by export_sessions and saves sessions into the local database. Session UUIDs are preserved so re-importing is safe. Args: file_path: Path to the export file (JSON or JSONL format). on_conflict: What to do if a session ID already exists. 'skip' (default) -- leave the existing session unchanged. 'replace' -- overwrite with the imported version. dry_run: If True, parse and validate the file but make no DB changes.
inspect_sessionsInspect stored sessions: list, filter, or get full detail for one session. Answers 'what do you know about me?' and helps users find, browse, and understand their stored session memory. Args: session_id: If provided, return full detail for this specific session. search: Full-text search query across title, summary, decisions, tags. tag: Filter by tag substring (e.g. 'agent:ron', 'side_hustle'). surface: Filter by surface ('code', 'cowork', 'chat'). since: Return sessions on or after this date (YYYY-MM-DD). limit: Max sessions to return (default 20). show_stats: If True, include aggregate counts (total, by_surface, by_project).
get_statsReturn a usage dashboard: session counts by surface, project, and tag; storage metrics (DB size, estimated tokens stored); and the 5 most recent sessions. Pro tier also includes ``semantic_index`` with session counts for the LanceDB semantic search index. Provides visibility into your memory usage -- who saved what, how much is stored, and what's been captured most recently. Includes hook_saves_failing status.
consolidate_memoriesRun memory consolidation for a project to build a structured digest. Analyzes recent SESSIONS and extracts decisions, open questions, and tech stack facts. Free tier: up to 3 consolidations per day. Pro: unlimited. Returns a digest dict with status, decisions found, open questions, and the formatted digest_markdown for reference. Acquires an exclusive lock; returns status='lock_held' if another consolidation is already running. Note: This consolidation analyzes SESSIONS ONLY. Structured memory items (decisions, questions, artifacts saved via save_memory_item) are a separate feature -- use query_memory_items to retrieve them. Users often query both digest and memory items together for complete recall. Args: project: Project name (matches the --project tag used when saving sessions) surface: Surface to consolidate ('code', 'cowork', 'chat', etc.) or None for all max_sessions: Maximum number of recent sessions to analyze (default 50) mode: 'heuristic' (free, default). 'llm' requires Pro (v0.6.1). dedup: Semantic dedup pass mode: 'off' (default), 'conservative', or 'balanced'. When 'off' (or unset, or unrecognised), the pass does not run and consolidation behaves exactly as before. 'conservative' collapses near-verbatim restatements (cosine > 0.97); 'balanced' collapses paraphrases (cosine > 0.95). Can also be set via the LORECONVO_CONSOLIDATION_DEDUP environment variable; an explicit argument always overrides the env var.
get_memory_digestRetrieve the current memory digest for a project (built from sessions) without re-running consolidation. Returns None if no digest exists. Use consolidate_memories first to generate one. Optionally set disable=True to suppress auto-load injection for this digest, or disable=False to re-enable injection. Omit disable to just read the current state. Note: This retrieves the SESSION-BASED digest only. Structured memory items (decisions, open questions, artifacts saved via save_memory_item) are separate -- use query_memory_items to retrieve them. Users often query both digest and memory items together for complete recall. Args: project: Project name surface: Surface filter (or None for all) disable: If provided, update the disabled flag on the digest max_tokens: Truncate digest_markdown to this estimated token limit (len // 4). Default 2000. If truncated, appends [TRUNCATED] marker.
set_session_expirySet or clear an expiry date on a session. After expires_at passes, the session is excluded from search_sessions, get_recent_sessions, and the auto-load hook. The session is NOT deleted -- recover it with search_sessions(include_expired=True). Pass expires_at=None to clear a previously set expiry. Args: session_id: ID of the session to update expires_at: ISO 8601 date string (e.g. '2027-01-01T00:00:00Z'), or None to clear
get_dream_logReturn recent consolidation log entries for transparency and diagnostics. Each entry shows: timestamp, project, surface, mode, source_count, trigger. Use this to confirm consolidation ran, check rate limit status, and diagnose fallbacks (e.g. api_key_found=false for LLM-mode fallback). Args: project: Filter by project (or None for all projects) surface: Filter by surface (or None for all) limit: Maximum number of entries to return (default 10, newest first)
get_docs_for_sessionReturn LoreDocs documents cross-linked to a LoreConvo session. Pro tier only. Queries the LoreDocs cross_product_links table. Both LoreConvo and LoreDocs must be installed. Returns an empty list for free-tier callers (not an error). Manual links (link_type='manual') are always sorted first. Auto-links created with a stale embedding model are marked with is_stale=True and include an upgrade_message. Args: session_id -- LoreConvo session UUID limit -- max results (default 5) Returns dict with: schema_version -- int, for version negotiation by callers cross_product_available -- bool tier_gate -- "satisfied" | "pro_required" links -- list of link dicts reason -- set when cross_product_available is False
session_link_docCreate a manual cross-product link from a LoreConvo session to a LoreDocs doc. Manual links are accessible on all tiers. The target doc must not be in a vault with cross_link_opt_out enabled. Both products must be installed. Args: session_id -- LoreConvo session UUID doc_id -- LoreDocs document ID vault_id -- LoreDocs vault containing the document Returns dict with: ok -- bool reason -- failure description on error. Specific since SH-100670: "LoreDocs not installed" | "LoreDocs installed but unreachable: <detail>" | "LoreDocs schema too old: <detail>" | "vault not found" | "vault has cross-linking disabled" | "document not found"
get_server_infoReturn MCP compatibility status for this LoreConvo server. Returns product version, installed mcp SDK version, tested version, and compatibility status. Useful for diagnosing version mismatches on running servers without requiring a restart. Returns dict with: product_name, product_version, install_kind (wheel|editable), version_from_source (if editable), mcp_installed, mcp_tested, mcp_accepted, status (ok|mismatch|undetermined|disabled|internal_error), note, error_detail (set only on internal_error), hook_saves_failing.
get_anti_patternsRetrieve sessions marked as anti-patterns. Delegates to SessionDatabase.get_anti_patterns (SH-102688) so the MCP server, fallback script, and CLI all share one implementation. Returns a list of dicts with a 'truncated' boolean. Use at session start or before attempting a known-tricky approach to surface past failures. Args: topic: Optional keyword to filter within anti-patterns. Omit for all anti-patterns ordered by recency. When provided, uses FTS5 with a fan-out heuristic; result may be truncated if anti-patterns are sparse in the corpus. limit: Max results to return (1-100). Defaults to 10. project: Restrict to a specific project slug. Case-sensitive.
tag_as_anti_patternMark an existing session as an anti-pattern. Idempotent. Args: session_id: The sessions.id value to mark (TEXT <= 255 chars). source: Attribution for this tag (e.g., 'claude-code', 'agent:gina'). reason: Human-readable reason for the tag. Stored in audit log.
untag_anti_patternRemove an anti-pattern tag from a session. Idempotent. The audit log row is written on successful removal; not written if the session was not tagged (idempotent no-op case). Args: session_id: The sessions.id value to untag (TEXT <= 255 chars). source: Attribution for this untag (e.g., 'claude-code', 'admin'). reason: Human-readable reason for the removal. Stored in audit log.
pin_sessionPin or unpin a session to exclude it from automated cleanup. keep_forever=True (default): session excluded from future cleanup; any existing expires_at is cleared atomically. keep_forever=False: pin removed; session can receive expiry again. Returns: {"ok": True, "session_id": "...", "keep_forever": bool} {"ok": False, "code": "invalid_session_id", "message": "..."} {"ok": False, "code": "invalid_param", "message": "..."} {"ok": False, "code": "session_not_found", "message": "..."} {"ok": False, "code": "db_error", "message": "..."} {"ok": False, "code": "feature_disabled", "message": "..."}
save_memory_itemSave a structured memory item: a decision, open question, or artifact. Replaces the old free-text decisions/open_questions/artifacts lists on sessions with queryable, lifecycle-tracked rows. Idempotent when external_id is given: a second save with the same (project, external_id) returns the existing item (created=False) instead of creating a duplicate. Args: item_type: One of 'decision', 'open_question', 'artifact'. title: The decision text, the question text, or the artifact identifier. Capped at 4096 chars. body: Free-text detail/rationale for decision/open_question. Ignored for artifacts -- use artifact_type instead. Capped at 4096 chars. session_id: Originating session, if any. Must reference an existing session. project: Project namespace (default 'unspecified'). tags: Freeform tag list. metadata: Freeform key-value metadata (mainly for artifacts). external_id: Caller-supplied dedup key, unique per (project, external_id). artifact_type: For item_type='artifact', the artifact's type (e.g. 'file', 'url').
query_memory_itemsQuery structured memory items by type, project, status, and recency. Args: item_type: Filter to 'decision', 'open_question', or 'artifact'. project: Filter to a project namespace. status: Filter to a lifecycle status (e.g. 'active', 'open', 'retired'). artifact_type: Filter artifacts by their artifact_type. Only applies with item_type='artifact'. days: Only items created in the last N days. limit: Max rows to return (default 50, max 200).
transition_memory_itemMove a memory item through its lifecycle. Valid transitions: 'retire' (decision -> retired); 'answer' and 'wont-answer' (open_question -> answered / wont-answer). Already-closed items return code='already_closed' so callers can retry idempotently. Args: item_id: The memory item's id. transition: 'retire', 'answer', or 'wont-answer'. reason: Optional free-text reason recorded on close. closing_session_id: Session performing the transition, if any. Must reference an existing session.
update_memory_itemCorrect a memory item's title, body, tags, or metadata, or move it between projects. Moving projects requires allow_project_change=True as an explicit guard against accidental cross-project moves. If the item has an external_id, the move is rejected with code='external_id_conflict' when the destination project already has an item with that external_id. Args: item_id: The memory item's id. title: New title, if changing. body: New body, if changing. Capped at 4096 chars. tags: New tag list, if changing (replaces, not merges). metadata: New metadata dict, if changing (replaces, not merges). new_project: Destination project, if moving. allow_project_change: Must be True to actually move projects.
configure_toolsList or set enabled MCP tool groups. Called with no arguments: lists every group name, its tool count, and whether it is currently enabled. Called with a list of group names: validates and persists the selection to config.json. The change takes effect on server restart -- already- connected clients may continue to see removed tools in their cached schema until they reconnect, and calls to a removed tool after restart return a standard 'unknown tool' protocol error. If the LORECONVO_TOOL_GROUPS environment variable is set, this tool returns an error instead of writing (the env var overrides config).
| rebuild_index_status | Return the current status of a background semantic-index rebuild. Call after rebuild_index() to monitor progress. Returns 'idle' when no rebuild has been started or the last rebuild has finished. Returns: - {'status': 'idle', 'message': '...'} - {'status': 'running', 'phase': '...', 'progress': N, 'total': N, 'progress_pct': N, 'elapsed_s': N.N} - {'status': 'complete', 'message': '...', 'indexed': N, 'total_in_db': N, 'exclusions': {reason: count}, 'elapsed_s': N.N} - {'status': 'error', 'message': '...'} | |
| get_project | Get project details including recent sessions and skill usage stats. Args: project_name: The project identifier | |
| list_projects | List all defined projects with session counts. | |
| create_project | Create or update a project definition. Projects group related sessions and can auto-associate based on skill usage. All changes to project instructions are logged for audit purposes. Args: name: Project identifier (e.g., 'secret-agent-man', 'project-ron') description: What this project is about expected_skills: Skills typically used in this project's sessions default_persona: Auto-tag new sessions with this persona instructions: Optional project-wide instructions or constraints session_id: Optional session ID for audit trail (typically provided by MCP context) | |
| loreconvo_onboard | Set up or update your LoreConvo workspace configuration. Call this once after installing LoreConvo to get a recommended setup. Call again any time to add projects or agents, or to regenerate your reference doc. Creates: - Project registrations for each project listed - A config file at ~/.loreconvo/onboard_config.json - A reference doc (markdown) in the response -- paste it into your CLAUDE.md or a LoreDocs vault so your AI assistant can apply your conventions consistently Args: name: Your workspace or team name (e.g. 'Labyrinth Analytics') projects: Snake_case project identifiers (e.g. ['side_hustle', 'finance']) agents: Agent names that will tag sessions (e.g. ['ron', 'meg']) tag_style: 'simple' (status + priority) or 'detailed' (adds effort, scout-run markers, date tag guidance) Surfaces: code (Claude Code), cowork (Claude.ai Projects), chat (Claude.ai chat), codex (Codex CLI). Custom values are allowed for other tools. Agent identity: use tags=['agent:name'] -- not the surface field. | |
| get_skill_history | Get all sessions that used a specific skill. Useful for understanding how often a skill is used and in what contexts. Args: skill_name: The skill to look up (e.g., 'rental-property-accounting') days_back: How far back to search (default 90 days) | |
| vault_suggest | Get proactive context suggestions based on your session history. Analyzes recent sessions and surfaces: - Sessions with unresolved open questions that need follow-up - Sessions with key decisions worth reviewing before starting new work - Skill gaps: skills expected by a project but not used recently Use at the start of a session to find the most valuable prior context, or when you're unsure what to work on next. When `project` is given and the initial window returns no suggestions but the project still has sessions, the window is expanded progressively (30, 90, 365, then all-time days) so older unresolved work is surfaced instead of returning an empty result. The response metadata reports the effective window (`days_back`), and -- when the window was expanded -- `window_expanded`, `expanded_to_days`, `initial_days_back`, and an `expansion_note`. An empty result with `project` set therefore means the project genuinely has no suggestions (no open questions, no >=2-decision sessions, no skill gaps) at any window, not merely that the default window was too narrow. Args: project: Filter suggestions to this project persona: Filter to sessions tagged with this persona (prefix matching) days_back: How far back to look (default 14 days) limit: Max suggestions to return (default 5) | |
| get_tier | Return the current LoreConvo license tier and status. Use this to confirm whether the Pro license key is loaded and valid. Returns a dict with keys: is_pro -- bool, True if Pro tier is active mode -- "licensed" | "dev_bypass" | "free" | "invalid_key" product -- product name from the license payload (if licensed) exp -- expiry date or "never" (if licensed) email -- customer email (if licensed and present) error -- error message (if mode is "invalid_key") upgrade_url -- Stripe checkout link (present when not already Pro) | |
| vault_set_tier | Activate a tier (free or pro) for LoreConvo. Pro tier removes the free-tier session limit (default: 50 sessions). After purchasing a Pro license, set LORECONVO_PRO=<your-license-key> in your environment and restart the server, then call this tool with tier='pro' to confirm Pro is active. Reverting to tier='free' re-enables limits (existing sessions are preserved -- only new saves are blocked once the limit is hit). | Aktion |
| export_sessions | Export portable session records to JSON or JSONL for migration. Exports matching session fields, skills, tags, and artifacts. Links and independent structured memory items are outside this export. Use output_path to write to a file; omit it to receive the data inline. Use import_sessions to load the exported file. Args: output_path: File path to write export (e.g. '/tmp/loreconvo_export.json'). If omitted, data is returned inline. project: Export only sessions from this project. tags: Export only sessions that have any of these tags. days_back: Limit to sessions from the last N days. Omit for all time. limit: Max sessions to export (default 1000). format: 'json' (array wrapped in metadata) or 'jsonl' (one session per line). | |
| export_for_anthropic | Export LoreConvo sessions to Anthropic managed-agents memory format. Pro only. Produces a JSON file in 'anthropic-memory-v1' format, suitable for import into Anthropic managed-agents memory stores. Only non-periodic, non-file-memory sessions are exported (contamination control). NOTE: Field mapping is preliminary pending Anthropic beta API schema stabilization. Cassandra will signal when the schema is stable. Save the output and validate against Anthropic docs before submitting to a managed-agents memory store. Args: output_path: File path to write the export. If omitted, data is returned inline. project: Export only sessions from this project. session_ids: List of specific session UUIDs to export. Overrides project filter. days_back: Limit to sessions from the last N days. | |
| import_sessions | Import sessions from a LoreConvo export file (JSON or JSONL). Reads an export created by export_sessions and saves sessions into the local database. Session UUIDs are preserved so re-importing is safe. Args: file_path: Path to the export file (JSON or JSONL format). on_conflict: What to do if a session ID already exists. 'skip' (default) -- leave the existing session unchanged. 'replace' -- overwrite with the imported version. dry_run: If True, parse and validate the file but make no DB changes. | |
| inspect_sessions | Inspect stored sessions: list, filter, or get full detail for one session. Answers 'what do you know about me?' and helps users find, browse, and understand their stored session memory. Args: session_id: If provided, return full detail for this specific session. search: Full-text search query across title, summary, decisions, tags. tag: Filter by tag substring (e.g. 'agent:ron', 'side_hustle'). surface: Filter by surface ('code', 'cowork', 'chat'). since: Return sessions on or after this date (YYYY-MM-DD). limit: Max sessions to return (default 20). show_stats: If True, include aggregate counts (total, by_surface, by_project). | |
| 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. Pro tier also includes ``semantic_index`` with session counts for the LanceDB semantic search index. Provides visibility into your memory usage -- who saved what, how much is stored, and what's been captured most recently. Includes hook_saves_failing status. | |
| consolidate_memories | Run memory consolidation for a project to build a structured digest. Analyzes recent SESSIONS and extracts decisions, open questions, and tech stack facts. Free tier: up to 3 consolidations per day. Pro: unlimited. Returns a digest dict with status, decisions found, open questions, and the formatted digest_markdown for reference. Acquires an exclusive lock; returns status='lock_held' if another consolidation is already running. Note: This consolidation analyzes SESSIONS ONLY. Structured memory items (decisions, questions, artifacts saved via save_memory_item) are a separate feature -- use query_memory_items to retrieve them. Users often query both digest and memory items together for complete recall. Args: project: Project name (matches the --project tag used when saving sessions) surface: Surface to consolidate ('code', 'cowork', 'chat', etc.) or None for all max_sessions: Maximum number of recent sessions to analyze (default 50) mode: 'heuristic' (free, default). 'llm' requires Pro (v0.6.1). dedup: Semantic dedup pass mode: 'off' (default), 'conservative', or 'balanced'. When 'off' (or unset, or unrecognised), the pass does not run and consolidation behaves exactly as before. 'conservative' collapses near-verbatim restatements (cosine > 0.97); 'balanced' collapses paraphrases (cosine > 0.95). Can also be set via the LORECONVO_CONSOLIDATION_DEDUP environment variable; an explicit argument always overrides the env var. | |
| get_memory_digest | Retrieve the current memory digest for a project (built from sessions) without re-running consolidation. Returns None if no digest exists. Use consolidate_memories first to generate one. Optionally set disable=True to suppress auto-load injection for this digest, or disable=False to re-enable injection. Omit disable to just read the current state. Note: This retrieves the SESSION-BASED digest only. Structured memory items (decisions, open questions, artifacts saved via save_memory_item) are separate -- use query_memory_items to retrieve them. Users often query both digest and memory items together for complete recall. Args: project: Project name surface: Surface filter (or None for all) disable: If provided, update the disabled flag on the digest max_tokens: Truncate digest_markdown to this estimated token limit (len // 4). Default 2000. If truncated, appends [TRUNCATED] marker. | |
| set_session_expiry | Set or clear an expiry date on a session. After expires_at passes, the session is excluded from search_sessions, get_recent_sessions, and the auto-load hook. The session is NOT deleted -- recover it with search_sessions(include_expired=True). Pass expires_at=None to clear a previously set expiry. Args: session_id: ID of the session to update expires_at: ISO 8601 date string (e.g. '2027-01-01T00:00:00Z'), or None to clear | |
| get_dream_log | Return recent consolidation log entries for transparency and diagnostics. Each entry shows: timestamp, project, surface, mode, source_count, trigger. Use this to confirm consolidation ran, check rate limit status, and diagnose fallbacks (e.g. api_key_found=false for LLM-mode fallback). Args: project: Filter by project (or None for all projects) surface: Filter by surface (or None for all) limit: Maximum number of entries to return (default 10, newest first) | |
| get_docs_for_session | Return LoreDocs documents cross-linked to a LoreConvo session. Pro tier only. Queries the LoreDocs cross_product_links table. Both LoreConvo and LoreDocs must be installed. Returns an empty list for free-tier callers (not an error). Manual links (link_type='manual') are always sorted first. Auto-links created with a stale embedding model are marked with is_stale=True and include an upgrade_message. Args: session_id -- LoreConvo session UUID limit -- max results (default 5) Returns dict with: schema_version -- int, for version negotiation by callers cross_product_available -- bool tier_gate -- "satisfied" | "pro_required" links -- list of link dicts reason -- set when cross_product_available is False | |
| session_link_doc | Create a manual cross-product link from a LoreConvo session to a LoreDocs doc. Manual links are accessible on all tiers. The target doc must not be in a vault with cross_link_opt_out enabled. Both products must be installed. Args: session_id -- LoreConvo session UUID doc_id -- LoreDocs document ID vault_id -- LoreDocs vault containing the document Returns dict with: ok -- bool reason -- failure description on error. Specific since SH-100670: "LoreDocs not installed" | "LoreDocs installed but unreachable: <detail>" | "LoreDocs schema too old: <detail>" | "vault not found" | "vault has cross-linking disabled" | "document not found" | |
| get_server_info | Return MCP compatibility status for this LoreConvo server. Returns product version, installed mcp SDK version, tested version, and compatibility status. Useful for diagnosing version mismatches on running servers without requiring a restart. Returns dict with: product_name, product_version, install_kind (wheel|editable), version_from_source (if editable), mcp_installed, mcp_tested, mcp_accepted, status (ok|mismatch|undetermined|disabled|internal_error), note, error_detail (set only on internal_error), hook_saves_failing. | |
| get_anti_patterns | Retrieve sessions marked as anti-patterns. Delegates to SessionDatabase.get_anti_patterns (SH-102688) so the MCP server, fallback script, and CLI all share one implementation. Returns a list of dicts with a 'truncated' boolean. Use at session start or before attempting a known-tricky approach to surface past failures. Args: topic: Optional keyword to filter within anti-patterns. Omit for all anti-patterns ordered by recency. When provided, uses FTS5 with a fan-out heuristic; result may be truncated if anti-patterns are sparse in the corpus. limit: Max results to return (1-100). Defaults to 10. project: Restrict to a specific project slug. Case-sensitive. | |
| tag_as_anti_pattern | Mark an existing session as an anti-pattern. Idempotent. Args: session_id: The sessions.id value to mark (TEXT <= 255 chars). source: Attribution for this tag (e.g., 'claude-code', 'agent:gina'). reason: Human-readable reason for the tag. Stored in audit log. | |
| untag_anti_pattern | Remove an anti-pattern tag from a session. Idempotent. The audit log row is written on successful removal; not written if the session was not tagged (idempotent no-op case). Args: session_id: The sessions.id value to untag (TEXT <= 255 chars). source: Attribution for this untag (e.g., 'claude-code', 'admin'). reason: Human-readable reason for the removal. Stored in audit log. | |
| pin_session | Pin or unpin a session to exclude it from automated cleanup. keep_forever=True (default): session excluded from future cleanup; any existing expires_at is cleared atomically. keep_forever=False: pin removed; session can receive expiry again. Returns: {"ok": True, "session_id": "...", "keep_forever": bool} {"ok": False, "code": "invalid_session_id", "message": "..."} {"ok": False, "code": "invalid_param", "message": "..."} {"ok": False, "code": "session_not_found", "message": "..."} {"ok": False, "code": "db_error", "message": "..."} {"ok": False, "code": "feature_disabled", "message": "..."} | |
| save_memory_item | Save a structured memory item: a decision, open question, or artifact. Replaces the old free-text decisions/open_questions/artifacts lists on sessions with queryable, lifecycle-tracked rows. Idempotent when external_id is given: a second save with the same (project, external_id) returns the existing item (created=False) instead of creating a duplicate. Args: item_type: One of 'decision', 'open_question', 'artifact'. title: The decision text, the question text, or the artifact identifier. Capped at 4096 chars. body: Free-text detail/rationale for decision/open_question. Ignored for artifacts -- use artifact_type instead. Capped at 4096 chars. session_id: Originating session, if any. Must reference an existing session. project: Project namespace (default 'unspecified'). tags: Freeform tag list. metadata: Freeform key-value metadata (mainly for artifacts). external_id: Caller-supplied dedup key, unique per (project, external_id). artifact_type: For item_type='artifact', the artifact's type (e.g. 'file', 'url'). | |
| query_memory_items | Query structured memory items by type, project, status, and recency. Args: item_type: Filter to 'decision', 'open_question', or 'artifact'. project: Filter to a project namespace. status: Filter to a lifecycle status (e.g. 'active', 'open', 'retired'). artifact_type: Filter artifacts by their artifact_type. Only applies with item_type='artifact'. days: Only items created in the last N days. limit: Max rows to return (default 50, max 200). | |
| transition_memory_item | Move a memory item through its lifecycle. Valid transitions: 'retire' (decision -> retired); 'answer' and 'wont-answer' (open_question -> answered / wont-answer). Already-closed items return code='already_closed' so callers can retry idempotently. Args: item_id: The memory item's id. transition: 'retire', 'answer', or 'wont-answer'. reason: Optional free-text reason recorded on close. closing_session_id: Session performing the transition, if any. Must reference an existing session. | |
| update_memory_item | Correct a memory item's title, body, tags, or metadata, or move it between projects. Moving projects requires allow_project_change=True as an explicit guard against accidental cross-project moves. If the item has an external_id, the move is rejected with code='external_id_conflict' when the destination project already has an item with that external_id. Args: item_id: The memory item's id. title: New title, if changing. body: New body, if changing. Capped at 4096 chars. tags: New tag list, if changing (replaces, not merges). metadata: New metadata dict, if changing (replaces, not merges). new_project: Destination project, if moving. allow_project_change: Must be True to actually move projects. | |
| configure_tools | List or set enabled MCP tool groups. Called with no arguments: lists every group name, its tool count, and whether it is currently enabled. Called with a list of group names: validates and persists the selection to config.json. The change takes effect on server restart -- already- connected clients may continue to see removed tools in their cached schema until they reconnect, and calls to a removed tool after restart return a standard 'unknown tool' protocol error. If the LORECONVO_TOOL_GROUPS environment variable is set, this tool returns an error instead of writing (the env var overrides config). |
Konfiguration
LORECONVO_PROSecretPro license key. Leave unset for the free tier.
| Name | Beschreibung | Typ |
|---|---|---|
| LORECONVO_PRO | Pro license key. Leave unset for the free tier. | Secret |
Automatisierte Checks
Geluften am 12. Nov. 2026Vollständiger Bericht →Unsere automatisierten Checks bestanden. Das ist kein Security-Audit: Lies den Code und gib dem Server nur den minimal notwendigen Zugriff. Wie die Checks funktionieren · Was du für mehr Punkte verbessern kannst
- Source Repository verknüpft und erreichbarBestanden
- Open Source Lizenz (OSI)No licenseBefund
- Commit oder Release im letzten JahrBestanden
- Package-Name ähnelt keinem populären PackageBestanden
- Remote Endpoint nutzt HTTPSNicht geprüft
- Destruktive Tools sind markiertBestanden
- Keine versteckten Anweisungen an das ModellBestanden
- Keine kritischen Advisories im Paket oder seinen AbhängigkeitenBestanden
README
Auf GitHub ansehenLoreConvo v0.11.0
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 --from loreconvo[server] 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 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.
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).
| Variant | Recall@5 | MRR |
|---|---|---|
| FTS5 + compound token expansion (default) | 88.9% | 0.875 |
| FTS5 baseline (no expansion) | 72.2% | 0.708 |
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.
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 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.
Cowork (Desktop App)
- Click the + button next to the prompt box
- Select Plugins
- Select Add plugin
- Browse to the
loreconvosource folder
Important: 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.
Claude Chat (Web)
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"
How It Works Across Surfaces
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:
- When a session ends,
auto_save.pycaptures the conversation and saves a structured summary (decisions, artifacts, open questions, tags) to the local SQLite database. - When a new session starts,
auto_load.pyqueries 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.
Your Data is Always Available
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.
Project Workspaces
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.
MEMORY.md Auto-Indexing
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).
Verify Installation
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.
Recommended CLAUDE.md Setup
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.
Plans: Free vs Pro
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.
| Free | Pro ($8/mo) | |
|---|---|---|
| Saved sessions | 50 | Unlimited |
| Full-text search (FTS5) | Yes | Yes |
| MEMORY.md auto-indexing | Yes | Yes |
| Project tagging, session linking, skill history | Yes | Yes |
| Auto-load / auto-save hooks | Yes | Yes |
| Local-first, no cloud, zero API costs | Yes | Yes |
| Related-session discovery | Keyword co-occurrence | Embedding-based (BGE-small-en-v1.5) |
| LLM async session summarization | -- | Yes (Claude Haiku, opt-in) |
Hybrid retrieval: vector + BM25 + recency reranking (rebuild_index) |
-- | Yes (Pro) |
Cross-product document linking (get_docs_for_session, session_link_doc) |
-- | Yes (also requires LoreDocs Pro) |
| Team memory -- export/merge sessions across machines | -- | Yes |
Anthropic managed-agent export (export_for_anthropic) |
-- | Yes |
Check your current tier and usage with get_tier. Activate a Pro license with
vault_set_tier.
Features
- Automatic session capture: Sessions save at session end and load at session start via Claude Code hooks -- no manual
save_sessioncall required - Cross-client memory: Your context follows you across Claude Code, Cowork, Cursor, Codex, and Hermes -- not locked to one IDE or machine
- Structured sessions: Captures decisions, artifacts, open questions -- not just raw text; optional reasoning_notes field stores agent reasoning chains
- Project organization: Group sessions by project with expected skill sets
- Skill tracking: Record which skills were used for smart filtering
- Persona tagging: Hierarchical personas for agent-specific memory (e.g.,
ron-bot:sql) - Full-text search: SQLite FTS5 for fast keyword search across all sessions
- MEMORY.md auto-indexing: Your project MEMORY.md is automatically indexed at session start and is searchable alongside regular sessions via
search_sessions - LLM async session summarization (Pro): Auto-saved sessions are upgraded to LLM-quality summaries in the background using Claude Haiku. Opt in by setting
LORECONVO_ANTHROPIC_API_KEY. A daily cap (LORECONVO_SUMMARIZER_DAILY_CAP, default 100) prevents runaway API spend. Pro tier only. - Embedding-based related session discovery (Pro):
get_related_sessionsautomatically 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. SetLORECONVO_EMBEDDING_LINKS=0to disable embedding links. - Cross-product document linking (Pro): Automatically discovers and links the LoreDocs documents most relevant to any session, and vice versa. Uses two new tools:
get_docs_for_sessionandsession_link_doc. Requires both LoreConvo Pro and LoreDocs Pro. - Configurable tool groups: Choose which groups of tools your assistant sees (
core,memory,graph,agents,admin) with theconfigure_toolstool orLORECONVO_TOOL_GROUPS. All groups are on by default. See Tool Groups. - Local-first: SQLite database, no cloud dependency, zero API costs
Tiers
Free - 50 sessions
- Full feature set: auto-load, full-text search, tagging, session linking, export and import
- Local SQLite storage -- your data, your machine, no cloud account required
- One-click install via the Anthropic Marketplace
Pro - $8/month
- Unlimited sessions
- Team memory: share sessions with teammates (local-first async export/import, no server required)
- Related session discovery and semantic search
- Anthropic managed-agents export
- LLM-quality session summarization in the background (async)
After checkout, your license key is emailed automatically to the address you used at checkout, usually within a few minutes. Questions: info@labyrinthanalyticsconsulting.com.
MCP Tools
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.
| Tool | What it does |
|---|---|
save_session |
Save a session summary with decisions, artifacts, and tags |
get_recent_sessions |
List recent sessions, optionally filtered by surface |
get_session |
Retrieve a specific session by ID |
search_sessions |
Full-text search across all saved sessions |
get_context_for |
Pull relevant context for a topic (best for "recall" use) |
tag_session |
Add a persona tag to a session |
link_sessions |
Connect related sessions with a relationship type |
get_related_sessions |
Find sessions related to a given session |
create_project |
Create a named project with expected skills |
get_project |
Get project details and associated sessions |
list_projects |
List all projects |
get_skill_history |
See which sessions used a specific skill |
vault_suggest |
Proactive suggestions for relevant context to load |
get_tier |
Check current tier and license key status |
vault_set_tier |
Set the active tier (free or pro) |
export_sessions |
Export sessions to a portable JSON format |
import_sessions |
Import sessions from a previously exported JSON file |
consolidate_memories |
Merge related sessions into persistent memory entries (Recall) |
get_memory_digest |
Inject a condensed memory digest into the current session (Recall) |
set_session_expiry |
Mark a session to expire and be pruned after a given date |
get_stats |
Show usage statistics (session count, surface breakdown) |
inspect_sessions |
Inspect session internals for debugging |
export_for_anthropic |
Export sessions in Anthropic managed-agent format (Pro) |
rebuild_index |
Rebuild the LanceDB semantic search index (Pro) |
rebuild_index_status |
Poll the status of an in-progress rebuild_index operation (Pro) |
loreconvo_onboard |
First-time setup wizard |
get_dream_log |
View the consolidation activity log |
get_docs_for_session |
Retrieve LoreDocs documents linked to a specific session (Pro -- requires LoreDocs Pro) |
session_link_doc |
Manually create a link between a session and a LoreDocs document (Pro -- requires LoreDocs Pro) |
pin_session |
Pin or unpin a session to exclude it from automated cleanup |
get_anti_patterns |
List sessions tagged as anti-patterns (approaches to avoid) |
tag_as_anti_pattern |
Tag a session as an anti-pattern so future recalls flag it |
untag_anti_pattern |
Remove an anti-pattern tag from a session |
save_memory_item |
Save a structured memory item: a decision, open question, or artifact |
query_memory_items |
Query structured memory items by type, project, status, and recency |
transition_memory_item |
Move a memory item through its lifecycle (retire, answer, wont-answer) |
update_memory_item |
Correct a memory item's title, body, tags, or metadata, or move it between projects |
configure_agent_context |
Store or update a named topic config so an agent auto-loads targeted context at session start |
inject_agent_context |
Return targeted session context for an agent, using stored or call-time topics |
graph_session_map |
Export a Mermaid knowledge graph of sessions and their links |
Requirements
- Python 3.11-3.14
- macOS or Linux
mcpandclick(auto-installed byinstall.sh)
Data and Privacy
LoreConvo is local-first. All data lives in ~/.loreconvo/sessions.db on your machine.
- Data collected: Session titles, summaries, tags, surface identifiers, project names, and skill names you provide when saving. No telemetry, usage analytics, or identifiers are collected automatically.
- Storage: SQLite database at
~/.loreconvo/sessions.db. No cloud storage. Override the path with theLORECONVO_DBenvironment variable. - Third-party sharing: None by default. Data leaves your machine only if you enable optional AI summarization by setting
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), andsave_session(summarize=True)) uses only this key; the genericANTHROPIC_API_KEYis never read. Leave it unset and everything stays local. - Retention: Data is retained until you delete it via
delete_sessionor remove the database file manually. No automatic expiry. - Contact: info@labyrinthanalyticsconsulting.com
Full privacy policy: https://labyrinthanalyticsconsulting.com/privacy
Troubleshooting
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.
Fallback Script (Direct DB Access)
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.
What's New
v0.11.0 (2026-11-06)
Added
- Secrets (AWS keys; API keys, passwords and tokens of 16 or more
characters written as
name=valueorname: value; bearer tokens; JWTs; PEM private keys) are now automatically redacted before anything is saved, before a summary is sent to Claude for summarization, and before results are returned -- across saved sessions and memory items. A new maintenance command,loreconvo-scan-secrets, can scan and clean up anything saved before this update (dry-run by default). Pro users should runrebuild_indexafterwards so the semantic search index is cleaned too. If it finds a match, rotate that credential -- redacting it here does not invalidate it elsewhere.
Fixed
- Deleted and expired sessions no longer linger in Pro semantic search
results. If you used semantic search before this update, run
rebuild_indexonce to clear out any old entries. - Agent context now stays within the requested project. Consolidation status is available when viewing a project without selecting a surface.
- The Python fallback now matches recent-session filtering and search ranking. Expiry changes require an explicit timestamp or a request to clear it.
See the full changelog for the complete release history.
LoreConvo MCP Fragen
Wie füge ich LoreConvo MCP zu Claude Code hinzu?
Führe claude mcp add --env 'LORECONVO_PRO=<YOUR_LORECONVO_PRO>' loreconvo -- uvx --from 'loreconvo[server]' loreconvo in deinem Terminal aus. Füge --scope user hinzu, damit der Server in jedem Projekt verfügbar ist.
Wie füge ich LoreConvo MCP zu Cursor hinzu?
Öffne ~/.cursor/mcp.json und füge den Server unter mcpServers hinzu, mit der Cursor-Config aus dem Installationsabschnitt oben.
Welche Tools bietet LoreConvo MCP?
Er stellt 42 Tools bereit, darunter save_session, get_recent_sessions, get_session, search_sessions, get_context_for.
Wo werden meine Daten gespeichert?
Deine Daten werden lokal in einer SQLite-Datenbank auf deinem eigenen Rechner unter ~/.loreconvo/sessions.db gespeichert.
Funktioniert LoreConvo mit Cursor und Claude Code?
Ja, es funktioniert mit mehreren Clients, darunter Claude Code, Cowork, Cursor, Codex und Hermes Agent.
Kann ich es mit der Claude Web-Oberfläche nutzen?
Da die Web-Oberfläche keine Plugins direkt unterstützt, kannst du ein bereitgestelltes Script nutzen, um deine Session in die Zwischenablage zu exportieren und in den Chat einzufügen.
Welche Art von Memory wird erfasst?
Es werden episodische Memory (Summaries, Artifacts und offene Fragen) sowie semantische Memory (stabile Projektergebnisse) erfasst.