bump: version 0.42.0 → 0.43.0

feat: Replace custom document chunker with LangChain MarkdownTextSplitter

.dockerignore

@@ -5,3 +5,4 @@
 !uv.lock
 
 !nextcloud_mcp_server/**/*.py
+!nextcloud_mcp_server/**/*.html

.github/workflows/bump-version.yml

@@ -15,12 +15,12 @@ jobs:
       packages: write
     steps:
       - name: Check out
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
         with:
           fetch-depth: 0
           token: "${{ secrets.PERSONAL_ACCESS_TOKEN }}"
       - name: Create bump and changelog
-        uses: commitizen-tools/commitizen-action@5b0848cd060263e24602d1eba03710e056ef7711 # 0.24.0
+        uses: commitizen-tools/commitizen-action@9615e7be1cf341393c52e865ebbdaa0712176d81 # 0.25.0
         with:
           github_token: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
           changelog_increment_filename: body.md

.github/workflows/docker-build-publish.yml

@@ -12,7 +12,7 @@ jobs:
       packages: write
     steps:
       - name: Checkout repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
 
       - name: Docker meta
         id: meta

.github/workflows/helm-release.yml

@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
         with:
           fetch-depth: 0
 

.github/workflows/release.yml

@@ -18,7 +18,7 @@ jobs:
       contents: read
     steps:
       - name: Checkout
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
       - name: Install uv
         uses: astral-sh/setup-uv@5a7eac68fb9809dea845d802897dc5c723910fa3 # v7.1.3
       - name: Install Python 3.11

.github/workflows/test.yml

@@ -9,7 +9,7 @@ jobs:
   linting:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
       - name: Install the latest version of uv
         uses: astral-sh/setup-uv@5a7eac68fb9809dea845d802897dc5c723910fa3 # v7.1.3
       - name: Check format
@@ -27,7 +27,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
         with:
           submodules: 'true'
 
@@ -85,4 +85,4 @@ jobs:
           NEXTCLOUD_USERNAME: "admin"
           NEXTCLOUD_PASSWORD: "admin"
         run: |
-          uv run pytest -v --log-cli-level=WARN -m smoke
+          uv run pytest -v --log-cli-level=WARN -m unit -m smoke

.gitmodules

@@ -1,6 +1,6 @@
-[submodule "oidc"]
-	path = third_party/oidc
-	url = https://github.com/cbcoutinho/oidc
 [submodule "third_party/oidc"]
 	path = third_party/oidc
 	url = https://github.com/cbcoutinho/oidc
+[submodule "third_party/notes"]
+	path = third_party/notes
+	url = https://github.com/cbcoutinho/notes

CHANGELOG.md

@@ -1,3 +1,109 @@
+## v0.43.0 (2025-11-18)
+
+### Feat
+
+- Replace custom document chunker with LangChain MarkdownTextSplitter
+
+## v0.42.0 (2025-11-17)
+
+### Feat
+
+- **viz**: Add dual-score display and improve UI controls
+
+## v0.41.0 (2025-11-17)
+
+### Feat
+
+- add configurable fusion algorithms for BM25 hybrid search
+- add chunk position tracking to vector indexing and search
+- add vector viz template and chunk context endpoint
+
+### Fix
+
+- prevent infinite loop in DocumentChunker with position tracking
+- Relax SearchResult validation to support DBSF fusion scores > 1.0
+
+## v0.40.0 (2025-11-16)
+
+### Feat
+
+- add unified provider architecture with Amazon Bedrock support
+
+### Fix
+
+- suppress Starlette middleware type warnings in ty checker
+
+## v0.39.0 (2025-11-16)
+
+### Feat
+
+- Implement BM25 hybrid search with native Qdrant RRF fusion
+
+### Fix
+
+- Handle named vectors in visualization and semantic search
+- Update vizApp to use bm25_hybrid algorithm and remove deprecated weights
+- Update viz routes to use BM25 hybrid search after refactor
+
+## v0.38.0 (2025-11-16)
+
+### Feat
+
+- add concurrent uploads and --force flag to upload command
+- implement RAG evaluation framework with CLI tooling
+
+### Fix
+
+- download qrels from BEIR ZIP instead of HuggingFace
+
+### Refactor
+
+- migrate asyncio to anyio for consistent structured concurrency
+- replace httpx client with NextcloudClient in upload command
+
+### Perf
+
+- Eliminate double-fetching in semantic search sampling
+- fix vector viz search performance and visual encoding
+- make note deletion concurrent in upload --force
+
+## v0.37.0 (2025-11-16)
+
+### Feat
+
+- Add OpenTelemetry tracing to @instrument_tool decorator
+
+## v0.36.0 (2025-11-15)
+
+### BREAKING CHANGE
+
+- Search algorithms now require Qdrant to be populated.
+Vector sync must be enabled and documents indexed for search to work.
+
+### Feat
+
+- Normalize hybrid search RRF scores to 0-1 range
+- Enhance vector visualization UI and parallelize search verification
+- Add Vector Viz tab to app home page
+- Add vector visualization pane with multi-select document types
+- Implement custom PCA to remove sklearn dependency
+- Add multi-document Protocol with cross-app search support
+- Update nc_semantic_search tool with algorithm selection
+- Implement unified search algorithm module
+
+### Fix
+
+- Reorder tabs and fix viz pane session access
+
+### Refactor
+
+- Optimize Nextcloud access verification with centralized filtering
+- Make all search algorithms query Qdrant payload, not Nextcloud
+
+### Perf
+
+- Exclude vector-sync status polling from distributed tracing
+
 ## v0.35.0 (2025-11-15)
 
 ### Feat

CLAUDE.md

@@ -17,13 +17,17 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 - **Use Python 3.10+ union syntax**: `str | None` instead of `Optional[str]`
 - **Use lowercase generics**: `dict[str, Any]` instead of `Dict[str, Any]`
 - **Type all function signatures** - Parameters and return types
-- **No explicit type checker configured** - Ruff handles linting only
+- **Type checker**: `ty` is configured for static type checking
+  ```bash
+  uv run ty check -- nextcloud_mcp_server
+  ```
 
 ### Code Quality
-- **Run ruff before committing**:
+- **Run ruff and ty before committing**:
   ```bash
   uv run ruff check
   uv run ruff format
+  uv run ty check -- nextcloud_mcp_server
   ```
 - **Ruff configuration** in pyproject.toml (extends select: ["I"] for import sorting)
 
@@ -57,8 +61,60 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 - `nextcloud_mcp_server/server/` - MCP tool/resource definitions
 - `nextcloud_mcp_server/auth/` - OAuth/OIDC authentication
 - `nextcloud_mcp_server/models/` - Pydantic response models
+- `nextcloud_mcp_server/providers/` - Unified LLM provider infrastructure (embeddings + generation)
 - `tests/` - Layered test suite (unit, smoke, integration, load)
 
+### Provider Architecture (ADR-015)
+
+**Unified Provider System** for embeddings and text generation:
+
+**Location:** `nextcloud_mcp_server/providers/`
+- `base.py` - `Provider` ABC with optional capabilities
+- `registry.py` - Auto-detection and factory pattern
+- `ollama.py` - Ollama provider (embeddings + generation)
+- `anthropic.py` - Anthropic provider (generation only)
+- `bedrock.py` - Amazon Bedrock provider (embeddings + generation)
+- `simple.py` - Simple in-memory provider (embeddings only, fallback)
+
+**Usage:**
+```python
+from nextcloud_mcp_server.providers import get_provider
+
+provider = get_provider()  # Auto-detects from environment
+
+# Check capabilities
+if provider.supports_embeddings:
+    embeddings = await provider.embed_batch(texts)
+
+if provider.supports_generation:
+    text = await provider.generate("prompt", max_tokens=500)
+```
+
+**Environment Variables:**
+
+Bedrock:
+- `AWS_REGION` - AWS region (e.g., "us-east-1")
+- `BEDROCK_EMBEDDING_MODEL` - Embedding model ID (e.g., "amazon.titan-embed-text-v2:0")
+- `BEDROCK_GENERATION_MODEL` - Generation model ID (e.g., "anthropic.claude-3-sonnet-20240229-v1:0")
+- `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` - Optional, uses AWS credential chain
+
+Ollama:
+- `OLLAMA_BASE_URL` - API URL (e.g., "http://localhost:11434")
+- `OLLAMA_EMBEDDING_MODEL` - Embedding model (default: "nomic-embed-text")
+- `OLLAMA_GENERATION_MODEL` - Generation model (e.g., "llama3.2:1b")
+- `OLLAMA_VERIFY_SSL` - SSL verification (default: "true")
+
+Simple (fallback, no config needed):
+- `SIMPLE_EMBEDDING_DIMENSION` - Dimension (default: 384)
+
+**Auto-Detection Priority:** Bedrock → Ollama → Simple
+
+**Backward Compatibility:**
+- Old code using `nextcloud_mcp_server.embedding.get_embedding_service()` still works
+- `EmbeddingService` now wraps `get_provider()` internally
+
+**For Details:** See `docs/ADR-015-unified-provider-architecture.md`
+
 ## Development Commands (Quick Reference)
 
 ### Testing

Dockerfile

@@ -1,15 +1,19 @@
-FROM ghcr.io/astral-sh/uv:0.9.9-python3.11-alpine@sha256:0faa7934fac1db7f5056f159c1224d144bab864fd2677a4066d25a686ae32edd
+FROM docker.io/library/python:3.12-slim-trixie@sha256:d86b4c74b936c438cd4cc3a9f7256b9a7c27ad68c7caf8c205e18d9845af0164
+
+COPY --from=ghcr.io/astral-sh/uv:0.9.10@sha256:29bd45092ea8902c0bbb7f0a338f0494a382b1f4b18355df5be270ade679ff1d /uv /uvx /bin/
 
 # Install dependencies
 # 1. git (required for caldav dependency from git)
 # 2. sqlite for development with token db
-RUN apk add --no-cache git sqlite
+RUN apt update && apt install --no-install-recommends --no-install-suggests -y \
+    git \
+    sqlite3 && apt clean
 
 WORKDIR /app
 
 COPY . .
 
-RUN uv sync --locked --no-dev --no-editable
+RUN uv sync --locked --no-dev --no-editable --no-cache
 
 ENV PYTHONUNBUFFERED=1
 ENV VIRTUAL_ENV=/app/.venv

app-hooks/post-installation/10-install-notes-app.sh

@@ -2,4 +2,30 @@
 
 set -euox pipefail
 
-php /var/www/html/occ app:enable notes
+echo "Installing and configuring notes app for testing..."
+
+# Check if development notes app is mounted at /opt/apps/notes
+if [ -d /opt/apps/notes ]; then
+    echo "Development notes app found at /opt/apps/notes"
+
+    # Remove any existing notes app in apps (from app store or old symlink)
+    if [ -e /var/www/html/custom_apps/notes ]; then
+        echo "Removing existing notes in apps..."
+        rm -rf /var/www/html/custom_apps/notes
+    fi
+
+    # Create symlink from apps to the mounted development version
+    # Per Nextcloud docs: apps outside server root need symlinks in server root
+    echo "Creating symlink: custom_apps/notes -> /opt/apps/notes"
+    ln -sf /opt/apps/notes /var/www/html/custom_apps/notes
+
+    echo "Enabling notes app from /opt/apps (development mode via symlink)"
+    php /var/www/html/occ app:enable notes
+elif [ -d /var/www/html/custom_apps/notes ]; then
+    echo "notes app directory found in apps (already installed)"
+    php /var/www/html/occ app:enable notes
+else
+    echo "notes app not found, installing from app store..."
+    php /var/www/html/occ app:install notes
+    php /var/www/html/occ app:enable notes
+fi

charts/nextcloud-mcp-server/Chart.lock

@@ -1,9 +1,9 @@
 dependencies:
 - name: qdrant
   repository: https://qdrant.github.io/qdrant-helm
-  version: 1.15.5
+  version: 1.16.0
 - name: ollama
   repository: https://otwld.github.io/ollama-helm
   version: 1.34.0
-digest: sha256:d51c97d05be2614b751c0dd7267ef7dc959eff5ebef859c5f895c5c554b7a874
-generated: "2025-11-09T17:08:02.86648061Z"
+digest: sha256:9dfb8d6e3d5488f669d4c37f3a766213b598ff3de2aead2c734789736c7835b4
+generated: "2025-11-17T17:08:48.055530019Z"

charts/nextcloud-mcp-server/Chart.yaml

@@ -2,8 +2,8 @@ apiVersion: v2
 name: nextcloud-mcp-server
 description: A Helm chart for Nextcloud MCP Server - enables AI assistants to interact with Nextcloud
 type: application
-version: 0.35.0
-appVersion: "0.35.0"
+version: 0.43.0
+appVersion: "0.43.0"
 keywords:
   - nextcloud
   - mcp
@@ -27,7 +27,7 @@ annotations:
   grafana_dashboard_folder: "Nextcloud MCP"
 dependencies:
   - name: qdrant
-    version: "1.15.5"
+    version: "1.16.0"
     repository: https://qdrant.github.io/qdrant-helm
     condition: qdrant.networkMode.deploySubchart
   - name: ollama

docker-compose.yml

@@ -3,7 +3,7 @@ services:
   # https://hub.docker.com/_/mariadb
   db:
     # Note: Check the recommend version here: https://docs.nextcloud.com/server/latest/admin_manual/installation/system_requirements.html#server
-    image: docker.io/library/mariadb:lts@sha256:6b848cb24fbbd87429917f6c4422ac53c343e85692eb0fef86553e99e4f422f3
+    image: docker.io/library/mariadb:lts@sha256:1cac8492bd78b1ec693238dc600be173397efd7b55eabc725abc281dc855b482
     restart: always
     command: --transaction-isolation=READ-COMMITTED
     volumes:
@@ -34,7 +34,7 @@ services:
       - ./app-hooks:/docker-entrypoint-hooks.d:ro
       # Mount OIDC development directory outside /var/www/html to avoid rsync conflicts
       # The post-installation hook will register /opt/apps as an additional app directory
-      #- ./third_party:/opt/apps:ro
+      - ./third_party:/opt/apps:ro
     environment:
       - NEXTCLOUD_TRUSTED_DOMAINS=app
       - NEXTCLOUD_ADMIN_USER=admin
@@ -225,7 +225,7 @@ services:
       - keycloak-oauth-storage:/app/.oauth
 
   qdrant:
-    image: qdrant/qdrant:v1.15.5@sha256:0fb8897412abc81d1c0430a899b9a81eb8328aa634e7242d1bc804c1fe8fe863
+    image: qdrant/qdrant:v1.16.0@sha256:1005201498cf927d835383d0f918b17d8c9da7db58550f169f694455e42d78f4
     restart: always
     ports:
       - 127.0.0.1:6333:6333  # REST API

docs/ADR-011-improving-semantic-search-quality.md

@@ -1,7 +1,8 @@
 # ADR-011: Improving Semantic Search Quality Through Better Chunking and Embeddings
 
-**Status**: Proposed
+**Status**: Partially Implemented (Chunking Complete, Embeddings Pending)
 **Date**: 2025-11-12
+**Implementation Date**: 2025-11-18 (Chunking)
 **Authors**: Development Team
 **Related**: ADR-003 (Vector Database Architecture), ADR-008 (MCP Sampling for RAG)
 
@@ -893,3 +894,50 @@ This ADR addresses the root causes of poor semantic search recall:
 - No new infrastructure or ongoing costs
 
 **Next Steps**: Approve ADR → Implement changes → Reindex → Validate → Production rollout
+
+## Implementation Status
+
+### Completed (2025-11-18)
+
+**✅ Semantic Markdown-Aware Chunking (Option C1 + C3 Hybrid)**
+
+Implementation details:
+- Replaced custom word-based chunking with `MarkdownTextSplitter` from LangChain
+- Optimized for Nextcloud Notes markdown content with special handling for:
+  - Headers (`#`, `##`, `###`, etc.)
+  - Code blocks (` ``` `)
+  - Lists (`-`, `*`, `1.`)
+  - Horizontal rules (`---`)
+  - Paragraphs and sentences
+- Maintained `ChunkWithPosition` interface for backward compatibility
+- Updated configuration defaults:
+  - `DOCUMENT_CHUNK_SIZE`: 512 words → 2048 characters
+  - `DOCUMENT_CHUNK_OVERLAP`: 50 words → 200 characters
+- Updated unit tests to verify position tracking and boundary preservation
+- All tests passing with markdown-aware character-based chunking
+
+**Files Modified**:
+- `nextcloud_mcp_server/vector/document_chunker.py` - LangChain integration
+- `nextcloud_mcp_server/config.py` - Character-based defaults
+- `tests/unit/test_document_chunker.py` - Updated test suite
+
+**Dependencies Added**:
+- `langchain-text-splitters>=1.0.0` (already present in `pyproject.toml`)
+
+**Migration Required**:
+- ⚠️ Full reindex required to apply new chunking strategy
+- Existing documents in vector database use old word-based chunks
+- See "Migration Strategy" section above for reindexing process
+
+### Pending
+
+**⏳ Embedding Model Upgrade (Option E1)**
+
+Still to be implemented:
+- Switch from `nomic-embed-text` (768-dim) to `mxbai-embed-large-v1` (1024-dim)
+- Implement dynamic dimension detection in `ollama_provider.py`
+- Create migration script for collection reindexing
+- Run benchmarking to validate improvement
+- Deploy to production with atomic collection swap
+
+**Estimated Timeline**: 1-2 weeks for implementation and validation

docs/ADR-014-bm25-search.md

@@ -0,0 +1,241 @@
+# ADR-014: Replace Custom Keyword Search with BM25 Hybrid Search via Qdrant
+
+**Date:** 2025-11-16
+
+**Status:** Implemented
+
+---
+
+### 1. Context
+
+Our RAG application currently employs two separate retrieval mechanisms:
+1.  **Dense (Semantic) Search:** Using vector embeddings stored in our Qdrant database to find semantically similar context.
+2.  **Keyword Search:** A custom-built fuzzy/character-based search to match-specific keywords, acronyms, and product codes that semantic search often misses.
+
+This dual-system approach has several drawbacks:
+* **Poor Relevance:** Our current keyword search is basic (e.g., `LIKE` queries or simple fuzzy matching). It is not as effective as modern full-text search algorithms like BM25.
+* **Clunky Fusion:** We lack a robust, principled method to combine the results from the two systems. This leads to disjointed logic in the application layer and suboptimal context being passed to the LLM.
+* **Architectural Complexity:** We must maintain two separate search pathways (one to Qdrant, one to the keyword search mechanism), increasing code complexity and maintenance overhead.
+
+Our vector database, **Qdrant**, natively supports **hybrid search** by combining dense vectors with BM25-based **sparse vectors** in a single collection.
+
+### 2. Decision
+
+We will **deprecate and remove** the existing custom keyword/fuzzy search functionality.
+
+We will **replace it by implementing native hybrid search within Qdrant**. This involves:
+1.  **Modifying the Qdrant Collection:** Updating our collection to support a named sparse vector index configured for BM25.
+2.  **Updating the Ingestion Pipeline:** For every document chunk, we will generate and upsert *both*:
+    * Its **dense vector** (from our existing embedding model).
+    * Its **sparse vector** (generated using a BM25-compatible model, e.g., `Qdrant/bm25` from `fastembed`).
+3.  **Refactoring Retrieval Logic:** All retrieval calls will be consolidated into a single Qdrant query using the `query_points` endpoint. This query will use the `prefetch` parameter to execute both dense and sparse searches, and Qdrant's built-in **Reciprocal Rank Fusion (RRF)** to automatically merge the results into a single, relevance-ranked list.
+4.  **Backfilling:** A one-time migration script will be created to generate and add sparse vectors for all existing documents in the Qdrant collection.
+
+---
+
+### 3. Considered Options
+
+#### Option 1: Native Qdrant Hybrid Search (Chosen)
+* Use Qdrant's built-in sparse vector and RRF capabilities.
+* **Pros:**
+    * **Consolidated Architecture:** Manages both dense and sparse indexes in one database.
+    * **No Data Sync Issues:** Updates are atomic. A single `upsert` updates both representations.
+    * **Built-in Fusion:** RRF is handled natively and efficiently by the database.
+    * **Superior Relevance:** Replaces our brittle custom search with the industry-standard BM25.
+* **Cons:**
+    * Requires a one-time data backfill which may be time-consuming.
+    * Adds a new step (sparse vector generation) to the ingestion pipeline.
+
+#### Option 2: External Full-Text Search (e.g., Elasticsearch)
+* Keep Qdrant for dense search and add a separate Elasticsearch/OpenSearch cluster for BM25.
+* **Pros:**
+    * Provides a very powerful, dedicated full-text search engine.
+* **Cons:**
+    * **High Complexity:** Introduces a new, stateful service to deploy, manage, and scale.
+    * **Data Sync Nightmare:** We would be responsible for ensuring that the document IDs and content in Qdrant and Elasticsearch are always perfectly synchronized. This is a major source of bugs.
+    * **Manual Fusion:** The application would have to query both systems and perform RRF manually.
+
+#### Option 3: Keep Current System
+* Make no changes.
+* **Pros:**
+    * No engineering effort required.
+* **Cons:**
+    * Fails to address the known relevance and architectural problems.
+    * Our RAG application's performance will remain suboptimal, especially for keyword-sensitive queries.
+
+---
+
+### 4. Rationale
+
+**Option 1 is the clear winner.** It directly solves our primary problem (poor keyword matching) by adopting the industry-standard BM25.
+
+Critically, it achieves this while **simplifying** our overall architecture, not complicating it. By leveraging features already present in our existing database (Qdrant), we avoid the massive operational and synchronization overhead of adding a second search system (Option 2).
+
+This decision consolidates our retrieval logic, eliminates the data consistency problem, and moves the complex fusion logic (RRF) from the application layer into the database, where it can be performed more efficiently.
+
+### 5. Consequences
+
+**New Work:**
+* **Ingestion:** The data ingestion pipeline must be updated to add the `fastembed` library (or similar), generate sparse vectors, and upsert them to the new named vector field in Qdrant.
+* **Retrieval:** The application's retrieval service must be refactored to use the `query_points` endpoint with `prefetch` and `fusion=models.Fusion.RRF`.
+* **Migration:** A one-time backfill script must be written and executed to add sparse vectors for all existing documents.
+* **Infrastructure:** The Qdrant collection schema must be updated (or re-created) to add the `sparse_vectors_config`.
+
+**Positive:**
+* **Improved Accuracy:** Retrieval will be significantly more accurate, handling both semantic and keyword queries robustly.
+* **Simplified Code:** The application's retrieval logic will be cleaner and simpler, with one endpoint instead of two.
+* **Reduced Maintenance:** We will remove the custom fuzzy-search code, which is brittle and difficult to maintain.
+
+**Negative:**
+* The data backfill process will require careful management to avoid downtime.
+* Ingestion time will slightly increase due to the extra step of sparse vector generation. This is considered a negligible trade-off for the gains in relevance.
+
+---
+
+### 6. Implementation Notes
+
+**Implementation completed on 2025-11-16**
+
+**Key Changes:**
+
+1. **Dependencies** (pyproject.toml:25):
+   - Added `fastembed>=0.4.2` for BM25 sparse vector embeddings
+   - Adjusted `pillow` version constraint to be compatible with fastembed
+
+2. **Qdrant Collection Schema** (nextcloud_mcp_server/vector/qdrant_client.py:113-128):
+   - Updated to named vectors: `{"dense": VectorParams(...), "sparse": SparseVectorParams(...)}`
+   - Added sparse vector configuration with BM25 index
+   - Maintains backward compatibility with existing collections (detects legacy schema)
+
+3. **BM25 Embedding Provider** (nextcloud_mcp_server/embedding/bm25_provider.py):
+   - Created `BM25SparseEmbeddingProvider` using FastEmbed's `Qdrant/bm25` model
+   - Implements `encode()` and `encode_batch()` methods
+   - Returns sparse vectors as `{indices: list[int], values: list[float]}` format
+
+4. **Document Indexing Pipeline** (nextcloud_mcp_server/vector/processor.py:229-255):
+   - Generates both dense (semantic) and sparse (BM25) embeddings for each document chunk
+   - Updates `PointStruct` to use named vectors: `vector={"dense": ..., "sparse": ...}`
+   - Maintains same chunking strategy (512 words, 50-word overlap)
+
+5. **BM25 Hybrid Search Algorithm** (nextcloud_mcp_server/search/bm25_hybrid.py):
+   - Implements `BM25HybridSearchAlgorithm` using Qdrant's native RRF fusion
+   - Uses `prefetch` parameter for parallel dense + sparse search
+   - Applies `fusion=models.Fusion.RRF` for automatic result merging
+   - Maintains same deduplication and filtering logic as semantic search
+
+6. **MCP Tool Updates** (nextcloud_mcp_server/server/semantic.py:39-68):
+   - Simplified `nc_semantic_search()` to use BM25 hybrid only
+   - Removed `algorithm`, `semantic_weight`, `keyword_weight`, `fuzzy_weight` parameters
+   - Updated default `score_threshold=0.0` for RRF scoring
+   - Returns `search_method="bm25_hybrid"` in responses
+
+7. **Legacy Algorithm Removal**:
+   - Deleted `nextcloud_mcp_server/search/keyword.py` (278 lines)
+   - Deleted `nextcloud_mcp_server/search/fuzzy.py` (220 lines)
+   - Deleted `nextcloud_mcp_server/search/hybrid.py` (238 lines - custom RRF)
+   - Updated `nextcloud_mcp_server/search/__init__.py` to export only BM25 hybrid
+
+**Migration Strategy:**
+- No migration required (vector sync feature is experimental)
+- New documents automatically indexed with both dense + sparse vectors
+- Collection re-creation on first startup with updated schema
+
+**Test Results:**
+- All unit tests passing (118 passed)
+- All integration tests passing (7 semantic search tests)
+- Code formatting verified with ruff
+
+**Benefits Realized:**
+- ✅ Consolidated architecture (single Qdrant database for both dense + sparse)
+- ✅ Native fusion algorithms (database-level, more efficient)
+- ✅ Industry-standard BM25 (replaces custom keyword search)
+- ✅ Simplified codebase (removed 736 lines of legacy code)
+- ✅ Better relevance (handles both semantic and keyword queries)
+- ✅ Configurable fusion methods (RRF and DBSF)
+
+---
+
+### 7. Fusion Algorithm Options
+
+**Update: 2025-11-16**
+
+The BM25 hybrid search now supports two fusion algorithms for combining dense (semantic) and sparse (BM25) search results:
+
+#### Reciprocal Rank Fusion (RRF)
+
+**Default fusion method.** RRF is a widely-used, well-established algorithm that combines rankings from multiple retrieval systems using the reciprocal rank formula:
+
+```
+RRF(doc) = Σ 1/(k + rank_i(doc))
+```
+
+where `k` is a constant (typically 60) and `rank_i(doc)` is the rank of the document in retrieval system `i`.
+
+**Characteristics:**
+- ✅ **General-purpose**: Works well across diverse query types and document collections
+- ✅ **Rank-based**: Focuses on relative rankings rather than absolute scores
+- ✅ **Established**: Well-tested, documented, and understood in IR literature
+- ✅ **Robust**: Less sensitive to score distribution differences between systems
+
+**When to use RRF:**
+- Default choice for most use cases
+- When you have mixed query types (semantic + keyword)
+- When retrieval systems have very different score ranges
+- When you want predictable, well-understood behavior
+
+#### Distribution-Based Score Fusion (DBSF)
+
+**Alternative fusion method.** DBSF normalizes scores from each retrieval system using distribution statistics before combining them:
+
+1. **Normalization**: For each query, calculates mean (μ) and standard deviation (σ) of scores
+2. **Outlier handling**: Uses μ ± 3σ as normalization bounds
+3. **Fusion**: Sums normalized scores across systems
+
+**Characteristics:**
+- ✅ **Score-aware**: Uses actual relevance scores, not just rankings
+- ✅ **Statistical**: Normalizes based on score distribution properties
+- ⚠️ **Experimental**: Newer algorithm, less battle-tested than RRF
+- ⚠️ **Sensitive**: May behave differently depending on score distributions
+
+**When to use DBSF:**
+- When retrieval systems have vastly different score ranges that RRF doesn't balance well
+- When you want to experiment with score-based (vs rank-based) fusion
+- When statistical normalization better matches your use case
+- For A/B testing against RRF to measure retrieval quality improvements
+
+#### Configuration
+
+Both fusion algorithms are exposed via the `fusion` parameter in MCP tools:
+
+```python
+# Use RRF (default)
+response = await nc_semantic_search(
+    query="async programming",
+    fusion="rrf"  # Can be omitted, RRF is default
+)
+
+# Use DBSF
+response = await nc_semantic_search(
+    query="async programming",
+    fusion="dbsf"
+)
+```
+
+The `nc_semantic_search_answer` tool also supports the `fusion` parameter and passes it through to the underlying search.
+
+#### Future: Configurable Weights
+
+**Current limitation**: Neither RRF nor DBSF currently support per-system weights (e.g., 0.8 for semantic, 0.2 for BM25). This is a Qdrant platform limitation tracked in [qdrant/qdrant#6067](https://github.com/qdrant/qdrant/issues/6067).
+
+When Qdrant adds weight support, the `fusion` parameter can be extended to accept weight configurations:
+
+```python
+# Hypothetical future API
+response = await nc_semantic_search(
+    query="async programming",
+    fusion="rrf",
+    fusion_weights={"dense": 0.7, "sparse": 0.3}  # Not yet implemented
+)
+```
+
+**Recommendation**: Start with RRF (default). If you encounter cases where keyword matches are under- or over-weighted, experiment with DBSF. Monitor [qdrant/qdrant#6067](https://github.com/qdrant/qdrant/issues/6067) for configurable weight support.

docs/ADR-015-unified-provider-architecture.md

@@ -0,0 +1,380 @@
+# ADR-015: Unified Provider Architecture for Embeddings and Text Generation
+
+**Status:** Accepted
+**Date:** 2025-01-16
+**Deciders:** Development Team
+**Related:** ADR-003 (Vector Database), ADR-008 (MCP Sampling), ADR-013 (RAG Evaluation)
+
+## Context
+
+Prior to this refactoring, the codebase had two separate provider systems:
+
+1. **Embedding Providers** (`nextcloud_mcp_server/embedding/`)
+   - Used `EmbeddingProvider` ABC with methods: `embed()`, `embed_batch()`, `get_dimension()`
+   - Had auto-detection via `EmbeddingService._detect_provider()`
+   - Used for semantic search and vector indexing (production)
+
+2. **LLM Providers** (`tests/rag_evaluation/llm_providers.py`)
+   - Used `LLMProvider` Protocol with method: `generate()`
+   - Had separate factory function `create_llm_provider()`
+   - Used only for RAG evaluation tests (not production)
+
+This fragmentation created several problems:
+
+### Problems with Dual Provider Systems
+
+1. **Code Duplication**
+   - Ollama configuration appeared in both `embedding/service.py` and `tests/rag_evaluation/llm_providers.py`
+   - Similar provider detection logic in multiple places
+   - Separate singleton patterns for each system
+
+2. **Limited Extensibility**
+   - Hard-coded provider detection in `EmbeddingService._detect_provider()`
+   - No support for providers that offer both capabilities (like Bedrock)
+   - Adding new providers required modifying multiple files
+
+3. **Inconsistent Patterns**
+   - BM25 provider didn't follow `EmbeddingProvider` ABC
+   - Different method names across providers (`embed` vs `encode`)
+   - ABC vs Protocol for type checking
+
+4. **Difficult Scaling**
+   - Adding Amazon Bedrock (our third provider) would exacerbate all issues
+   - No clear path for future providers (OpenAI, Cohere, etc.)
+
+### Amazon Bedrock Requirements
+
+Bedrock naturally supports **both** embeddings and text generation:
+- **Embeddings**: `amazon.titan-embed-text-v1/v2`, `cohere.embed-*`
+- **Text Generation**: `anthropic.claude-*`, `meta.llama3-*`, `amazon.titan-text-*`
+- **Unified API**: Single `invoke_model()` method via bedrock-runtime
+
+This made it the perfect opportunity to establish a unified provider architecture.
+
+## Decision
+
+We refactored the provider infrastructure to use a **unified Provider ABC** with optional capabilities:
+
+### 1. Unified Provider Interface
+
+**New Structure:**
+```
+nextcloud_mcp_server/providers/
+├── __init__.py
+├── base.py              # Provider ABC with optional capabilities
+├── registry.py          # Auto-detection and factory
+├── ollama.py            # Supports both embedding + generation
+├── anthropic.py         # Generation only
+├── bedrock.py           # Supports both embedding + generation
+└── simple.py            # Embedding only (testing fallback)
+```
+
+**Base Class (`providers/base.py`):**
+```python
+class Provider(ABC):
+    @property
+    @abstractmethod
+    def supports_embeddings(self) -> bool:
+        """Whether this provider supports embedding generation."""
+        pass
+
+    @property
+    @abstractmethod
+    def supports_generation(self) -> bool:
+        """Whether this provider supports text generation."""
+        pass
+
+    @abstractmethod
+    async def embed(self, text: str) -> list[float]:
+        """Generate embedding (raises NotImplementedError if not supported)."""
+        pass
+
+    @abstractmethod
+    async def embed_batch(self, texts: list[str]) -> list[list[float]]:
+        """Generate batch embeddings (raises NotImplementedError if not supported)."""
+        pass
+
+    @abstractmethod
+    def get_dimension(self) -> int:
+        """Get embedding dimension (raises NotImplementedError if not supported)."""
+        pass
+
+    @abstractmethod
+    async def generate(self, prompt: str, max_tokens: int = 500) -> str:
+        """Generate text (raises NotImplementedError if not supported)."""
+        pass
+
+    @abstractmethod
+    async def close(self) -> None:
+        """Close provider and release resources."""
+        pass
+```
+
+### 2. Provider Registry
+
+**Auto-Detection Priority** (`providers/registry.py`):
+```python
+class ProviderRegistry:
+    @staticmethod
+    def create_provider() -> Provider:
+        # 1. Bedrock (AWS_REGION or BEDROCK_*_MODEL)
+        # 2. Ollama (OLLAMA_BASE_URL)
+        # 3. Simple (fallback)
+```
+
+**Environment Variables:**
+
+**Bedrock:**
+- `AWS_REGION`: AWS region (e.g., "us-east-1")
+- `AWS_ACCESS_KEY_ID`: AWS access key (optional, uses credential chain)
+- `AWS_SECRET_ACCESS_KEY`: AWS secret key (optional)
+- `BEDROCK_EMBEDDING_MODEL`: Model ID for embeddings (e.g., "amazon.titan-embed-text-v2:0")
+- `BEDROCK_GENERATION_MODEL`: Model ID for text generation (e.g., "anthropic.claude-3-sonnet-20240229-v1:0")
+
+**Ollama:**
+- `OLLAMA_BASE_URL`: Ollama API base URL (e.g., "http://localhost:11434")
+- `OLLAMA_EMBEDDING_MODEL`: Model for embeddings (default: "nomic-embed-text")
+- `OLLAMA_GENERATION_MODEL`: Model for text generation (e.g., "llama3.2:1b")
+- `OLLAMA_VERIFY_SSL`: Verify SSL certificates (default: "true")
+
+**Simple (no configuration, fallback):**
+- `SIMPLE_EMBEDDING_DIMENSION`: Embedding dimension (default: 384)
+
+### 3. Backward Compatibility
+
+**Old Code Continues to Work:**
+```python
+# Old way (still works)
+from nextcloud_mcp_server.embedding import get_embedding_service
+
+service = get_embedding_service()  # Returns singleton Provider
+embeddings = await service.embed_batch(texts)
+```
+
+**New Way (recommended):**
+```python
+# New way (cleaner)
+from nextcloud_mcp_server.providers import get_provider
+
+provider = get_provider()  # Returns singleton Provider
+embeddings = await provider.embed_batch(texts)
+
+# Can also use generation if provider supports it
+if provider.supports_generation:
+    text = await provider.generate("prompt")
+```
+
+**Migration Path:**
+- `embedding/service.py` now wraps `providers.get_provider()` for compatibility
+- `tests/rag_evaluation/llm_providers.py` now uses unified providers
+- Old imports still work, marked as deprecated in docstrings
+
+### 4. Amazon Bedrock Implementation
+
+**Features:**
+- Supports both embeddings and text generation
+- Model-specific request/response handling for:
+  - Titan Embed (amazon.titan-embed-text-*)
+  - Cohere Embed (cohere.embed-*)
+  - Claude (anthropic.claude-*)
+  - Llama (meta.llama3-*)
+  - Titan Text (amazon.titan-text-*)
+  - Mistral (mistral.*)
+- Uses boto3 bedrock-runtime client
+- Graceful degradation if boto3 not installed
+- Async implementation matching existing patterns
+
+**Model-Specific Handling:**
+```python
+# Bedrock embedding request (Titan)
+{"inputText": text}
+
+# Bedrock generation request (Claude)
+{
+    "anthropic_version": "bedrock-2023-05-31",
+    "max_tokens": max_tokens,
+    "temperature": 0.7,
+    "messages": [{"role": "user", "content": prompt}]
+}
+```
+
+## Consequences
+
+### Positive
+
+1. **Sustainable Provider Additions**
+   - New providers only need to implement `Provider` ABC
+   - Auto-detection via environment variables
+   - No modifications to existing code required
+
+2. **Code Consolidation**
+   - Single provider interface instead of two
+   - Unified configuration pattern
+   - Eliminated duplication
+
+3. **Better Extensibility**
+   - Providers can support one or both capabilities
+   - Clear capability detection via properties
+   - Registry pattern simplifies auto-detection
+
+4. **Improved Testing**
+   - RAG evaluation can use any provider (Ollama, Anthropic, Bedrock)
+   - Comprehensive unit tests for all providers
+   - Mocked boto3 tests for Bedrock
+
+5. **Production-Ready Bedrock Support**
+   - Full embedding and generation support
+   - Multiple model families supported
+   - AWS credential chain integration
+
+### Neutral
+
+1. **Optional Boto3 Dependency**
+   - boto3 is dev dependency only (not required for core functionality)
+   - Bedrock provider gracefully fails if boto3 not installed
+   - Users who want Bedrock must `pip install boto3`
+
+2. **Capability Properties**
+   - All providers must implement capability properties
+   - Methods raise `NotImplementedError` if capability not supported
+   - Clear error messages guide users to alternatives
+
+### Negative
+
+1. **Migration Effort**
+   - Existing code must be migrated to new imports (optional, backward compatible)
+   - Documentation needs updating
+   - Users must learn new environment variables
+
+2. **Increased Complexity**
+   - Provider base class has more methods (embedding + generation)
+   - More environment variables to configure
+   - Capability detection adds runtime checks
+
+## Implementation
+
+### Files Created
+
+**New Provider Infrastructure:**
+- `nextcloud_mcp_server/providers/__init__.py`
+- `nextcloud_mcp_server/providers/base.py`
+- `nextcloud_mcp_server/providers/registry.py`
+- `nextcloud_mcp_server/providers/ollama.py`
+- `nextcloud_mcp_server/providers/anthropic.py`
+- `nextcloud_mcp_server/providers/bedrock.py`
+- `nextcloud_mcp_server/providers/simple.py`
+
+**Tests:**
+- `tests/unit/providers/__init__.py`
+- `tests/unit/providers/test_bedrock.py` (9 unit tests)
+
+**Documentation:**
+- `docs/ADR-015-unified-provider-architecture.md` (this file)
+
+### Files Modified
+
+**Backward Compatibility:**
+- `nextcloud_mcp_server/embedding/service.py` - Now wraps `get_provider()`
+- `tests/rag_evaluation/llm_providers.py` - Uses unified providers
+
+**Dependencies:**
+- `pyproject.toml` - Added `boto3>=1.35.0` to dev dependencies
+
+### Testing Results
+
+**Unit Tests:** 127 passed (including 9 new Bedrock tests)
+**Type Checking:** All checks passed (ty)
+**Linting:** All checks passed (ruff)
+**Backward Compatibility:** Verified - existing embedding tests work
+
+## Alternatives Considered
+
+### Alternative 1: Keep Separate Provider Systems
+
+**Pros:**
+- No refactoring needed
+- Simpler short-term
+
+**Cons:**
+- Bedrock would need to be implemented twice
+- Continued code duplication
+- No long-term scalability
+
+**Decision:** Rejected - technical debt would continue to grow
+
+### Alternative 2: Separate Embedding and Generation Providers
+
+Use composition instead of unified interface:
+```python
+class CombinedProvider:
+    def __init__(self, embedding: EmbeddingProvider, generation: LLMProvider):
+        self.embedding = embedding
+        self.generation = generation
+```
+
+**Pros:**
+- Clearer separation of concerns
+- Simpler individual providers
+
+**Cons:**
+- Bedrock and Ollama naturally do both - artificial separation
+- More complex configuration (two providers to configure)
+- More boilerplate code
+
+**Decision:** Rejected - unified interface better matches provider capabilities
+
+### Alternative 3: Plugin System
+
+Dynamic provider registration via entry points:
+```python
+# setup.py
+entry_points={
+    'nextcloud_mcp.providers': [
+        'ollama = nextcloud_mcp_server.providers.ollama:OllamaProvider',
+        'bedrock = nextcloud_mcp_server.providers.bedrock:BedrockProvider',
+    ]
+}
+```
+
+**Pros:**
+- Most extensible
+- Third-party providers possible
+
+**Cons:**
+- Over-engineered for current needs
+- Added complexity
+- No immediate benefit
+
+**Decision:** Deferred - can add later if needed
+
+## Future Work
+
+1. **Additional Providers**
+   - OpenAI (embeddings + generation)
+   - Cohere (embeddings + generation)
+   - Google Vertex AI
+   - Azure OpenAI
+
+2. **Provider Features**
+   - Streaming generation support
+   - Batch API optimization (when available)
+   - Model-specific optimizations
+   - Cost tracking and metrics
+
+3. **Configuration Improvements**
+   - Provider profiles (development, production)
+   - Model aliasing (e.g., "small", "large")
+   - Fallback provider chains
+
+4. **Testing**
+   - Integration tests with real Bedrock endpoints
+   - Performance benchmarking across providers
+   - Cost comparison analysis
+
+## References
+
+- [boto3 Bedrock Runtime Documentation](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/bedrock-runtime.html)
+- [Amazon Bedrock User Guide](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html)
+- ADR-003: Vector Database and Semantic Search
+- ADR-008: MCP Sampling for Semantic Search
+- ADR-013: RAG Evaluation Framework

docs/bedrock-setup.md

@@ -0,0 +1,338 @@
+# Amazon Bedrock Setup Guide
+
+This guide covers how to configure the Nextcloud MCP Server to use Amazon Bedrock for embeddings and text generation.
+
+## Prerequisites
+
+1. **AWS Account** with access to Amazon Bedrock
+2. **boto3 library** installed: `pip install boto3` or `uv sync --group dev`
+3. **Model Access** - Request access to models in AWS Bedrock console
+
+## Required AWS Permissions
+
+### IAM Policy for Bedrock Access
+
+The AWS IAM user or role needs the following permissions:
+
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Sid": "BedrockInvokeModels",
+      "Effect": "Allow",
+      "Action": [
+        "bedrock:InvokeModel",
+        "bedrock:InvokeModelWithResponseStream"
+      ],
+      "Resource": [
+        "arn:aws:bedrock:*::foundation-model/*"
+      ]
+    }
+  ]
+}
+```
+
+### Minimal Permissions (Production)
+
+For production deployments, restrict to specific models:
+
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Sid": "BedrockEmbeddings",
+      "Effect": "Allow",
+      "Action": [
+        "bedrock:InvokeModel"
+      ],
+      "Resource": [
+        "arn:aws:bedrock:us-east-1::foundation-model/amazon.titan-embed-text-v2:0"
+      ]
+    },
+    {
+      "Sid": "BedrockGeneration",
+      "Effect": "Allow",
+      "Action": [
+        "bedrock:InvokeModel"
+      ],
+      "Resource": [
+        "arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-3-sonnet-20240229-v1:0"
+      ]
+    }
+  ]
+}
+```
+
+### Additional Permissions (Optional)
+
+For advanced use cases:
+
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Sid": "BedrockListModels",
+      "Effect": "Allow",
+      "Action": [
+        "bedrock:ListFoundationModels",
+        "bedrock:GetFoundationModel"
+      ],
+      "Resource": "*"
+    },
+    {
+      "Sid": "BedrockAsyncInvoke",
+      "Effect": "Allow",
+      "Action": [
+        "bedrock:InvokeModelAsync",
+        "bedrock:GetAsyncInvoke",
+        "bedrock:ListAsyncInvokes"
+      ],
+      "Resource": [
+        "arn:aws:bedrock:*::foundation-model/*"
+      ]
+    }
+  ]
+}
+```
+
+## Model Access
+
+Before using Bedrock models, you must request access in the AWS Console:
+
+1. Navigate to **Amazon Bedrock** → **Model access**
+2. Click **Manage model access**
+3. Select models you want to use:
+   - **Embeddings:** Amazon Titan Embed Text, Cohere Embed
+   - **Text Generation:** Anthropic Claude, Meta Llama, Amazon Titan Text
+4. Click **Request model access**
+5. Wait for approval (usually instant for most models)
+
+## Supported Models
+
+### Embedding Models
+
+| Provider | Model ID | Dimensions | Best For |
+|----------|----------|------------|----------|
+| Amazon Titan | `amazon.titan-embed-text-v1` | 1,536 | General purpose |
+| Amazon Titan | `amazon.titan-embed-text-v2:0` | 1,024 | Latest, improved quality |
+| Cohere | `cohere.embed-english-v3` | 1,024 | English text |
+| Cohere | `cohere.embed-multilingual-v3` | 1,024 | Multilingual |
+
+### Text Generation Models
+
+| Provider | Model ID | Context | Best For |
+|----------|----------|---------|----------|
+| Anthropic | `anthropic.claude-3-sonnet-20240229-v1:0` | 200K | Balanced performance |
+| Anthropic | `anthropic.claude-3-haiku-20240307-v1:0` | 200K | Fast, cost-effective |
+| Anthropic | `anthropic.claude-3-opus-20240229-v1:0` | 200K | Highest quality |
+| Meta | `meta.llama3-8b-instruct-v1:0` | 8K | Fast, open-source |
+| Meta | `meta.llama3-70b-instruct-v1:0` | 8K | High quality |
+| Amazon | `amazon.titan-text-express-v1` | 8K | Fast, low cost |
+| Mistral | `mistral.mistral-7b-instruct-v0:2` | 32K | Efficient |
+
+## Configuration
+
+### Environment Variables
+
+**Required:**
+```bash
+AWS_REGION=us-east-1
+```
+
+**Optional (at least one model required):**
+```bash
+# For embeddings
+BEDROCK_EMBEDDING_MODEL=amazon.titan-embed-text-v2:0
+
+# For text generation (RAG evaluation)
+BEDROCK_GENERATION_MODEL=anthropic.claude-3-sonnet-20240229-v1:0
+```
+
+**AWS Credentials (choose one method):**
+
+**Method 1: Environment Variables**
+```bash
+AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
+AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
+```
+
+**Method 2: AWS Credentials File** (`~/.aws/credentials`)
+```ini
+[default]
+aws_access_key_id = AKIAIOSFODNN7EXAMPLE
+aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
+```
+
+**Method 3: IAM Role** (when running on AWS EC2/ECS/Lambda)
+- No credentials needed, uses instance/task role automatically
+
+### Docker Configuration
+
+Add to your `docker-compose.yml`:
+
+```yaml
+services:
+  mcp:
+    environment:
+      - AWS_REGION=us-east-1
+      - BEDROCK_EMBEDDING_MODEL=amazon.titan-embed-text-v2:0
+      - BEDROCK_GENERATION_MODEL=anthropic.claude-3-sonnet-20240229-v1:0
+      - AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID}
+      - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY}
+```
+
+Or use AWS credentials file volume mount:
+
+```yaml
+services:
+  mcp:
+    volumes:
+      - ~/.aws:/root/.aws:ro
+    environment:
+      - AWS_REGION=us-east-1
+      - BEDROCK_EMBEDDING_MODEL=amazon.titan-embed-text-v2:0
+```
+
+## Usage Examples
+
+### Embeddings Only
+
+```bash
+export AWS_REGION=us-east-1
+export BEDROCK_EMBEDDING_MODEL=amazon.titan-embed-text-v2:0
+export AWS_ACCESS_KEY_ID=your-key
+export AWS_SECRET_ACCESS_KEY=your-secret
+
+uv run nextcloud-mcp-server
+```
+
+### Both Embeddings and Generation
+
+```bash
+export AWS_REGION=us-east-1
+export BEDROCK_EMBEDDING_MODEL=amazon.titan-embed-text-v2:0
+export BEDROCK_GENERATION_MODEL=anthropic.claude-3-sonnet-20240229-v1:0
+
+# For RAG evaluation with Bedrock
+export RAG_EVAL_PROVIDER=bedrock
+export RAG_EVAL_BEDROCK_MODEL=anthropic.claude-3-sonnet-20240229-v1:0
+
+uv run python -m tests.rag_evaluation.evaluate
+```
+
+### Programmatic Usage
+
+```python
+from nextcloud_mcp_server.providers import BedrockProvider
+
+# Embeddings only
+provider = BedrockProvider(
+    region_name="us-east-1",
+    embedding_model="amazon.titan-embed-text-v2:0",
+)
+
+embeddings = await provider.embed_batch(["text1", "text2"])
+
+# Both capabilities
+provider = BedrockProvider(
+    region_name="us-east-1",
+    embedding_model="amazon.titan-embed-text-v2:0",
+    generation_model="anthropic.claude-3-sonnet-20240229-v1:0",
+)
+
+# Generate embeddings
+embedding = await provider.embed("query text")
+
+# Generate text
+response = await provider.generate("Write a summary", max_tokens=500)
+```
+
+## Cost Considerations
+
+### Embedding Costs (as of Jan 2025)
+
+| Model | Price per 1K tokens |
+|-------|---------------------|
+| Titan Embed Text v2 | $0.0001 |
+| Cohere Embed English v3 | $0.0001 |
+
+### Generation Costs (as of Jan 2025)
+
+| Model | Input (per 1K tokens) | Output (per 1K tokens) |
+|-------|----------------------|------------------------|
+| Claude 3 Haiku | $0.00025 | $0.00125 |
+| Claude 3 Sonnet | $0.003 | $0.015 |
+| Claude 3 Opus | $0.015 | $0.075 |
+| Llama 3 8B | $0.0003 | $0.0006 |
+| Titan Text Express | $0.0002 | $0.0006 |
+
+**Note:** Prices vary by region. Check [AWS Bedrock Pricing](https://aws.amazon.com/bedrock/pricing/) for current rates.
+
+## Troubleshooting
+
+### Error: "Executable doesn't exist" or boto3 not found
+
+**Solution:**
+```bash
+uv sync --group dev  # Installs boto3
+```
+
+### Error: "AccessDeniedException"
+
+**Causes:**
+1. IAM permissions missing
+2. Model access not requested
+3. Wrong AWS region
+
+**Solution:**
+1. Verify IAM policy includes `bedrock:InvokeModel`
+2. Request model access in Bedrock console
+3. Check model is available in your region
+
+### Error: "ResourceNotFoundException"
+
+**Cause:** Invalid model ID or model not available in region
+
+**Solution:**
+- Verify model ID matches exactly (case-sensitive)
+- Check model availability in your AWS region
+- Use `aws bedrock list-foundation-models` to see available models
+
+### Error: "ThrottlingException"
+
+**Cause:** Rate limit exceeded
+
+**Solution:**
+- Reduce request rate
+- Request quota increase via AWS Support
+- Use batch operations where possible
+
+## Security Best Practices
+
+1. **Use IAM Roles** when running on AWS infrastructure
+2. **Rotate Access Keys** regularly if using IAM users
+3. **Restrict Permissions** to only required models
+4. **Enable CloudTrail** for audit logging
+5. **Use AWS Secrets Manager** for credential management
+6. **Monitor Costs** with AWS Cost Explorer and Budgets
+
+## Regional Availability
+
+Amazon Bedrock is available in:
+- **US East (N. Virginia)**: `us-east-1` ✅ Most models
+- **US West (Oregon)**: `us-west-2` ✅ Most models
+- **Asia Pacific (Singapore)**: `ap-southeast-1`
+- **Asia Pacific (Tokyo)**: `ap-northeast-1`
+- **Europe (Frankfurt)**: `eu-central-1`
+
+**Note:** Model availability varies by region. Check the [AWS Bedrock documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html) for current availability.
+
+## References
+
+- [AWS Bedrock Documentation](https://docs.aws.amazon.com/bedrock/)
+- [AWS Bedrock Pricing](https://aws.amazon.com/bedrock/pricing/)
+- [boto3 Bedrock Runtime API](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/bedrock-runtime.html)
+- [Provider Architecture ADR](./ADR-015-unified-provider-architecture.md)

docs/observability.md

@@ -243,7 +243,7 @@ If you see cardinality warnings:
 The observability stack integrates at multiple layers:
 
 1. **HTTP Layer**: `ObservabilityMiddleware` tracks all HTTP requests
-2. **MCP Layer**: Tools use `@trace_mcp_tool` for span creation
+2. **MCP Layer**: Tools use `@instrument_tool` for automatic metrics and trace span creation
 3. **Client Layer**: `BaseNextcloudClient` tracks all API calls
 4. **OAuth Layer**: Token operations are traced and metered
 5. **Background Tasks**: Vector sync operations emit metrics/traces

nextcloud_mcp_server/app.py

@@ -1478,6 +1478,7 @@ def get_app(transport: str = "sse", enabled_apps: list[str] | None = None):
         vector_sync_status_fragment,
     )
     from nextcloud_mcp_server.auth.viz_routes import (
+        chunk_context_endpoint,
         vector_visualization_html,
         vector_visualization_search,
     )
@@ -1509,6 +1510,11 @@ def get_app(transport: str = "sse", enabled_apps: list[str] | None = None):
             vector_visualization_search,
             methods=["GET"],
         ),  # /app/vector-viz/search
+        Route(
+            "/chunk-context",
+            chunk_context_endpoint,
+            methods=["GET"],
+        ),  # /app/chunk-context
         # Webhook management routes (admin-only)
         Route("/webhooks", webhook_management_pane, methods=["GET"]),  # /app/webhooks
         Route(
@@ -1523,7 +1529,7 @@ def get_app(transport: str = "sse", enabled_apps: list[str] | None = None):
 
     browser_app = Starlette(routes=browser_routes)
     browser_app.add_middleware(
-        AuthenticationMiddleware,
+        AuthenticationMiddleware,  # type: ignore[invalid-argument-type]
         backend=SessionAuthBackend(oauth_enabled=oauth_enabled),
     )
 
@@ -1613,7 +1619,7 @@ def get_app(transport: str = "sse", enabled_apps: list[str] | None = None):
 
     # Add CORS middleware to allow browser-based clients like MCP Inspector
     app.add_middleware(
-        CORSMiddleware,
+        CORSMiddleware,  # type: ignore[invalid-argument-type]
         allow_origins=["*"],  # Allow all origins for development
         allow_credentials=True,
         allow_methods=["*"],
@@ -1623,7 +1629,7 @@ def get_app(transport: str = "sse", enabled_apps: list[str] | None = None):
 
     # Add observability middleware (metrics + tracing)
     if settings.metrics_enabled or settings.otel_exporter_otlp_endpoint:
-        app.add_middleware(ObservabilityMiddleware)
+        app.add_middleware(ObservabilityMiddleware)  # type: ignore[invalid-argument-type]
         logger.info("Observability middleware enabled (metrics and/or tracing)")
 
     # Add exception handler for scope challenges (OAuth mode only)

nextcloud_mcp_server/auth/templates/vector_viz.html

@@ -0,0 +1,339 @@
+<style>
+    .viz-card {
+        background: white;
+        border-radius: 8px;
+        padding: 20px;
+        margin-bottom: 20px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    .viz-controls {
+        margin-bottom: 20px;
+    }
+    .viz-control-row {
+        display: grid;
+        grid-template-columns: 2fr 1fr auto;
+        gap: 12px;
+        margin-bottom: 12px;
+        align-items: end;
+    }
+    .viz-control-group {
+        margin-bottom: 15px;
+    }
+    .viz-control-group label {
+        display: block;
+        margin-bottom: 5px;
+        font-weight: 500;
+        color: #333;
+    }
+    .viz-control-group input[type="text"],
+    .viz-control-group input[type="number"],
+    .viz-control-group select {
+        width: 100%;
+        padding: 8px 12px;
+        border: 1px solid #ddd;
+        border-radius: 4px;
+        font-size: 14px;
+    }
+    .viz-control-group input[type="range"] {
+        width: 100%;
+    }
+    .viz-control-group select[multiple] {
+        min-height: 100px;
+    }
+    .viz-weight-display {
+        display: inline-block;
+        min-width: 40px;
+        text-align: right;
+        color: #666;
+    }
+    .viz-btn {
+        background: #0066cc;
+        color: white;
+        border: none;
+        padding: 10px 20px;
+        border-radius: 4px;
+        cursor: pointer;
+        font-size: 14px;
+        font-weight: 500;
+    }
+    .viz-btn:hover {
+        background: #0052a3;
+    }
+    .viz-btn-secondary {
+        background: #6c757d;
+        color: white;
+        border: none;
+        padding: 6px 12px;
+        border-radius: 4px;
+        cursor: pointer;
+        font-size: 13px;
+        margin-bottom: 12px;
+    }
+    .viz-btn-secondary:hover {
+        background: #5a6268;
+    }
+    #viz-plot-container {
+        width: 100%;
+        height: 600px;
+        position: relative;
+    }
+    #viz-plot {
+        width: 100%;
+        height: 100%;
+    }
+    .viz-loading {
+        text-align: center;
+        padding: 40px;
+        color: #666;
+    }
+    .viz-loading-overlay {
+        position: absolute;
+        inset: 0;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        background: white;
+        color: #666;
+    }
+    .viz-no-results {
+        text-align: center;
+        padding: 40px;
+        color: #666;
+        font-style: italic;
+    }
+    .viz-advanced-section {
+        margin-top: 16px;
+        padding: 16px;
+        background: #f8f9fa;
+        border-radius: 4px;
+        border: 1px solid #dee2e6;
+    }
+    .viz-advanced-grid {
+        display: grid;
+        grid-template-columns: 1fr 1fr;
+        gap: 20px;
+    }
+    .viz-info-box {
+        background: #e3f2fd;
+        border-left: 4px solid #2196f3;
+        padding: 12px;
+        margin-bottom: 20px;
+        font-size: 14px;
+    }
+    .chunk-toggle-btn {
+        background: #6c757d;
+        color: white;
+        border: none;
+        padding: 4px 10px;
+        border-radius: 3px;
+        cursor: pointer;
+        font-size: 12px;
+        margin-top: 6px;
+    }
+    .chunk-toggle-btn:hover {
+        background: #5a6268;
+    }
+    .chunk-context {
+        background: #f8f9fa;
+        border: 1px solid #dee2e6;
+        border-radius: 4px;
+        padding: 12px;
+        margin-top: 8px;
+        font-family: monospace;
+        font-size: 13px;
+        line-height: 1.6;
+        white-space: pre-wrap;
+        word-wrap: break-word;
+    }
+    .chunk-text {
+        color: #666;
+    }
+    .chunk-matched {
+        background: #fff3cd;
+        border: 1px solid #ffc107;
+        padding: 2px 4px;
+        border-radius: 2px;
+        font-weight: 500;
+        color: #333;
+    }
+    .chunk-ellipsis {
+        color: #999;
+        font-style: italic;
+    }
+</style>
+
+<div x-data="vizApp()">
+    <div class="viz-card">
+        <h2>Vector Visualization</h2>
+        <div class="viz-info-box">
+            Testing search algorithms on your indexed documents. User: <strong>{{ username }}</strong>
+        </div>
+
+        <form @submit.prevent="executeSearch">
+            <div class="viz-controls">
+                <!-- Main Controls -->
+                <div class="viz-control-group">
+                    <label>Search Query</label>
+                    <input type="text" x-model="query" placeholder="Enter search query..." required />
+                </div>
+
+                <div class="viz-control-row">
+                    <div class="viz-control-group" style="margin-bottom: 0;">
+                        <label>Algorithm</label>
+                        <select x-model="algorithm">
+                            <option value="semantic">Semantic (Dense Vectors)</option>
+                            <option value="bm25_hybrid" selected>BM25 Hybrid (Dense + Sparse)</option>
+                        </select>
+                    </div>
+
+                    <div class="viz-control-group" style="margin-bottom: 0;">
+                        <label>Fusion Method</label>
+                        <select x-model="fusion" :disabled="algorithm !== 'bm25_hybrid'" :style="algorithm !== 'bm25_hybrid' ? 'opacity: 0.5; cursor: not-allowed;' : ''">
+                            <option value="rrf" selected>RRF (Reciprocal Rank Fusion)</option>
+                            <option value="dbsf">DBSF (Distribution-Based Score Fusion)</option>
+                        </select>
+                    </div>
+
+                    <div style="display: flex; align-items: flex-end;">
+                        <button type="submit" class="viz-btn" style="width: 100%;">Search & Visualize</button>
+                    </div>
+
+                    <div style="display: flex; align-items: flex-end;">
+                        <button type="button" class="viz-btn-secondary" @click="showAdvanced = !showAdvanced" style="white-space: nowrap;">
+                            <span x-text="showAdvanced ? 'Hide Advanced' : 'Advanced'"></span>
+                        </button>
+                    </div>
+                </div>
+
+                <!-- Advanced Options (Collapsible) -->
+                <div class="viz-advanced-section" x-show="showAdvanced" x-transition.opacity.duration.200ms>
+                    <h3 style="margin-top: 0; margin-bottom: 16px; font-size: 16px;">Advanced Options</h3>
+
+                    <div class="viz-advanced-grid">
+                        <div class="viz-control-group">
+                            <label style="display: block; margin-bottom: 8px;">Document Types</label>
+                            <div style="display: grid; grid-template-columns: 1fr; gap: 6px;">
+                                <label style="display: flex; align-items: center; cursor: pointer; font-weight: normal;">
+                                    <input type="checkbox" x-model="docTypes" value="" style="margin-right: 8px;">
+                                    <span>All Types</span>
+                                </label>
+                                <label style="display: flex; align-items: center; cursor: pointer; font-weight: normal;">
+                                    <input type="checkbox" x-model="docTypes" value="note" style="margin-right: 8px;">
+                                    <span>Notes</span>
+                                </label>
+                                <label style="display: flex; align-items: center; cursor: pointer; font-weight: normal;">
+                                    <input type="checkbox" x-model="docTypes" value="file" style="margin-right: 8px;">
+                                    <span>Files</span>
+                                </label>
+                                <label style="display: flex; align-items: center; cursor: pointer; font-weight: normal;">
+                                    <input type="checkbox" x-model="docTypes" value="calendar" style="margin-right: 8px;">
+                                    <span>Calendar Events</span>
+                                </label>
+                                <label style="display: flex; align-items: center; cursor: pointer; font-weight: normal;">
+                                    <input type="checkbox" x-model="docTypes" value="contact" style="margin-right: 8px;">
+                                    <span>Contacts</span>
+                                </label>
+                                <label style="display: flex; align-items: center; cursor: pointer; font-weight: normal;">
+                                    <input type="checkbox" x-model="docTypes" value="deck" style="margin-right: 8px;">
+                                    <span>Deck Cards</span>
+                                </label>
+                            </div>
+                        </div>
+
+                        <div>
+                            <div class="viz-control-group">
+                                <label>Score Threshold (Semantic/Hybrid)</label>
+                                <input type="number" x-model.number="scoreThreshold" min="0" max="1" step="any" />
+                            </div>
+
+                            <div class="viz-control-group">
+                                <label>Result Limit</label>
+                                <input type="number" x-model.number="limit" min="1" max="100" />
+                            </div>
+                        </div>
+                    </div>
+
+                    <!-- Info: BM25 Hybrid fusion methods -->
+                    <div x-show="algorithm === 'bm25_hybrid'" style="margin-top: 16px; padding: 12px; background: #e9ecef; border-radius: 4px;">
+                        <p style="margin: 0; font-size: 14px; color: #666;">
+                            <strong>BM25 Hybrid Search:</strong> Combines dense semantic vectors with sparse BM25 keyword vectors.
+                        </p>
+                        <p style="margin: 8px 0 0 0; font-size: 13px; color: #666;">
+                            <strong>RRF:</strong> Reciprocal Rank Fusion - Rank-based fusion producing scores in [0.0, 1.0]
+                        </p>
+                        <p style="margin: 4px 0 0 0; font-size: 13px; color: #666;">
+                            <strong>DBSF:</strong> Distribution-Based Score Fusion - Sums normalized scores (can exceed 1.0)
+                        </p>
+                    </div>
+                </div>
+            </div>
+        </form>
+    </div>
+
+    <div class="viz-card">
+        <div id="viz-plot-container">
+            <div x-show="loading" class="viz-loading-overlay" x-transition.opacity.duration.200ms>
+                Executing search and computing PCA projection...
+            </div>
+            <div id="viz-plot" x-show="!loading" x-transition.opacity.duration.200ms></div>
+        </div>
+    </div>
+
+    <div class="viz-card">
+        <h3>Search Results (<span x-text="loading ? '...' : results.length"></span>)</h3>
+
+        <div x-show="loading" class="viz-loading" x-transition.opacity.duration.200ms>
+            Loading results...
+        </div>
+
+        <div x-show="!loading && results.length === 0" class="viz-no-results" x-transition.opacity.duration.200ms>
+            No results found. Try a different query or adjust your search parameters.
+        </div>
+
+        <template x-if="!loading && results.length > 0">
+            <div x-transition.opacity.duration.200ms>
+                <template x-for="result in results" :key="result.id">
+                    <div style="padding: 12px; border-bottom: 1px solid #eee;">
+                        <a :href="getNextcloudUrl(result)" target="_blank" style="font-weight: 500; color: #0066cc; text-decoration: none;">
+                            <span x-text="result.title"></span>
+                        </a>
+                        <div style="font-size: 14px; color: #666; margin-top: 4px;" x-text="result.excerpt"></div>
+                        <div style="font-size: 12px; color: #999; margin-top: 4px;">
+                            Raw Score: <span x-text="result.original_score.toFixed(3)"></span>
+                            (<span x-text="(result.score * 100).toFixed(0)"></span>% relative) |
+                            Type: <span x-text="result.doc_type"></span>
+                        </div>
+
+                        <!-- Show Chunk button (only if chunk position is available) -->
+                        <template x-if="hasChunkPosition(result)">
+                            <button
+                                class="chunk-toggle-btn"
+                                @click="toggleChunk(result)"
+                                x-text="isChunkExpanded(`${result.doc_type}_${result.id}`) ? 'Hide Chunk' : 'Show Chunk'"
+                            ></button>
+                        </template>
+
+                        <!-- Chunk context (expanded inline) -->
+                        <template x-if="isChunkExpanded(`${result.doc_type}_${result.id}`)">
+                            <div class="chunk-context" x-transition.opacity.duration.200ms>
+                                <template x-if="chunkLoading[`${result.doc_type}_${result.id}`]">
+                                    <div style="color: #666; font-style: italic;">Loading chunk...</div>
+                                </template>
+                                <template x-if="!chunkLoading[`${result.doc_type}_${result.id}`]">
+                                    <div>
+                                        <template x-if="expandedChunks[`${result.doc_type}_${result.id}`]?.has_more_before">
+                                            <span class="chunk-ellipsis">...</span>
+                                        </template>
+                                        <span class="chunk-text" x-text="expandedChunks[`${result.doc_type}_${result.id}`]?.before_context"></span><span class="chunk-matched" x-text="expandedChunks[`${result.doc_type}_${result.id}`]?.chunk_text"></span><span class="chunk-text" x-text="expandedChunks[`${result.doc_type}_${result.id}`]?.after_context"></span><template x-if="expandedChunks[`${result.doc_type}_${result.id}`]?.has_more_after">
+                                            <span class="chunk-ellipsis">...</span>
+                                        </template>
+                                    </div>
+                                </template>
+                            </div>
+                        </template>
+                    </div>
+                </template>
+            </div>
+        </template>
+    </div>
+</div>

nextcloud_mcp_server/auth/userinfo_routes.py

@@ -676,16 +676,16 @@ async def user_info_html(request: Request) -> HTMLResponse:
             function vizApp() {{
                 return {{
                     query: '',
-                    algorithm: 'hybrid',
+                    algorithm: 'bm25_hybrid',
+                    fusion: 'rrf',  // Default fusion method for BM25 Hybrid
                     showAdvanced: false,
                     docTypes: [''],  // Default to "All Types"
                     limit: 50,
-                    scoreThreshold: 0.7,
-                    semanticWeight: 0.5,
-                    keywordWeight: 0.3,
-                    fuzzyWeight: 0.2,
+                    scoreThreshold: 0.0,
                     loading: false,
                     results: [],
+                    expandedChunks: {{}},  // Track which chunks are expanded (result_id -> chunk data)
+                    chunkLoading: {{}},    // Track loading state per result
 
                     async executeSearch() {{
                         this.loading = true;
@@ -697,11 +697,13 @@ async def user_info_html(request: Request) -> HTMLResponse:
                                 algorithm: this.algorithm,
                                 limit: this.limit,
                                 score_threshold: this.scoreThreshold,
-                                semantic_weight: this.semanticWeight,
-                                keyword_weight: this.keywordWeight,
-                                fuzzy_weight: this.fuzzyWeight,
                             }});
 
+                            // Add fusion parameter for BM25 Hybrid
+                            if (this.algorithm === 'bm25_hybrid') {{
+                                params.append('fusion', this.fusion);
+                            }}
+
                             // Add doc_types parameter (filter out empty string for "All Types")
                             const selectedTypes = this.docTypes.filter(t => t !== '');
                             if (selectedTypes.length > 0) {{
@@ -735,7 +737,7 @@ async def user_info_html(request: Request) -> HTMLResponse:
                             y: coordinates.map(c => c[1]),
                             mode: 'markers',
                             type: 'scatter',
-                            text: results.map(r => `${{r.title}}<br>Score: ${{r.score.toFixed(3)}}`),
+                            text: results.map(r => `${{r.title}}<br>Raw Score: ${{r.original_score.toFixed(3)}} (${{(r.score * 100).toFixed(0)}}% relative)`),
                             marker: {{
                                 // Multi-channel encoding: size + opacity + color for visual hierarchy
                                 // Power scaling (score^2) amplifies visual differences dramatically
@@ -784,6 +786,51 @@ async def user_info_html(request: Request) -> HTMLResponse:
                             default:
                                 return `${{baseUrl}}`;
                         }}
+                    }},
+
+                    hasChunkPosition(result) {{
+                        // Check if result has position metadata
+                        return result.chunk_start_offset != null && result.chunk_end_offset != null;
+                    }},
+
+                    isChunkExpanded(resultKey) {{
+                        return this.expandedChunks[resultKey] !== undefined;
+                    }},
+
+                    async toggleChunk(result) {{
+                        const resultKey = `${{result.doc_type}}_${{result.id}}`;
+
+                        // If already expanded, collapse
+                        if (this.isChunkExpanded(resultKey)) {{
+                            delete this.expandedChunks[resultKey];
+                            return;
+                        }}
+
+                        // Otherwise, fetch and expand
+                        this.chunkLoading[resultKey] = true;
+
+                        try {{
+                            const params = new URLSearchParams({{
+                                doc_type: result.doc_type,
+                                doc_id: result.id,
+                                start: result.chunk_start_offset,
+                                end: result.chunk_end_offset,
+                                context: 500  // 500 chars before/after
+                            }});
+
+                            const response = await fetch(`/app/chunk-context?${{params}}`);
+                            const data = await response.json();
+
+                            if (data.success) {{
+                                this.expandedChunks[resultKey] = data;
+                            }} else {{
+                                alert('Failed to load chunk: ' + data.error);
+                            }}
+                        }} catch (error) {{
+                            alert('Error loading chunk: ' + error.message);
+                        }} finally {{
+                            delete this.chunkLoading[resultKey];
+                        }}
                     }}
                 }}
             }}

nextcloud_mcp_server/auth/viz_routes.py

@@ -12,17 +12,17 @@ All processing happens server-side following ADR-012:
 
 import logging
 import time
+from pathlib import Path
 
 import numpy as np
+from jinja2 import Environment, FileSystemLoader
 from starlette.authentication import requires
 from starlette.requests import Request
 from starlette.responses import HTMLResponse, JSONResponse
 
 from nextcloud_mcp_server.config import get_settings
 from nextcloud_mcp_server.search import (
-    FuzzySearchAlgorithm,
-    HybridSearchAlgorithm,
-    KeywordSearchAlgorithm,
+    BM25HybridSearchAlgorithm,
     SemanticSearchAlgorithm,
 )
 from nextcloud_mcp_server.vector.pca import PCA
@@ -30,6 +30,10 @@ from nextcloud_mcp_server.vector.qdrant_client import get_qdrant_client
 
 logger = logging.getLogger(__name__)
 
+# Setup Jinja2 environment for templates
+_template_dir = Path(__file__).parent / "templates"
+_jinja_env = Environment(loader=FileSystemLoader(_template_dir))
+
 
 @requires("authenticated", redirect="oauth_login")
 async def vector_visualization_html(request: Request) -> HTMLResponse:
@@ -65,266 +69,9 @@ async def vector_visualization_html(request: Request) -> HTMLResponse:
         else "unknown"
     )
 
-    html_content = f"""
-        <style>
-            .viz-card {{
-                background: white;
-                border-radius: 8px;
-                padding: 20px;
-                margin-bottom: 20px;
-                box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-            }}
-            .viz-controls {{
-                margin-bottom: 20px;
-            }}
-            .viz-control-row {{
-                display: grid;
-                grid-template-columns: 2fr 1fr auto;
-                gap: 12px;
-                margin-bottom: 12px;
-                align-items: end;
-            }}
-            .viz-control-group {{
-                margin-bottom: 15px;
-            }}
-            .viz-control-group label {{
-                display: block;
-                margin-bottom: 5px;
-                font-weight: 500;
-                color: #333;
-            }}
-            .viz-control-group input[type="text"],
-            .viz-control-group input[type="number"],
-            .viz-control-group select {{
-                width: 100%;
-                padding: 8px 12px;
-                border: 1px solid #ddd;
-                border-radius: 4px;
-                font-size: 14px;
-            }}
-            .viz-control-group input[type="range"] {{
-                width: 100%;
-            }}
-            .viz-control-group select[multiple] {{
-                min-height: 100px;
-            }}
-            .viz-weight-display {{
-                display: inline-block;
-                min-width: 40px;
-                text-align: right;
-                color: #666;
-            }}
-            .viz-btn {{
-                background: #0066cc;
-                color: white;
-                border: none;
-                padding: 10px 20px;
-                border-radius: 4px;
-                cursor: pointer;
-                font-size: 14px;
-                font-weight: 500;
-            }}
-            .viz-btn:hover {{
-                background: #0052a3;
-            }}
-            .viz-btn-secondary {{
-                background: #6c757d;
-                color: white;
-                border: none;
-                padding: 6px 12px;
-                border-radius: 4px;
-                cursor: pointer;
-                font-size: 13px;
-                margin-bottom: 12px;
-            }}
-            .viz-btn-secondary:hover {{
-                background: #5a6268;
-            }}
-            #viz-plot-container {{
-                width: 100%;
-                height: 600px;
-                position: relative;
-            }}
-            #viz-plot {{
-                width: 100%;
-                height: 100%;
-            }}
-            .viz-loading {{
-                text-align: center;
-                padding: 40px;
-                color: #666;
-            }}
-            .viz-loading-overlay {{
-                position: absolute;
-                inset: 0;
-                display: flex;
-                align-items: center;
-                justify-content: center;
-                background: white;
-                color: #666;
-            }}
-            .viz-no-results {{
-                text-align: center;
-                padding: 40px;
-                color: #666;
-                font-style: italic;
-            }}
-            .viz-advanced-section {{
-                margin-top: 16px;
-                padding: 16px;
-                background: #f8f9fa;
-                border-radius: 4px;
-                border: 1px solid #dee2e6;
-            }}
-            .viz-advanced-grid {{
-                display: grid;
-                grid-template-columns: 1fr 1fr;
-                gap: 20px;
-            }}
-            .viz-info-box {{
-                background: #e3f2fd;
-                border-left: 4px solid #2196f3;
-                padding: 12px;
-                margin-bottom: 20px;
-                font-size: 14px;
-            }}
-        </style>
-
-        <div x-data="vizApp()">
-            <div class="viz-card">
-                <h2>Vector Visualization</h2>
-                <div class="viz-info-box">
-                    Testing search algorithms on your indexed documents. User: <strong>{username}</strong>
-                </div>
-
-                <form @submit.prevent="executeSearch">
-                    <div class="viz-controls">
-                        <!-- Main Controls -->
-                        <div class="viz-control-group">
-                            <label>Search Query</label>
-                            <input type="text" x-model="query" placeholder="Enter search query..." required />
-                        </div>
-
-                        <div class="viz-control-row">
-                            <div class="viz-control-group" style="margin-bottom: 0;">
-                                <label>Algorithm</label>
-                                <select x-model="algorithm">
-                                    <option value="semantic">Semantic (Vector Similarity)</option>
-                                    <option value="keyword">Keyword (Token Matching)</option>
-                                    <option value="fuzzy">Fuzzy (Character Overlap)</option>
-                                    <option value="hybrid" selected>Hybrid (RRF Fusion)</option>
-                                </select>
-                            </div>
-
-                            <div style="display: flex; align-items: flex-end;">
-                                <button type="submit" class="viz-btn" style="width: 100%;">Search & Visualize</button>
-                            </div>
-
-                            <div style="display: flex; align-items: flex-end;">
-                                <button type="button" class="viz-btn-secondary" @click="showAdvanced = !showAdvanced" style="white-space: nowrap;">
-                                    <span x-text="showAdvanced ? 'Hide Advanced' : 'Advanced'"></span>
-                                </button>
-                            </div>
-                        </div>
-
-                        <!-- Advanced Options (Collapsible) -->
-                        <div class="viz-advanced-section" x-show="showAdvanced" x-transition.opacity.duration.200ms>
-                            <h3 style="margin-top: 0; margin-bottom: 16px; font-size: 16px;">Advanced Options</h3>
-
-                            <div class="viz-advanced-grid">
-                                <div class="viz-control-group">
-                                    <label>Document Types</label>
-                                    <select x-model="docTypes" multiple>
-                                        <option value="">All Types (cross-app search)</option>
-                                        <option value="note">Notes</option>
-                                        <option value="file">Files</option>
-                                        <option value="calendar">Calendar Events</option>
-                                        <option value="contact">Contacts</option>
-                                        <option value="deck">Deck Cards</option>
-                                    </select>
-                                    <small style="color: #666; display: block; margin-top: 4px;">
-                                        Hold Ctrl/Cmd to select multiple
-                                    </small>
-                                </div>
-
-                                <div>
-                                    <div class="viz-control-group">
-                                        <label>Score Threshold (Semantic/Hybrid)</label>
-                                        <input type="number" x-model.number="scoreThreshold" min="0" max="1" step="0.1" />
-                                    </div>
-
-                                    <div class="viz-control-group">
-                                        <label>Result Limit</label>
-                                        <input type="number" x-model.number="limit" min="1" max="100" />
-                                    </div>
-                                </div>
-                            </div>
-
-                            <!-- Hybrid Weights (only when hybrid selected) -->
-                            <div x-show="algorithm === 'hybrid'" style="margin-top: 16px; padding: 12px; background: #e9ecef; border-radius: 4px;">
-                                <label style="margin-bottom: 12px; display: block;">Hybrid Algorithm Weights</label>
-
-                                <div style="margin-bottom: 8px;">
-                                    <label style="display: inline-block; width: 100px; font-weight: normal;">Semantic:</label>
-                                    <input type="range" x-model.number="semanticWeight" min="0" max="1" step="0.1" style="width: 200px; display: inline-block;">
-                                    <span class="viz-weight-display" x-text="semanticWeight.toFixed(1)"></span>
-                                </div>
-                                <div style="margin-bottom: 8px;">
-                                    <label style="display: inline-block; width: 100px; font-weight: normal;">Keyword:</label>
-                                    <input type="range" x-model.number="keywordWeight" min="0" max="1" step="0.1" style="width: 200px; display: inline-block;">
-                                    <span class="viz-weight-display" x-text="keywordWeight.toFixed(1)"></span>
-                                </div>
-                                <div>
-                                    <label style="display: inline-block; width: 100px; font-weight: normal;">Fuzzy:</label>
-                                    <input type="range" x-model.number="fuzzyWeight" min="0" max="1" step="0.1" style="width: 200px; display: inline-block;">
-                                    <span class="viz-weight-display" x-text="fuzzyWeight.toFixed(1)"></span>
-                                </div>
-                            </div>
-                        </div>
-                    </div>
-                </form>
-            </div>
-
-            <div class="viz-card">
-                <div id="viz-plot-container">
-                    <div x-show="loading" class="viz-loading-overlay" x-transition.opacity.duration.200ms>
-                        Executing search and computing PCA projection...
-                    </div>
-                    <div id="viz-plot" x-show="!loading" x-transition.opacity.duration.200ms></div>
-                </div>
-            </div>
-
-            <div class="viz-card">
-                <h3>Search Results (<span x-text="loading ? '...' : results.length"></span>)</h3>
-
-                <div x-show="loading" class="viz-loading" x-transition.opacity.duration.200ms>
-                    Loading results...
-                </div>
-
-                <div x-show="!loading && results.length === 0" class="viz-no-results" x-transition.opacity.duration.200ms>
-                    No results found. Try a different query or adjust your search parameters.
-                </div>
-
-                <template x-if="!loading && results.length > 0">
-                    <div x-transition.opacity.duration.200ms>
-                        <template x-for="result in results" :key="result.id">
-                            <div style="padding: 12px; border-bottom: 1px solid #eee;">
-                                <a :href="getNextcloudUrl(result)" target="_blank" style="font-weight: 500; color: #0066cc; text-decoration: none;">
-                                    <span x-text="result.title"></span>
-                                </a>
-                                <div style="font-size: 14px; color: #666; margin-top: 4px;" x-text="result.excerpt"></div>
-                                <div style="font-size: 12px; color: #999; margin-top: 4px;">
-                                    Score: <span x-text="result.score.toFixed(3)"></span> |
-                                    Type: <span x-text="result.doc_type"></span>
-                                </div>
-                            </div>
-                        </template>
-                    </div>
-                </template>
-            </div>
-        </div>
-    """
-
+    # Load and render template
+    template = _jinja_env.get_template("vector_viz.html")
+    html_content = template.render(username=username)
     return HTMLResponse(content=html_content)
 
 
@@ -365,12 +112,10 @@ async def vector_visualization_search(request: Request) -> JSONResponse:
 
     # Parse query parameters
     query = request.query_params.get("query", "")
-    algorithm = request.query_params.get("algorithm", "hybrid")
+    algorithm = request.query_params.get("algorithm", "bm25_hybrid")
     limit = int(request.query_params.get("limit", "50"))
-    score_threshold = float(request.query_params.get("score_threshold", "0.7"))
-    semantic_weight = float(request.query_params.get("semantic_weight", "0.5"))
-    keyword_weight = float(request.query_params.get("keyword_weight", "0.3"))
-    fuzzy_weight = float(request.query_params.get("fuzzy_weight", "0.2"))
+    score_threshold = float(request.query_params.get("score_threshold", "0.0"))
+    fusion = request.query_params.get("fusion", "rrf")  # Default to RRF
 
     # Parse doc_types (comma-separated list, None = all types)
     doc_types_param = request.query_params.get("doc_types", "")
@@ -378,7 +123,7 @@ async def vector_visualization_search(request: Request) -> JSONResponse:
 
     logger.info(
         f"Viz search: user={username}, query='{query}', "
-        f"algorithm={algorithm}, limit={limit}, doc_types={doc_types}"
+        f"algorithm={algorithm}, fusion={fusion}, limit={limit}, doc_types={doc_types}"
     )
 
     try:
@@ -395,15 +140,9 @@ async def vector_visualization_search(request: Request) -> JSONResponse:
             # Create search algorithm (no client needed - verification removed)
             if algorithm == "semantic":
                 search_algo = SemanticSearchAlgorithm(score_threshold=score_threshold)
-            elif algorithm == "keyword":
-                search_algo = KeywordSearchAlgorithm()
-            elif algorithm == "fuzzy":
-                search_algo = FuzzySearchAlgorithm()
-            elif algorithm == "hybrid":
-                search_algo = HybridSearchAlgorithm(
-                    semantic_weight=semantic_weight,
-                    keyword_weight=keyword_weight,
-                    fuzzy_weight=fuzzy_weight,
+            elif algorithm == "bm25_hybrid":
+                search_algo = BM25HybridSearchAlgorithm(
+                    score_threshold=score_threshold, fusion=fusion
                 )
             else:
                 return JSONResponse(
@@ -445,7 +184,7 @@ async def vector_visualization_search(request: Request) -> JSONResponse:
             search_results = all_results[:limit]
             search_duration = time.perf_counter() - search_start
 
-        # Normalize scores relative to this result set for better visualization
+        # Store original scores and normalize for visualization
         # (best result = 1.0, worst result = 0.0 within THIS result set)
         # This makes visual encoding meaningful regardless of RRF normalization
         if search_results:
@@ -458,8 +197,11 @@ async def vector_visualization_search(request: Request) -> JSONResponse:
                 f"→ [0.0, 1.0]"
             )
 
-            # Rescale each result's score to 0-1 within this result set
+            # Store original score and rescale to 0-1 for visualization
             for r in search_results:
+                # Store original score before normalization
+                r.original_score = r.score
+                # Rescale for visual encoding
                 r.score = (r.score - min_score) / score_range
 
         if not search_results:
@@ -495,7 +237,7 @@ async def vector_visualization_search(request: Request) -> JSONResponse:
                 ]
             ),
             limit=len(doc_ids) * 2,  # Account for multiple chunks per doc
-            with_vectors=True,
+            with_vectors=["dense"],  # Only fetch dense vectors for visualization
             with_payload=["doc_id"],  # Need doc_id to map vectors to results
         )
 
@@ -511,8 +253,19 @@ async def vector_visualization_search(request: Request) -> JSONResponse:
                 }
             )
 
-        # Extract vectors
-        vectors = np.array([p.vector for p in points if p.vector is not None])
+        # Extract dense vectors (handle both named and unnamed vectors)
+        def extract_dense_vector(point):
+            if point.vector is None:
+                return None
+            # If named vectors (dict), extract "dense"
+            if isinstance(point.vector, dict):
+                return point.vector.get("dense")
+            # If unnamed vector (array), use directly
+            return point.vector
+
+        vectors = np.array(
+            [v for v in (extract_dense_vector(p) for p in points) if v is not None]
+        )
         vector_fetch_duration = time.perf_counter() - vector_fetch_start
 
         if len(vectors) < 2:
@@ -567,7 +320,12 @@ async def vector_visualization_search(request: Request) -> JSONResponse:
                 "doc_type": r.doc_type,
                 "title": r.title,
                 "excerpt": r.excerpt,
-                "score": r.score,
+                "score": r.score,  # Normalized score for visual encoding (0-1)
+                "original_score": getattr(
+                    r, "original_score", r.score
+                ),  # Raw score from algorithm
+                "chunk_start_offset": r.chunk_start_offset,
+                "chunk_end_offset": r.chunk_end_offset,
             }
             for r in search_results
         ]
@@ -610,3 +368,125 @@ async def vector_visualization_search(request: Request) -> JSONResponse:
             {"success": False, "error": str(e)},
             status_code=500,
         )
+
+
+@requires("authenticated", redirect="oauth_login")
+async def chunk_context_endpoint(request: Request) -> JSONResponse:
+    """Fetch chunk text with surrounding context for visualization.
+
+    This endpoint retrieves the matched chunk along with surrounding text
+    to provide context for the search result. Used by the viz pane to
+    display chunks inline.
+
+    Query parameters:
+        doc_type: Document type (e.g., "note")
+        doc_id: Document ID
+        start: Chunk start offset (character position)
+        end: Chunk end offset (character position)
+        context: Characters of context before/after (default: 500)
+
+    Returns:
+        JSON with chunk_text, before_context, after_context, and flags
+    """
+    try:
+        # Get query parameters
+        doc_type = request.query_params.get("doc_type")
+        doc_id = request.query_params.get("doc_id")
+        start_str = request.query_params.get("start")
+        end_str = request.query_params.get("end")
+        context_chars = int(request.query_params.get("context", "500"))
+
+        # Validate required parameters
+        if not all([doc_type, doc_id, start_str, end_str]):
+            return JSONResponse(
+                {
+                    "success": False,
+                    "error": "Missing required parameters: doc_type, doc_id, start, end",
+                },
+                status_code=400,
+            )
+
+        start = int(start_str)
+        end = int(end_str)
+
+        # Currently only support notes
+        if doc_type != "note":
+            return JSONResponse(
+                {"success": False, "error": f"Unsupported doc_type: {doc_type}"},
+                status_code=400,
+            )
+
+        # Get authenticated HTTP client and fetch note
+        from nextcloud_mcp_server.auth.userinfo_routes import (
+            _get_authenticated_client_for_userinfo,
+        )
+        from nextcloud_mcp_server.client.notes import NotesClient
+
+        # Get username from request auth
+        username = (
+            request.user.display_name
+            if hasattr(request.user, "display_name")
+            else "unknown"
+        )
+
+        # Create notes client with authenticated HTTP client
+        http_client = await _get_authenticated_client_for_userinfo(request)
+        notes_client = NotesClient(http_client, username)
+
+        # Fetch full note content
+        note = await notes_client.get_note(int(doc_id))
+        full_content = f"{note['title']}\n\n{note['content']}"
+
+        # Validate offsets
+        if start < 0 or end > len(full_content) or start >= end:
+            return JSONResponse(
+                {
+                    "success": False,
+                    "error": f"Invalid offsets: start={start}, end={end}, content_length={len(full_content)}",
+                },
+                status_code=400,
+            )
+
+        # Extract chunk
+        chunk_text = full_content[start:end]
+
+        # Extract context before and after
+        before_start = max(0, start - context_chars)
+        before_context = full_content[before_start:start]
+
+        after_end = min(len(full_content), end + context_chars)
+        after_context = full_content[end:after_end]
+
+        # Determine if there's more content
+        has_more_before = before_start > 0
+        has_more_after = after_end < len(full_content)
+
+        logger.info(
+            f"Fetched chunk context for {doc_type}_{doc_id}: "
+            f"chunk_len={len(chunk_text)}, before_len={len(before_context)}, "
+            f"after_len={len(after_context)}"
+        )
+
+        return JSONResponse(
+            {
+                "success": True,
+                "chunk_text": chunk_text,
+                "before_context": before_context,
+                "after_context": after_context,
+                "has_more_before": has_more_before,
+                "has_more_after": has_more_after,
+            }
+        )
+
+    except ValueError as e:
+        logger.error(f"Invalid parameter format: {e}")
+        return JSONResponse(
+            {"success": False, "error": f"Invalid parameter format: {e}"},
+            status_code=400,
+        )
+    except Exception as e:
+        logger.error(f"Chunk context error: {e}", exc_info=True)
+        return JSONResponse(
+            {"success": False, "error": str(e)},
+            status_code=500,
+        )

nextcloud_mcp_server/config.py

@@ -181,8 +181,8 @@ class Settings:
     ollama_verify_ssl: bool = True
 
     # Document chunking settings (for vector embeddings)
-    document_chunk_size: int = 512  # Words per chunk
-    document_chunk_overlap: int = 50  # Overlapping words between chunks
+    document_chunk_size: int = 2048  # Characters per chunk
+    document_chunk_overlap: int = 200  # Overlapping characters between chunks
 
     # Observability settings
     metrics_enabled: bool = True
@@ -227,10 +227,10 @@ class Settings:
                 f"Overlap should be 10-20% of chunk size for optimal results."
             )
 
-        if self.document_chunk_size < 100:
+        if self.document_chunk_size < 512:
             logger.warning(
-                f"DOCUMENT_CHUNK_SIZE is set to {self.document_chunk_size} words, which is quite small. "
-                f"Smaller chunks may lose context. Consider using at least 256 words."
+                f"DOCUMENT_CHUNK_SIZE is set to {self.document_chunk_size} characters, which is quite small. "
+                f"Smaller chunks may lose context. Consider using at least 1024 characters."
             )
 
         if self.document_chunk_overlap < 0:
@@ -335,8 +335,8 @@ def get_settings() -> Settings:
         ollama_embedding_model=os.getenv("OLLAMA_EMBEDDING_MODEL", "nomic-embed-text"),
         ollama_verify_ssl=os.getenv("OLLAMA_VERIFY_SSL", "true").lower() == "true",
         # Document chunking settings
-        document_chunk_size=int(os.getenv("DOCUMENT_CHUNK_SIZE", "512")),
-        document_chunk_overlap=int(os.getenv("DOCUMENT_CHUNK_OVERLAP", "50")),
+        document_chunk_size=int(os.getenv("DOCUMENT_CHUNK_SIZE", "2048")),
+        document_chunk_overlap=int(os.getenv("DOCUMENT_CHUNK_OVERLAP", "200")),
         # Observability settings
         metrics_enabled=os.getenv("METRICS_ENABLED", "true").lower() == "true",
         metrics_port=int(os.getenv("METRICS_PORT", "9090")),

nextcloud_mcp_server/embedding/__init__.py

@@ -1,6 +1,13 @@
 """Embedding service package for generating vector embeddings."""
 
-from .service import EmbeddingService, get_embedding_service
+from .bm25_provider import BM25SparseEmbeddingProvider
+from .service import EmbeddingService, get_bm25_service, get_embedding_service
 from .simple_provider import SimpleEmbeddingProvider
 
-__all__ = ["EmbeddingService", "get_embedding_service", "SimpleEmbeddingProvider"]
+__all__ = [
+    "EmbeddingService",
+    "get_embedding_service",
+    "BM25SparseEmbeddingProvider",
+    "get_bm25_service",
+    "SimpleEmbeddingProvider",
+]

nextcloud_mcp_server/embedding/bm25_provider.py

@@ -0,0 +1,74 @@
+"""BM25 sparse embedding provider using FastEmbed."""
+
+import logging
+from typing import Any
+
+from fastembed import SparseTextEmbedding
+
+logger = logging.getLogger(__name__)
+
+
+class BM25SparseEmbeddingProvider:
+    """
+    BM25 sparse embedding provider for hybrid search.
+
+    Uses FastEmbed's BM25 model to generate sparse vectors for keyword-based
+    retrieval. These sparse vectors are combined with dense semantic vectors
+    in Qdrant using Reciprocal Rank Fusion (RRF) for hybrid search.
+
+    Unlike dense embeddings which have fixed dimensions, sparse embeddings
+    have variable-length vectors with (index, value) pairs representing
+    term frequencies in the BM25 vocabulary.
+    """
+
+    def __init__(self, model_name: str = "Qdrant/bm25"):
+        """
+        Initialize BM25 sparse embedding provider.
+
+        Args:
+            model_name: FastEmbed BM25 model name (default: Qdrant/bm25)
+        """
+        self.model_name = model_name
+        logger.info(f"Initializing BM25 sparse embedding provider: {model_name}")
+
+        # Initialize FastEmbed sparse embedding model
+        self.model = SparseTextEmbedding(model_name=model_name)
+        logger.info(f"BM25 sparse embedding model loaded: {model_name}")
+
+    def encode(self, text: str) -> dict[str, Any]:
+        """
+        Generate BM25 sparse embedding for a single text.
+
+        Args:
+            text: Input text to encode
+
+        Returns:
+            Dictionary with 'indices' and 'values' keys for Qdrant sparse vector
+        """
+        # FastEmbed returns a generator, take first result
+        sparse_embedding = next(iter(self.model.embed([text])))
+
+        return {
+            "indices": sparse_embedding.indices.tolist(),
+            "values": sparse_embedding.values.tolist(),
+        }
+
+    def encode_batch(self, texts: list[str]) -> list[dict[str, Any]]:
+        """
+        Generate BM25 sparse embeddings for multiple texts (batched).
+
+        Args:
+            texts: List of texts to encode
+
+        Returns:
+            List of dictionaries with 'indices' and 'values' for each text
+        """
+        sparse_embeddings = list(self.model.embed(texts))
+
+        return [
+            {
+                "indices": emb.indices.tolist(),
+                "values": emb.values.tolist(),
+            }
+            for emb in sparse_embeddings
+        ]

nextcloud_mcp_server/embedding/service.py

@@ -1,56 +1,30 @@
-"""Embedding service with provider detection."""
+"""Embedding service with provider detection.
+
+DEPRECATED: This module is maintained for backward compatibility.
+New code should use nextcloud_mcp_server.providers.get_provider() directly.
+"""
 
 import logging
-import os
 
-from .base import EmbeddingProvider
-from .ollama_provider import OllamaEmbeddingProvider
-from .simple_provider import SimpleEmbeddingProvider
+from nextcloud_mcp_server.providers import get_provider
+
+from .bm25_provider import BM25SparseEmbeddingProvider
 
 logger = logging.getLogger(__name__)
 
 
 class EmbeddingService:
-    """Unified embedding service with automatic provider detection."""
+    """
+    Unified embedding service with automatic provider detection.
+
+    DEPRECATED: This class wraps the new unified provider infrastructure
+    for backward compatibility. New code should use
+    nextcloud_mcp_server.providers.get_provider() directly.
+    """
 
     def __init__(self):
         """Initialize embedding service with auto-detected provider."""
-        self.provider = self._detect_provider()
-
-    def _detect_provider(self) -> EmbeddingProvider:
-        """
-        Auto-detect available embedding provider.
-
-        Checks environment variables in order:
-        1. OLLAMA_BASE_URL - Use Ollama provider (production)
-        2. OPENAI_API_KEY - Use OpenAI provider (future)
-        3. Fallback to SimpleEmbeddingProvider (testing/development)
-
-        Returns:
-            Configured embedding provider
-        """
-        # Ollama provider (production)
-        ollama_url = os.getenv("OLLAMA_BASE_URL")
-        if ollama_url:
-            logger.info(f"Using Ollama embedding provider: {ollama_url}")
-            return OllamaEmbeddingProvider(
-                base_url=ollama_url,
-                model=os.getenv("OLLAMA_EMBEDDING_MODEL", "nomic-embed-text"),
-                verify_ssl=os.getenv("OLLAMA_VERIFY_SSL", "true").lower() == "true",
-            )
-
-        # OpenAI provider (future implementation)
-        # openai_key = os.getenv("OPENAI_API_KEY")
-        # if openai_key:
-        #     return OpenAIEmbeddingProvider(api_key=openai_key)
-
-        # Fallback to simple provider for development/testing
-        logger.warning(
-            "No embedding provider configured (OLLAMA_BASE_URL or OPENAI_API_KEY not set). "
-            "Using SimpleEmbeddingProvider for testing/development. "
-            "For production, configure an external embedding service."
-        )
-        return SimpleEmbeddingProvider(dimension=384)
+        self.provider = get_provider()
 
     async def embed(self, text: str) -> list[float]:
         """
@@ -109,3 +83,20 @@ def get_embedding_service() -> EmbeddingService:
     if _embedding_service is None:
         _embedding_service = EmbeddingService()
     return _embedding_service
+
+
+# BM25 sparse embedding singleton
+_bm25_service: BM25SparseEmbeddingProvider | None = None
+
+
+def get_bm25_service() -> BM25SparseEmbeddingProvider:
+    """
+    Get singleton BM25 sparse embedding service instance.
+
+    Returns:
+        Global BM25SparseEmbeddingProvider instance
+    """
+    global _bm25_service
+    if _bm25_service is None:
+        _bm25_service = BM25SparseEmbeddingProvider()
+    return _bm25_service

nextcloud_mcp_server/models/semantic.py

@@ -19,9 +19,22 @@ class SemanticSearchResult(BaseModel):
         default="", description="Document category (notes) or location (calendar)"
     )
     excerpt: str = Field(description="Excerpt from matching chunk")
-    score: float = Field(description="Semantic similarity score (0-1)")
+    score: float = Field(
+        description=(
+            "Relevance score (≥ 0.0, higher is better). "
+            "Score range depends on fusion method: "
+            "RRF produces scores in [0.0, 1.0], "
+            "DBSF can exceed 1.0 (sum of normalized scores from multiple systems)"
+        )
+    )
     chunk_index: int = Field(description="Index of matching chunk in document")
     total_chunks: int = Field(description="Total number of chunks in document")
+    chunk_start_offset: Optional[int] = Field(
+        default=None, description="Character position where chunk starts in document"
+    )
+    chunk_end_offset: Optional[int] = Field(
+        default=None, description="Character position where chunk ends in document"
+    )
 
 
 class SemanticSearchResponse(BaseResponse):

nextcloud_mcp_server/observability/metrics.py

@@ -404,10 +404,11 @@ def update_vector_sync_queue_size(size: int) -> None:
 
 def instrument_tool(func):
     """
-    Decorator to automatically instrument MCP tool functions with metrics.
+    Decorator to automatically instrument MCP tool functions with metrics and tracing.
 
-    Wraps async tool functions to record execution time and success/error status.
-    Compatible with @mcp.tool() and @require_scopes() decorators.
+    Wraps async tool functions to record execution time, success/error status, and
+    create OpenTelemetry trace spans. Compatible with @mcp.tool() and @require_scopes()
+    decorators.
 
     Usage:
         @mcp.tool()
@@ -420,24 +421,46 @@ def instrument_tool(func):
         func: The async function to instrument
 
     Returns:
-        Wrapped function with metrics instrumentation
+        Wrapped function with metrics and tracing instrumentation
     """
     import functools
     import time
 
+    from nextcloud_mcp_server.observability.tracing import trace_operation
+
     @functools.wraps(func)
     async def wrapper(*args, **kwargs):
         tool_name = func.__name__
         start_time = time.time()
-        try:
-            result = await func(*args, **kwargs)
-            duration = time.time() - start_time
-            record_tool_call(tool_name, duration, "success")
-            return result
-        except Exception as e:
-            duration = time.time() - start_time
-            record_tool_call(tool_name, duration, "error")
-            record_tool_error(tool_name, type(e).__name__)
-            raise
+
+        # Extract tool arguments for tracing (sanitize sensitive fields)
+        # kwargs contains the actual arguments passed to the tool
+        tool_args = {
+            k: v
+            for k, v in kwargs.items()
+            if k not in ("password", "token", "secret", "api_key", "etag", "ctx")
+        }
+
+        # Create trace span with metrics collection
+        with trace_operation(
+            f"mcp.tool.{tool_name}",
+            attributes={
+                "mcp.tool.name": tool_name,
+                "mcp.tool.args": str(tool_args)[:500]
+                if tool_args
+                else None,  # Limit to 500 chars
+            },
+            record_exception=True,
+        ):
+            try:
+                result = await func(*args, **kwargs)
+                duration = time.time() - start_time
+                record_tool_call(tool_name, duration, "success")
+                return result
+            except Exception as e:
+                duration = time.time() - start_time
+                record_tool_call(tool_name, duration, "error")
+                record_tool_error(tool_name, type(e).__name__)
+                raise
 
     return wrapper

nextcloud_mcp_server/providers/__init__.py

@@ -0,0 +1,18 @@
+"""Unified provider infrastructure for embeddings and text generation."""
+
+from .anthropic import AnthropicProvider
+from .base import Provider
+from .bedrock import BedrockProvider
+from .ollama import OllamaProvider
+from .registry import get_provider, reset_provider
+from .simple import SimpleProvider
+
+__all__ = [
+    "Provider",
+    "OllamaProvider",
+    "AnthropicProvider",
+    "SimpleProvider",
+    "BedrockProvider",
+    "get_provider",
+    "reset_provider",
+]

nextcloud_mcp_server/providers/anthropic.py

@@ -0,0 +1,97 @@
+"""Unified Anthropic provider for text generation."""
+
+import logging
+
+from anthropic import AsyncAnthropic
+
+from .base import Provider
+
+logger = logging.getLogger(__name__)
+
+
+class AnthropicProvider(Provider):
+    """
+    Anthropic provider for text generation.
+
+    Supports Claude models via the Anthropic API.
+    Note: Anthropic doesn't provide embedding models, only text generation.
+    """
+
+    def __init__(self, api_key: str, model: str = "claude-3-5-sonnet-20241022"):
+        """
+        Initialize Anthropic provider.
+
+        Args:
+            api_key: Anthropic API key
+            model: Model name (e.g., "claude-3-5-sonnet-20241022")
+        """
+        self.client = AsyncAnthropic(api_key=api_key)
+        self.model = model
+
+        logger.info(f"Initialized Anthropic provider (model={model})")
+
+    @property
+    def supports_embeddings(self) -> bool:
+        """Whether this provider supports embedding generation."""
+        return False
+
+    @property
+    def supports_generation(self) -> bool:
+        """Whether this provider supports text generation."""
+        return True
+
+    async def embed(self, text: str) -> list[float]:
+        """
+        Generate embedding vector for text.
+
+        Raises:
+            NotImplementedError: Anthropic doesn't provide embedding models
+        """
+        raise NotImplementedError(
+            "Embedding not supported by Anthropic - use Ollama or Bedrock for embeddings"
+        )
+
+    async def embed_batch(self, texts: list[str]) -> list[list[float]]:
+        """
+        Generate embeddings for multiple texts.
+
+        Raises:
+            NotImplementedError: Anthropic doesn't provide embedding models
+        """
+        raise NotImplementedError(
+            "Embedding not supported by Anthropic - use Ollama or Bedrock for embeddings"
+        )
+
+    def get_dimension(self) -> int:
+        """
+        Get embedding dimension.
+
+        Raises:
+            NotImplementedError: Anthropic doesn't provide embedding models
+        """
+        raise NotImplementedError(
+            "Embedding not supported by Anthropic - use Ollama or Bedrock for embeddings"
+        )
+
+    async def generate(self, prompt: str, max_tokens: int = 500) -> str:
+        """
+        Generate text using Anthropic API.
+
+        Args:
+            prompt: The prompt to generate from
+            max_tokens: Maximum tokens to generate
+
+        Returns:
+            Generated text
+        """
+        message = await self.client.messages.create(
+            model=self.model,
+            max_tokens=max_tokens,
+            temperature=0.7,
+            messages=[{"role": "user", "content": prompt}],
+        )
+        return message.content[0].text
+
+    async def close(self) -> None:
+        """Close the client (no-op for Anthropic SDK)."""
+        pass

nextcloud_mcp_server/providers/base.py

@@ -0,0 +1,91 @@
+"""Unified provider interface for embeddings and text generation."""
+
+from abc import ABC, abstractmethod
+
+
+class Provider(ABC):
+    """
+    Unified base class for LLM providers.
+
+    Providers can support embeddings, text generation, or both.
+    Use capability properties to determine what features are available.
+    """
+
+    @property
+    @abstractmethod
+    def supports_embeddings(self) -> bool:
+        """Whether this provider supports embedding generation."""
+        pass
+
+    @property
+    @abstractmethod
+    def supports_generation(self) -> bool:
+        """Whether this provider supports text generation."""
+        pass
+
+    @abstractmethod
+    async def embed(self, text: str) -> list[float]:
+        """
+        Generate embedding vector for text.
+
+        Args:
+            text: Input text to embed
+
+        Returns:
+            Vector embedding as list of floats
+
+        Raises:
+            NotImplementedError: If provider doesn't support embeddings
+        """
+        pass
+
+    @abstractmethod
+    async def embed_batch(self, texts: list[str]) -> list[list[float]]:
+        """
+        Generate embeddings for multiple texts (optimized).
+
+        Args:
+            texts: List of texts to embed
+
+        Returns:
+            List of vector embeddings
+
+        Raises:
+            NotImplementedError: If provider doesn't support embeddings
+        """
+        pass
+
+    @abstractmethod
+    def get_dimension(self) -> int:
+        """
+        Get embedding dimension for this provider.
+
+        Returns:
+            Vector dimension (e.g., 768 for nomic-embed-text)
+
+        Raises:
+            NotImplementedError: If provider doesn't support embeddings
+        """
+        pass
+
+    @abstractmethod
+    async def generate(self, prompt: str, max_tokens: int = 500) -> str:
+        """
+        Generate text from a prompt.
+
+        Args:
+            prompt: The prompt to generate from
+            max_tokens: Maximum tokens to generate
+
+        Returns:
+            Generated text
+
+        Raises:
+            NotImplementedError: If provider doesn't support generation
+        """
+        pass
+
+    @abstractmethod
+    async def close(self) -> None:
+        """Close the provider and release resources."""
+        pass

nextcloud_mcp_server/providers/bedrock.py

@@ -0,0 +1,397 @@
+"""Amazon Bedrock provider for embeddings and text generation."""
+
+import json
+import logging
+from typing import Any
+
+try:
+    import boto3
+    from botocore.exceptions import BotoCoreError, ClientError
+
+    BOTO3_AVAILABLE = True
+except ImportError:
+    BOTO3_AVAILABLE = False
+
+from .base import Provider
+
+logger = logging.getLogger(__name__)
+
+
+class BedrockProvider(Provider):
+    """
+    Amazon Bedrock provider supporting both embeddings and text generation.
+
+    Uses AWS Bedrock Runtime API with boto3. Supports various model families:
+    - Embeddings: amazon.titan-embed-text-v1, amazon.titan-embed-text-v2, cohere.embed-*
+    - Text Generation: anthropic.claude-*, meta.llama3-*, amazon.titan-text-*, mistral.*, etc.
+
+    Requires AWS credentials configured via:
+    - Environment variables (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION)
+    - AWS credentials file (~/.aws/credentials)
+    - IAM role (when running on AWS)
+    """
+
+    def __init__(
+        self,
+        region_name: str | None = None,
+        embedding_model: str | None = None,
+        generation_model: str | None = None,
+        aws_access_key_id: str | None = None,
+        aws_secret_access_key: str | None = None,
+    ):
+        """
+        Initialize Bedrock provider.
+
+        Args:
+            region_name: AWS region (e.g., "us-east-1"). Defaults to AWS_REGION env var.
+            embedding_model: Model ID for embeddings (e.g., "amazon.titan-embed-text-v2:0").
+                None disables embeddings.
+            generation_model: Model ID for text generation (e.g., "anthropic.claude-3-sonnet-20240229-v1:0").
+                None disables generation.
+            aws_access_key_id: AWS access key (optional, uses default credential chain if not provided)
+            aws_secret_access_key: AWS secret key (optional, uses default credential chain if not provided)
+
+        Raises:
+            ImportError: If boto3 is not installed
+        """
+        if not BOTO3_AVAILABLE:
+            raise ImportError(
+                "boto3 is required for Bedrock provider. Install with: pip install boto3"
+            )
+
+        self.embedding_model = embedding_model
+        self.generation_model = generation_model
+        self._dimension: int | None = None  # Detected dynamically
+
+        # Initialize bedrock-runtime client
+        client_kwargs: dict[str, Any] = {}
+        if region_name:
+            client_kwargs["region_name"] = region_name
+        if aws_access_key_id:
+            client_kwargs["aws_access_key_id"] = aws_access_key_id
+        if aws_secret_access_key:
+            client_kwargs["aws_secret_access_key"] = aws_secret_access_key
+
+        self.client = boto3.client("bedrock-runtime", **client_kwargs)
+
+        logger.info(
+            f"Initialized Bedrock provider in region {region_name or 'default'} "
+            f"(embedding_model={embedding_model}, generation_model={generation_model})"
+        )
+
+    @property
+    def supports_embeddings(self) -> bool:
+        """Whether this provider supports embedding generation."""
+        return self.embedding_model is not None
+
+    @property
+    def supports_generation(self) -> bool:
+        """Whether this provider supports text generation."""
+        return self.generation_model is not None
+
+    def _create_embedding_request(self, text: str) -> dict[str, Any]:
+        """
+        Create model-specific embedding request payload.
+
+        Args:
+            text: Input text to embed
+
+        Returns:
+            Request payload dict for the embedding model
+        """
+        if not self.embedding_model:
+            raise NotImplementedError(
+                "Embedding not supported - no embedding_model configured"
+            )
+
+        # Titan Embed models
+        if self.embedding_model.startswith("amazon.titan-embed"):
+            return {"inputText": text}
+
+        # Cohere Embed models
+        elif self.embedding_model.startswith("cohere.embed"):
+            return {"texts": [text], "input_type": "search_document"}
+
+        # Unknown model - try Titan format as default
+        else:
+            logger.warning(
+                f"Unknown embedding model format for {self.embedding_model}, "
+                "using Titan format as default"
+            )
+            return {"inputText": text}
+
+    def _parse_embedding_response(self, response: dict[str, Any]) -> list[float]:
+        """
+        Parse model-specific embedding response.
+
+        Args:
+            response: Raw response from Bedrock
+
+        Returns:
+            Embedding vector as list of floats
+        """
+        # Titan Embed models
+        if self.embedding_model and self.embedding_model.startswith(
+            "amazon.titan-embed"
+        ):
+            return response["embedding"]
+
+        # Cohere Embed models
+        elif self.embedding_model and self.embedding_model.startswith("cohere.embed"):
+            return response["embeddings"][0]
+
+        # Unknown model - try Titan format as default
+        else:
+            logger.warning(
+                f"Unknown embedding response format for {self.embedding_model}, "
+                "trying Titan format"
+            )
+            return response.get("embedding", response.get("embeddings", [None])[0])
+
+    async def embed(self, text: str) -> list[float]:
+        """
+        Generate embedding vector for text.
+
+        Args:
+            text: Input text to embed
+
+        Returns:
+            Vector embedding as list of floats
+
+        Raises:
+            NotImplementedError: If embeddings not enabled (no embedding_model)
+            ClientError: If Bedrock API call fails
+        """
+        if not self.supports_embeddings:
+            raise NotImplementedError(
+                "Embedding not supported - no embedding_model configured"
+            )
+
+        try:
+            request_body = self._create_embedding_request(text)
+
+            response = self.client.invoke_model(
+                modelId=self.embedding_model,
+                body=json.dumps(request_body),
+                accept="application/json",
+                contentType="application/json",
+            )
+
+            response_body = json.loads(response["body"].read())
+            embedding = self._parse_embedding_response(response_body)
+
+            return embedding
+
+        except (BotoCoreError, ClientError) as e:
+            logger.error(f"Bedrock embedding error: {e}")
+            raise
+
+    async def embed_batch(self, texts: list[str]) -> list[list[float]]:
+        """
+        Generate embeddings for multiple texts.
+
+        Note: Current implementation sends requests sequentially.
+        Future optimization could use asyncio for concurrent requests.
+
+        Args:
+            texts: List of texts to embed
+
+        Returns:
+            List of vector embeddings
+
+        Raises:
+            NotImplementedError: If embeddings not enabled (no embedding_model)
+            ClientError: If Bedrock API call fails
+        """
+        if not self.supports_embeddings:
+            raise NotImplementedError(
+                "Embedding not supported - no embedding_model configured"
+            )
+
+        embeddings = []
+        for text in texts:
+            embedding = await self.embed(text)
+            embeddings.append(embedding)
+        return embeddings
+
+    async def _detect_dimension(self):
+        """
+        Detect embedding dimension by generating a test embedding.
+        """
+        if self._dimension is None and self.supports_embeddings:
+            logger.debug(
+                f"Detecting embedding dimension for model {self.embedding_model}..."
+            )
+            test_embedding = await self.embed("test")
+            self._dimension = len(test_embedding)
+            logger.info(
+                f"Detected embedding dimension: {self._dimension} "
+                f"for model {self.embedding_model}"
+            )
+
+    def get_dimension(self) -> int:
+        """
+        Get embedding dimension.
+
+        Returns:
+            Vector dimension for the configured embedding model
+
+        Raises:
+            NotImplementedError: If embeddings not enabled (no embedding_model)
+            RuntimeError: If dimension not detected yet (call _detect_dimension first)
+        """
+        if not self.supports_embeddings:
+            raise NotImplementedError(
+                "Embedding not supported - no embedding_model configured"
+            )
+
+        if self._dimension is None:
+            raise RuntimeError(
+                f"Embedding dimension not detected yet for model {self.embedding_model}. "
+                "Call _detect_dimension() first or generate an embedding."
+            )
+        return self._dimension
+
+    def _create_generation_request(
+        self, prompt: str, max_tokens: int
+    ) -> dict[str, Any]:
+        """
+        Create model-specific text generation request payload.
+
+        Args:
+            prompt: The prompt to generate from
+            max_tokens: Maximum tokens to generate
+
+        Returns:
+            Request payload dict for the generation model
+        """
+        if not self.generation_model:
+            raise NotImplementedError(
+                "Text generation not supported - no generation_model configured"
+            )
+
+        # Anthropic Claude models
+        if self.generation_model.startswith("anthropic.claude"):
+            return {
+                "anthropic_version": "bedrock-2023-05-31",
+                "max_tokens": max_tokens,
+                "temperature": 0.7,
+                "messages": [{"role": "user", "content": prompt}],
+            }
+
+        # Meta Llama models
+        elif self.generation_model.startswith("meta.llama"):
+            return {"prompt": prompt, "max_gen_len": max_tokens, "temperature": 0.7}
+
+        # Amazon Titan Text models
+        elif self.generation_model.startswith("amazon.titan-text"):
+            return {
+                "inputText": prompt,
+                "textGenerationConfig": {
+                    "maxTokenCount": max_tokens,
+                    "temperature": 0.7,
+                },
+            }
+
+        # Mistral models
+        elif self.generation_model.startswith("mistral"):
+            return {"prompt": prompt, "max_tokens": max_tokens, "temperature": 0.7}
+
+        # Unknown model - try Claude format as default
+        else:
+            logger.warning(
+                f"Unknown generation model format for {self.generation_model}, "
+                "using Claude format as default"
+            )
+            return {
+                "anthropic_version": "bedrock-2023-05-31",
+                "max_tokens": max_tokens,
+                "temperature": 0.7,
+                "messages": [{"role": "user", "content": prompt}],
+            }
+
+    def _parse_generation_response(self, response: dict[str, Any]) -> str:
+        """
+        Parse model-specific text generation response.
+
+        Args:
+            response: Raw response from Bedrock
+
+        Returns:
+            Generated text
+        """
+        # Anthropic Claude models
+        if self.generation_model and self.generation_model.startswith(
+            "anthropic.claude"
+        ):
+            return response["content"][0]["text"]
+
+        # Meta Llama models
+        elif self.generation_model and self.generation_model.startswith("meta.llama"):
+            return response["generation"]
+
+        # Amazon Titan Text models
+        elif self.generation_model and self.generation_model.startswith(
+            "amazon.titan-text"
+        ):
+            return response["results"][0]["outputText"]
+
+        # Mistral models
+        elif self.generation_model and self.generation_model.startswith("mistral"):
+            return response["outputs"][0]["text"]
+
+        # Unknown model - try common response fields
+        else:
+            logger.warning(
+                f"Unknown generation response format for {self.generation_model}, "
+                "trying common fields"
+            )
+            # Try common response field names
+            for field in ["text", "generation", "outputText", "completion"]:
+                if field in response:
+                    return response[field]
+            # Last resort: return JSON string
+            return json.dumps(response)
+
+    async def generate(self, prompt: str, max_tokens: int = 500) -> str:
+        """
+        Generate text from a prompt.
+
+        Args:
+            prompt: The prompt to generate from
+            max_tokens: Maximum tokens to generate
+
+        Returns:
+            Generated text
+
+        Raises:
+            NotImplementedError: If generation not enabled (no generation_model)
+            ClientError: If Bedrock API call fails
+        """
+        if not self.supports_generation:
+            raise NotImplementedError(
+                "Text generation not supported - no generation_model configured"
+            )
+
+        try:
+            request_body = self._create_generation_request(prompt, max_tokens)
+
+            response = self.client.invoke_model(
+                modelId=self.generation_model,
+                body=json.dumps(request_body),
+                accept="application/json",
+                contentType="application/json",
+            )
+
+            response_body = json.loads(response["body"].read())
+            text = self._parse_generation_response(response_body)
+
+            return text
+
+        except (BotoCoreError, ClientError) as e:
+            logger.error(f"Bedrock generation error: {e}")
+            raise
+
+    async def close(self) -> None:
+        """Close the client (no-op for boto3 clients)."""
+        pass

nextcloud_mcp_server/providers/ollama.py

@@ -0,0 +1,221 @@
+"""Unified Ollama provider for embeddings and text generation."""
+
+import logging
+
+import httpx
+
+from .base import Provider
+
+logger = logging.getLogger(__name__)
+
+
+class OllamaProvider(Provider):
+    """
+    Ollama provider supporting both embeddings and text generation.
+
+    Supports TLS, SSL verification, and automatic model loading.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        embedding_model: str | None = None,
+        generation_model: str | None = None,
+        verify_ssl: bool = True,
+        timeout: httpx.Timeout | None = None,
+    ):
+        """
+        Initialize Ollama provider.
+
+        Args:
+            base_url: Ollama API base URL (e.g., https://ollama.internal.example.com:443)
+            embedding_model: Model for embeddings (e.g., "nomic-embed-text"). None disables embeddings.
+            generation_model: Model for text generation (e.g., "llama3.2:1b"). None disables generation.
+            verify_ssl: Verify SSL certificates (default: True)
+            timeout: HTTP timeout configuration
+        """
+        self.base_url = base_url.rstrip("/")
+        self.embedding_model = embedding_model
+        self.generation_model = generation_model
+        self.verify_ssl = verify_ssl
+
+        if timeout is None:
+            timeout = httpx.Timeout(timeout=120, connect=5)
+
+        self.client = httpx.AsyncClient(verify=verify_ssl, timeout=timeout)
+        self._dimension: int | None = None  # Detected dynamically for embeddings
+
+        logger.info(
+            f"Initialized Ollama provider: {base_url} "
+            f"(embedding_model={embedding_model}, generation_model={generation_model}, "
+            f"verify_ssl={verify_ssl})"
+        )
+
+        # Pre-check and auto-load models
+        if embedding_model:
+            self._check_model_is_loaded(embedding_model, autoload=True)
+        if generation_model:
+            self._check_model_is_loaded(generation_model, autoload=True)
+
+    @property
+    def supports_embeddings(self) -> bool:
+        """Whether this provider supports embedding generation."""
+        return self.embedding_model is not None
+
+    @property
+    def supports_generation(self) -> bool:
+        """Whether this provider supports text generation."""
+        return self.generation_model is not None
+
+    async def embed(self, text: str) -> list[float]:
+        """
+        Generate embedding vector for text.
+
+        Args:
+            text: Input text to embed
+
+        Returns:
+            Vector embedding as list of floats
+
+        Raises:
+            NotImplementedError: If embeddings not enabled (no embedding_model)
+        """
+        if not self.supports_embeddings:
+            raise NotImplementedError(
+                "Embedding not supported - no embedding_model configured"
+            )
+
+        response = await self.client.post(
+            f"{self.base_url}/api/embeddings",
+            json={"model": self.embedding_model, "prompt": text},
+        )
+        response.raise_for_status()
+        return response.json()["embedding"]
+
+    async def embed_batch(self, texts: list[str]) -> list[list[float]]:
+        """
+        Generate embeddings for multiple texts (batched requests).
+
+        Note: Ollama doesn't have native batch API, so we send requests sequentially.
+
+        Args:
+            texts: List of texts to embed
+
+        Returns:
+            List of vector embeddings
+
+        Raises:
+            NotImplementedError: If embeddings not enabled (no embedding_model)
+        """
+        if not self.supports_embeddings:
+            raise NotImplementedError(
+                "Embedding not supported - no embedding_model configured"
+            )
+
+        embeddings = []
+        for text in texts:
+            embedding = await self.embed(text)
+            embeddings.append(embedding)
+        return embeddings
+
+    async def _detect_dimension(self):
+        """
+        Detect embedding dimension by generating a test embedding.
+
+        This method queries the model to determine the actual dimension
+        instead of relying on hardcoded values.
+        """
+        if self._dimension is None and self.supports_embeddings:
+            logger.debug(
+                f"Detecting embedding dimension for model {self.embedding_model}..."
+            )
+            test_embedding = await self.embed("test")
+            self._dimension = len(test_embedding)
+            logger.info(
+                f"Detected embedding dimension: {self._dimension} "
+                f"for model {self.embedding_model}"
+            )
+
+    def get_dimension(self) -> int:
+        """
+        Get embedding dimension.
+
+        Returns:
+            Vector dimension for the configured embedding model
+
+        Raises:
+            NotImplementedError: If embeddings not enabled (no embedding_model)
+            RuntimeError: If dimension not detected yet (call _detect_dimension first)
+        """
+        if not self.supports_embeddings:
+            raise NotImplementedError(
+                "Embedding not supported - no embedding_model configured"
+            )
+
+        if self._dimension is None:
+            raise RuntimeError(
+                f"Embedding dimension not detected yet for model {self.embedding_model}. "
+                "Call _detect_dimension() first or generate an embedding."
+            )
+        return self._dimension
+
+    async def generate(self, prompt: str, max_tokens: int = 500) -> str:
+        """
+        Generate text from a prompt.
+
+        Args:
+            prompt: The prompt to generate from
+            max_tokens: Maximum tokens to generate
+
+        Returns:
+            Generated text
+
+        Raises:
+            NotImplementedError: If generation not enabled (no generation_model)
+        """
+        if not self.supports_generation:
+            raise NotImplementedError(
+                "Text generation not supported - no generation_model configured"
+            )
+
+        response = await self.client.post(
+            f"{self.base_url}/api/generate",
+            json={
+                "model": self.generation_model,
+                "prompt": prompt,
+                "stream": False,
+                "options": {
+                    "num_predict": max_tokens,
+                    "temperature": 0.7,
+                },
+            },
+        )
+        response.raise_for_status()
+        data = response.json()
+        return data["response"]
+
+    def _check_model_is_loaded(self, model: str, autoload: bool = True):
+        """
+        Check if model is loaded in Ollama, optionally auto-loading it.
+
+        Args:
+            model: Model name to check
+            autoload: Whether to automatically pull the model if not loaded
+        """
+        response = httpx.get(f"{self.base_url}/api/tags")
+        response.raise_for_status()
+
+        models = [m["name"] for m in response.json().get("models", [])]
+        logger.info("Ollama has following models pre-loaded: %s", models)
+
+        if (model not in models) and autoload:
+            logger.warning(
+                "Model '%s' not yet available in ollama, attempting to pull now...",
+                model,
+            )
+            response = httpx.post(f"{self.base_url}/api/pull", json={"model": model})
+            response.raise_for_status()
+
+    async def close(self) -> None:
+        """Close HTTP client."""
+        await self.client.aclose()

nextcloud_mcp_server/providers/registry.py

@@ -0,0 +1,126 @@
+"""Provider registry and factory for auto-detection and instantiation."""
+
+import logging
+import os
+
+from .base import Provider
+from .bedrock import BedrockProvider
+from .ollama import OllamaProvider
+from .simple import SimpleProvider
+
+logger = logging.getLogger(__name__)
+
+
+class ProviderRegistry:
+    """
+    Registry for provider auto-detection and instantiation.
+
+    Checks environment variables in priority order and creates appropriate provider:
+    1. Bedrock (AWS_REGION + BEDROCK_*_MODEL)
+    2. Ollama (OLLAMA_BASE_URL)
+    3. Simple (fallback for testing/development)
+    """
+
+    @staticmethod
+    def create_provider() -> Provider:
+        """
+        Auto-detect and create provider based on environment variables.
+
+        Priority order:
+        1. Bedrock - if AWS_REGION or BEDROCK_EMBEDDING_MODEL is set
+        2. Ollama - if OLLAMA_BASE_URL is set
+        3. Simple - fallback for testing/development
+
+        Returns:
+            Provider instance
+
+        Environment Variables:
+            Bedrock:
+                - AWS_REGION: AWS region (e.g., "us-east-1")
+                - AWS_ACCESS_KEY_ID: AWS access key (optional, uses credential chain)
+                - AWS_SECRET_ACCESS_KEY: AWS secret key (optional)
+                - BEDROCK_EMBEDDING_MODEL: Model ID for embeddings (e.g., "amazon.titan-embed-text-v2:0")
+                - BEDROCK_GENERATION_MODEL: Model ID for text generation (e.g., "anthropic.claude-3-sonnet-20240229-v1:0")
+
+            Ollama:
+                - OLLAMA_BASE_URL: Ollama API base URL (e.g., "http://localhost:11434")
+                - OLLAMA_EMBEDDING_MODEL: Model for embeddings (default: "nomic-embed-text")
+                - OLLAMA_GENERATION_MODEL: Model for text generation (e.g., "llama3.2:1b")
+                - OLLAMA_VERIFY_SSL: Verify SSL certificates (default: "true")
+
+            Simple (no configuration needed, fallback):
+                - SIMPLE_EMBEDDING_DIMENSION: Embedding dimension (default: 384)
+        """
+        # 1. Check for Bedrock
+        aws_region = os.getenv("AWS_REGION")
+        bedrock_embedding_model = os.getenv("BEDROCK_EMBEDDING_MODEL")
+        bedrock_generation_model = os.getenv("BEDROCK_GENERATION_MODEL")
+
+        if aws_region or bedrock_embedding_model or bedrock_generation_model:
+            logger.info(
+                f"Using Bedrock provider: region={aws_region}, "
+                f"embedding_model={bedrock_embedding_model}, "
+                f"generation_model={bedrock_generation_model}"
+            )
+            return BedrockProvider(
+                region_name=aws_region,
+                embedding_model=bedrock_embedding_model,
+                generation_model=bedrock_generation_model,
+                aws_access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
+                aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
+            )
+
+        # 2. Check for Ollama
+        ollama_url = os.getenv("OLLAMA_BASE_URL")
+        if ollama_url:
+            embedding_model = os.getenv("OLLAMA_EMBEDDING_MODEL", "nomic-embed-text")
+            generation_model = os.getenv("OLLAMA_GENERATION_MODEL")
+            verify_ssl = os.getenv("OLLAMA_VERIFY_SSL", "true").lower() == "true"
+
+            logger.info(
+                f"Using Ollama provider: {ollama_url}, "
+                f"embedding_model={embedding_model}, "
+                f"generation_model={generation_model}"
+            )
+            return OllamaProvider(
+                base_url=ollama_url,
+                embedding_model=embedding_model,
+                generation_model=generation_model,
+                verify_ssl=verify_ssl,
+            )
+
+        # 3. Fallback to Simple provider for development/testing
+        dimension = int(os.getenv("SIMPLE_EMBEDDING_DIMENSION", "384"))
+        logger.warning(
+            "No provider configured (AWS_REGION, OLLAMA_BASE_URL not set). "
+            "Using SimpleProvider for testing/development. "
+            "For production, configure Bedrock or Ollama."
+        )
+        return SimpleProvider(dimension=dimension)
+
+
+# Singleton instance
+_provider: Provider | None = None
+
+
+def get_provider() -> Provider:
+    """
+    Get singleton provider instance.
+
+    Returns:
+        Global Provider instance (auto-detected on first call)
+    """
+    global _provider
+    if _provider is None:
+        _provider = ProviderRegistry.create_provider()
+    return _provider
+
+
+def reset_provider():
+    """
+    Reset singleton provider instance.
+
+    Useful for testing or reconfiguration.
+    """
+    global _provider
+    _provider = None

nextcloud_mcp_server/providers/simple.py

@@ -0,0 +1,149 @@
+"""Simple in-process embedding provider for testing.
+
+This provider uses a basic TF-IDF-like approach with feature hashing to generate
+deterministic embeddings without requiring external services. Suitable for testing
+but not for production use.
+"""
+
+import hashlib
+import math
+import re
+from collections import Counter
+
+from .base import Provider
+
+
+class SimpleProvider(Provider):
+    """Simple deterministic embedding provider using feature hashing.
+
+    This implementation:
+    - Tokenizes text into words
+    - Uses feature hashing to map words to fixed-size vectors
+    - Applies TF-IDF-like weighting
+    - Normalizes vectors to unit length
+
+    Not suitable for production but good for testing semantic search infrastructure.
+    Only supports embeddings, not text generation.
+    """
+
+    def __init__(self, dimension: int = 384):
+        """Initialize simple embedding provider.
+
+        Args:
+            dimension: Embedding dimension (default: 384)
+        """
+        self.dimension = dimension
+
+    @property
+    def supports_embeddings(self) -> bool:
+        """Whether this provider supports embedding generation."""
+        return True
+
+    @property
+    def supports_generation(self) -> bool:
+        """Whether this provider supports text generation."""
+        return False
+
+    def _tokenize(self, text: str) -> list[str]:
+        """Tokenize text into lowercase words.
+
+        Args:
+            text: Input text
+
+        Returns:
+            List of lowercase word tokens
+        """
+        # Simple word tokenization
+        text = text.lower()
+        words = re.findall(r"\b\w+\b", text)
+        return words
+
+    def _hash_word(self, word: str) -> int:
+        """Hash word to dimension index.
+
+        Args:
+            word: Word to hash
+
+        Returns:
+            Index in range [0, dimension)
+        """
+        hash_bytes = hashlib.md5(word.encode()).digest()
+        hash_int = int.from_bytes(hash_bytes[:4], byteorder="big")
+        return hash_int % self.dimension
+
+    def _embed_single(self, text: str) -> list[float]:
+        """Generate embedding for single text.
+
+        Args:
+            text: Input text
+
+        Returns:
+            Normalized embedding vector
+        """
+        tokens = self._tokenize(text)
+        if not tokens:
+            return [0.0] * self.dimension
+
+        # Count term frequencies
+        term_freq = Counter(tokens)
+
+        # Initialize vector
+        vector = [0.0] * self.dimension
+
+        # Apply TF weighting with feature hashing
+        for word, count in term_freq.items():
+            idx = self._hash_word(word)
+            # Simple TF weighting: log(1 + count)
+            vector[idx] += math.log1p(count)
+
+        # Normalize to unit length
+        norm = math.sqrt(sum(x * x for x in vector))
+        if norm > 0:
+            vector = [x / norm for x in vector]
+
+        return vector
+
+    async def embed(self, text: str) -> list[float]:
+        """Generate embedding vector for text.
+
+        Args:
+            text: Input text to embed
+
+        Returns:
+            Vector embedding as list of floats
+        """
+        return self._embed_single(text)
+
+    async def embed_batch(self, texts: list[str]) -> list[list[float]]:
+        """Generate embeddings for multiple texts.
+
+        Args:
+            texts: List of texts to embed
+
+        Returns:
+            List of vector embeddings
+        """
+        return [self._embed_single(text) for text in texts]
+
+    def get_dimension(self) -> int:
+        """Get embedding dimension.
+
+        Returns:
+            Vector dimension
+        """
+        return self.dimension
+
+    async def generate(self, prompt: str, max_tokens: int = 500) -> str:
+        """
+        Generate text from a prompt.
+
+        Raises:
+            NotImplementedError: Simple provider doesn't support text generation
+        """
+        raise NotImplementedError(
+            "Text generation not supported by Simple provider - use Ollama, Anthropic, or Bedrock"
+        )
+
+    async def close(self) -> None:
+        """Close the provider (no-op for simple provider)."""
+        pass

nextcloud_mcp_server/search/__init__.py

@@ -1,13 +1,11 @@
-"""Search algorithms module for unified multi-algorithm search.
+"""Search algorithms module for BM25 hybrid search.
 
-This module provides a unified interface for different search algorithms:
-- Semantic search (vector similarity)
-- Keyword search (token-based matching)
-- Fuzzy search (character overlap)
-- Hybrid search (RRF fusion of multiple algorithms)
+This module provides BM25 hybrid search combining:
+- Dense semantic vectors (vector similarity via embeddings)
+- Sparse BM25 vectors (keyword-based retrieval)
 
-All algorithms share the same interface and can be used interchangeably by both
-MCP tools and the visualization pane.
+Results are fused using Qdrant's native Reciprocal Rank Fusion (RRF) for
+optimal relevance across both semantic and keyword queries.
 """
 
 from nextcloud_mcp_server.search.algorithms import (
@@ -16,9 +14,7 @@ from nextcloud_mcp_server.search.algorithms import (
     SearchResult,
     get_indexed_doc_types,
 )
-from nextcloud_mcp_server.search.fuzzy import FuzzySearchAlgorithm
-from nextcloud_mcp_server.search.hybrid import HybridSearchAlgorithm
-from nextcloud_mcp_server.search.keyword import KeywordSearchAlgorithm
+from nextcloud_mcp_server.search.bm25_hybrid import BM25HybridSearchAlgorithm
 from nextcloud_mcp_server.search.semantic import SemanticSearchAlgorithm
 
 __all__ = [
@@ -27,7 +23,5 @@ __all__ = [
     "SearchResult",
     "get_indexed_doc_types",
     "SemanticSearchAlgorithm",
-    "KeywordSearchAlgorithm",
-    "FuzzySearchAlgorithm",
-    "HybridSearchAlgorithm",
+    "BM25HybridSearchAlgorithm",
 ]

nextcloud_mcp_server/search/algorithms.py

@@ -127,8 +127,12 @@ class SearchResult:
         doc_type: Document type (note, file, calendar, contact, etc.)
         title: Document title
         excerpt: Content excerpt showing match context
-        score: Relevance score (0.0-1.0, higher is better)
+        score: Relevance score (≥ 0.0, higher is better)
+            - RRF fusion: scores in [0.0, 1.0]
+            - DBSF fusion: scores can exceed 1.0 (sum of normalized scores)
         metadata: Additional algorithm-specific metadata
+        chunk_start_offset: Character position where chunk starts (None if not available)
+        chunk_end_offset: Character position where chunk ends (None if not available)
     """
 
     id: int
@@ -137,11 +141,20 @@ class SearchResult:
     excerpt: str
     score: float
     metadata: dict[str, Any] | None = None
+    chunk_start_offset: int | None = None
+    chunk_end_offset: int | None = None
 
     def __post_init__(self):
-        """Validate score is in valid range."""
-        if not 0.0 <= self.score <= 1.0:
-            raise ValueError(f"Score must be between 0.0 and 1.0, got {self.score}")
+        """Validate score is non-negative.
+
+        Note: Different fusion methods produce different score ranges:
+        - RRF (Reciprocal Rank Fusion): Bounded to [0.0, 1.0]
+        - DBSF (Distribution-Based Score Fusion): Unbounded (can exceed 1.0)
+          DBSF sums normalized scores from multiple systems, so scores can be
+          1.5, 2.0, etc. when multiple systems agree a document is highly relevant.
+        """
+        if self.score < 0.0:
+            raise ValueError(f"Score must be non-negative, got {self.score}")
 
 
 class SearchAlgorithm(ABC):

nextcloud_mcp_server/search/bm25_hybrid.py

@@ -0,0 +1,223 @@
+"""BM25 hybrid search algorithm using Qdrant native RRF fusion."""
+
+import logging
+from typing import Any
+
+from qdrant_client import models
+from qdrant_client.models import FieldCondition, Filter, MatchValue
+
+from nextcloud_mcp_server.config import get_settings
+from nextcloud_mcp_server.embedding import get_bm25_service, get_embedding_service
+from nextcloud_mcp_server.observability.metrics import record_qdrant_operation
+from nextcloud_mcp_server.search.algorithms import SearchAlgorithm, SearchResult
+from nextcloud_mcp_server.vector.qdrant_client import get_qdrant_client
+
+logger = logging.getLogger(__name__)
+
+
+class BM25HybridSearchAlgorithm(SearchAlgorithm):
+    """
+    Hybrid search combining dense semantic vectors with BM25 sparse vectors.
+
+    Uses Qdrant's native Reciprocal Rank Fusion (RRF) to automatically merge
+    results from both dense (semantic) and sparse (BM25 keyword) searches.
+    This provides the best of both worlds: semantic understanding for conceptual
+    queries and precise keyword matching for specific terms, acronyms, and codes.
+
+    The fusion happens efficiently in the database using the prefetch mechanism,
+    eliminating the need for application-layer result merging.
+    """
+
+    def __init__(self, score_threshold: float = 0.0, fusion: str = "rrf"):
+        """
+        Initialize BM25 hybrid search algorithm.
+
+        Args:
+            score_threshold: Minimum fusion score (0-1, default: 0.0 to allow fusion scoring)
+                           Note: Both RRF and DBSF produce normalized scores
+            fusion: Fusion algorithm to use: "rrf" (Reciprocal Rank Fusion, default)
+                   or "dbsf" (Distribution-Based Score Fusion)
+
+        Raises:
+            ValueError: If fusion is not "rrf" or "dbsf"
+        """
+        if fusion not in ("rrf", "dbsf"):
+            raise ValueError(
+                f"Invalid fusion algorithm '{fusion}'. Must be 'rrf' or 'dbsf'"
+            )
+
+        self.score_threshold = score_threshold
+        self.fusion = models.Fusion.RRF if fusion == "rrf" else models.Fusion.DBSF
+        self.fusion_name = fusion
+
+    @property
+    def name(self) -> str:
+        return "bm25_hybrid"
+
+    @property
+    def requires_vector_db(self) -> bool:
+        return True
+
+    async def search(
+        self,
+        query: str,
+        user_id: str,
+        limit: int = 10,
+        doc_type: str | None = None,
+        **kwargs: Any,
+    ) -> list[SearchResult]:
+        """
+        Execute hybrid search using dense + sparse vectors with native RRF fusion.
+
+        Returns unverified results from Qdrant. Access verification should be
+        performed separately at the final output stage using verify_search_results().
+
+        Args:
+            query: Natural language or keyword search query
+            user_id: User ID for filtering
+            limit: Maximum results to return
+            doc_type: Optional document type filter
+            **kwargs: Additional parameters (score_threshold override)
+
+        Returns:
+            List of unverified SearchResult objects ranked by RRF fusion score
+
+        Raises:
+            McpError: If vector sync is not enabled or search fails
+        """
+        settings = get_settings()
+        score_threshold = kwargs.get("score_threshold", self.score_threshold)
+
+        logger.info(
+            f"BM25 hybrid search: query='{query}', user={user_id}, "
+            f"limit={limit}, score_threshold={score_threshold}, doc_type={doc_type}, "
+            f"fusion={self.fusion_name}"
+        )
+
+        # Generate dense embedding for semantic search
+        embedding_service = get_embedding_service()
+        dense_embedding = await embedding_service.embed(query)
+        logger.debug(f"Generated dense embedding (dimension={len(dense_embedding)})")
+
+        # Generate sparse embedding for BM25 keyword search
+        bm25_service = get_bm25_service()
+        sparse_embedding = bm25_service.encode(query)
+        logger.debug(
+            f"Generated sparse embedding "
+            f"({len(sparse_embedding['indices'])} non-zero terms)"
+        )
+
+        # Build Qdrant filter
+        filter_conditions = [
+            FieldCondition(
+                key="user_id",
+                match=MatchValue(value=user_id),
+            )
+        ]
+
+        # Add doc_type filter if specified
+        if doc_type:
+            filter_conditions.append(
+                FieldCondition(
+                    key="doc_type",
+                    match=MatchValue(value=doc_type),
+                )
+            )
+
+        query_filter = Filter(must=filter_conditions)
+
+        # Execute hybrid search with Qdrant native RRF fusion
+        qdrant_client = await get_qdrant_client()
+        try:
+            # Use prefetch to run both dense and sparse searches
+            # Qdrant will automatically merge results using RRF
+            search_response = await qdrant_client.query_points(
+                collection_name=settings.get_collection_name(),
+                prefetch=[
+                    # Dense semantic search
+                    models.Prefetch(
+                        query=dense_embedding,
+                        using="dense",
+                        limit=limit * 2,  # Get extra for deduplication
+                        filter=query_filter,
+                    ),
+                    # Sparse BM25 search
+                    models.Prefetch(
+                        query=models.SparseVector(
+                            indices=sparse_embedding["indices"],
+                            values=sparse_embedding["values"],
+                        ),
+                        using="sparse",
+                        limit=limit * 2,  # Get extra for deduplication
+                        filter=query_filter,
+                    ),
+                ],
+                # Fusion query (RRF or DBSF based on initialization)
+                query=models.FusionQuery(fusion=self.fusion),
+                limit=limit * 2,  # Get extra for deduplication
+                score_threshold=score_threshold,
+                with_payload=True,
+                with_vectors=False,  # Don't return vectors to save bandwidth
+            )
+            record_qdrant_operation("search", "success")
+        except Exception:
+            record_qdrant_operation("search", "error")
+            raise
+
+        logger.info(
+            f"Qdrant {self.fusion_name.upper()} fusion returned {len(search_response.points)} results "
+            f"(before deduplication)"
+        )
+
+        if search_response.points:
+            # Log top 3 fusion scores to help with threshold tuning
+            top_scores = [p.score for p in search_response.points[:3]]
+            logger.debug(
+                f"Top 3 {self.fusion_name.upper()} fusion scores: {top_scores}"
+            )
+
+        # Deduplicate by (doc_id, doc_type) - multiple chunks per document
+        seen_docs = set()
+        results = []
+
+        for result in search_response.points:
+            doc_id = int(result.payload["doc_id"])
+            doc_type = result.payload.get("doc_type", "note")
+            doc_key = (doc_id, doc_type)
+
+            # Skip if we've already seen this document
+            if doc_key in seen_docs:
+                continue
+
+            seen_docs.add(doc_key)
+
+            # Return unverified results (verification happens at output stage)
+            results.append(
+                SearchResult(
+                    id=doc_id,
+                    doc_type=doc_type,
+                    title=result.payload.get("title", "Untitled"),
+                    excerpt=result.payload.get("excerpt", ""),
+                    score=result.score,  # Fusion score (RRF or DBSF)
+                    metadata={
+                        "chunk_index": result.payload.get("chunk_index"),
+                        "total_chunks": result.payload.get("total_chunks"),
+                        "search_method": f"bm25_hybrid_{self.fusion_name}",
+                    },
+                    chunk_start_offset=result.payload.get("chunk_start_offset"),
+                    chunk_end_offset=result.payload.get("chunk_end_offset"),
+                )
+            )
+
+            if len(results) >= limit:
+                break
+
+        logger.info(f"Returning {len(results)} unverified results after deduplication")
+        if results:
+            result_details = [
+                f"{r.doc_type}_{r.id} (score={r.score:.3f}, title='{r.title}')"
+                for r in results[:5]  # Show top 5
+            ]
+            logger.debug(f"Top results: {', '.join(result_details)}")
+
+        return results

nextcloud_mcp_server/search/fuzzy.py

@@ -1,219 +0,0 @@
-"""Fuzzy search algorithm using character overlap matching on Qdrant payload."""
-
-import logging
-from typing import Any
-
-from qdrant_client.models import FieldCondition, Filter, MatchValue
-
-from nextcloud_mcp_server.config import get_settings
-from nextcloud_mcp_server.search.algorithms import SearchAlgorithm, SearchResult
-from nextcloud_mcp_server.vector.qdrant_client import get_qdrant_client
-
-logger = logging.getLogger(__name__)
-
-
-class FuzzySearchAlgorithm(SearchAlgorithm):
-    """Fuzzy search using simple character-based similarity.
-
-    Implements character overlap matching with configurable threshold:
-    - Compares character sets between query and text
-    - Requires configurable % character overlap to match (default: 70%)
-    - Tolerant to typos and minor variations
-    """
-
-    def __init__(self, threshold: float = 0.7):
-        """Initialize fuzzy search algorithm.
-
-        Args:
-            threshold: Minimum character overlap ratio (0-1, default: 0.7)
-        """
-        if not 0.0 <= threshold <= 1.0:
-            raise ValueError(f"Threshold must be between 0.0 and 1.0, got {threshold}")
-        self.threshold = threshold
-
-    @property
-    def name(self) -> str:
-        return "fuzzy"
-
-    async def search(
-        self,
-        query: str,
-        user_id: str,
-        limit: int = 10,
-        doc_type: str | None = None,
-        **kwargs: Any,
-    ) -> list[SearchResult]:
-        """Execute fuzzy search using character overlap on Qdrant payload.
-
-        Queries Qdrant for all indexed documents, then scores based on character
-        overlap in title and excerpt fields. Returns unverified results - access
-        verification should be performed separately at the final output stage.
-
-        Args:
-            query: Search query
-            user_id: User ID for filtering
-            limit: Maximum results to return
-            doc_type: Optional document type filter (None = all types)
-            **kwargs: Additional parameters (threshold override)
-
-        Returns:
-            List of unverified SearchResult objects ranked by character overlap score
-        """
-        settings = get_settings()
-        threshold = kwargs.get("threshold", self.threshold)
-
-        logger.info(
-            f"Fuzzy search: query='{query}', user={user_id}, "
-            f"limit={limit}, threshold={threshold}, doc_type={doc_type}"
-        )
-
-        # Build Qdrant filter
-        filter_conditions = [
-            FieldCondition(key="user_id", match=MatchValue(value=user_id))
-        ]
-        if doc_type:
-            filter_conditions.append(
-                FieldCondition(key="doc_type", match=MatchValue(value=doc_type))
-            )
-
-        # Scroll through Qdrant to get all matching documents
-        qdrant_client = await get_qdrant_client()
-        collection = settings.get_collection_name()
-
-        all_points = []
-        offset = None
-
-        # Scroll through all points matching filter
-        while True:
-            scroll_result, next_offset = await qdrant_client.scroll(
-                collection_name=collection,
-                scroll_filter=Filter(must=filter_conditions),
-                limit=100,  # Batch size
-                offset=offset,
-                with_payload=["doc_id", "doc_type", "title", "excerpt", "chunk_index"],
-                with_vectors=False,  # Don't need vectors
-            )
-
-            all_points.extend(scroll_result)
-
-            if next_offset is None:
-                break
-            offset = next_offset
-
-        logger.debug(f"Retrieved {len(all_points)} points from Qdrant for fuzzy search")
-
-        # Deduplicate by (doc_id, doc_type) - keep first chunk
-        seen_docs = {}
-        for point in all_points:
-            doc_id = int(point.payload["doc_id"])
-            dtype = point.payload.get("doc_type", "note")
-            doc_key = (doc_id, dtype)
-
-            chunk_idx = point.payload.get("chunk_index", 0)
-            if doc_key not in seen_docs or chunk_idx == 0:
-                seen_docs[doc_key] = point
-
-        logger.debug(f"Deduplicated to {len(seen_docs)} unique documents")
-
-        # Score each document based on fuzzy matches
-        scored_results = []
-        query_lower = query.lower()
-
-        for doc_key, point in seen_docs.items():
-            doc_id, dtype = doc_key
-            title = point.payload.get("title", "")
-            excerpt = point.payload.get("excerpt", "")
-
-            # Check title match
-            title_score = self._calculate_char_overlap(query_lower, title.lower())
-
-            # Check excerpt match
-            excerpt_score = self._calculate_char_overlap(query_lower, excerpt.lower())
-
-            # Use best score
-            best_score = max(title_score, excerpt_score)
-
-            if best_score >= threshold:
-                match_location = "title" if title_score >= excerpt_score else "excerpt"
-                scored_results.append(
-                    {
-                        "doc_id": doc_id,
-                        "doc_type": dtype,
-                        "title": title,
-                        "excerpt": excerpt
-                        if excerpt_score >= title_score
-                        else f"Title match: {title}",
-                        "score": best_score,
-                        "match_location": match_location,
-                    }
-                )
-
-        # Sort by score (descending) and limit
-        scored_results.sort(key=lambda x: x["score"], reverse=True)
-        top_results = scored_results[:limit]
-
-        # Return unverified results (verification happens at output stage)
-        final_results = []
-        for result in top_results:
-            final_results.append(
-                SearchResult(
-                    id=result["doc_id"],
-                    doc_type=result["doc_type"],
-                    title=result["title"],
-                    excerpt=result["excerpt"],
-                    score=result["score"],
-                    metadata={"match_location": result["match_location"]},
-                )
-            )
-
-        logger.info(f"Fuzzy search returned {len(final_results)} unverified results")
-        if final_results:
-            result_details = [
-                f"{r.doc_type}_{r.id} (score={r.score:.3f}, title='{r.title}')"
-                for r in final_results[:5]
-            ]
-            logger.debug(f"Top fuzzy results: {', '.join(result_details)}")
-
-        return final_results
-
-    def _calculate_char_overlap(self, query: str, text: str) -> float:
-        """Calculate character overlap ratio between query and text.
-
-        Args:
-            query: Query string (normalized)
-            text: Text to compare (normalized)
-
-        Returns:
-            Overlap ratio (0.0-1.0)
-        """
-        if not query or not text:
-            return 0.0
-
-        # Convert to character sets
-        query_chars = set(query)
-        text_chars = set(text)
-
-        # Calculate overlap
-        overlap = query_chars & text_chars
-        overlap_ratio = len(overlap) / len(query_chars)
-
-        return overlap_ratio
-
-    def _extract_excerpt(self, content: str, max_length: int = 200) -> str:
-        """Extract excerpt from content.
-
-        Args:
-            content: Full document content
-            max_length: Maximum excerpt length
-
-        Returns:
-            Excerpt string
-        """
-        if not content:
-            return ""
-
-        excerpt = content[:max_length].strip()
-        if len(content) > max_length:
-            excerpt += "..."
-
-        return excerpt

nextcloud_mcp_server/search/hybrid.py

@@ -1,278 +0,0 @@
-"""Hybrid search algorithm using Reciprocal Rank Fusion (RRF)."""
-
-import logging
-from collections import defaultdict
-from typing import Any
-
-import anyio
-
-from nextcloud_mcp_server.search.algorithms import SearchAlgorithm, SearchResult
-from nextcloud_mcp_server.search.fuzzy import FuzzySearchAlgorithm
-from nextcloud_mcp_server.search.keyword import KeywordSearchAlgorithm
-from nextcloud_mcp_server.search.semantic import SemanticSearchAlgorithm
-
-logger = logging.getLogger(__name__)
-
-
-class HybridSearchAlgorithm(SearchAlgorithm):
-    """Hybrid search combining multiple algorithms using Reciprocal Rank Fusion.
-
-    Implements RRF from ADR-003 to combine results from:
-    - Semantic search (vector similarity)
-    - Keyword search (token matching)
-    - Fuzzy search (character overlap)
-
-    RRF formula: score = weight / (k + rank)
-    where k=60 (standard value) and rank is 1-indexed position.
-    """
-
-    DEFAULT_RRF_K = 60  # Standard RRF constant
-
-    def __init__(
-        self,
-        semantic_weight: float = 0.5,
-        keyword_weight: float = 0.3,
-        fuzzy_weight: float = 0.2,
-        rrf_k: int = DEFAULT_RRF_K,
-    ):
-        """Initialize hybrid search with algorithm weights.
-
-        Args:
-            semantic_weight: Weight for semantic results (default: 0.5)
-            keyword_weight: Weight for keyword results (default: 0.3)
-            fuzzy_weight: Weight for fuzzy results (default: 0.2)
-            rrf_k: RRF constant for rank decay (default: 60)
-
-        Raises:
-            ValueError: If weights are invalid
-        """
-        # Validate weights
-        if semantic_weight < 0 or keyword_weight < 0 or fuzzy_weight < 0:
-            raise ValueError("Weights must be non-negative")
-
-        total_weight = semantic_weight + keyword_weight + fuzzy_weight
-        if total_weight > 1.0:
-            raise ValueError(f"Weights sum to {total_weight:.2f}, must be ≤1.0")
-
-        if total_weight == 0.0:
-            raise ValueError("At least one weight must be > 0")
-
-        self.semantic_weight = semantic_weight
-        self.keyword_weight = keyword_weight
-        self.fuzzy_weight = fuzzy_weight
-        self.rrf_k = rrf_k
-        self.total_weight = total_weight
-
-        # Initialize sub-algorithms
-        self.semantic = SemanticSearchAlgorithm()
-        self.keyword = KeywordSearchAlgorithm()
-        self.fuzzy = FuzzySearchAlgorithm()
-
-    @property
-    def name(self) -> str:
-        return "hybrid"
-
-    @property
-    def requires_vector_db(self) -> bool:
-        # Requires vector DB if semantic search has non-zero weight
-        return self.semantic_weight > 0
-
-    async def search(
-        self,
-        query: str,
-        user_id: str,
-        limit: int = 10,
-        doc_type: str | None = None,
-        **kwargs: Any,
-    ) -> list[SearchResult]:
-        """Execute hybrid search using RRF to combine algorithms.
-
-        Returns unverified results from combined algorithms. Access verification
-        should be performed separately at the final output stage.
-
-        Args:
-            query: Search query
-            user_id: User ID for filtering
-            limit: Maximum results to return
-            doc_type: Optional document type filter
-            **kwargs: Additional parameters passed to sub-algorithms
-
-        Returns:
-            List of unverified SearchResult objects ranked by RRF combined score
-        """
-        logger.info(
-            f"Hybrid search: query='{query}', user={user_id}, limit={limit}, "
-            f"weights=(semantic={self.semantic_weight}, keyword={self.keyword_weight}, "
-            f"fuzzy={self.fuzzy_weight})"
-        )
-
-        # Prepare algorithm configurations for parallel execution
-        algo_configs = []
-        if self.semantic_weight > 0:
-            algo_configs.append(
-                (
-                    "semantic",
-                    self.semantic.search,
-                    query,
-                    user_id,
-                    limit * 2,
-                    doc_type,
-                    kwargs,
-                )
-            )
-        if self.keyword_weight > 0:
-            algo_configs.append(
-                (
-                    "keyword",
-                    self.keyword.search,
-                    query,
-                    user_id,
-                    limit * 2,
-                    doc_type,
-                    kwargs,
-                )
-            )
-        if self.fuzzy_weight > 0:
-            algo_configs.append(
-                (
-                    "fuzzy",
-                    self.fuzzy.search,
-                    query,
-                    user_id,
-                    limit * 2,
-                    doc_type,
-                    kwargs,
-                )
-            )
-
-        # Pre-allocate results list and extract algorithm names
-        results_list = [None] * len(algo_configs)
-        algo_names = [name for name, *_ in algo_configs]
-
-        async def search_one(
-            index: int,
-            search_func,
-            query_arg: str,
-            user_id_arg: str,
-            limit_arg: int,
-            doc_type_arg: str | None,
-            kwargs_arg: dict,
-        ):
-            """Execute one search algorithm and store result at index."""
-            result = await search_func(
-                query_arg, user_id_arg, limit_arg, doc_type_arg, **kwargs_arg
-            )
-            results_list[index] = result
-
-        # Execute searches in parallel using anyio task group
-        async with anyio.create_task_group() as tg:
-            for idx, (name, search_func, q, uid, lim, dt, kw) in enumerate(
-                algo_configs
-            ):
-                tg.start_soon(search_one, idx, search_func, q, uid, lim, dt, kw)
-
-        # Build results dict
-        algo_results = {}
-        for algo_name, results in zip(algo_names, results_list):
-            algo_results[algo_name] = results
-            logger.debug(f"{algo_name} returned {len(results)} results")
-
-        # Combine using RRF
-        combined_results = self._reciprocal_rank_fusion(
-            algo_results,
-            {
-                "semantic": self.semantic_weight,
-                "keyword": self.keyword_weight,
-                "fuzzy": self.fuzzy_weight,
-            },
-            limit,
-        )
-
-        logger.info(f"Hybrid search returned {len(combined_results)} combined results")
-        if combined_results:
-            result_details = [
-                f"{r.doc_type}_{r.id} (score={r.score:.3f}, title='{r.title}')"
-                for r in combined_results[:5]
-            ]
-            logger.debug(f"Top hybrid results: {', '.join(result_details)}")
-
-        return combined_results
-
-    def _reciprocal_rank_fusion(
-        self,
-        algo_results: dict[str, list[SearchResult]],
-        weights: dict[str, float],
-        limit: int,
-    ) -> list[SearchResult]:
-        """Combine multiple ranked result lists using RRF.
-
-        Args:
-            algo_results: Dict of algorithm_name -> ranked results
-            weights: Dict of algorithm_name -> weight (0-1)
-            limit: Maximum results to return
-
-        Returns:
-            Combined and re-ranked results
-        """
-        # Track RRF scores per document
-        rrf_scores: dict[tuple[int, str], float] = defaultdict(float)
-        # Track best result object for each document
-        best_results: dict[tuple[int, str], SearchResult] = {}
-
-        for algo_name, results in algo_results.items():
-            weight = weights.get(algo_name, 0.0)
-            if weight == 0:
-                continue
-
-            for rank, result in enumerate(results, start=1):
-                doc_key = (result.id, result.doc_type)
-
-                # RRF formula: weight / (k + rank)
-                rrf_score = weight / (self.rrf_k + rank)
-                rrf_scores[doc_key] += rrf_score
-
-                # Track best result object (prefer higher original scores)
-                if doc_key not in best_results:
-                    best_results[doc_key] = result
-                elif result.score > best_results[doc_key].score:
-                    best_results[doc_key] = result
-
-        # Sort by combined RRF score
-        sorted_docs = sorted(
-            rrf_scores.items(),
-            key=lambda x: x[1],
-            reverse=True,
-        )[:limit]
-
-        # Calculate normalization factor to scale RRF scores to 0-1 range
-        # Theoretical max RRF score = total_weight / (rrf_k + 1)
-        # Normalization factor = (rrf_k + 1) / total_weight
-        normalization_factor = (self.rrf_k + 1) / self.total_weight
-
-        # Build final results with normalized RRF scores
-        final_results = []
-        for doc_key, rrf_score in sorted_docs:
-            result = best_results[doc_key]
-
-            # Normalize RRF score to 0-1 range for better user comprehension
-            normalized_score = rrf_score * normalization_factor
-
-            # Create new result with normalized score
-            # Keep original metadata but add RRF details
-            metadata = result.metadata or {}
-            metadata["rrf_score_raw"] = rrf_score  # Original RRF score
-            metadata["original_score"] = result.score  # Original algorithm score
-            metadata["normalization_factor"] = normalization_factor
-
-            final_results.append(
-                SearchResult(
-                    id=result.id,
-                    doc_type=result.doc_type,
-                    title=result.title,
-                    excerpt=result.excerpt,
-                    score=normalized_score,  # Use normalized score (0-1 range)
-                    metadata=metadata,
-                )
-            )
-
-        return final_results

nextcloud_mcp_server/search/keyword.py

@@ -1,277 +0,0 @@
-"""Keyword search algorithm using token-based matching on Qdrant payload (ADR-001)."""
-
-import logging
-from typing import Any
-
-from qdrant_client.models import FieldCondition, Filter, MatchValue
-
-from nextcloud_mcp_server.config import get_settings
-from nextcloud_mcp_server.search.algorithms import SearchAlgorithm, SearchResult
-from nextcloud_mcp_server.vector.qdrant_client import get_qdrant_client
-
-logger = logging.getLogger(__name__)
-
-
-class KeywordSearchAlgorithm(SearchAlgorithm):
-    """Keyword search using token-based matching with weighted scoring.
-
-    Implements token-based search from ADR-001:
-    - Title matches weighted 3x higher than content matches
-    - Case-insensitive token matching
-    - Relevance scoring based on match frequency and location
-    """
-
-    # Weighting constants from ADR-001
-    TITLE_WEIGHT = 3.0
-    CONTENT_WEIGHT = 1.0
-
-    @property
-    def name(self) -> str:
-        return "keyword"
-
-    async def search(
-        self,
-        query: str,
-        user_id: str,
-        limit: int = 10,
-        doc_type: str | None = None,
-        **kwargs: Any,
-    ) -> list[SearchResult]:
-        """Execute keyword search using token matching on Qdrant payload.
-
-        Queries Qdrant for all indexed documents, then scores based on token
-        matches in title and excerpt fields. Returns unverified results - access
-        verification should be performed separately at the final output stage.
-
-        Args:
-            query: Search query to tokenize and match
-            user_id: User ID for filtering
-            limit: Maximum results to return
-            doc_type: Optional document type filter (None = all types)
-            **kwargs: Additional parameters (unused)
-
-        Returns:
-            List of unverified SearchResult objects ranked by keyword match score
-        """
-        settings = get_settings()
-
-        logger.info(
-            f"Keyword search: query='{query}', user={user_id}, "
-            f"limit={limit}, doc_type={doc_type}"
-        )
-
-        # Tokenize query
-        query_tokens = self._process_query(query)
-        logger.debug(f"Query tokens: {query_tokens}")
-
-        # Build Qdrant filter
-        filter_conditions = [
-            FieldCondition(key="user_id", match=MatchValue(value=user_id))
-        ]
-        if doc_type:
-            filter_conditions.append(
-                FieldCondition(key="doc_type", match=MatchValue(value=doc_type))
-            )
-
-        # Scroll through Qdrant to get all matching documents
-        # We need title and excerpt from payload for token matching
-        qdrant_client = await get_qdrant_client()
-        collection = settings.get_collection_name()
-
-        all_points = []
-        offset = None
-
-        # Scroll through all points matching filter
-        while True:
-            scroll_result, next_offset = await qdrant_client.scroll(
-                collection_name=collection,
-                scroll_filter=Filter(must=filter_conditions),
-                limit=100,  # Batch size
-                offset=offset,
-                with_payload=[
-                    "doc_id",
-                    "doc_type",
-                    "title",
-                    "excerpt",
-                    "chunk_index",
-                    "total_chunks",
-                ],
-                with_vectors=False,  # Don't need vectors for keyword search
-            )
-
-            all_points.extend(scroll_result)
-
-            if next_offset is None:
-                break
-            offset = next_offset
-
-        logger.debug(
-            f"Retrieved {len(all_points)} points from Qdrant for keyword search"
-        )
-
-        # Deduplicate by (doc_id, doc_type) - keep best chunk per document
-        seen_docs = {}
-        for point in all_points:
-            doc_id = int(point.payload["doc_id"])
-            dtype = point.payload.get("doc_type", "note")
-            doc_key = (doc_id, dtype)
-
-            # Keep first chunk (chunk_index=0) as it has the most relevant content
-            chunk_idx = point.payload.get("chunk_index", 0)
-            if doc_key not in seen_docs or chunk_idx == 0:
-                seen_docs[doc_key] = point
-
-        logger.debug(f"Deduplicated to {len(seen_docs)} unique documents")
-
-        # Score each document based on keyword matches
-        scored_results = []
-        for doc_key, point in seen_docs.items():
-            doc_id, dtype = doc_key
-            title = point.payload.get("title", "")
-            excerpt = point.payload.get("excerpt", "")
-
-            # Calculate keyword match score
-            score = self._calculate_score(query_tokens, title, excerpt)
-
-            if score > 0:  # Only include matches
-                scored_results.append(
-                    {
-                        "doc_id": doc_id,
-                        "doc_type": dtype,
-                        "title": title,
-                        "excerpt": excerpt,
-                        "score": score,
-                    }
-                )
-
-        # Sort by score (descending) and limit
-        scored_results.sort(key=lambda x: x["score"], reverse=True)
-        top_results = scored_results[:limit]
-
-        # Return unverified results (verification happens at output stage)
-        final_results = []
-        for result in top_results:
-            final_results.append(
-                SearchResult(
-                    id=result["doc_id"],
-                    doc_type=result["doc_type"],
-                    title=result["title"],
-                    excerpt=result["excerpt"],
-                    score=result["score"],
-                    metadata={},
-                )
-            )
-
-        logger.info(f"Keyword search returned {len(final_results)} unverified results")
-        if final_results:
-            result_details = [
-                f"{r.doc_type}_{r.id} (score={r.score:.3f}, title='{r.title}')"
-                for r in final_results[:5]
-            ]
-            logger.debug(f"Top keyword results: {', '.join(result_details)}")
-
-        return final_results
-
-    def _process_query(self, query: str) -> list[str]:
-        """Tokenize and normalize query.
-
-        Args:
-            query: Raw query string
-
-        Returns:
-            List of normalized tokens
-        """
-        # Convert to lowercase and split into tokens
-        tokens = query.lower().split()
-
-        # Filter out very short tokens (optional)
-        tokens = [token for token in tokens if len(token) > 1]
-
-        return tokens
-
-    def _calculate_score(
-        self, query_tokens: list[str], title: str, content: str
-    ) -> float:
-        """Calculate relevance score based on token matches.
-
-        Args:
-            query_tokens: List of query tokens
-            title: Document title
-            content: Document content
-
-        Returns:
-            Relevance score (0.0-1.0)
-        """
-        if not query_tokens:
-            return 0.0
-
-        # Process title and content
-        title_tokens = title.lower().split()
-        content_tokens = content.lower().split()
-
-        score = 0.0
-
-        # Count matches in title
-        title_matches = sum(1 for qt in query_tokens if qt in title_tokens)
-        if query_tokens:  # Avoid division by zero
-            title_match_ratio = title_matches / len(query_tokens)
-            score += self.TITLE_WEIGHT * title_match_ratio
-
-        # Count matches in content
-        content_matches = sum(1 for qt in query_tokens if qt in content_tokens)
-        if query_tokens:
-            content_match_ratio = content_matches / len(query_tokens)
-            score += self.CONTENT_WEIGHT * content_match_ratio
-
-        # Normalize score to 0-1 range
-        # Max score would be TITLE_WEIGHT + CONTENT_WEIGHT if all tokens match everywhere
-        max_score = self.TITLE_WEIGHT + self.CONTENT_WEIGHT
-        normalized_score = min(score / max_score, 1.0)
-
-        return normalized_score
-
-    def _extract_excerpt(
-        self, content: str, query_tokens: list[str], max_length: int = 200
-    ) -> str:
-        """Extract excerpt showing match context.
-
-        Args:
-            content: Full document content
-            query_tokens: Query tokens to find
-            max_length: Maximum excerpt length in characters
-
-        Returns:
-            Excerpt string with context around matches
-        """
-        if not content:
-            return ""
-
-        content_lower = content.lower()
-
-        # Find first occurrence of any query token
-        first_match_pos = -1
-        for token in query_tokens:
-            pos = content_lower.find(token)
-            if pos != -1:
-                if first_match_pos == -1 or pos < first_match_pos:
-                    first_match_pos = pos
-
-        if first_match_pos == -1:
-            # No matches found, return beginning
-            return content[:max_length].strip() + (
-                "..." if len(content) > max_length else ""
-            )
-
-        # Extract context around match
-        start = max(0, first_match_pos - max_length // 2)
-        end = min(len(content), first_match_pos + max_length // 2)
-
-        excerpt = content[start:end].strip()
-
-        # Add ellipsis if truncated
-        if start > 0:
-            excerpt = "..." + excerpt
-        if end < len(content):
-            excerpt = excerpt + "..."
-
-        return excerpt

nextcloud_mcp_server/search/semantic.py

@@ -101,6 +101,7 @@ class SemanticSearchAlgorithm(SearchAlgorithm):
             search_response = await qdrant_client.query_points(
                 collection_name=settings.get_collection_name(),
                 query=query_embedding,
+                using="dense",  # Use named dense vector (BM25 hybrid collections)
                 query_filter=Filter(must=filter_conditions),
                 limit=limit * 2,  # Get extra for deduplication
                 score_threshold=score_threshold,
@@ -149,6 +150,8 @@ class SemanticSearchAlgorithm(SearchAlgorithm):
                         "chunk_index": result.payload.get("chunk_index"),
                         "total_chunks": result.payload.get("total_chunks"),
                     },
+                    chunk_start_offset=result.payload.get("chunk_start_offset"),
+                    chunk_end_offset=result.payload.get("chunk_end_offset"),
                 )
             )
 

nextcloud_mcp_server/server/semantic.py

@@ -1,7 +1,6 @@
 """Semantic search MCP tools using vector database."""
 
 import logging
-from typing import Literal
 
 import anyio
 from httpx import RequestError
@@ -26,12 +25,7 @@ from nextcloud_mcp_server.models.semantic import (
 from nextcloud_mcp_server.observability.metrics import (
     instrument_tool,
 )
-from nextcloud_mcp_server.search import (
-    FuzzySearchAlgorithm,
-    HybridSearchAlgorithm,
-    KeywordSearchAlgorithm,
-    SemanticSearchAlgorithm,
-)
+from nextcloud_mcp_server.search.bm25_hybrid import BM25HybridSearchAlgorithm
 
 logger = logging.getLogger(__name__)
 
@@ -47,36 +41,34 @@ def configure_semantic_tools(mcp: FastMCP):
         ctx: Context,
         limit: int = 10,
         doc_types: list[str] | None = None,
-        score_threshold: float = 0.7,
-        algorithm: Literal["semantic", "keyword", "fuzzy", "hybrid"] = "hybrid",
-        semantic_weight: float = 0.5,
-        keyword_weight: float = 0.3,
-        fuzzy_weight: float = 0.2,
+        score_threshold: float = 0.0,
+        fusion: str = "rrf",
     ) -> SemanticSearchResponse:
         """
-        Search Nextcloud content using configurable algorithms with cross-app support.
+        Search Nextcloud content using BM25 hybrid search with cross-app support.
 
-        Supports multiple search algorithms with client-configurable weighting:
-        - semantic: Vector similarity search (requires VECTOR_SYNC_ENABLED=true)
-        - keyword: Token-based matching (title matches weighted 3x)
-        - fuzzy: Character overlap matching (typo-tolerant)
-        - hybrid: Combines all algorithms using Reciprocal Rank Fusion (default)
+        Uses Qdrant's native hybrid search combining:
+        - Dense semantic vectors: For conceptual similarity and natural language queries
+        - BM25 sparse vectors: For precise keyword matching, acronyms, and specific terms
 
-        Document types are queried from the vector database to determine what's
-        actually indexed. Currently only "note" documents are fully supported.
+        Results are automatically fused using the selected fusion algorithm in the
+        database for optimal relevance. This provides the best of both semantic
+        understanding and keyword precision.
+
+        Requires VECTOR_SYNC_ENABLED=true. Currently only "note" documents are
+        fully supported for indexing.
 
         Args:
-            query: Natural language search query
+            query: Natural language or keyword search query
             limit: Maximum number of results to return (default: 10)
             doc_types: Document types to search (e.g., ["note", "file"]). None = search all indexed types (default)
-            score_threshold: Minimum similarity score for semantic/hybrid (0-1, default: 0.7)
-            algorithm: Search algorithm to use (default: "hybrid")
-            semantic_weight: Weight for semantic results in hybrid mode (default: 0.5)
-            keyword_weight: Weight for keyword results in hybrid mode (default: 0.3)
-            fuzzy_weight: Weight for fuzzy results in hybrid mode (default: 0.2)
+            score_threshold: Minimum fusion score (0-1, default: 0.0)
+            fusion: Fusion algorithm: "rrf" (Reciprocal Rank Fusion, default) or "dbsf" (Distribution-Based Score Fusion)
+                   RRF: Good general-purpose fusion using reciprocal ranks
+                   DBSF: Uses distribution-based normalization, may better balance different score ranges
 
         Returns:
-            SemanticSearchResponse with matching documents and relevance scores
+            SemanticSearchResponse with matching documents ranked by fusion scores
         """
         from nextcloud_mcp_server.config import get_settings
 
@@ -85,42 +77,24 @@ def configure_semantic_tools(mcp: FastMCP):
         username = client.username
 
         logger.info(
-            f"Search: query='{query}', user={username}, algorithm={algorithm}, "
-            f"limit={limit}, score_threshold={score_threshold}"
+            f"BM25 hybrid search: query='{query}', user={username}, "
+            f"limit={limit}, score_threshold={score_threshold}, fusion={fusion}"
         )
 
+        # Check that vector sync is enabled
+        if not settings.vector_sync_enabled:
+            raise McpError(
+                ErrorData(
+                    code=-1,
+                    message="BM25 hybrid search requires VECTOR_SYNC_ENABLED=true",
+                )
+            )
+
         try:
-            # Create appropriate algorithm instance
-            if algorithm == "semantic":
-                if not settings.vector_sync_enabled:
-                    raise McpError(
-                        ErrorData(
-                            code=-1,
-                            message="Semantic search requires VECTOR_SYNC_ENABLED=true",
-                        )
-                    )
-                search_algo = SemanticSearchAlgorithm(score_threshold=score_threshold)
-            elif algorithm == "keyword":
-                search_algo = KeywordSearchAlgorithm()
-            elif algorithm == "fuzzy":
-                search_algo = FuzzySearchAlgorithm()
-            elif algorithm == "hybrid":
-                if semantic_weight > 0 and not settings.vector_sync_enabled:
-                    raise McpError(
-                        ErrorData(
-                            code=-1,
-                            message="Hybrid search with semantic component requires VECTOR_SYNC_ENABLED=true",
-                        )
-                    )
-                search_algo = HybridSearchAlgorithm(
-                    semantic_weight=semantic_weight,
-                    keyword_weight=keyword_weight,
-                    fuzzy_weight=fuzzy_weight,
-                )
-            else:
-                raise McpError(
-                    ErrorData(code=-1, message=f"Unknown algorithm: {algorithm}")
-                )
+            # Create BM25 hybrid search algorithm with specified fusion
+            search_algo = BM25HybridSearchAlgorithm(
+                score_threshold=score_threshold, fusion=fusion
+            )
 
             # Execute search across requested document types
             # If doc_types is None, search all indexed types (cross-app search)
@@ -184,16 +158,18 @@ def configure_semantic_tools(mcp: FastMCP):
                         total_chunks=r.metadata.get("total_chunks", 1)
                         if r.metadata
                         else 1,
+                        chunk_start_offset=r.chunk_start_offset,
+                        chunk_end_offset=r.chunk_end_offset,
                     )
                 )
 
-            logger.info(f"Returning {len(results)} results from {algorithm} search")
+            logger.info(f"Returning {len(results)} results from BM25 hybrid search")
 
             return SemanticSearchResponse(
                 results=results,
                 query=query,
                 total_found=len(results),
-                search_method=algorithm,
+                search_method=f"bm25_hybrid_{fusion}",
             )
 
         except ValueError as e:
@@ -225,6 +201,7 @@ def configure_semantic_tools(mcp: FastMCP):
         limit: int = 5,
         score_threshold: float = 0.7,
         max_answer_tokens: int = 500,
+        fusion: str = "rrf",
     ) -> SamplingSearchResponse:
         """
         Semantic search with LLM-generated answer using MCP sampling.
@@ -249,6 +226,7 @@ def configure_semantic_tools(mcp: FastMCP):
             limit: Maximum number of documents to retrieve (default: 5)
             score_threshold: Minimum similarity score 0-1 (default: 0.7)
             max_answer_tokens: Maximum tokens for generated answer (default: 500)
+            fusion: Fusion algorithm: "rrf" (Reciprocal Rank Fusion, default) or "dbsf" (Distribution-Based Score Fusion)
 
         Returns:
             SamplingSearchResponse containing:
@@ -288,6 +266,7 @@ def configure_semantic_tools(mcp: FastMCP):
             ctx=ctx,
             limit=limit,
             score_threshold=score_threshold,
+            fusion=fusion,
         )
 
         # 2. Handle no results case - don't waste a sampling call

nextcloud_mcp_server/vector/document_chunker.py

@@ -1,51 +1,91 @@
-"""Document chunking for large texts."""
+"""Document chunking for large texts using LangChain text splitters."""
 
 import logging
+from dataclasses import dataclass
+
+from langchain_text_splitters import MarkdownTextSplitter
 
 logger = logging.getLogger(__name__)
 
 
-class DocumentChunker:
-    """Chunk large documents for optimal embedding."""
+@dataclass
+class ChunkWithPosition:
+    """A text chunk with its character position in the original document."""
 
-    def __init__(self, chunk_size: int = 512, overlap: int = 50):
+    text: str
+    start_offset: int  # Character position where chunk starts
+    end_offset: int  # Character position where chunk ends (exclusive)
+
+
+class DocumentChunker:
+    """Chunk large documents for optimal embedding using LangChain text splitters.
+
+    Uses MarkdownTextSplitter which is optimized for Markdown content like
+    Nextcloud Notes. Respects markdown structure (headers, code blocks, lists)
+    while maintaining semantic boundaries.
+    """
+
+    def __init__(self, chunk_size: int = 2048, overlap: int = 200):
         """
         Initialize document chunker.
 
         Args:
-            chunk_size: Number of words per chunk (default: 512)
-            overlap: Number of overlapping words between chunks (default: 50)
+            chunk_size: Number of characters per chunk (default: 2048)
+            overlap: Number of overlapping characters between chunks (default: 200)
         """
         self.chunk_size = chunk_size
         self.overlap = overlap
 
-    def chunk_text(self, content: str) -> list[str]:
-        """
-        Split text into overlapping chunks.
+        # Initialize LangChain MarkdownTextSplitter
+        # Optimized for Markdown content with special handling for:
+        # - Headers (# ## ###)
+        # - Code blocks (``` ```)
+        # - Lists (- * 1.)
+        # - Horizontal rules (---)
+        # - Paragraphs and sentences
+        # This preserves both markdown structure and semantic boundaries
+        self.splitter = MarkdownTextSplitter(
+            chunk_size=chunk_size,
+            chunk_overlap=overlap,
+            add_start_index=True,  # Enable position tracking
+            strip_whitespace=True,
+        )
 
-        Uses simple word-based chunking with configurable overlap to preserve
-        context across chunk boundaries.
+    def chunk_text(self, content: str) -> list[ChunkWithPosition]:
+        """
+        Split text into overlapping chunks with position tracking.
+
+        Uses LangChain's MarkdownTextSplitter to create chunks that respect
+        both markdown structure and semantic boundaries. Optimized for Nextcloud
+        Notes content with special handling for headers, code blocks, lists, etc.
+        Preserves character positions for each chunk to enable precise document
+        retrieval.
 
         Args:
-            content: Text content to chunk
+            content: Markdown text content to chunk
 
         Returns:
-            List of text chunks (may be single item if content is small)
+            List of chunks with their character positions in the original content
         """
-        # Simple word-based chunking
-        words = content.split()
+        # Handle empty content - return single empty chunk for backward compatibility
+        if not content:
+            return [ChunkWithPosition(text="", start_offset=0, end_offset=0)]
 
-        if len(words) <= self.chunk_size:
-            return [content]
+        # Use LangChain to create documents with position tracking
+        docs = self.splitter.create_documents([content])
 
-        chunks = []
-        start = 0
+        # Convert LangChain Documents to ChunkWithPosition objects
+        chunks = [
+            ChunkWithPosition(
+                text=doc.page_content,
+                start_offset=doc.metadata.get("start_index", 0),
+                end_offset=doc.metadata.get("start_index", 0) + len(doc.page_content),
+            )
+            for doc in docs
+        ]
 
-        while start < len(words):
-            end = start + self.chunk_size
-            chunk_words = words[start:end]
-            chunks.append(" ".join(chunk_words))
-            start = end - self.overlap
-
-        logger.debug(f"Chunked document into {len(chunks)} chunks ({len(words)} words)")
+        logger.debug(
+            f"Chunked document into {len(chunks)} chunks "
+            f"(chunk_size={self.chunk_size}, overlap={self.overlap})"
+        )
         return chunks

nextcloud_mcp_server/vector/processor.py

@@ -15,7 +15,7 @@ from qdrant_client.models import FieldCondition, Filter, MatchValue, PointStruct
 
 from nextcloud_mcp_server.client import NextcloudClient
 from nextcloud_mcp_server.config import get_settings
-from nextcloud_mcp_server.embedding import get_embedding_service
+from nextcloud_mcp_server.embedding import get_bm25_service, get_embedding_service
 from nextcloud_mcp_server.observability.metrics import (
     record_qdrant_operation,
     record_vector_sync_processing,
@@ -233,15 +233,24 @@ async def _index_document(
     )
     chunks = chunker.chunk_text(content)
 
-    # Generate embeddings (I/O bound - external API call)
+    # Extract chunk texts for embedding
+    chunk_texts = [chunk.text for chunk in chunks]
+
+    # Generate dense embeddings (I/O bound - external API call)
     embedding_service = get_embedding_service()
-    embeddings = await embedding_service.embed_batch(chunks)
+    dense_embeddings = await embedding_service.embed_batch(chunk_texts)
+
+    # Generate sparse embeddings (BM25 for keyword matching)
+    bm25_service = get_bm25_service()
+    sparse_embeddings = bm25_service.encode_batch(chunk_texts)
 
     # Prepare Qdrant points
     indexed_at = int(time.time())
     points = []
 
-    for i, (chunk, embedding) in enumerate(zip(chunks, embeddings)):
+    for i, (chunk, dense_emb, sparse_emb) in enumerate(
+        zip(chunks, dense_embeddings, sparse_embeddings)
+    ):
         # Generate deterministic UUID for point ID
         # Using uuid5 with DNS namespace and combining doc info
         point_name = f"{doc_task.doc_type}:{doc_task.doc_id}:chunk:{i}"
@@ -250,18 +259,24 @@ async def _index_document(
         points.append(
             PointStruct(
                 id=point_id,
-                vector=embedding,
+                vector={
+                    "dense": dense_emb,
+                    "sparse": sparse_emb,
+                },
                 payload={
                     "user_id": doc_task.user_id,
                     "doc_id": doc_task.doc_id,
                     "doc_type": doc_task.doc_type,
                     "title": title,
-                    "excerpt": chunk[:200],
+                    "excerpt": chunk.text[:200],
                     "indexed_at": indexed_at,
                     "modified_at": doc_task.modified_at,
                     "etag": etag,
                     "chunk_index": i,
                     "total_chunks": len(chunks),
+                    "chunk_start_offset": chunk.start_offset,
+                    "chunk_end_offset": chunk.end_offset,
+                    "metadata_version": 2,  # v2 includes position metadata
                 },
             )
         )

nextcloud_mcp_server/vector/qdrant_client.py

@@ -2,7 +2,7 @@
 
 import logging
 
-from qdrant_client import AsyncQdrantClient
+from qdrant_client import AsyncQdrantClient, models
 from qdrant_client.models import Distance, VectorParams
 
 from nextcloud_mcp_server.config import get_settings
@@ -84,7 +84,12 @@ async def get_qdrant_client() -> AsyncQdrantClient:
                 f"Collection '{collection_name}' found, validating dimensions..."
             )
             collection_info = await _qdrant_client.get_collection(collection_name)
-            actual_dimension = collection_info.config.params.vectors.size
+            # Handle both named vectors (dict) and legacy single vector
+            vectors = collection_info.config.params.vectors
+            if isinstance(vectors, dict):
+                actual_dimension = vectors["dense"].size
+            else:
+                actual_dimension = vectors.size
 
             # Validate dimension matches
             if actual_dimension != expected_dimension:
@@ -112,17 +117,27 @@ async def get_qdrant_client() -> AsyncQdrantClient:
             )
             await _qdrant_client.create_collection(
                 collection_name=collection_name,
-                vectors_config=VectorParams(
-                    size=expected_dimension,
-                    distance=Distance.COSINE,
-                ),
+                vectors_config={
+                    "dense": VectorParams(
+                        size=expected_dimension,
+                        distance=Distance.COSINE,
+                    ),
+                },
+                sparse_vectors_config={
+                    "sparse": models.SparseVectorParams(
+                        index=models.SparseIndexParams(
+                            on_disk=False,
+                        )
+                    ),
+                },
             )
             logger.info(
                 f"Created Qdrant collection: {collection_name}\n"
-                f"  Dimension: {expected_dimension}\n"
-                f"  Model: {settings.ollama_embedding_model}\n"
+                f"  Dense vector dimension: {expected_dimension}\n"
+                f"  Dense embedding model: {settings.ollama_embedding_model}\n"
+                f"  Sparse vectors: BM25 (for hybrid search)\n"
                 f"  Distance: COSINE\n"
-                f"Background sync will index all documents with this embedding model."
+                f"Background sync will index all documents with dense + sparse vectors."
             )
 
     return _qdrant_client

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nextcloud-mcp-server"
-version = "0.35.0"
+version = "0.43.0"
 description = "Model Context Protocol (MCP) server for Nextcloud integration - enables AI assistants to interact with Nextcloud data"
 authors = [
     {name = "Chris Coutinho", email = "chris@coutinho.io"}
@@ -12,7 +12,7 @@ keywords = ["nextcloud", "mcp", "model-context-protocol", "llm", "ai", "claude",
 dependencies = [
     "mcp[cli] (>=1.21,<1.22)",
     "httpx (>=0.28.1,<0.29.0)",
-    "pillow (>=12.0.0,<12.1.0)",
+    "pillow (>=10.3.0,<12.0.0)", # Compatible with fastembed
     "icalendar (>=6.0.0,<7.0.0)",
     "pythonvcard4>=0.2.0",
     "pydantic>=2.11.4",
@@ -22,6 +22,9 @@ dependencies = [
     "aiosqlite>=0.20.0", # Async SQLite for refresh token storage
     "authlib>=1.6.5",
     "qdrant-client>=1.7.0",
+    "fastembed>=0.7.3", # BM25 sparse vector embeddings for hybrid search
+    "anthropic>=0.42.0", # For RAG evaluation with Anthropic LLMs
+    "boto3>=1.35.0", # For Amazon Bedrock provider (optional)
     # Observability dependencies
     "prometheus-client>=0.21.0", # Prometheus metrics
     "opentelemetry-api>=1.28.2", # OpenTelemetry API
@@ -31,6 +34,8 @@ dependencies = [
     "opentelemetry-instrumentation-logging>=0.49b2", # Logging integration
     "opentelemetry-exporter-otlp-proto-grpc>=1.28.2", # OTLP gRPC exporter
     "python-json-logger>=3.2.0", # Structured JSON logging
+    "jinja2>=3.1.6",
+    "langchain-text-splitters>=1.0.0",
 ]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -102,9 +107,8 @@ module-root = ""
 
 [dependency-groups]
 dev = [
-    "anthropic>=0.42.0",  # For RAG evaluation with Anthropic LLMs
     "commitizen>=4.8.2",
-    "datasets>=3.3.0",  # For BeIR nfcorpus dataset loading
+    "datasets>=3.3.0", # For BeIR nfcorpus dataset loading
     "ipython>=9.2.0",
     "playwright>=1.49.1",
     "pytest>=8.3.5",

tests/rag_evaluation/llm_providers.py

@@ -1,99 +1,20 @@
 """LLM provider abstraction for RAG evaluation.
 
-Supports Ollama (local) and Anthropic (cloud) providers for both ground truth
+DEPRECATED: This module is maintained for backward compatibility with RAG evaluation tests.
+New code should use nextcloud_mcp_server.providers directly.
+
+Supports Ollama (local), Anthropic (cloud), and Bedrock (AWS) providers for both ground truth
 generation and evaluation.
 """
 
 import os
-from typing import Protocol
 
-import httpx
-from anthropic import AsyncAnthropic
-
-
-class LLMProvider(Protocol):
-    """Protocol for LLM providers."""
-
-    async def generate(self, prompt: str, max_tokens: int = 500) -> str:
-        """Generate text from a prompt.
-
-        Args:
-            prompt: The prompt to generate from
-            max_tokens: Maximum tokens to generate
-
-        Returns:
-            Generated text
-        """
-        ...
-
-    async def close(self) -> None:
-        """Close the provider and release resources."""
-        ...
-
-
-class OllamaProvider:
-    """Ollama provider for local LLM inference."""
-
-    def __init__(self, base_url: str, model: str):
-        """Initialize Ollama provider.
-
-        Args:
-            base_url: Ollama API base URL (e.g., http://localhost:11434)
-            model: Model name (e.g., llama3.1:8b)
-        """
-        self.base_url = base_url.rstrip("/")
-        self.model = model
-        self.client = httpx.AsyncClient(timeout=600.0)  # 10 min timeout for generation
-
-    async def generate(self, prompt: str, max_tokens: int = 500) -> str:
-        """Generate text using Ollama API."""
-        response = await self.client.post(
-            f"{self.base_url}/api/generate",
-            json={
-                "model": self.model,
-                "prompt": prompt,
-                "stream": False,
-                "options": {
-                    "num_predict": max_tokens,
-                    "temperature": 0.7,
-                },
-            },
-        )
-        response.raise_for_status()
-        data = response.json()
-        return data["response"]
-
-    async def close(self):
-        """Close the HTTP client."""
-        await self.client.aclose()
-
-
-class AnthropicProvider:
-    """Anthropic provider for cloud LLM inference."""
-
-    def __init__(self, api_key: str, model: str):
-        """Initialize Anthropic provider.
-
-        Args:
-            api_key: Anthropic API key
-            model: Model name (e.g., claude-3-5-sonnet-20241022)
-        """
-        self.client = AsyncAnthropic(api_key=api_key)
-        self.model = model
-
-    async def generate(self, prompt: str, max_tokens: int = 500) -> str:
-        """Generate text using Anthropic API."""
-        message = await self.client.messages.create(
-            model=self.model,
-            max_tokens=max_tokens,
-            temperature=0.7,
-            messages=[{"role": "user", "content": prompt}],
-        )
-        return message.content[0].text
-
-    async def close(self):
-        """Close the client (no-op for Anthropic)."""
-        pass
+from nextcloud_mcp_server.providers import (
+    AnthropicProvider,
+    BedrockProvider,
+    OllamaProvider,
+    Provider,
+)
 
 
 def create_llm_provider(
@@ -102,18 +23,24 @@ def create_llm_provider(
     ollama_model: str | None = None,
     anthropic_api_key: str | None = None,
     anthropic_model: str | None = None,
-) -> LLMProvider:
+    bedrock_region: str | None = None,
+    bedrock_model: str | None = None,
+) -> Provider:
     """Create an LLM provider from environment variables or arguments.
 
     Args:
-        provider: Provider type ('ollama' or 'anthropic'). Defaults to RAG_EVAL_PROVIDER env var or 'ollama'
+        provider: Provider type ('ollama', 'anthropic', or 'bedrock').
+            Defaults to RAG_EVAL_PROVIDER env var or 'ollama'
         ollama_base_url: Ollama base URL. Defaults to RAG_EVAL_OLLAMA_BASE_URL or 'http://localhost:11434'
-        ollama_model: Ollama model. Defaults to RAG_EVAL_OLLAMA_MODEL or 'llama3.1:8b'
+        ollama_model: Ollama model. Defaults to RAG_EVAL_OLLAMA_MODEL or 'llama3.2:1b'
         anthropic_api_key: Anthropic API key. Defaults to RAG_EVAL_ANTHROPIC_API_KEY env var
         anthropic_model: Anthropic model. Defaults to RAG_EVAL_ANTHROPIC_MODEL or 'claude-3-5-sonnet-20241022'
+        bedrock_region: AWS region. Defaults to RAG_EVAL_BEDROCK_REGION or AWS_REGION env var
+        bedrock_model: Bedrock model ID. Defaults to RAG_EVAL_BEDROCK_MODEL or
+            'anthropic.claude-3-sonnet-20240229-v1:0'
 
     Returns:
-        LLMProvider instance
+        Provider instance
 
     Raises:
         ValueError: If provider is invalid or required credentials are missing
@@ -130,7 +57,9 @@ def create_llm_provider(
             or "http://localhost:11434"
         )
         model = ollama_model or os.environ.get("RAG_EVAL_OLLAMA_MODEL", "llama3.2:1b")
-        return OllamaProvider(base_url=base_url, model=model)
+        return OllamaProvider(
+            base_url=base_url, embedding_model=None, generation_model=model
+        )
 
     elif provider == "anthropic":
         api_key = anthropic_api_key or os.environ.get("RAG_EVAL_ANTHROPIC_API_KEY")
@@ -143,7 +72,18 @@ def create_llm_provider(
         )
         return AnthropicProvider(api_key=api_key, model=model)
 
+    elif provider == "bedrock":
+        region = bedrock_region or os.environ.get(
+            "RAG_EVAL_BEDROCK_REGION", os.environ.get("AWS_REGION", "us-east-1")
+        )
+        model = bedrock_model or os.environ.get(
+            "RAG_EVAL_BEDROCK_MODEL", "anthropic.claude-3-sonnet-20240229-v1:0"
+        )
+        return BedrockProvider(
+            region_name=region, embedding_model=None, generation_model=model
+        )
+
     else:
         raise ValueError(
-            f"Invalid provider: {provider}. Must be 'ollama' or 'anthropic'."
+            f"Invalid provider: {provider}. Must be 'ollama', 'anthropic', or 'bedrock'."
         )

tests/unit/providers/__init__.py

@@ -0,0 +1 @@
+"""Unit tests for provider infrastructure."""

tests/unit/providers/test_bedrock.py

@@ -0,0 +1,280 @@
+"""Unit tests for Bedrock provider."""
+
+import json
+from unittest.mock import MagicMock
+
+import pytest
+
+from nextcloud_mcp_server.providers.bedrock import BOTO3_AVAILABLE, BedrockProvider
+
+
+@pytest.fixture
+def mock_bedrock_client(mocker):
+    """Mock boto3 bedrock-runtime client."""
+    if not BOTO3_AVAILABLE:
+        pytest.skip("boto3 not installed")
+
+    mock_client = MagicMock()
+    mocker.patch("boto3.client", return_value=mock_client)
+    return mock_client
+
+
+@pytest.mark.unit
+async def test_bedrock_embedding_titan(mock_bedrock_client):
+    """Test Bedrock embedding with Titan model."""
+    # Mock response
+    mock_response = {
+        "body": MagicMock(
+            read=MagicMock(
+                return_value=json.dumps({"embedding": [0.1, 0.2, 0.3]}).encode()
+            )
+        )
+    }
+    mock_bedrock_client.invoke_model.return_value = mock_response
+
+    # Create provider
+    provider = BedrockProvider(
+        region_name="us-east-1",
+        embedding_model="amazon.titan-embed-text-v2:0",
+        generation_model=None,
+    )
+
+    # Test embedding
+    embedding = await provider.embed("test text")
+
+    assert embedding == [0.1, 0.2, 0.3]
+    mock_bedrock_client.invoke_model.assert_called_once()
+    call_args = mock_bedrock_client.invoke_model.call_args
+
+    assert call_args.kwargs["modelId"] == "amazon.titan-embed-text-v2:0"
+    body = json.loads(call_args.kwargs["body"])
+    assert body == {"inputText": "test text"}
+
+
+@pytest.mark.unit
+async def test_bedrock_embedding_batch(mock_bedrock_client):
+    """Test Bedrock batch embedding."""
+    # Mock response
+    mock_response = {
+        "body": MagicMock(
+            read=MagicMock(
+                return_value=json.dumps({"embedding": [0.1, 0.2, 0.3]}).encode()
+            )
+        )
+    }
+    mock_bedrock_client.invoke_model.return_value = mock_response
+
+    # Create provider
+    provider = BedrockProvider(
+        region_name="us-east-1",
+        embedding_model="amazon.titan-embed-text-v2:0",
+        generation_model=None,
+    )
+
+    # Test batch embedding
+    embeddings = await provider.embed_batch(["text1", "text2"])
+
+    assert len(embeddings) == 2
+    assert embeddings[0] == [0.1, 0.2, 0.3]
+    assert embeddings[1] == [0.1, 0.2, 0.3]
+    assert mock_bedrock_client.invoke_model.call_count == 2
+
+
+@pytest.mark.unit
+async def test_bedrock_generation_claude(mock_bedrock_client):
+    """Test Bedrock text generation with Claude model."""
+    # Mock response
+    mock_response = {
+        "body": MagicMock(
+            read=MagicMock(
+                return_value=json.dumps(
+                    {"content": [{"text": "Generated response"}]}
+                ).encode()
+            )
+        )
+    }
+    mock_bedrock_client.invoke_model.return_value = mock_response
+
+    # Create provider
+    provider = BedrockProvider(
+        region_name="us-east-1",
+        embedding_model=None,
+        generation_model="anthropic.claude-3-sonnet-20240229-v1:0",
+    )
+
+    # Test generation
+    text = await provider.generate("test prompt", max_tokens=100)
+
+    assert text == "Generated response"
+    mock_bedrock_client.invoke_model.assert_called_once()
+    call_args = mock_bedrock_client.invoke_model.call_args
+
+    assert call_args.kwargs["modelId"] == "anthropic.claude-3-sonnet-20240229-v1:0"
+    body = json.loads(call_args.kwargs["body"])
+    assert body["messages"][0]["content"] == "test prompt"
+    assert body["max_tokens"] == 100
+
+
+@pytest.mark.unit
+async def test_bedrock_generation_llama(mock_bedrock_client):
+    """Test Bedrock text generation with Llama model."""
+    # Mock response
+    mock_response = {
+        "body": MagicMock(
+            read=MagicMock(
+                return_value=json.dumps({"generation": "Llama response"}).encode()
+            )
+        )
+    }
+    mock_bedrock_client.invoke_model.return_value = mock_response
+
+    # Create provider
+    provider = BedrockProvider(
+        region_name="us-east-1",
+        embedding_model=None,
+        generation_model="meta.llama3-8b-instruct-v1:0",
+    )
+
+    # Test generation
+    text = await provider.generate("test prompt")
+
+    assert text == "Llama response"
+    body = json.loads(mock_bedrock_client.invoke_model.call_args.kwargs["body"])
+    assert body["prompt"] == "test prompt"
+    assert "max_gen_len" in body
+
+
+@pytest.mark.unit
+async def test_bedrock_both_capabilities(mock_bedrock_client):
+    """Test Bedrock with both embedding and generation models."""
+    # Mock responses
+    embed_response = {
+        "body": MagicMock(
+            read=MagicMock(return_value=json.dumps({"embedding": [0.1, 0.2]}).encode())
+        )
+    }
+    gen_response = {
+        "body": MagicMock(
+            read=MagicMock(
+                return_value=json.dumps({"content": [{"text": "Response"}]}).encode()
+            )
+        )
+    }
+
+    # Mock to return different responses based on modelId
+    def mock_invoke(modelId, body, **kwargs):
+        if "embed" in modelId:
+            return embed_response
+        else:
+            return gen_response
+
+    mock_bedrock_client.invoke_model.side_effect = mock_invoke
+
+    # Create provider with both models
+    provider = BedrockProvider(
+        region_name="us-east-1",
+        embedding_model="amazon.titan-embed-text-v2:0",
+        generation_model="anthropic.claude-3-sonnet-20240229-v1:0",
+    )
+
+    assert provider.supports_embeddings is True
+    assert provider.supports_generation is True
+
+    # Test both capabilities
+    embedding = await provider.embed("test")
+    assert embedding == [0.1, 0.2]
+
+    text = await provider.generate("test")
+    assert text == "Response"
+
+
+@pytest.mark.unit
+async def test_bedrock_no_embeddings():
+    """Test Bedrock provider with no embedding model raises error."""
+    provider = BedrockProvider(
+        region_name="us-east-1",
+        embedding_model=None,
+        generation_model="anthropic.claude-3-sonnet-20240229-v1:0",
+    )
+
+    assert provider.supports_embeddings is False
+
+    with pytest.raises(NotImplementedError, match="no embedding_model configured"):
+        await provider.embed("test")
+
+    with pytest.raises(NotImplementedError, match="no embedding_model configured"):
+        await provider.embed_batch(["test"])
+
+    with pytest.raises(NotImplementedError, match="no embedding_model configured"):
+        provider.get_dimension()
+
+
+@pytest.mark.unit
+async def test_bedrock_no_generation():
+    """Test Bedrock provider with no generation model raises error."""
+    provider = BedrockProvider(
+        region_name="us-east-1",
+        embedding_model="amazon.titan-embed-text-v2:0",
+        generation_model=None,
+    )
+
+    assert provider.supports_generation is False
+
+    with pytest.raises(NotImplementedError, match="no generation_model configured"):
+        await provider.generate("test")
+
+
+@pytest.mark.unit
+async def test_bedrock_dimension_detection(mock_bedrock_client):
+    """Test dimension detection for Bedrock embeddings."""
+    # Mock response with specific dimension
+    mock_response = {
+        "body": MagicMock(
+            read=MagicMock(
+                return_value=json.dumps(
+                    {"embedding": [0.1] * 1536}  # 1536-dim embedding
+                ).encode()
+            )
+        )
+    }
+    mock_bedrock_client.invoke_model.return_value = mock_response
+
+    provider = BedrockProvider(
+        region_name="us-east-1",
+        embedding_model="amazon.titan-embed-text-v2:0",
+    )
+
+    # Dimension not detected yet
+    with pytest.raises(RuntimeError, match="not detected yet"):
+        provider.get_dimension()
+
+    # Detect dimension
+    await provider._detect_dimension()
+
+    # Now dimension should be available
+    assert provider.get_dimension() == 1536
+
+
+@pytest.mark.unit
+async def test_bedrock_cohere_embedding(mock_bedrock_client):
+    """Test Bedrock with Cohere embedding model."""
+    # Mock response
+    mock_response = {
+        "body": MagicMock(
+            read=MagicMock(
+                return_value=json.dumps({"embeddings": [[0.1, 0.2, 0.3]]}).encode()
+            )
+        )
+    }
+    mock_bedrock_client.invoke_model.return_value = mock_response
+
+    provider = BedrockProvider(
+        region_name="us-east-1",
+        embedding_model="cohere.embed-english-v3",
+    )
+
+    embedding = await provider.embed("test text")
+
+    assert embedding == [0.1, 0.2, 0.3]
+    body = json.loads(mock_bedrock_client.invoke_model.call_args.kwargs["body"])
+    assert body == {"texts": ["test text"], "input_type": "search_document"}

tests/unit/search/__init__.py

@@ -0,0 +1 @@
+"""Unit tests for search algorithms."""

tests/unit/search/test_bm25_hybrid.py

@@ -0,0 +1,54 @@
+"""Unit tests for BM25 hybrid search algorithm."""
+
+import pytest
+from qdrant_client import models
+
+from nextcloud_mcp_server.search.bm25_hybrid import BM25HybridSearchAlgorithm
+
+
+@pytest.mark.unit
+def test_bm25_hybrid_initialization_default():
+    """Test BM25HybridSearchAlgorithm initializes with default RRF fusion."""
+    algo = BM25HybridSearchAlgorithm()
+
+    assert algo.score_threshold == 0.0
+    assert algo.fusion == models.Fusion.RRF
+    assert algo.fusion_name == "rrf"
+    assert algo.name == "bm25_hybrid"
+
+
+@pytest.mark.unit
+def test_bm25_hybrid_initialization_with_rrf():
+    """Test BM25HybridSearchAlgorithm initializes with explicit RRF fusion."""
+    algo = BM25HybridSearchAlgorithm(score_threshold=0.5, fusion="rrf")
+
+    assert algo.score_threshold == 0.5
+    assert algo.fusion == models.Fusion.RRF
+    assert algo.fusion_name == "rrf"
+
+
+@pytest.mark.unit
+def test_bm25_hybrid_initialization_with_dbsf():
+    """Test BM25HybridSearchAlgorithm initializes with DBSF fusion."""
+    algo = BM25HybridSearchAlgorithm(score_threshold=0.7, fusion="dbsf")
+
+    assert algo.score_threshold == 0.7
+    assert algo.fusion == models.Fusion.DBSF
+    assert algo.fusion_name == "dbsf"
+
+
+@pytest.mark.unit
+def test_bm25_hybrid_invalid_fusion_raises_error():
+    """Test BM25HybridSearchAlgorithm raises ValueError for invalid fusion."""
+    with pytest.raises(ValueError) as exc_info:
+        BM25HybridSearchAlgorithm(fusion="invalid")
+
+    assert "Invalid fusion algorithm 'invalid'" in str(exc_info.value)
+    assert "Must be 'rrf' or 'dbsf'" in str(exc_info.value)
+
+
+@pytest.mark.unit
+def test_bm25_hybrid_requires_vector_db():
+    """Test BM25HybridSearchAlgorithm reports it requires vector database."""
+    algo = BM25HybridSearchAlgorithm()
+    assert algo.requires_vector_db is True

tests/unit/search/test_search_result.py

@@ -0,0 +1,135 @@
+"""Unit tests for SearchResult validation."""
+
+import pytest
+
+from nextcloud_mcp_server.search.algorithms import SearchResult
+
+
+@pytest.mark.unit
+def test_search_result_rrf_score_in_range():
+    """Test SearchResult accepts RRF scores in [0.0, 1.0] range."""
+    result = SearchResult(
+        id=1,
+        doc_type="note",
+        title="Test Note",
+        excerpt="Test excerpt",
+        score=0.85,
+    )
+
+    assert result.score == 0.85
+
+
+@pytest.mark.unit
+def test_search_result_rrf_score_at_lower_bound():
+    """Test SearchResult accepts RRF score at lower bound (0.0)."""
+    result = SearchResult(
+        id=1,
+        doc_type="note",
+        title="Test Note",
+        excerpt="Test excerpt",
+        score=0.0,
+    )
+
+    assert result.score == 0.0
+
+
+@pytest.mark.unit
+def test_search_result_rrf_score_at_upper_bound():
+    """Test SearchResult accepts RRF score at upper bound (1.0)."""
+    result = SearchResult(
+        id=1,
+        doc_type="note",
+        title="Test Note",
+        excerpt="Test excerpt",
+        score=1.0,
+    )
+
+    assert result.score == 1.0
+
+
+@pytest.mark.unit
+def test_search_result_dbsf_score_above_one():
+    """Test SearchResult accepts DBSF scores > 1.0.
+
+    DBSF (Distribution-Based Score Fusion) sums normalized scores from multiple
+    systems (dense semantic + sparse BM25), so scores can exceed 1.0 when both
+    systems strongly agree a document is relevant.
+    """
+    # Typical DBSF score when both systems agree
+    result = SearchResult(
+        id=1,
+        doc_type="note",
+        title="Highly Relevant Note",
+        excerpt="Contains keywords and is semantically similar",
+        score=1.55,
+    )
+
+    assert result.score == 1.55
+
+
+@pytest.mark.unit
+def test_search_result_dbsf_score_edge_case():
+    """Test SearchResult accepts DBSF maximum theoretical score (2.0).
+
+    Maximum DBSF score with 2 systems: 1.0 (dense) + 1.0 (sparse) = 2.0
+    """
+    result = SearchResult(
+        id=1,
+        doc_type="note",
+        title="Perfect Match",
+        excerpt="Perfect semantic and keyword match",
+        score=2.0,
+    )
+
+    assert result.score == 2.0
+
+
+@pytest.mark.unit
+def test_search_result_negative_score_raises_error():
+    """Test SearchResult rejects negative scores."""
+    with pytest.raises(ValueError) as exc_info:
+        SearchResult(
+            id=1,
+            doc_type="note",
+            title="Test Note",
+            excerpt="Test excerpt",
+            score=-0.1,
+        )
+
+    assert "Score must be non-negative" in str(exc_info.value)
+    assert "got -0.1" in str(exc_info.value)
+
+
+@pytest.mark.unit
+def test_search_result_with_metadata():
+    """Test SearchResult with optional metadata field."""
+    result = SearchResult(
+        id=1,
+        doc_type="note",
+        title="Test Note",
+        excerpt="Test excerpt",
+        score=1.25,
+        metadata={"fusion_method": "dbsf", "dense_score": 0.8, "sparse_score": 0.45},
+    )
+
+    assert result.score == 1.25
+    assert result.metadata["fusion_method"] == "dbsf"
+    assert result.metadata["dense_score"] == 0.8
+    assert result.metadata["sparse_score"] == 0.45
+
+
+@pytest.mark.unit
+def test_search_result_with_chunk_offsets():
+    """Test SearchResult with chunk offset information."""
+    result = SearchResult(
+        id=1,
+        doc_type="note",
+        title="Test Note",
+        excerpt="matching chunk text",
+        score=0.9,
+        chunk_start_offset=100,
+        chunk_end_offset=500,
+    )
+
+    assert result.chunk_start_offset == 100
+    assert result.chunk_end_offset == 500

tests/unit/test_document_chunker.py

@@ -0,0 +1,288 @@
+"""Unit tests for DocumentChunker with LangChain text splitters."""
+
+from nextcloud_mcp_server.vector.document_chunker import (
+    ChunkWithPosition,
+    DocumentChunker,
+)
+
+
+class TestDocumentChunkerPositions:
+    """Test suite for DocumentChunker position tracking functionality."""
+
+    def test_single_chunk_simple_text(self):
+        """Test that single-chunk documents return correct positions."""
+        chunker = DocumentChunker(chunk_size=2048, overlap=200)
+        content = "This is a short document."
+
+        chunks = chunker.chunk_text(content)
+
+        assert len(chunks) == 1
+        assert isinstance(chunks[0], ChunkWithPosition)
+        assert chunks[0].text == content
+        assert chunks[0].start_offset == 0
+        assert chunks[0].end_offset == len(content)
+
+    def test_multiple_chunks_positions(self):
+        """Test that multi-chunk documents have correct positions."""
+        # Use small chunk size to force multiple chunks
+        chunker = DocumentChunker(chunk_size=50, overlap=10)
+        # Create content longer than chunk size
+        content = (
+            "This is the first sentence with some important content. "
+            "This is the second sentence with more details. "
+            "This is the third sentence continuing the discussion. "
+            "This is the fourth sentence adding more context."
+        )
+
+        chunks = chunker.chunk_text(content)
+
+        # Verify we got multiple chunks
+        assert len(chunks) > 1
+
+        # Verify all chunks are ChunkWithPosition
+        for chunk in chunks:
+            assert isinstance(chunk, ChunkWithPosition)
+
+        # Verify first chunk starts at 0
+        assert chunks[0].start_offset == 0
+
+        # Verify last chunk ends at content length
+        assert chunks[-1].end_offset == len(content)
+
+        # Verify chunks are contiguous or overlap (minimal gaps allowed)
+        for i in range(len(chunks) - 1):
+            # Next chunk should start at or near current chunk end
+            # Allow small gaps (1-2 chars) for whitespace/punctuation at boundaries
+            gap = chunks[i + 1].start_offset - chunks[i].end_offset
+            assert gap <= 2, f"Gap too large between chunks: {gap} characters"
+
+        # Verify we can reconstruct the content using positions
+        for chunk in chunks:
+            extracted = content[chunk.start_offset : chunk.end_offset]
+            assert extracted == chunk.text
+
+    def test_chunk_positions_with_whitespace(self):
+        """Test position tracking with various whitespace."""
+        chunker = DocumentChunker(chunk_size=30, overlap=5)
+        content = "First sentence here.  Second sentence.\n\nThird sentence.\tFourth sentence."
+
+        chunks = chunker.chunk_text(content)
+
+        # Verify positions correctly handle whitespace
+        for chunk in chunks:
+            extracted = content[chunk.start_offset : chunk.end_offset]
+            assert extracted == chunk.text
+            # LangChain strips whitespace by default
+            assert len(chunk.text.strip()) > 0
+
+    def test_empty_content(self):
+        """Test that empty content returns empty chunk."""
+        chunker = DocumentChunker(chunk_size=2048, overlap=200)
+        content = ""
+
+        chunks = chunker.chunk_text(content)
+
+        assert len(chunks) == 1
+        assert chunks[0].text == ""
+        assert chunks[0].start_offset == 0
+        assert chunks[0].end_offset == 0
+
+    def test_chunk_overlap_positions(self):
+        """Test that overlapping chunks have correct positions."""
+        chunker = DocumentChunker(chunk_size=50, overlap=15)
+        content = (
+            "This is sentence one with content. "
+            "This is sentence two with more. "
+            "This is sentence three continuing. "
+            "This is sentence four adding details."
+        )
+
+        chunks = chunker.chunk_text(content)
+
+        # Verify overlap exists if we have multiple chunks
+        if len(chunks) > 1:
+            for i in range(len(chunks) - 1):
+                current_chunk = chunks[i]
+                next_chunk = chunks[i + 1]
+
+                # Verify positions are valid
+                assert next_chunk.start_offset >= 0
+                assert current_chunk.end_offset <= len(content)
+
+                # With overlap, next chunk may start before current ends
+                assert next_chunk.start_offset <= current_chunk.end_offset
+
+    def test_unicode_content_positions(self):
+        """Test position tracking with Unicode characters."""
+        chunker = DocumentChunker(chunk_size=50, overlap=10)
+        content = (
+            "Hello 世界. こんにちは there. мир Привет world. שלום مرحبا 你好 friend."
+        )
+
+        chunks = chunker.chunk_text(content)
+
+        # Verify all chunks extract correctly
+        for chunk in chunks:
+            extracted = content[chunk.start_offset : chunk.end_offset]
+            assert extracted == chunk.text
+
+        # Verify full coverage
+        if len(chunks) == 1:
+            assert chunks[0].start_offset == 0
+            assert chunks[0].end_offset == len(content)
+
+    def test_realistic_note_content(self):
+        """Test with realistic note content similar to Nextcloud Notes."""
+        chunker = DocumentChunker(chunk_size=200, overlap=50)
+        content = """My Project Notes
+
+This is a note about my project. It contains several paragraphs of text
+that should be chunked appropriately for embedding.
+
+## Key Points
+
+- First important point with some details
+- Second point that needs to be remembered
+- Third point for future reference
+
+The document continues with more content here. We want to make sure that
+the chunking preserves context across boundaries while maintaining proper
+position tracking for each chunk.
+
+This allows us to highlight the exact chunk that matched a search query,
+which builds trust in the RAG system."""
+
+        chunks = chunker.chunk_text(content)
+
+        # Should have multiple chunks
+        assert len(chunks) > 1
+
+        # Verify all chunks
+        for chunk in chunks:
+            assert isinstance(chunk, ChunkWithPosition)
+            # Verify extraction
+            extracted = content[chunk.start_offset : chunk.end_offset]
+            assert extracted == chunk.text
+            # Verify positions are valid
+            assert chunk.start_offset >= 0
+            assert chunk.end_offset <= len(content)
+            assert chunk.start_offset < chunk.end_offset
+
+    def test_semantic_boundary_preservation(self):
+        """Test that LangChain creates semantically coherent chunks."""
+        chunker = DocumentChunker(chunk_size=100, overlap=20)
+        content = (
+            "First sentence is here. "
+            "Second sentence follows. "
+            "Third sentence continues. "
+            "Fourth sentence ends."
+        )
+
+        chunks = chunker.chunk_text(content)
+
+        # Verify all chunks are extractable using their positions
+        for chunk in chunks:
+            extracted = content[chunk.start_offset : chunk.end_offset]
+            assert extracted == chunk.text
+
+            # Verify chunk text is meaningful (not empty or just whitespace)
+            assert len(chunk.text.strip()) > 0
+
+            # Verify positions are valid
+            assert chunk.start_offset >= 0
+            assert chunk.end_offset <= len(content)
+            assert chunk.start_offset < chunk.end_offset
+
+    def test_paragraph_boundary_preservation(self):
+        """Test that LangChain preserves paragraph boundaries."""
+        chunker = DocumentChunker(chunk_size=80, overlap=15)
+        content = """First paragraph here.
+
+Second paragraph here.
+
+Third paragraph here.
+
+Fourth paragraph here."""
+
+        chunks = chunker.chunk_text(content)
+
+        # LangChain should prefer splitting at paragraph boundaries (\n\n)
+        # Verify we got multiple chunks
+        assert len(chunks) >= 1
+
+        # Verify all positions work correctly
+        for chunk in chunks:
+            extracted = content[chunk.start_offset : chunk.end_offset]
+            assert extracted == chunk.text
+
+    def test_default_parameters(self):
+        """Test that default parameters work correctly."""
+        chunker = DocumentChunker()  # Use defaults: 2048 chars, 200 overlap
+
+        # Create content that's smaller than default chunk size
+        content = (
+            "This is a short note with a few sentences. It should fit in one chunk."
+        )
+
+        chunks = chunker.chunk_text(content)
+
+        assert len(chunks) == 1
+        assert chunks[0].text == content
+        assert chunks[0].start_offset == 0
+        assert chunks[0].end_offset == len(content)
+
+    def test_large_document_chunking(self):
+        """Test chunking of a large document."""
+        chunker = DocumentChunker(chunk_size=100, overlap=20)
+
+        # Create a large document with multiple paragraphs
+        paragraphs = [
+            f"This is paragraph {i} with some meaningful content about topic {i}. "
+            f"It contains multiple sentences to make it realistic. "
+            f"The content should be properly chunked."
+            for i in range(10)
+        ]
+        content = "\n\n".join(paragraphs)
+
+        chunks = chunker.chunk_text(content)
+
+        # Should create multiple chunks
+        assert len(chunks) > 1
+
+        # Verify all chunks are valid
+        for chunk in chunks:
+            assert isinstance(chunk, ChunkWithPosition)
+            assert len(chunk.text) > 0
+            # Verify extraction
+            extracted = content[chunk.start_offset : chunk.end_offset]
+            assert extracted == chunk.text
+
+        # Verify first and last positions
+        assert chunks[0].start_offset == 0
+        assert chunks[-1].end_offset == len(content)
+
+    def test_position_tracking_with_overlap(self):
+        """Test that position tracking works correctly with overlap."""
+        chunker = DocumentChunker(chunk_size=50, overlap=15)
+        content = "A" * 25 + ". " + "B" * 25 + ". " + "C" * 25 + ". " + "D" * 25 + "."
+
+        chunks = chunker.chunk_text(content)
+
+        if len(chunks) > 1:
+            # Verify overlap creates correct positions
+            for i in range(len(chunks) - 1):
+                # Each chunk should be extractable
+                assert (
+                    content[chunks[i].start_offset : chunks[i].end_offset]
+                    == chunks[i].text
+                )
+
+                # Next chunk should overlap with current
+                # (start before current ends)
+                if chunks[i + 1].start_offset < chunks[i].end_offset:
+                    # There is overlap - verify content matches
+                    overlap_start = chunks[i + 1].start_offset
+                    overlap_end = chunks[i].end_offset
+                    overlap_text = content[overlap_start:overlap_end]
+                    assert overlap_text in chunks[i].text
+                    assert overlap_text in chunks[i + 1].text

tests/unit/test_instrument_tool.py

@@ -0,0 +1,217 @@
+"""
+Unit tests for @instrument_tool decorator.
+
+Tests that the decorator correctly instruments MCP tools with both
+Prometheus metrics and OpenTelemetry tracing.
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from nextcloud_mcp_server.observability.metrics import instrument_tool
+
+pytestmark = pytest.mark.unit
+
+
+@pytest.fixture
+def mock_metrics():
+    """Mock Prometheus metrics."""
+    with (
+        patch(
+            "nextcloud_mcp_server.observability.metrics.record_tool_call"
+        ) as mock_record,
+        patch(
+            "nextcloud_mcp_server.observability.metrics.record_tool_error"
+        ) as mock_error,
+    ):
+        yield {"record_tool_call": mock_record, "record_tool_error": mock_error}
+
+
+@pytest.fixture
+def mock_tracer():
+    """Mock OpenTelemetry tracer."""
+    with patch(
+        "nextcloud_mcp_server.observability.tracing.trace_operation"
+    ) as mock_trace:
+        # Configure mock to act as a context manager that allows exceptions to propagate
+        mock_trace.return_value.__enter__ = MagicMock(return_value=None)
+        mock_trace.return_value.__exit__ = MagicMock(
+            return_value=False
+        )  # Return False to allow exceptions to propagate
+        yield mock_trace
+
+
+class TestInstrumentToolDecorator:
+    """Test the @instrument_tool decorator."""
+
+    async def test_decorator_creates_trace_span(self, mock_tracer, mock_metrics):
+        """Test that decorator creates OpenTelemetry span with correct attributes."""
+
+        @instrument_tool
+        async def example_tool(query: str, limit: int = 10):
+            return {"results": []}
+
+        # Call the tool
+        await example_tool(query="test query", limit=5)
+
+        # Verify trace_operation was called with correct parameters
+        mock_tracer.assert_called_once()
+        call_args = mock_tracer.call_args
+
+        # Check span name
+        assert call_args[0][0] == "mcp.tool.example_tool"
+
+        # Check span attributes
+        attributes = call_args[1]["attributes"]
+        assert attributes["mcp.tool.name"] == "example_tool"
+        assert "query" in attributes["mcp.tool.args"]
+        assert "test query" in attributes["mcp.tool.args"]
+        assert "limit" in attributes["mcp.tool.args"]
+
+        # Verify record_exception parameter
+        assert call_args[1]["record_exception"] is True
+
+    async def test_decorator_sanitizes_sensitive_arguments(
+        self, mock_tracer, mock_metrics
+    ):
+        """Test that sensitive arguments are excluded from span attributes."""
+
+        @instrument_tool
+        async def example_tool(
+            query: str, password: str, token: str, api_key: str, ctx: object
+        ):
+            return {"success": True}
+
+        # Call with sensitive parameters
+        await example_tool(
+            query="test",
+            password="secret123",
+            token="bearer_token",
+            api_key="api_key_123",
+            ctx=MagicMock(),
+        )
+
+        # Verify trace was created
+        mock_tracer.assert_called_once()
+        attributes = mock_tracer.call_args[1]["attributes"]
+
+        # Check that sensitive fields are NOT in attributes
+        tool_args = attributes["mcp.tool.args"]
+        assert "password" not in tool_args
+        assert "secret123" not in tool_args
+        assert "token" not in tool_args
+        assert "bearer_token" not in tool_args
+        assert "api_key" not in tool_args
+        assert "api_key_123" not in tool_args
+        assert "ctx" not in tool_args
+
+        # Check that non-sensitive field IS included
+        assert "query" in tool_args
+        assert "test" in tool_args
+
+    async def test_decorator_limits_argument_string_length(
+        self, mock_tracer, mock_metrics
+    ):
+        """Test that tool arguments are limited to 500 characters."""
+
+        @instrument_tool
+        async def example_tool(query: str):
+            return {"results": []}
+
+        # Create a very long query string (>500 chars)
+        long_query = "x" * 1000
+
+        await example_tool(query=long_query)
+
+        # Verify arguments were truncated
+        mock_tracer.assert_called_once()
+        attributes = mock_tracer.call_args[1]["attributes"]
+        tool_args = attributes["mcp.tool.args"]
+
+        assert len(tool_args) <= 500
+
+    async def test_decorator_records_success_metrics(self, mock_tracer, mock_metrics):
+        """Test that successful tool execution records metrics."""
+
+        @instrument_tool
+        async def example_tool():
+            return {"success": True}
+
+        # Call the tool
+        await example_tool()
+
+        # Verify success metrics were recorded
+        mock_metrics["record_tool_call"].assert_called_once()
+        call_args = mock_metrics["record_tool_call"].call_args
+        assert call_args[0][0] == "example_tool"  # tool_name
+        assert isinstance(call_args[0][1], float)  # duration
+        assert call_args[0][2] == "success"  # status
+
+    async def test_decorator_records_error_metrics(self, mock_tracer, mock_metrics):
+        """Test that tool errors are recorded in metrics."""
+
+        @instrument_tool
+        async def failing_tool():
+            raise ValueError("Test error")
+
+        # Call the tool and expect exception
+        with pytest.raises(ValueError, match="Test error"):
+            await failing_tool()
+
+        # Verify error metrics were recorded
+        mock_metrics["record_tool_call"].assert_called_once()
+        call_args = mock_metrics["record_tool_call"].call_args
+        assert call_args[0][0] == "failing_tool"  # tool_name
+        assert isinstance(call_args[0][1], float)  # duration
+        assert call_args[0][2] == "error"  # status
+
+        # Verify error type was recorded
+        mock_metrics["record_tool_error"].assert_called_once()
+        error_args = mock_metrics["record_tool_error"].call_args
+        assert error_args[0][0] == "failing_tool"  # tool_name
+        assert error_args[0][1] == "ValueError"  # error_type
+
+    async def test_decorator_preserves_function_metadata(
+        self, mock_tracer, mock_metrics
+    ):
+        """Test that decorator preserves function name and docstring."""
+
+        @instrument_tool
+        async def example_tool():
+            """This is a test tool."""
+            return {"success": True}
+
+        # Verify function metadata is preserved
+        assert example_tool.__name__ == "example_tool"
+        assert example_tool.__doc__ == "This is a test tool."
+
+    async def test_decorator_preserves_return_value(self, mock_tracer, mock_metrics):
+        """Test that decorator returns the original function's return value."""
+
+        @instrument_tool
+        async def example_tool(value: int):
+            return {"result": value * 2}
+
+        # Call the tool
+        result = await example_tool(value=5)
+
+        # Verify return value is unchanged
+        assert result == {"result": 10}
+
+    async def test_decorator_with_no_arguments(self, mock_tracer, mock_metrics):
+        """Test decorator with tool that takes no arguments."""
+
+        @instrument_tool
+        async def no_args_tool():
+            return {"status": "ok"}
+
+        # Call the tool
+        await no_args_tool()
+
+        # Verify tracing works with no arguments
+        mock_tracer.assert_called_once()
+        attributes = mock_tracer.call_args[1]["attributes"]
+
+        # tool_args should be None when there are no kwargs
+        assert attributes["mcp.tool.args"] is None