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
A
license - permissive license
-
quality - not tested
D
maintenance

Maintenance

Maintainers
Response time
Release cycle
Releases (12mo)
Commit activity

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Servers

  • F
    license
    A
    quality
    -
    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
    13
  • A
    license
    A
    quality
    B
    maintenance
    Local-first RAG indexing and semantic search MCP server. Enables document retrieval and context-aware queries using local embedding models.
    3
    9
    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
    -
    quality
    A
    maintenance
    Read-only local-first MCP server enabling AI assistants to semantically search private Markdown, PDF, and Tika-backed knowledge bases without data upload.
    45
    MIT

View all related MCP servers

Related MCP Connectors

  • Remote ChromaDB vector database MCP server with streamable HTTP transport

  • Serve a folder of Markdown notes as an MCP server: hybrid search, reading, and sourced answers.

  • Persistent memory for AI agents. Search, store, and recall across sessions.

View all MCP Connectors

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/andreehultgren/lore-db'

If you have feedback or need assistance with the MCP directory API, please join our Discord server