Lore

lore-knowledge-mcp · Operational knowledge layer for engineering teams and their AI agents.

The Problem

Your agents start every session knowing nothing about your systems. Every runbook you've written. Every gotcha you've hit. Every incident you've debugged. None of it carries forward.

You re-explain. They re-discover. Context vanishes when the session ends.

Lore fixes that.

Without Lore                     With Lore
─────────────────────────────    ──────────────────────────────────
Agent starts fresh every time    Agent queries Lore on startup
"How does our infra work?"       Gets: topology, gotchas, runbooks,
You re-explain everything        past incidents, verified decisions
Context lost at session end      Knowledge persists across all sessions

How It's Different

Lore is not a second brain. It's the operational intelligence your agents need to work in your environment — not just any environment.

What Lore Does

Knowledge Base

Your team's operational knowledge — always queryable by any agent. Capture the things that matter: runbooks, hard-won gotchas, architecture decisions, deployment state. Every entry carries attribution so agents know who wrote it and whether a human has verified it.

Investigations

When something breaks, open a structured investigation. Document the symptom, test hypotheses, record what you tried and what you found. Six months later when the same issue resurfaces — different engineer, different agent — the trail is there.

Journal

A permanent record of milestones, architecture decisions, and buying decisions. The kind of thing that lives in someone's head until they leave the team.

Built for Multi-Agent Systems

In a multi-agent environment, provenance matters. Every Lore entry carries author, source_type, and verified.

kb_search("proxmox lxc dns")

  [1] "LXC inherits host resolv.conf — Tailscale breaks containers"
      david · human · ✓ verified

  [2] "LXC DNS fix after Tailscale install"
      engineer-agent · agent · unreviewed

  [3] "LXC DNS configuration reference"
      research-agent · agent · ✗ disputed

Your agents know: result 1 is production-safe. Result 2, spot-check before acting. Result 3, review first.

Semantic Search (v0.6.0+)

Lore finds entries by meaning, not just keywords. Search "DNS broken in containers" and it returns an entry titled "LXC containers inherit resolv.conf from the host" — no keyword overlap required.

Powered by local sentence-transformers embeddings (no API key, no external calls), combined with FTS5 lexical search and Reciprocal Rank Fusion. The same model used by mcp-memory-service, fully self-hosted.

Enable it

Heads up: Semantic search is feature-complete and shipping in a future release. The v0.6.0 release that included it was yanked from PyPI on 2026-05-24 while we set up a proper staging and end-to-end testing pipeline. You can run it from source today by cloning the repo and running pip install -e ".[semantic]".

# Once a stable release is published:
pip install lore-knowledge-mcp[semantic]
LORE_SEMANTIC_SEARCH=true lore-mcp

What you get

Backfill existing KB

If you already have entries, generate embeddings for them:

kb_backfill_embeddings()    # idempotent, safe to re-run
kb_embedding_status()       # check coverage

Configuration

For multilingual content, set LORE_EMBEDDING_MODEL=paraphrase-multilingual-MiniLM-L12-v2 (same 384d, no schema change).

Automating Lore in Your Workflow

Add one line to every agent's system prompt and one entry to ~/.mcp.json — that's the entire integration. Each phase of your engineering workflow reads prior knowledge from Lore and writes its findings back, so nothing is re-discovered from scratch.

→ How to wire Lore into a 6-phase multi-agent pipeline — full walkthrough with code examples for every phase: research, architecture review, implementation, adversarial code review, QA, and documentation.

Quick Start

No database setup required. Lore runs out of the box with SQLite.

1. Install

pip install lore-knowledge-mcp

Optional: semantic search

Note: The v0.6.0 PyPI release was yanked — see Semantic Search for current install status.

pip install lore-knowledge-mcp[semantic]

Then set LORE_SEMANTIC_SEARCH=true. See Semantic Search for details.

2. Start the server

# Stdio mode (for local MCP clients like Claude Code)
lore-mcp

# HTTP mode (for remote or multi-agent access)
lore-mcp --host 0.0.0.0 --port 8000

# HTTP mode WITH authentication (recommended for teams / LAN exposure)
LORE_API_KEY="$(openssl rand -hex 32)" lore-mcp --host 0.0.0.0 --port 8000

Authentication (LORE_API_KEY)

HTTP auth is opt-in and off by default:

• LORE_API_KEY unset → the HTTP server is open (no auth), exactly as before. This keeps existing no-auth deployments working. When you bind to a non-localhost host (0.0.0.0 or a LAN IP) without a key, Lore logs a prominent startup WARNING that the server is reachable on your network with no authentication.
• LORE_API_KEY set → every HTTP/SSE request must include Authorization: Bearer <key>. Missing or wrong tokens get 401 {"error":"unauthorized"} (token compared in constant time). Health endpoints (/health, /healthz, /) stay open so liveness probes keep working. stdio mode is never affected — it has no network surface.

The same rule applies to the HTTP entry point (lore-mcp --host/--port, which invokes the FastMCP server).

CORS: origins default to * with credentials disabled (the spec forbids * + credentials). Set LORE_CORS_ORIGINS to a comma-separated allow-list (e.g. https://app.example.com,https://admin.example.com) to restrict origins; credentialed CORS is enabled automatically when origins are explicit.

3. Add to your MCP client

Claude Code / Claude Desktop — add to ~/.mcp.json:

{
  "mcpServers": {
    "lore": {
      "type": "stdio",
      "command": "lore-mcp"
    }
  }
}

Or for HTTP mode (recommended for teams). When the server is started with LORE_API_KEY set, include a matching bearer token in the client config:

{
  "mcpServers": {
    "lore": {
      "type": "http",
      "url": "http://localhost:8000/mcp",
      "headers": {
        "Authorization": "Bearer <your LORE_API_KEY>"
      }
    }
  }
}

If the server is started without LORE_API_KEY, omit the headers block — the endpoint is open.

That’s it. Lore is ready.

Tool Reference

Knowledge Base

Investigations

Journal

Document Ingestion

MCP Index

Search

Backends

SQLite is the default. No configuration needed — just install and run. The SQLite database and any local-file search corpus live under KNOWLEDGE_DATA_DIR, which defaults to ./knowledge-data (a portable, relative path — set it to an absolute path for a stable on-disk location).

PostgreSQL is for teams who want a shared knowledge layer accessible from multiple machines or agents simultaneously. DB_BACKEND=postgres (and the postgresql alias) select the bundled local PostgreSQL client — the same path as DB_BACKEND=local. Connection defaults are generic (DB_NAME=lore, DB_USER=lore_user); override them with the connection variables below.

# PostgreSQL setup
export DB_BACKEND=postgres          # "postgresql" and "local" also work
export DB_HOST=your-db-host
export DB_PORT=5432
export DB_NAME=lore                 # default: lore
export DB_USER=your-user            # default: lore_user
export DB_PASSWORD=your-password
lore-mcp

Configuration reference

The deployment-specific search roots (LATVIAN_LEARNING_ROOT, LATVIAN_XTTS_ROOT, INGEST_ROOT) are unset by default. When a root is not configured, the dependent search tool returns an empty, clearly-labelled "not configured" result instead of scanning a nonexistent path — so a fresh install works out of the box.

Hermes Memory Provider

A Hermes agent memory provider plugin that backs conversation memory with Lore is available as a separate package:

hermes-lore-plugin — drop-in memory provider for the Hermes agent. Stores KB entries in Lore, prefetches relevant context on session start, and deduplicates before storing.

License

MIT — see LICENSE