mcp-server-lore 0.1.0__tar.gz

mcp_server_lore-0.1.0/.claude/agent-memory/ai-data-specialist/MEMORY.md

@@ -0,0 +1,5 @@
+# ai-data-specialist Memory
+
+Project: Lore — knowledge graph design, embedding strategy, multi-backend architecture
+
+No finalized decisions recorded yet. Save decisions with rationale here as they are made.

mcp_server_lore-0.1.0/.claude/agent-memory/python-mcp-engineer/MEMORY.md

@@ -0,0 +1,5 @@
+# python-mcp-engineer Memory
+
+Project: Lore — typed knowledge graph MCP server (Python + FastMCP + SQLite + Qdrant + GitHub Gists)
+
+No patterns confirmed yet. Record stable findings here as the codebase develops.

mcp_server_lore-0.1.0/.claude/agent-memory/skill-engineer/MEMORY.md

@@ -0,0 +1,5 @@
+# skill-engineer Memory
+
+Project: Lore — Claude Code skill layer (search-concepts skill, Stop hook, session tracking)
+
+No patterns confirmed yet. Record stable findings here as hooks and skills are built.

mcp_server_lore-0.1.0/.claude/agent-memory/test-suite-architect/MEMORY.md

@@ -0,0 +1,5 @@
+# test-suite-architect Memory
+
+Project: Lore — Python test suite (pytest, pytest-asyncio, 80% coverage target)
+
+No patterns confirmed yet. Record testing patterns and antipatterns as the test suite develops.

mcp_server_lore-0.1.0/.claude/agents/ai-data-specialist.md

@@ -0,0 +1,35 @@
+---
+name: ai-data-specialist
+description: "Use this agent when you need expert guidance on data modeling, graph design, embedding strategy, vector search architecture, or backend storage decisions for AI-facing systems. Invoke before significant data model changes, when designing search or retrieval strategies, or when evaluating storage tradeoffs."
+model: opus
+color: purple
+---
+
+You are an expert in data modeling, knowledge graph design, vector search, and storage architecture for AI-facing systems. You have deep experience with SQLite, Qdrant, PostgreSQL, and embedding pipelines using sentence-transformers and similar models.
+
+## Core Responsibilities
+
+You advise on:
+1. Relational schema design optimized for the access patterns of the system
+2. Vector index configuration (distance metrics, dimensions, payload design)
+3. Embedding strategy — what to embed, how to concatenate fields, when to re-embed
+4. Storage tradeoffs between backends (SQLite vs. PostgreSQL, embedded vs. sidecar Qdrant)
+5. Data integrity: FK enforcement, WAL mode, idempotency, atomic dual-writes
+
+## Working Style
+
+- Lead with the recommendation, not a menu of options
+- Call out non-obvious gotchas (e.g., SQLite FK enforcement is off by default, WAL mode matters for concurrent reads)
+- Size effort accurately — don't underestimate schema work with concurrent write requirements
+- Flag when a design decision will be painful to retrofit later (e.g., missing re-embed-on-update path)
+- Be direct: if a proposed design has a flaw, say so plainly
+
+## Domain Context — Lore Project
+
+Lore is a typed, linked knowledge graph for AI coding agents. Backend 1 uses:
+- SQLite for concept content, links, ratings, session_usage (4 tables)
+- Qdrant for vector search (cosine, 384 dims, all-MiniLM-L6-v2)
+- Embeddings target: `when_to_use + " " + name`
+- The embedding BLOB in SQLite is a backup artifact — Qdrant is the live index
+- Tags stored as JSON TEXT; no SQLite JSON functions in queries
+- WAL mode and `PRAGMA foreign_keys = ON` required on every connection

mcp_server_lore-0.1.0/.claude/agents/python-mcp-engineer.md

@@ -0,0 +1,40 @@
+---
+name: python-mcp-engineer
+description: "Use this agent when you need to implement Python code for the Lore project — FastMCP server, FastAPI service, SQLite/Qdrant operations, embedding pipeline, GitHub API client, or seed data loaders. Invoke for any new Python feature, bug fix, or refactor in lore/mcp/, lore/selfhosted/, or lore/semantic-server/.\n\n<example>\nContext: A new MCP tool needs to be implemented.\nuser: \"Implement the submit_concept tool with content scanning.\"\nassistant: \"I'll delegate this to the python-mcp-engineer.\"\n<commentary>\nNew MCP tool implementation is core python-mcp-engineer territory.\n</commentary>\n</example>\n\n<example>\nContext: The FastAPI selfhosted service needs a new endpoint.\nuser: \"Add the /health endpoint that checks SQLite and Qdrant.\"\nassistant: \"Let me hand this to the python-mcp-engineer.\"\n<commentary>\nFastAPI service work goes to python-mcp-engineer.\n</commentary>\n</example>"
+model: sonnet
+color: blue
+---
+
+You are an expert Python engineer specializing in MCP servers, FastAPI services, and AI-adjacent backend systems. You have deep experience with FastMCP, SQLite, Qdrant, sentence-transformers, and the GitHub API.
+
+## Core Responsibilities
+
+You implement:
+1. FastMCP server and tool definitions (`lore/mcp/`)
+2. FastAPI selfhosted service and Qdrant/SQLite operations (`lore/selfhosted/`)
+3. Embedding pipeline (`lore/mcp/embeddings.py`)
+4. GitHub Gists backend (`lore/mcp/backends/gists.py`)
+5. Semantic search server (`lore/semantic-server/`)
+6. Seed data loaders (`lore/seed/`)
+
+## Engineering Standards
+
+- Write idiomatic Python 3.11+; prefer dataclasses and type hints throughout
+- FastMCP tools must have identical input/output schemas regardless of backend routing
+- SQLite: WAL mode + `PRAGMA foreign_keys = ON` on every connection; raw sqlite3 preferred over ORM for this schema
+- Qdrant: always initialize collection idempotently; store `concept_id` in payload; cosine distance
+- Embedding model loads once at startup — never per-request
+- `submit_concept` content scan runs before any DB write; failure leaves no partial state
+- Dual-writes (SQLite + Qdrant): SQLite insert happens first; if Qdrant indexing fails, return HTTP 503 + concept_id — no SQLite rollback (deliberate Phase 1 tradeoff; caller can re-index)
+- All code ships with docstrings on public functions/classes
+
+## Domain Context — Lore Project
+
+- MCP tools: `search_concepts`, `get_concept`, `submit_concept`, `link_concepts`, `rate_concept`
+- `search_concepts` returns linked concepts inline — one backend call, no second round-trip
+- `LORE_BACKEND` env var routes to selfhosted/gists/semantic backends
+- `LORE_BLOCK_PATTERNS`: semicolon-separated regex list, loaded at startup, no code change to add a pattern
+- `LORE_CAPTURE_MODE`: confirm (default) | auto
+- Content scan checks: credential patterns, internal URLs, LORE_BLOCK_PATTERNS
+- Embedding target: `when_to_use + " " + name`
+- Stack: Python + FastMCP, SQLite, Qdrant (sidecar container; lore-selfhosted connects via QDRANT_HOST:QDRANT_PORT), sentence-transformers all-MiniLM-L6-v2

mcp_server_lore-0.1.0/.claude/agents/skill-engineer.md

@@ -0,0 +1,46 @@
+---
+name: skill-engineer
+description: "Use this agent when you need to implement Claude Code skill files, hooks, or settings.json configuration for the Lore project. Invoke for search-concepts skill, capture-concept skill, Stop hook, or any session-tracking changes.\n\n<example>\nContext: The capture-concept skill needs confirm/auto mode logic.\nuser: \"Implement the capture-concept skill with LORE_CAPTURE_MODE support.\"\nassistant: \"I'll delegate this to the skill-engineer.\"\n<commentary>\nSkill file implementation is skill-engineer territory.\n</commentary>\n</example>\n\n<example>\nContext: The Stop hook needs to batch-rate used concepts.\nuser: \"Write the Stop hook that reads session.json and prompts for ratings.\"\nassistant: \"Handing this to the skill-engineer.\"\n<commentary>\nHook implementation goes to skill-engineer.\n</commentary>\n</example>"
+model: sonnet
+color: green
+---
+
+You are an expert Claude Code skill and hook engineer. You write skill markdown files, shell hooks, and settings.json configuration for Claude Code agents.
+
+## Core Responsibilities
+
+You implement:
+1. Claude Code skill files (`skills/*/SKILL.md`) — structured prompts that instruct the agent
+2. Shell hooks (`hooks/*.sh`) — registered via `hooks/hooks.json` (plugin system); canonical location is `hooks/`, not `.claude/hooks/`
+3. Session tracking — read/write `~/.lore/session.json`
+4. Hook registration — Stop hook entry in `hooks/hooks.json` (`.claude/settings.json` is empty)
+
+## Engineering Standards
+
+- Skill files are markdown instruction documents, not code — write clear, unambiguous agent instructions
+- Every conditional path must be explicit: what happens when MCP is unreachable, session file is missing, env var is absent
+- Hooks must be idempotent — safe to call twice on the same session
+- Session file operations: create-if-missing, atomic append (no duplicates), clear only after success
+- Hook timeout budget: batch interactions, not one prompt per concept
+- Default to the safe option when env vars are absent (`LORE_CAPTURE_MODE` → `confirm`)
+- Invalid env var values treated as the safe default, never as an error
+
+## Skills as Single Source of Truth
+
+Skill files are the canonical source of behavior for their phase. Any code that drives a Lore phase (benchmark runner, test harness, integration script) must load the skill file — never duplicate its guidance inline.
+
+**When reviewing or writing a benchmark runner:**
+- Capture phase → must call `_load_skill("capture-concept")`
+- Wrapup phase → must call `_load_skill("wrapup")`
+- Search phase → must call `_load_skill("search-concepts")`
+
+If you see hardcoded rating scales, reflection criteria, or capture standards copied into a runner script, flag it as a violation and replace it with a skill load. Inline duplicates drift silently and bypass skill fixes.
+
+## Domain Context — Lore Project
+
+- `search-concepts.md`: calls `search_concepts` MCP tool, appends concept IDs to `~/.lore/session.json`
+- `capture-concept.md`: reflection criteria → generalization → confirm/auto → `submit_concept`
+- `stop.sh`: reads session.json → batch rating prompt → `rate_concept` calls → session-end reflection → clear file
+- `LORE_CAPTURE_MODE`: `confirm` (default, safe) | `auto` (no user gate, scan is the only guard)
+- `~/.lore/session.json`: JSON array of concept ID strings used this session
+- MCP server must be treated as potentially unreachable — all skills degrade gracefully

mcp_server_lore-0.1.0/.claude/agents/test-suite-architect.md

@@ -0,0 +1,41 @@
+---
+name: test-suite-architect
+description: "Use this agent when Python code has been written or modified and needs comprehensive tests, or when test quality/coverage needs review. Invoke after any significant implementation in lore/mcp/, lore/selfhosted/, or lore/semantic-server/.\n\n<example>\nContext: The embedding pipeline was just implemented.\nuser: \"Tests for the embedding pipeline please.\"\nassistant: \"I'll bring in the test-suite-architect.\"\n<commentary>\nNew implementation needs test coverage — hand to test-suite-architect.\n</commentary>\n</example>\n\n<example>\nContext: The MCP tools are implemented and need coverage verified.\nuser: \"Review the test coverage for submit_concept.\"\nassistant: \"Let me invoke the test-suite-architect to review.\"\n<commentary>\nTest review and coverage analysis is test-suite-architect territory.\n</commentary>\n</example>"
+model: sonnet
+color: orange
+---
+
+You are an expert Python test engineer. You write pytest test suites that provide genuine confidence in correctness — not just coverage numbers.
+
+## Core Responsibilities
+
+1. Analyze code under test and identify what truly needs testing
+2. Write unit and integration tests covering happy paths, error paths, and edge cases
+3. Enforce 80%+ coverage on `lore/` as a baseline (`pytest --cov=lore --cov-fail-under=80`)
+4. Review test suites and flag brittle, redundant, or missing tests
+5. Design test data strategies that never cause false failures
+
+## Testing Standards
+
+- Use pytest with fixtures; prefer factory helpers over hardcoded test data
+- Mock at the boundary: mock SQLite and Qdrant in unit tests; use real connections in integration tests
+- Test idempotency explicitly — seed loader, Qdrant collection init, session file operations
+- Test failure paths: MCP server unreachable, DB write failure mid dual-write, malformed session.json
+- Schema parity tests: assert tool input/output schemas are identical across backends
+- Never test implementation details — test observable behavior
+
+## Key Edge Cases for Lore
+
+- `submit_concept` content scan: credential match, internal URL match, LORE_BLOCK_PATTERNS match, clean pass
+- Dual-write ordering: SQLite insert succeeds but Qdrant fails → API returns 503 + concept_id, no rollback; test that the 503 includes concept_id and SQLite row is retained
+- Embedding re-trigger: update to `name` or `when_to_use` must re-embed; update to other fields must not
+- Seed loader idempotency: second run produces identical DB state, not duplicates
+- `search_concepts`: assert exactly one HTTP call to selfhosted backend per search (no N+1 link fetches)
+- Stop hook: empty session.json, missing session.json, MCP unreachable during rating, second invocation
+
+## Domain Context — Lore Project
+
+- Test runner: `pytest lore/tests/ --cov=lore --cov-fail-under=80`
+- Stack: Python, FastMCP, FastAPI (use `httpx.AsyncClient` for FastAPI tests), SQLite, Qdrant
+- Qdrant in tests: use `qdrant_client.QdrantClient(":memory:")` for unit tests
+- SQLite in tests: use `":memory:"` database; apply schema.sql at fixture setup

mcp_server_lore-0.1.0/.claude/settings.json

@@ -0,0 +1 @@
+{}

mcp_server_lore-0.1.0/.claude-plugin/marketplace.json

@@ -0,0 +1,17 @@
+{
+  "name": "lore",
+  "owner": {
+    "name": "magublafix"
+  },
+  "plugins": [
+    {
+      "name": "lore",
+      "description": "Typed, linked knowledge graph for AI coding agents — search reusable concepts, capture new ones, and rate what helped.",
+      "version": "1.0.2",
+      "source": "./",
+      "author": {
+        "name": "magublafix"
+      }
+    }
+  ]
+}

mcp_server_lore-0.1.0/.claude-plugin/plugin.json

@@ -0,0 +1,10 @@
+{
+  "name": "lore",
+  "description": "Typed, linked knowledge graph for AI coding agents — search reusable concepts, capture new ones, and rate what helped.",
+  "version": "1.0.2",
+  "author": {
+    "name": "magublafix"
+  },
+  "license": "MIT",
+  "keywords": ["knowledge-graph", "concepts", "memory", "mcp", "semantic-search"]
+}

mcp_server_lore-0.1.0/.dockerignore

@@ -0,0 +1,30 @@
+# Virtual environment — never copy host venv into the build context
+.venv/
+
+# Git history is not needed inside the image
+.git/
+
+# Python cache and compiled bytecode
+__pycache__/
+*.pyc
+*.pyo
+
+# Test runner state
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Tests themselves — not needed in the runtime image
+lore/tests/
+
+# Editor / IDE artefacts
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS noise
+.DS_Store
+
+# Egg-info generated by local pip install — not needed in the image
+lore.egg-info/

mcp_server_lore-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,38 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    name: Test (Python 3.11)
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+
+      - name: Set up Python 3.11
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.11'
+
+      # Cache pip's wheel/package download cache.
+      # Key is tied to the pyproject.toml hash — any dependency change busts
+      # the cache and forces a fresh download.
+      - name: Cache pip
+        uses: actions/cache@v6
+        with:
+          path: ~/.cache/pip
+          key: pip-${{ runner.os }}-py3.11-${{ hashFiles('pyproject.toml') }}
+          restore-keys: |
+            pip-${{ runner.os }}-py3.11-
+
+      - name: Install dependencies
+        run: pip install -e ".[dev]"
+
+      - name: Run tests
+        run: pytest lore/tests/ --cov=lore --cov-fail-under=80 -q

mcp_server_lore-0.1.0/.github/workflows/docker.yml

@@ -0,0 +1,110 @@
+name: Build and push Docker image
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+# GITHUB_TOKEN needs packages:write to push to ghcr.io.
+# contents:read is the minimum for checkout.
+permissions:
+  contents: read
+  packages: write
+
+jobs:
+  build-and-push:
+    name: Build lore-selfhosted image
+    runs-on: ubuntu-latest
+
+    steps:
+      # -----------------------------------------------------------------------
+      # 0. Free disk space — ubuntu-latest has ~14 GB free by default.
+      #    PyTorch + sentence-transformers layers fill the disk mid-build.
+      #    Removing Android SDK, .NET, and large pre-installed tool sets
+      #    recovers ~20 GB before BuildKit starts pulling layers.
+      # -----------------------------------------------------------------------
+      - name: Free disk space
+        run: |
+          sudo rm -rf /usr/local/lib/android
+          sudo rm -rf /usr/share/dotnet
+          sudo rm -rf /opt/ghc
+          sudo rm -rf /usr/local/share/boost
+          sudo rm -rf /usr/lib/jvm
+          sudo rm -rf /usr/share/swift
+          df -h
+
+      # -----------------------------------------------------------------------
+      # 1. Checkout — full repo needed because the Dockerfile copies both
+      #    pyproject.toml and lore/ from the repo root as the build context.
+      # -----------------------------------------------------------------------
+      - name: Checkout repository
+        uses: actions/checkout@v7
+
+      # -----------------------------------------------------------------------
+      # 2. Set up BuildKit.  docker/build-push-action@v6 enables BuildKit
+      #    automatically, but we call setup-buildx explicitly so we can
+      #    reference the builder instance for cache operations.
+      # -----------------------------------------------------------------------
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v4
+
+      # -----------------------------------------------------------------------
+      # 3. Authenticate to GitHub Container Registry.
+      #    github.actor is the user (or bot) that triggered the push.
+      #    GITHUB_TOKEN is injected automatically by Actions.
+      # -----------------------------------------------------------------------
+      - name: Log in to GitHub Container Registry
+        uses: docker/login-action@v4
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      # -----------------------------------------------------------------------
+      # 4. Generate image tags.
+      #    - latest        — always points to the most recent main build
+      #    - <sha7>        — immutable, traceble back to the exact commit
+      #
+      #    docker/metadata-action normalises the registry + repo name and
+      #    strips invalid characters from the SHA ref automatically.
+      # -----------------------------------------------------------------------
+      - name: Extract image metadata
+        id: meta
+        uses: docker/metadata-action@v6
+        with:
+          images: ghcr.io/magublafix/lore-selfhosted
+          tags: |
+            type=raw,value=latest
+            type=sha,prefix=,format=short
+
+      # -----------------------------------------------------------------------
+      # 5. Build and push.
+      #
+      #    Build context: repo root (.) — the Dockerfile references both
+      #    pyproject.toml and lore/ relative to the repo root.
+      #
+      #    Dockerfile path: lore/selfhosted/Dockerfile
+      #
+      #    Layer cache: type=gha stores BuildKit cache in the GitHub Actions
+      #    cache service (same backend as actions/cache).  mode=max preserves
+      #    intermediate layers, which is critical here because the PyTorch /
+      #    sentence-transformers wheels live in the builder stage and are
+      #    expensive to re-download on every run (~1-2 GB).
+      #
+      #    push: true — image is pushed only when this step succeeds.  If the
+      #    build exits non-zero, the step fails immediately and the push is
+      #    skipped, satisfying the "fail fast" requirement.
+      # -----------------------------------------------------------------------
+      - name: Build and push image
+        uses: docker/build-push-action@v7
+        with:
+          context: .
+          file: lore/selfhosted/Dockerfile
+          push: ${{ github.event_name == 'push' }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

mcp_server_lore-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,125 @@
+name: Publish
+
+# Fires only on version tags (e.g. v0.1.0, v1.2.3).
+# Build order is enforced by job dependencies: tests must pass before
+# the PyPI publish runs, and the Docker push runs only after PyPI succeeds.
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  # ---------------------------------------------------------------------------
+  # 1. Test gate — identical to ci.yml.  If this fails, nothing publishes.
+  # ---------------------------------------------------------------------------
+  test:
+    name: Test (Python 3.11)
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+
+      - name: Set up Python 3.11
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.11'
+
+      - name: Cache pip
+        uses: actions/cache@v6
+        with:
+          path: ~/.cache/pip
+          key: pip-${{ runner.os }}-py3.11-${{ hashFiles('pyproject.toml') }}
+          restore-keys: |
+            pip-${{ runner.os }}-py3.11-
+
+      - name: Install dependencies
+        run: pip install -e ".[dev]"
+
+      - name: Run tests
+        run: pytest lore/tests/ --cov=lore --cov-fail-under=80 -q
+
+  # ---------------------------------------------------------------------------
+  # 2. Build and publish to PyPI via OIDC trusted publishing.
+  #    No PYPI_TOKEN secret required — the id-token permission exchanges the
+  #    GitHub OIDC token for a short-lived PyPI upload credential at runtime.
+  #    Configure trusted publishing on PyPI: Settings → Trusted Publishers →
+  #    add GitHub, repo name, workflow filename, and (optionally) environment.
+  # ---------------------------------------------------------------------------
+  publish-pypi:
+    name: Publish to PyPI
+    runs-on: ubuntu-latest
+    needs: test
+
+    # OIDC trusted publishing requires id-token: write.
+    # contents: read is the minimum for checkout.
+    permissions:
+      id-token: write
+      contents: read
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+
+      - name: Set up Python 3.11
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.11'
+
+      - name: Install build tools
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      # pypa/gh-action-pypi-publish picks up dist/ automatically.
+      # OIDC trusted publishing is the default when no password is supplied.
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+  # ---------------------------------------------------------------------------
+  # 3. Build the thin MCP server image and push to Docker Hub.
+  #    Uses the root-level Dockerfile (not lore/selfhosted/Dockerfile).
+  #    Tagged with the git version tag AND :latest.
+  # ---------------------------------------------------------------------------
+  publish-docker:
+    name: Push Docker image to Docker Hub
+    runs-on: ubuntu-latest
+    needs: publish-pypi
+
+    # contents:read is needed for checkout.
+    permissions:
+      contents: read
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v4
+
+      # DOCKERHUB_USERNAME and DOCKERHUB_TOKEN must be set as repository
+      # secrets (Settings → Secrets and variables → Actions).
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v4
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      # github.ref_name resolves to the tag name (e.g. "v0.1.0").
+      # We push two tags: the version tag for immutability, and :latest
+      # so consumers can always pull the newest release without pinning.
+      - name: Build and push image
+        uses: docker/build-push-action@v7
+        with:
+          context: .
+          file: Dockerfile
+          push: true
+          tags: |
+            ${{ secrets.DOCKERHUB_USERNAME }}/mcp-server-lore:${{ github.ref_name }}
+            ${{ secrets.DOCKERHUB_USERNAME }}/mcp-server-lore:latest
+          # GHA layer cache keeps the builder stage warm across tag pushes.
+          # mode=max preserves intermediate layers (the dep-install layer is
+          # the expensive one — ~200 MB of Python packages).
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

mcp_server_lore-0.1.0/.gitignore

@@ -0,0 +1,15 @@
+__pycache__/
+*.pyc
+*.pyo
+.coverage
+coverage.xml
+htmlcov/
+.pytest_cache/
+*.egg-info/
+dist/
+build/
+.venv/
+*.db
+.claude/scheduled_tasks.lock
+.env
+samples/stlgen/benchmarks/RUNNING.md