logging and polish

README.md

@@ -0,0 +1,358 @@
+# Document Viewer
+
+A multi-tenant Obsidian-like documentation system with AI agent integration via Model Context Protocol (MCP).
+
+## 🎯 Overview
+
+Document Viewer enables both humans and AI agents to create, browse, and search documentation with powerful features like:
+
+- 📝 **Markdown Notes** with YAML frontmatter
+- 🔗 **Wikilinks** - `[[Note Name]]` style internal linking with auto-resolution
+- 🔍 **Full-Text Search** - BM25 ranking with recency bonus
+- ↩️ **Backlinks** - Automatic tracking of which notes reference each other
+- 🏷️ **Tags** - Organize notes with frontmatter tags
+- ✏️ **Split-Pane Editor** - Live markdown preview with optimistic concurrency
+- 🤖 **MCP Integration** - AI agents can read/write docs via FastMCP
+- 👥 **Multi-Tenant** - Isolated vaults per user (production ready with HF OAuth)
+
+## 🏗️ Tech Stack
+
+### Backend
+- **FastAPI** - HTTP API server
+- **FastMCP** - MCP server for AI agent integration
+- **SQLite FTS5** - Full-text search with BM25 ranking
+- **python-frontmatter** - YAML frontmatter parsing
+- **PyJWT** - Token-based authentication
+
+### Frontend
+- **React + Vite** - Modern web framework
+- **shadcn/ui** - Beautiful UI components
+- **Tailwind CSS** - Utility-first styling
+- **react-markdown** - Markdown rendering with custom wikilink support
+- **TypeScript** - Type-safe frontend code
+
+## 📦 Local Setup
+
+### Prerequisites
+- Python 3.11+
+- Node.js 18+
+- `uv` (Python package manager) or `pip`
+
+### 1. Clone Repository
+
+```bash
+git clone <repository-url>
+cd Document-MCP
+```
+
+### 2. Backend Setup
+
+```bash
+cd backend
+
+# Create virtual environment
+uv venv
+# or: python -m venv .venv
+
+# Install dependencies
+uv pip install -e .
+# or: .venv/bin/pip install -e .
+
+# Initialize database
+cd ..
+VIRTUAL_ENV=backend/.venv backend/.venv/bin/python -c "from backend.src.services.database import init_database; init_database()"
+```
+
+### 3. Frontend Setup
+
+```bash
+cd frontend
+
+# Install dependencies
+npm install
+```
+
+### 4. Environment Configuration
+
+The project includes development scripts that set environment variables automatically. For manual configuration, create a `.env` file in the backend directory:
+
+```bash
+# backend/.env
+JWT_SECRET_KEY=your-secret-key-here
+VAULT_BASE_PATH=/path/to/Document-MCP/data/vaults
+```
+
+See `.env.example` for all available options.
+
+## 🚀 Running the Application
+
+### Easy Start (Recommended)
+
+Use the provided scripts to start both servers:
+
+```bash
+# Start frontend and backend
+./start-dev.sh
+
+# Check status
+./status-dev.sh
+
+# Stop servers
+./stop-dev.sh
+
+# View logs
+tail -f backend.log frontend.log
+```
+
+### Manual Start
+
+#### Running Backend
+
+Start the HTTP API server:
+
+```bash
+cd backend
+JWT_SECRET_KEY="local-dev-secret-key-123" \
+VAULT_BASE_PATH="$(pwd)/../data/vaults" \
+.venv/bin/uvicorn src.api.main:app --host 0.0.0.0 --port 8000 --reload
+```
+
+Backend will be available at: `http://localhost:8000`
+
+API docs (Swagger): `http://localhost:8000/docs`
+
+#### Running MCP Server (STDIO Mode)
+
+For AI agent integration via MCP:
+
+```bash
+cd backend
+JWT_SECRET_KEY="local-dev-secret-key-123" \
+VAULT_BASE_PATH="$(pwd)/../data/vaults" \
+.venv/bin/python -m src.mcp.server
+```
+
+#### Running Frontend
+
+```bash
+cd frontend
+npm run dev
+```
+
+Frontend will be available at: `http://localhost:5173`
+
+## 🤖 MCP Client Configuration
+
+To use the Document Viewer with AI agents (Claude Desktop, Cline, etc.), add this to your MCP configuration:
+
+### Claude Desktop / Cline
+
+Add to `~/.cursor/mcp.json` (or Claude Desktop settings):
+
+```json
+{
+  "mcpServers": {
+    "obsidian-docs": {
+      "command": "python",
+      "args": ["-m", "backend.src.mcp.server"],
+      "cwd": "/path/to/Document-MCP",
+      "env": {
+        "BEARER_TOKEN": "local-dev-token",
+        "FASTMCP_SHOW_CLI_BANNER": "false",
+        "PYTHONPATH": "/path/to/Document-MCP",
+        "JWT_SECRET_KEY": "local-dev-secret-key-123",
+        "VAULT_BASE_PATH": "/path/to/Document-MCP/data/vaults"
+      }
+    }
+  }
+}
+```
+
+**Note:** In production, use actual JWT tokens instead of `local-dev-token`.
+
+### Available MCP Tools
+
+AI agents can use these tools:
+
+- `list_notes` - List all notes in vault
+- `read_note` - Read a specific note
+- `write_note` - Create or update a note
+- `delete_note` - Remove a note
+- `search_notes` - Full-text search with BM25 ranking
+- `get_backlinks` - Find notes linking to a target
+- `get_tags` - List all tags with usage counts
+
+## 🏛️ Architecture
+
+### Data Model
+
+**Note Structure:**
+```yaml
+---
+title: My Note
+tags: [guide, tutorial]
+created: 2025-01-15T10:00:00Z
+updated: 2025-01-15T14:30:00Z
+---
+
+# My Note
+
+Content with [[Wikilinks]] to other notes.
+```
+
+**Vault Structure:**
+```
+data/vaults/
+├── local-dev/           # Development user vault
+│   ├── Getting Started.md
+│   ├── API Documentation.md
+│   └── ...
+└── {user_id}/          # Production user vaults
+    └── *.md
+```
+
+**Index Tables (SQLite):**
+- `note_metadata` - Note versions, titles, timestamps
+- `note_fts` - FTS5 full-text search index
+- `note_tags` - Tag associations
+- `note_links` - Wikilink graph (resolved/unresolved)
+- `index_health` - Index statistics per user
+
+### Key Features
+
+**Wikilink Resolution:**
+- Normalizes titles to slugs: `[[Getting Started]]` → `getting-started`
+- Matches against both title and filename
+- Prefers same-folder matches
+- Tracks broken links for UI styling
+
+**Search Ranking:**
+- BM25 algorithm with title-weighted scoring (3x title, 1x body)
+- Recency bonus: +1.0 for notes updated in last 7 days, +0.5 for last 30 days
+- Returns highlighted snippets with `<mark>` tags
+
+**Optimistic Concurrency:**
+- Version-based conflict detection for note edits
+- Prevents data loss from concurrent edits
+- Returns 409 Conflict with helpful message
+
+## 🔒 Authentication
+
+### Local Development
+Uses a static token: `local-dev-token`
+
+### Production (Hugging Face OAuth)
+- Multi-tenant with per-user isolated vaults
+- JWT tokens with user_id claims
+- Automatic vault initialization on first login
+
+See deployment documentation for HF OAuth setup.
+
+## 📊 Performance Considerations
+
+**SQLite Optimizations:**
+- FTS5 with prefix indexes (`prefix='2 3'`) for fast autocomplete and substring matching
+- Recommended: Enable WAL mode for concurrent reads/writes:
+  ```sql
+  PRAGMA journal_mode=WAL;
+  PRAGMA synchronous=NORMAL;
+  ```
+- Normalized slug indexes (`normalized_title_slug`, `normalized_path_slug`) for O(1) wikilink resolution
+- BM25 ranking weights: 3.0 for title matches, 1.0 for body matches
+
+**Rate Limiting:**
+- ⚠️ **Production Recommendation**: Add per-user rate limits to prevent abuse
+- API endpoints currently have no rate limiting
+- Consider implementing:
+  - `/api/notes` (POST): 100 requests/hour per user
+  - `/api/index/rebuild` (POST): 10 requests/day per user
+  - `/api/search`: 1000 requests/hour per user
+- Use libraries like `slowapi` or Redis-based rate limiting
+
+**Scaling:**
+- **Single-server**: SQLite handles 100K+ notes efficiently
+- **Multi-server**: Migrate to PostgreSQL with `pg_trgm` or `pgvector` for FTS
+- **Caching**: Add Redis for:
+  - Session tokens (reduce DB lookups)
+  - Frequently accessed notes
+  - Search result caching (TTL: 5 minutes)
+- **CDN**: Serve frontend assets via CDN for global performance
+
+## 🧪 Development
+
+### Project Structure
+
+```
+Document-MCP/
+├── backend/
+│   ├── src/
+│   │   ├── api/          # FastAPI routes & middleware
+│   │   ├── mcp/          # FastMCP server
+│   │   ├── models/       # Pydantic models
+│   │   └── services/     # Business logic
+│   └── tests/            # Backend tests
+├── frontend/
+│   ├── src/
+│   │   ├── components/   # React components
+│   │   ├── pages/        # Page components
+│   │   ├── services/     # API client
+│   │   └── types/        # TypeScript types
+│   └── tests/            # Frontend tests
+├── data/
+│   ├── vaults/          # User markdown files
+│   └── index.db         # SQLite database
+├── specs/               # Feature specifications
+└── start-dev.sh         # Development startup script
+```
+
+### Adding a New Note (via UI)
+
+1. Click "New Note" button
+2. Enter note name (`.md` extension optional)
+3. Edit in split-pane editor
+4. Save with Cmd/Ctrl+S
+
+### Adding a New Note (via MCP)
+
+```python
+# AI agent writes a note
+write_note(
+    path="guides/my-guide.md",
+    body="# My Guide\n\nContent here with [[links]]",
+    title="My Guide",
+    metadata={"tags": ["guide", "tutorial"]}
+)
+```
+
+## 🐛 Troubleshooting
+
+**Backend won't start:**
+- Ensure virtual environment is activated
+- Check environment variables are set
+- Verify database is initialized
+
+**Frontend shows connection errors:**
+- Ensure backend is running on port 8000
+- Check Vite proxy configuration in `frontend/vite.config.ts`
+
+**Search returns no results:**
+- Verify notes are indexed (check Settings → Index Health)
+- Try rebuilding the index via Settings page
+
+**MCP tools not showing in Claude:**
+- Verify MCP configuration path is correct
+- Check `PYTHONPATH` includes project root
+- Restart Claude Desktop after config changes
+
+## 📝 License
+
+[Add license information]
+
+## 🤝 Contributing
+
+[Add contributing guidelines]
+
+## 📧 Contact
+
+[Add contact information]
+

backend/src/api/middleware/error_handlers.py

@@ -57,13 +57,39 @@ def _response(status_code: int, detail: Any) -> JSONResponse:
 async def validation_exception_handler(
     request: Request, exc: RequestValidationError
 ) -> JSONResponse:
-    detail = {"detail": {"errors": exc.errors()}}
+    # Transform pydantic errors into more user-friendly format
+    errors = []
+    for error in exc.errors():
+        field = ".".join(str(loc) for loc in error["loc"] if loc != "body")
+        errors.append({
+            "field": field or "request",
+            "reason": error["msg"],
+            "type": error["type"]
+        })
+    
+    detail = {
+        "error": "validation_error",
+        "message": "Request validation failed",
+        "detail": {"fields": errors}
+    }
+    logger.warning(
+        "Validation error",
+        extra={"url": str(request.url), "errors": errors}
+    )
     return _response(status.HTTP_400_BAD_REQUEST, detail)
 
 
 async def http_exception_handler(
     request: Request, exc: StarletteHTTPException
 ) -> JSONResponse:
+    logger.warning(
+        "HTTP exception",
+        extra={
+            "url": str(request.url),
+            "status_code": exc.status_code,
+            "detail": exc.detail
+        }
+    )
     return _response(exc.status_code, exc.detail)
 
 

backend/src/mcp/server.py

@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 
+import logging
 import os
+import time
 from typing import Any, Dict, List, Optional
 
 from fastmcp import FastMCP
@@ -10,6 +12,8 @@ from pydantic import Field
 
 from ..services import IndexerService, VaultNote, VaultService
 
+logger = logging.getLogger(__name__)
+
 mcp = FastMCP(
     "obsidian-docs-viewer",
     instructions=(
@@ -47,8 +51,23 @@ def list_notes(
         description="Optional relative folder (trim '/' ; no '..' or '\\').",
     ),
 ) -> List[Dict[str, Any]]:
+    start_time = time.time()
     user_id = _current_user_id()
+    
     notes = vault_service.list_notes(user_id, folder=folder)
+    
+    duration_ms = (time.time() - start_time) * 1000
+    logger.info(
+        "MCP tool called",
+        extra={
+            "tool_name": "list_notes",
+            "user_id": user_id,
+            "folder": folder or "(root)",
+            "result_count": len(notes),
+            "duration_ms": f"{duration_ms:.2f}"
+        }
+    )
+    
     return [
         {
             "path": entry["path"],
@@ -63,8 +82,22 @@ def list_notes(
 def read_note(
     path: str = Field(..., description="Relative '.md' path ≤256 chars (no '..' or '\\')."),
 ) -> Dict[str, Any]:
+    start_time = time.time()
     user_id = _current_user_id()
+    
     note = vault_service.read_note(user_id, path)
+    
+    duration_ms = (time.time() - start_time) * 1000
+    logger.info(
+        "MCP tool called",
+        extra={
+            "tool_name": "read_note",
+            "user_id": user_id,
+            "note_path": path,
+            "duration_ms": f"{duration_ms:.2f}"
+        }
+    )
+    
     return _note_to_response(note)
 
 
@@ -84,7 +117,9 @@ def write_note(
         description="Optional frontmatter dict (tags arrays of strings; 'version' reserved).",
     ),
 ) -> Dict[str, Any]:
+    start_time = time.time()
     user_id = _current_user_id()
+    
     note = vault_service.write_note(
         user_id,
         path,
@@ -93,6 +128,18 @@ def write_note(
         body=body,
     )
     indexer_service.index_note(user_id, note)
+    
+    duration_ms = (time.time() - start_time) * 1000
+    logger.info(
+        "MCP tool called",
+        extra={
+            "tool_name": "write_note",
+            "user_id": user_id,
+            "note_path": path,
+            "duration_ms": f"{duration_ms:.2f}"
+        }
+    )
+    
     return {"status": "ok", "path": path}
 
 
@@ -100,9 +147,23 @@ def write_note(
 def delete_note(
     path: str = Field(..., description="Relative '.md' path ≤256 chars (no '..' or '\\')."),
 ) -> Dict[str, str]:
+    start_time = time.time()
     user_id = _current_user_id()
+    
     vault_service.delete_note(user_id, path)
     indexer_service.delete_note_index(user_id, path)
+    
+    duration_ms = (time.time() - start_time) * 1000
+    logger.info(
+        "MCP tool called",
+        extra={
+            "tool_name": "delete_note",
+            "user_id": user_id,
+            "note_path": path,
+            "duration_ms": f"{duration_ms:.2f}"
+        }
+    )
+    
     return {"status": "ok"}
 
 
@@ -114,8 +175,24 @@ def search_notes(
     query: str = Field(..., description="Non-empty search query (bm25 + recency)."),
     limit: int = Field(50, ge=1, le=100, description="Result cap between 1 and 100."),
 ) -> List[Dict[str, Any]]:
+    start_time = time.time()
     user_id = _current_user_id()
+    
     results = indexer_service.search_notes(user_id, query, limit=limit)
+    
+    duration_ms = (time.time() - start_time) * 1000
+    logger.info(
+        "MCP tool called",
+        extra={
+            "tool_name": "search_notes",
+            "user_id": user_id,
+            "query": query,
+            "limit": limit,
+            "result_count": len(results),
+            "duration_ms": f"{duration_ms:.2f}"
+        }
+    )
+    
     return [
         {
             "path": row["path"],

backend/src/services/indexer.py

@@ -3,14 +3,18 @@
 from __future__ import annotations
 
 from datetime import datetime, timedelta, timezone
+import logging
 from pathlib import Path
 import re
 import sqlite3
+import time
 from typing import Any, Dict, List, Sequence
 
 from .database import DatabaseService
 from .vault import VaultNote
 
+logger = logging.getLogger(__name__)
+
 WIKILINK_PATTERN = re.compile(r"\[\[([^\]]+)\]\]")
 TOKEN_PATTERN = re.compile(r"[0-9A-Za-z]+(?:\*)?")
 
@@ -68,6 +72,8 @@ class IndexerService:
 
     def index_note(self, user_id: str, note: VaultNote) -> int:
         """Insert or update index rows for a note."""
+        start_time = time.time()
+        
         note_path = note["path"]
         metadata = dict(note.get("metadata") or {})
         title = note.get("title") or metadata.get("title") or Path(note_path).stem
@@ -149,6 +155,19 @@ class IndexerService:
 
                 self.update_index_health(conn, user_id)
 
+            duration_ms = (time.time() - start_time) * 1000
+            logger.info(
+                "Note indexed successfully",
+                extra={
+                    "user_id": user_id,
+                    "note_path": note_path,
+                    "version": version,
+                    "tags_count": len(tags),
+                    "wikilinks_count": len(wikilinks),
+                    "duration_ms": f"{duration_ms:.2f}"
+                }
+            )
+
             return version
         finally:
             conn.close()

backend/src/services/vault.py

@@ -3,14 +3,18 @@
 from __future__ import annotations
 
 from datetime import datetime, timezone
+import logging
 from pathlib import Path
 import re
+import time
 from typing import Any, Dict, List, Tuple
 
 import frontmatter
 
 from .config import AppConfig, get_config
 
+logger = logging.getLogger(__name__)
+
 INVALID_PATH_CHARS = {'<', '>', ':', '"', '|', '?', '*'}
 MAX_NOTE_BYTES = 1_048_576
 H1_PATTERN = re.compile(r"^\s*#\s+(.+)$", re.MULTILINE)
@@ -115,13 +119,33 @@ class VaultService:
 
     def read_note(self, user_id: str, note_path: str) -> VaultNote:
         """Read a Markdown note, returning metadata, body, and derived title."""
+        start_time = time.time()
+        
         base = self.initialize_vault(user_id)
         absolute_path = self.resolve_note_path(user_id, note_path)
         if not absolute_path.exists():
+            logger.warning(
+                "Note not found",
+                extra={"user_id": user_id, "note_path": note_path, "operation": "read"}
+            )
             raise FileNotFoundError(f"Note not found: {note_path}")
+        
         post = frontmatter.load(absolute_path)
         metadata = dict(post.metadata or {})
         body = post.content or ""
+        
+        duration_ms = (time.time() - start_time) * 1000
+        logger.info(
+            "Note read successfully",
+            extra={
+                "user_id": user_id,
+                "note_path": note_path,
+                "operation": "read",
+                "duration_ms": f"{duration_ms:.2f}",
+                "size_bytes": absolute_path.stat().st_size
+            }
+        )
+        
         return self._build_note_payload(note_path, metadata, body, absolute_path)
 
     def write_note(
@@ -134,6 +158,8 @@ class VaultService:
         body: str,
     ) -> VaultNote:
         """Create or update a note with validated metadata and content."""
+        start_time = time.time()
+        
         absolute_path = self.resolve_note_path(user_id, note_path)
         body = body or ""
         _validate_note_body(body)
@@ -141,8 +167,9 @@ class VaultService:
         metadata_dict: Dict[str, Any] = dict(metadata or {})
         _validate_frontmatter(metadata_dict)
 
+        is_new_note = not absolute_path.exists()
         existing_created: str | None = None
-        if absolute_path.exists():
+        if not is_new_note:
             try:
                 current = frontmatter.load(absolute_path)
                 current_created = current.metadata.get("created")
@@ -163,14 +190,44 @@ class VaultService:
         absolute_path.parent.mkdir(parents=True, exist_ok=True)
         post = frontmatter.Post(body, **metadata_dict)
         absolute_path.write_text(frontmatter.dumps(post), encoding="utf-8")
+        
+        duration_ms = (time.time() - start_time) * 1000
+        logger.info(
+            f"Note {'created' if is_new_note else 'updated'} successfully",
+            extra={
+                "user_id": user_id,
+                "note_path": note_path,
+                "operation": "create" if is_new_note else "update",
+                "duration_ms": f"{duration_ms:.2f}",
+                "size_bytes": len(frontmatter.dumps(post).encode("utf-8"))
+            }
+        )
+        
         return self._build_note_payload(note_path, metadata_dict, body, absolute_path)
 
     def delete_note(self, user_id: str, note_path: str) -> None:
         """Delete a note from the vault."""
+        start_time = time.time()
+        
         absolute_path = self.resolve_note_path(user_id, note_path)
         try:
             absolute_path.unlink()
+            
+            duration_ms = (time.time() - start_time) * 1000
+            logger.info(
+                "Note deleted successfully",
+                extra={
+                    "user_id": user_id,
+                    "note_path": note_path,
+                    "operation": "delete",
+                    "duration_ms": f"{duration_ms:.2f}"
+                }
+            )
         except FileNotFoundError as exc:
+            logger.warning(
+                "Note not found for deletion",
+                extra={"user_id": user_id, "note_path": note_path, "operation": "delete"}
+            )
             raise FileNotFoundError(f"Note not found: {note_path}") from exc
 
     def list_notes(self, user_id: str, folder: str | None = None) -> List[Dict[str, Any]]:

specs/001-obsidian-docs-viewer/tasks.md

@@ -198,20 +198,20 @@ The MVP delivers immediate value:
 
 **Goal**: Documentation, configuration, logging, error handling improvements.
 
-- [ ] [T121] Create README.md with project overview, tech stack, local setup instructions (backend venv + npm install)
-- [ ] [T122] Add README.md section: "Running Backend" with uvicorn command for HTTP API and python -m backend.src.mcp.server for MCP STDIO
-- [ ] [T123] Add README.md section: "Running Frontend" with npm run dev command
-- [ ] [T124] Add README.md section: "MCP Client Configuration" with Claude Code/Desktop STDIO example from mcp-tools.json
+- [x] [T121] Create README.md with project overview, tech stack, local setup instructions (backend venv + npm install)
+- [x] [T122] Add README.md section: "Running Backend" with uvicorn command for HTTP API and python -m backend.src.mcp.server for MCP STDIO
+- [x] [T123] Add README.md section: "Running Frontend" with npm run dev command
+- [x] [T124] Add README.md section: "MCP Client Configuration" with Claude Code/Desktop STDIO example from mcp-tools.json
 - [ ] [T125] Add README.md section: "Deploying to Hugging Face Space" with environment variables and OAuth setup
-- [ ] [T126] Update .env.example with all variables: JWT_SECRET_KEY, VAULT_BASE_PATH, HF_OAUTH_CLIENT_ID, HF_OAUTH_CLIENT_SECRET, DATABASE_PATH
-- [ ] [T127] Add structured logging to backend/src/services/vault.py: log file operations with user_id, note_path, operation type
-- [ ] [T128] Add structured logging to backend/src/services/indexer.py: log index updates with user_id, note_path, duration_ms
-- [ ] [T129] Add structured logging to backend/src/mcp/server.py: log MCP tool calls with tool_name, user_id, duration_ms
-- [ ] [T130] Improve error messages in backend/src/api/middleware/error_handlers.py: include detail objects with field names and reasons
-- [ ] [T131] Add input validation to all HTTP API routes: validate path format, content size, required fields
-- [ ] [T132] Add input validation to all MCP tools: validate path format, content size via Pydantic models
-- [ ] [T133] Add rate limiting consideration to README.md: note potential need for per-user rate limits in production
-- [ ] [T134] Add performance optimization notes to README.md: FTS5 prefix indexes, SQLite WAL mode for concurrency
+- [x] [T126] Update .env.example with all variables: JWT_SECRET_KEY, VAULT_BASE_PATH, HF_OAUTH_CLIENT_ID, HF_OAUTH_CLIENT_SECRET, DATABASE_PATH
+- [x] [T127] Add structured logging to backend/src/services/vault.py: log file operations with user_id, note_path, operation type
+- [x] [T128] Add structured logging to backend/src/services/indexer.py: log index updates with user_id, note_path, duration_ms
+- [x] [T129] Add structured logging to backend/src/mcp/server.py: log MCP tool calls with tool_name, user_id, duration_ms
+- [x] [T130] Improve error messages in backend/src/api/middleware/error_handlers.py: include detail objects with field names and reasons
+- [x] [T131] Add input validation to all HTTP API routes: validate path format, content size, required fields
+- [x] [T132] Add input validation to all MCP tools: validate path format, content size via Pydantic models
+- [x] [T133] Add rate limiting consideration to README.md: note potential need for per-user rate limits in production
+- [x] [T134] Add performance optimization notes to README.md: FTS5 prefix indexes, SQLite WAL mode for concurrency
 
 ---