Add Docker distribution, auto-reindex on model change, update all docs

- Dockerfile (node:24-alpine multi-stage) + GitHub Actions workflow for ghcr.io
- Graph persistence now stores embedding model name; auto-reindex on model change
- Comprehensive docs update: ARCHITECTURE.md, SPEC.md, CLAUDE.md, README.md (57 tools, 6 graphs, skills, prompts page, Docker quick start)
- Help articles: add SkillGraph to graph-structure, cross-graph, knowledge/task tools
- Remove orphaned files (PromptMascot, old roles/scenarios)
- Fix repo URL in package.json

Author: prih

.dockerignore

@@ -0,0 +1,17 @@
+node_modules
+ui/node_modules
+dist
+ui/dist
+.graph-memory
+.cache
+models/
+data
+.env
+graph-memory.yaml
+demo-project/.graph-memory
+demo-project/.notes
+demo-project/.tasks
+demo-project/.skills
+.git
+*.md
+!README.md

.github/workflows/docker.yml

@@ -0,0 +1,46 @@
+name: Build and Push Docker Image
+
+on:
+  push:
+    branches: [main]
+    tags: ['v*']
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Log in to Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          tags: |
+            type=raw,value=latest,enable={{is_default_branch}}
+            type=sha,prefix=
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+
+      - name: Build and push
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}

ARCHITECTURE.md

@@ -156,12 +156,12 @@ src/
 ui/                  # React web UI (Feature-Sliced Design)
   src/
     app/             # App.tsx (routes), theme.ts, styles.css
-    pages/           # dashboard, knowledge, tasks, skills, docs, files, search, graph, tools, help
+    pages/           # dashboard, knowledge, tasks, skills, docs, files, prompts, search, graph, tools, help
     widgets/         # layout (sidebar + project selector + theme toggle)
     features/        # note-crud, task-crud, skill-crud
     entities/        # project, note, task, skill, file, doc, code, graph
     shared/          # api/client.ts, lib/useWebSocket.ts, lib/ThemeModeContext.tsx
-    content/         # help articles (markdown) bundled into the UI
+    content/         # help articles + prompt templates (markdown) bundled into the UI
 demo-project/        # Demo "TaskFlow" project for testing and demonstration
   src/               # 18 TypeScript files (models, services, controllers, middleware, utils)
   docs/              # 11 markdown docs (architecture, API, guides, changelog)
@@ -251,8 +251,11 @@ demo-project/        # Demo "TaskFlow" project for testing and demonstration
   and by the indexer when files are removed (`cleanupProxies`)
 - **Cross-graph tools**: `cross_references` is the only tool that requires both `docGraph` and
   `codeGraph`; registered only when both are available; bridges definitions (code) ↔ examples (docs)
-- **Graph persistence**: graphology `export()`/`import()` serialized as JSON;
-  filenames: `docs.json`, `code.json`, `knowledge.json`, `file-index.json`, `tasks.json`, and `skills.json` in `graphMemory` directory
+- **Graph persistence**: graphology `export()`/`import()` serialized as JSON with embedding
+  model metadata; filenames: `docs.json`, `code.json`, `knowledge.json`, `file-index.json`,
+  `tasks.json`, and `skills.json` in `graphMemory` directory. Each JSON file wraps the
+  graphology export with `{ embeddingModel: "...", graph: {...} }`. On load, if the configured
+  model differs from the stored model, the graph is automatically discarded and re-indexed
 - **File mirror (write)**: `KnowledgeGraphManager`, `TaskGraphManager`, and `SkillGraphManager` write markdown files to
   `{projectDir}/.notes/{id}/note.md`, `{projectDir}/.tasks/{id}/task.md`, and `{projectDir}/.skills/{id}/skill.md` on every mutation.
   Files use YAML frontmatter (id, tags, timestamps, relations) + markdown body (`# Title\n\nContent`).
@@ -301,8 +304,8 @@ demo-project/        # Demo "TaskFlow" project for testing and demonstration
   Each project has its own 6 graphs, embedFns, indexer, watcher, and mutation queue.
   YAML config hot-reload (add/remove/change projects without restart). Auto-save every 30s.
   `PromiseQueue` serializes mutation tool handlers per project to prevent race conditions
-- **REST API**: Express app on the same HTTP server (`/api/*`). CRUD endpoints for knowledge
-  and tasks, search endpoints for docs/code/files, graph export for visualization, tools
+- **REST API**: Express app on the same HTTP server (`/api/*`). CRUD endpoints for knowledge,
+  tasks, and skills; search endpoints for docs/code/files; graph export for visualization; tools
   explorer (list/get/call MCP tools via HTTP). Zod validation on all request bodies and
   query params. Response format: `{ results: [...] }` for lists, direct object for singles,
   204 for DELETEs
@@ -316,14 +319,21 @@ demo-project/        # Demo "TaskFlow" project for testing and demonstration
   with configurable column visibility, drag-drop with drop-zone highlights, inline creation,
   filter bar, due date/estimate badges, quick actions on hover, scrollable columns),
   Skills (skill/recipe management with triggers and usage tracking),
-  Docs (browse indexed documentation), Files (browser), Search (cross-graph),
+  Docs (browse indexed documentation), Files (browser),
+  Prompts (AI prompt generator with scenarios, roles, styles, live preview, export as skill),
+  Search (cross-graph),
   Graph (cytoscape.js visualization), Tools (MCP tools explorer with live execution),
   Help (built-in searchable documentation). Light/dark theme toggle. Built output served as
   static files from HTTP server with SPA fallback. Dev server: Vite on :5173, proxies `/api` to :3000
 - **`--reindex` flag**: all three CLI commands (`index`, `mcp`, `serve`) support `--reindex`
   to discard persisted graphs and re-create them from scratch. When set, `load*()` functions
   return fresh empty graphs (skip disk read), and the indexer re-indexes all files since
   no mtime data exists in the fresh graphs
+- **Docker**: multi-stage Dockerfile (node:24-alpine). Build stage: `npm run build` (server + UI).
+  Runtime stage: production deps + dist/ + ui/dist/. Entry: `node dist/cli/index.js serve`.
+  Three volume mounts: `/data/config/graph-memory.yaml` (config), `/data/projects/` (project dirs),
+  `/data/models/` (embedding model cache). GitHub Actions workflow builds and pushes to
+  `ghcr.io/prih/mcp-graph-memory` on push to `main` or version tags
 
 ## Configuration
 

CLAUDE.md

@@ -0,0 +1,37 @@
+FROM node:24-alpine AS build
+
+WORKDIR /app
+
+# Install dependencies (server)
+COPY package.json package-lock.json ./
+RUN npm ci
+
+# Install dependencies (UI)
+COPY ui/package.json ui/package-lock.json ./ui/
+RUN cd ui && npm ci
+
+# Copy source
+COPY tsconfig.json tsconfig.build.json ./
+COPY src/ ./src/
+COPY ui/ ./ui/
+
+# Build server + UI
+RUN npm run build
+
+# --- Runtime ---
+FROM node:24-alpine
+
+WORKDIR /app
+
+COPY package.json package-lock.json ./
+RUN npm ci --omit=dev
+
+COPY --from=build /app/dist ./dist
+COPY --from=build /app/ui/dist ./ui/dist
+
+ENV NODE_ENV=production
+
+EXPOSE 3000
+
+ENTRYPOINT ["node", "dist/cli/index.js"]
+CMD ["serve", "--config", "/data/config/graph-memory.yaml"]

Dockerfile

@@ -4,6 +4,88 @@ An MCP server that builds a **semantic graph memory** from a project directory.
 It indexes markdown documentation and TypeScript/JavaScript source code into graph structures,
 then exposes them as MCP tools that any AI assistant can use to navigate and search the project.
 
+## Quick start with Docker
+
+### 1. Create a config file
+
+Create `graph-memory.yaml` — paths must be relative to the container filesystem:
+
+```yaml
+server:
+  host: "0.0.0.0"
+  port: 3000
+  modelsDir: "/data/models"
+
+projects:
+  my-app:
+    projectDir: "/data/projects/my-app"
+    docsPattern: "docs/**/*.md"
+    codePattern: "src/**/*.{ts,tsx}"
+    excludePattern: "node_modules/**,dist/**"
+```
+
+### 2. Run with Docker
+
+```bash
+docker run -d \
+  --name graph-memory \
+  -p 3000:3000 \
+  -v $(pwd)/graph-memory.yaml:/data/config/graph-memory.yaml:ro \
+  -v /path/to/my-app:/data/projects/my-app:ro \
+  -v graph-memory-models:/data/models \
+  ghcr.io/prih/mcp-graph-memory
+```
+
+Three mounts:
+| Mount | Container path | Description |
+|-------|---------------|-------------|
+| **Config** | `/data/config/graph-memory.yaml` | Your config file (read-only) |
+| **Projects** | `/data/projects/` | Project directories to index (read-only, unless you use knowledge/tasks/skills — then remove `:ro`) |
+| **Models** | `/data/models/` | Embedding model cache — use a named volume so models persist across container restarts |
+
+The embedding model (`Xenova/all-MiniLM-L6-v2`, ~90MB) is downloaded on first startup. Subsequent starts use the cached model from the volume.
+
+### 3. Run with Docker Compose
+
+```yaml
+# docker-compose.yaml
+services:
+  graph-memory:
+    image: ghcr.io/prih/mcp-graph-memory
+    ports:
+      - "3000:3000"
+    volumes:
+      - ./graph-memory.yaml:/data/config/graph-memory.yaml:ro
+      - /path/to/my-app:/data/projects/my-app
+      - models:/data/models
+    restart: unless-stopped
+
+volumes:
+  models:
+```
+
+```bash
+docker compose up -d
+```
+
+### 4. Connect
+
+- **Web UI**: `http://localhost:3000`
+- **MCP (Streamable HTTP)**: `http://localhost:3000/mcp/my-app`
+- **REST API**: `http://localhost:3000/api/projects`
+
+To force re-index all projects from scratch:
+
+```bash
+docker run --rm \
+  -v $(pwd)/graph-memory.yaml:/data/config/graph-memory.yaml:ro \
+  -v /path/to/my-app:/data/projects/my-app \
+  -v graph-memory-models:/data/models \
+  ghcr.io/prih/mcp-graph-memory serve --config /data/config/graph-memory.yaml --reindex
+```
+
+> **Multiple projects**: mount each project directory separately and add entries to `graph-memory.yaml`. The config file is watched for changes — add or remove projects without restarting the container.
+
 ## What it does
 
 - Parses **markdown files** into heading-based chunks, links related files via graph edges
@@ -117,7 +199,7 @@ then exposes them as MCP tools that any AI assistant can use to navigate and sea
 | `recall_skills`    | Recall relevant skills for a task context (lower minScore for higher recall) |
 | `bump_skill_usage` | Increment skill usage counter + set lastUsedAt                 |
 
-## Installation
+## Installation (from source)
 
 ```bash
 npm install
@@ -281,12 +363,13 @@ Pass these IDs to `get_node`, `get_symbol`, or `get_note` to fetch full content.
 
 The `serve` command starts a web UI at `http://localhost:3000` with:
 
-- **Dashboard** — project stats (notes, tasks, docs, code, files) + recent activity
+- **Dashboard** — project stats (notes, tasks, skills, docs, code, files) + recent activity
 - **Knowledge** — notes CRUD, semantic search, relations, cross-graph links
 - **Tasks** — kanban board with configurable columns, drag-drop with drop-zone highlights, inline task creation, filter bar (search/priority/tags), due date and estimate badges, quick actions on hover, scrollable columns
+- **Skills** — skill/recipe management with triggers, steps, and usage tracking
 - **Docs** — browse and search indexed markdown documentation
 - **Files** — file browser with directory navigation, metadata, search
-- **Skills** — skill/recipe management with triggers, steps, and usage tracking
+- **Prompts** — AI prompt generator with scenario presets, role/style/graph selection, live preview, copy & export as skill
 - **Search** — unified semantic search across all 6 graphs
 - **Graph** — interactive force-directed graph visualization (Cytoscape.js)
 - **Tools** — MCP tools explorer with live execution from the browser