Skip to main content
Glama

Lore DB

A local, vector-based knowledge base with semantic search, a web UI, and an MCP server for use with Claude and other AI tools.

  • Python backend — FastAPI REST API, sentence-transformer embeddings, SQLite storage

  • React frontend — document management, semantic search, analytics dashboard

  • MCP server — eight tools (get, search, create, update, delete, verify, stale, reindex) over HTTP or stdio

  • Multi-namespace — isolate knowledge bases per project using the X-KB-Namespace header or KB_NAMESPACE env var

  • Analytics — tracks MCP tool usage (searches, views, creates) in a separate SQLite database

Architecture

proxy (nginx :8765)
  ├── /api/         → backend (FastAPI :8000)
  ├── /mcp/         → mcp    (FastMCP :8000, streamable-http)
  └── /             → frontend (nginx :80, React SPA)

Module

Description

backend/app/vector_store.py

SQLite document store + all-MiniLM-L6-v2 semantic embeddings

backend/app/api.py

FastAPI CRUD, search, reindex, analytics, namespace endpoints

backend/app/mcp_server.py

MCP tools (stdio, SSE, streamable-http transports)

backend/app/service.py

Per-namespace KB instances with LRU caching

backend/app/analytics.py

MCP event logging in a global analytics.db

frontend/

Vite + React + TypeScript, TanStack Router, Tailwind

Related MCP server: ragi

Quick Start

Production

npm run start

Runs docker compose up --build -d. The app is available at http://localhost:8765.

npm run stop      # docker compose down
npm run restart   # down + up --build -d

Development (hot reload)

npm run dev

Runs docker compose -f docker-compose.dev.yml up --build. The app is available at http://localhost:8766.

  • Backend restarts on Python file changes (--reload)

  • Frontend uses the Vite dev server with full HMR

  • Uses a separate database at .localdata/backend-dev/ so dev never touches prod data

Persistent Storage

SQLite databases are stored on the host and are gitignored:

Path

Contents

.localdata/backend/knowledge_base*.db

Document store (one file per namespace)

.localdata/backend/analytics.db

MCP event log

MCP Configuration

The MCP server is exposed at http://localhost:8765/mcp/ using the streamable-http transport.

Add a .mcp.json in the directory where you start Claude:

{
  "mcpServers": {
    "knowledge-base": {
      "type": "http",
      "url": "http://localhost:8765/mcp/",
      "headers": {
        "X-KB-Namespace": "my-project"
      }
    }
  }
}

Set X-KB-Namespace to any alphanumeric slug. Each unique namespace gets its own isolated database.

Available MCP Tools

Tool

Description

get_document(document_id)

Fetch full document content

search_documents(query, limit)

Semantic + lexical search with freshness decay

create_document(title, content)

Add a new document

update_document(document_id, ...)

Update title and/or content

delete_document(document_id)

Remove a document

verify_document(document_id)

Confirm a document is still accurate (bumps freshness timestamp)

get_stale_documents(days_threshold)

Find documents that may be outdated

reindex_documents

Re-embed all documents (run after first deploy or model changes)

Stdio fallback

For direct CLI invocation without the HTTP server:

{
  "mcpServers": {
    "knowledge-base": {
      "type": "stdio",
      "command": "docker",
      "args": [
        "compose",
        "exec",
        "-T",
        "-e",
        "KB_NAMESPACE=my-project",
        "backend",
        "python",
        "-m",
        "app.mcp_server"
      ]
    }
  }
}

Reindexing

Run reindex_documents() via MCP tool, the Settings page, or curl after:

  • First deploy switching from the old hash embedder to all-MiniLM-L6-v2

  • Upgrading to a different embedding model

curl -X POST http://localhost:8765/api/reindex -H "X-Kb-Namespace: my-project"

Normal create and update operations always auto-embed — no manual reindex needed.

Running Tests

cd backend
python -m pytest tests/ -v

Related MCP Connectors

Related MCP Servers

  • F
    license
    A
    quality
    Not graded
    maintenance
    A local-first knowledge base server that enables AI clients to store, retrieve, and manage documents using semantic search. Provides privacy-focused, offline-capable memory for AI assistants with tools for ingesting, querying, updating, and deleting knowledge.
    7
    10 npm
    -
  • A
    license
    A
    quality
    D
    maintenance
    Local-first RAG indexing and semantic search MCP server. Enables document retrieval and context-aware queries using local embedding models.
    3
    6 npm
    MIT
  • F
    license
    A
    quality
    D
    maintenance
    Enables indexing local documents (PDF, Markdown, text, code) into a knowledge base and querying them via semantic search using local embeddings, all running privately on your machine.
    4
    -
  • A
    license
    Not graded
    quality
    D
    maintenance
    Provides local semantic search over files using embeddings, enabling directory indexing and natural language queries without external services.
    MIT