build: bump submodule

.github/workflows/bump-version.yml

@@ -20,7 +20,7 @@ jobs:
           fetch-depth: 0
           token: "${{ secrets.PERSONAL_ACCESS_TOKEN }}"
       - name: Create bump and changelog
-        uses: commitizen-tools/commitizen-action@9615e7be1cf341393c52e865ebbdaa0712176d81 # 0.25.0
+        uses: commitizen-tools/commitizen-action@5b0848cd060263e24602d1eba03710e056ef7711 # 0.24.0
         with:
           github_token: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
           changelog_increment_filename: body.md

.gitignore

@@ -13,6 +13,3 @@ docker-compose.override.yml
 # Generated by pytest used to login users
 .nextcloud_oauth_*.json
 .playwright-mcp/
-
-# RAG Evaluation
-tests/rag_evaluation/fixtures/

.gitmodules

@@ -4,3 +4,6 @@
 [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,53 +1,3 @@
-## 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

CLAUDE.md

@@ -5,29 +5,23 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 ## Coding Conventions
 
 ### async/await Patterns
-- **Use anyio for all async operations** - Provides structured concurrency
+- **Use anyio + asyncio hybrid** - Both libraries are available
   - pytest runs in `anyio` mode (`anyio_mode = "auto"` in pyproject.toml)
-  - Use `anyio.create_task_group()` for concurrent execution (NOT `asyncio.gather()`)
-  - Use `anyio.Lock()` for synchronization primitives (NOT `asyncio.Lock()`)
-  - Use `anyio.run()` for entry points (NOT `asyncio.run()`)
+  - asyncio used in auth modules (refresh_token_storage.py, token_exchange.py, token_broker.py)
+  - anyio used in calendar.py, client_registration.py, app.py
   - Prefer standard async/await syntax without explicit library imports when possible
-  - Examples: app.py, search/hybrid.py, search/verification.py, auth/token_broker.py
 
 ### Type Hints
 - **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
-- **Type checker**: `ty` is configured for static type checking
-  ```bash
-  uv run ty check -- nextcloud_mcp_server
-  ```
+- **No explicit type checker configured** - Ruff handles linting only
 
 ### Code Quality
-- **Run ruff and ty before committing**:
+- **Run ruff 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)
 
@@ -61,60 +55,8 @@ 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,13 +1,9 @@
-FROM python:3.12-slim-trixie
-
-COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+FROM ghcr.io/astral-sh/uv:0.9.9-python3.11-alpine@sha256:0faa7934fac1db7f5056f159c1224d144bab864fd2677a4066d25a686ae32edd
 
 # Install dependencies
 # 1. git (required for caldav dependency from git)
 # 2. sqlite for development with token db
-RUN apt update && apt install --no-install-recommends --no-install-suggests -y \
-    git \
-    sqlite3
+RUN apk add --no-cache git sqlite
 
 WORKDIR /app
 

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/apps/notes ]; then
+        echo "Removing existing notes in apps..."
+        rm -rf /var/www/html/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: apps/notes -> /opt/apps/notes"
+    ln -sf /opt/apps/notes /var/www/html/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/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.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.40.0
-appVersion: "0.40.0"
+version: 0.36.0
+appVersion: "0.36.0"
 keywords:
   - nextcloud
   - mcp

docker-compose.yml

@@ -70,13 +70,11 @@ services:
   mcp:
     build: .
     restart: always
-    command: ["--transport", "streamable-http"]
     depends_on:
       app:
         condition: service_healthy
     ports:
       - 127.0.0.1:8000:8000
-      - 127.0.0.1:9090:9090
     volumes:
       - mcp-data:/app/data
     environment:
@@ -87,7 +85,7 @@ services:
 
       # Vector sync configuration (ADR-007)
       - VECTOR_SYNC_ENABLED=true
-      - VECTOR_SYNC_SCAN_INTERVAL=60
+      - VECTOR_SYNC_SCAN_INTERVAL=10
       - VECTOR_SYNC_PROCESSOR_WORKERS=1
 
       #- LOG_FORMAT=json
@@ -195,8 +193,8 @@ services:
       # Provider auto-detected from OIDC_DISCOVERY_URL issuer
       # Using internal Docker hostname for discovery to get consistent issuer
       - OIDC_DISCOVERY_URL=http://keycloak:8080/realms/nextcloud-mcp/.well-known/openid-configuration
-      - NEXTCLOUD_OIDC_CLIENT_ID=nextcloud-mcp-server
-      - NEXTCLOUD_OIDC_CLIENT_SECRET=mcp-secret-change-in-production
+      - OIDC_CLIENT_ID=nextcloud-mcp-server
+      - OIDC_CLIENT_SECRET=mcp-secret-change-in-production
       - OIDC_JWKS_URI=http://keycloak:8080/realms/nextcloud-mcp/protocol/openid-connect/certs
 
       # Nextcloud API endpoint (for accessing APIs with validated token)
@@ -242,6 +240,17 @@ services:
     profiles:
       - qdrant
 
+  open-webui:
+    image: ghcr.io/open-webui/open-webui:main
+    environment:
+      - OLLAMA_BASE_URL=https://ollama.internal.coutinho.io
+    ports:
+      - 127.0.0.1:3000:8080
+    volumes:
+      - open-webui:/app/backend/data
+    profiles:
+      - open-webui
+
 volumes:
   nextcloud:
   db:
@@ -251,3 +260,4 @@ volumes:
   keycloak-oauth-storage:
   qdrant-data:
   mcp-data:
+  open-webui:

docs/ADR-013-rag-evaluation.md

@@ -1,254 +0,0 @@
-## ADR-013: RAG Evaluation Testing Framework
-
-**Status:** Proposed
-
-**Date:** 2025-11-15
-
-### Context
-
-The `nc_semantic_search_answer` tool implements a Retrieval-Augmented Generation (RAG) system where:
-1. **Retrieval**: Vector sync pipeline indexes Nextcloud documents (notes, calendar, contacts, etc.) into a vector database
-2. **Generation**: MCP client's LLM synthesizes answers from retrieved documents via MCP sampling (ADR-008)
-
-We need a testing framework to evaluate RAG system performance and identify whether failures occur in retrieval (wrong documents found) or generation (poor answer quality). This framework must use industry-standard evaluation methodologies while remaining practical to implement and maintain.
-
-To establish a baseline, we will use the **BeIR/nfcorpus** dataset (medical/biomedical corpus) with ~5,000 documents and established query/answer pairs.
-
-Homepage: https://www.cl.uni-heidelberg.de/statnlpgroup/nfcorpus/
-Download: https://public.ukp.informatik.tu-darmstadt.de/thakur/BEIR/datasets/nfcorpus.zip
-
-### Decision
-
-We will implement a **two-part evaluation framework** that independently tests retrieval and generation quality using pytest fixtures.
-
-#### In Scope
-
-**1. Retrieval Evaluation**
-Tests the vector sync/embedding pipeline's ability to find relevant documents.
-
-- **Metric: Context Recall** (Did we retrieve documents containing the answer?)
-  - **Evaluation method**: Heuristic - Check if ground-truth document IDs appear in top-k retrieval results
-  - **Test**: Query → Semantic search → Assert expected doc IDs present
-
-**2. Generation Evaluation**
-Tests the MCP client LLM's ability to synthesize correct answers from retrieved context.
-
-- **Metric: Answer Correctness** (Is the generated answer factually correct?)
-  - **Evaluation method**: LLM-as-judge - Compare RAG answer against ground-truth answer
-  - **Test**: Query → `nc_semantic_search_answer` → LLM evaluates answer vs. ground truth (binary true/false)
-
-#### Out of Scope (Initial Implementation)
-
-- **Context Relevance/Precision**: Measuring irrelevant documents in retrieval results
-- **Faithfulness/Groundedness**: Detecting hallucinations not supported by retrieved context
-- **Answer Relevance**: Whether answer addresses the specific question asked
-- **Out-of-Scope Handling**: Testing "I don't know" responses when answer isn't in context
-- **Continuous benchmarking**: Automated tracking of metric trends over time
-- **Custom domain datasets**: Production-specific test data (medical corpus used initially)
-
-These remain valuable for future iterations but add complexity beyond our initial goals.
-
-#### Implementation
-
-**Test Structure**
-
-Location: `tests/rag_evaluation/`
-- `test_retrieval_quality.py` - Retrieval evaluation tests
-- `test_generation_quality.py` - Generation evaluation tests
-- `conftest.py` - Fixtures for test data, MCP clients, and evaluation LLMs
-
-**Required Pytest Fixtures**
-
-1. **`nfcorpus_test_data`** (session-scoped)
-   - Downloads/caches BeIR nfcorpus dataset at runtime
-   - Loads 5 pre-selected test queries with:
-     - Query text
-     - Pre-generated ground-truth answer (from `tests/rag_evaluation/fixtures/ground_truth.json`)
-     - Expected document IDs (from qrels with score=2)
-   - Uploads all corpus documents as notes in test Nextcloud instance
-   - Triggers vector sync to index documents
-   - Waits for indexing completion
-   - Returns test case data structure
-
-2. **`mcp_sampling_client`** (session-scoped)
-   - Creates MCP client that supports sampling
-   - Configurable LLM provider (ollama or anthropic) via environment:
-     - `RAG_EVAL_PROVIDER=ollama` (default) or `anthropic`
-     - `RAG_EVAL_OLLAMA_BASE_URL=http://localhost:11434`
-     - `RAG_EVAL_OLLAMA_MODEL=llama3.1:8b`
-     - `RAG_EVAL_ANTHROPIC_API_KEY=sk-...`
-     - `RAG_EVAL_ANTHROPIC_MODEL=claude-3-5-sonnet-20241022`
-   - Returns configured MCP client fixture
-
-3. **`evaluation_llm`** (session-scoped)
-   - Separate LLM instance for evaluation (independent from MCP client)
-   - Same provider configuration as `mcp_sampling_client`
-   - Returns callable: `async def evaluate(prompt: str) -> str`
-
-**Test Implementation Examples**
-
-```python
-# tests/rag_evaluation/test_retrieval_quality.py
-async def test_retrieval_recall(nc_client, nfcorpus_test_data):
-    """Test that semantic search retrieves documents containing the answer."""
-    for test_case in nfcorpus_test_data:
-        # Perform semantic search (retrieval only, no generation)
-        results = await nc_client.notes.semantic_search(
-            query=test_case.query,
-            limit=10
-        )
-
-        retrieved_doc_ids = {r.document_id for r in results}
-        expected_doc_ids = set(test_case.expected_document_ids)
-
-        # Context Recall: Are expected documents in top-k results?
-        recall = len(expected_doc_ids & retrieved_doc_ids) / len(expected_doc_ids)
-        assert recall >= 0.8, f"Recall {recall} below threshold for query: {test_case.query}"
-
-
-# tests/rag_evaluation/test_generation_quality.py
-async def test_answer_correctness(mcp_sampling_client, evaluation_llm, nfcorpus_test_data):
-    """Test that RAG system generates factually correct answers."""
-    for test_case in nfcorpus_test_data:
-        # Execute full RAG pipeline (retrieval + generation)
-        result = await mcp_sampling_client.call_tool(
-            "nc_semantic_search_answer",
-            arguments={"query": test_case.query, "limit": 5}
-        )
-
-        rag_answer = result["generated_answer"]
-
-        # LLM-as-judge evaluation
-        evaluation_prompt = f"""Compare these two answers and respond with only TRUE or FALSE.
-
-Question: {test_case.query}
-
-Generated Answer: {rag_answer}
-
-Ground Truth Answer: {test_case.ground_truth}
-
-Are these answers semantically equivalent (do they convey the same factual information)?
-Respond with only: TRUE or FALSE"""
-
-        evaluation_result = await evaluation_llm(evaluation_prompt)
-
-        assert evaluation_result.strip().upper() == "TRUE", \
-            f"Answer mismatch for query: {test_case.query}\nGot: {rag_answer}\nExpected: {test_case.ground_truth}"
-```
-
-**Dataset Integration**
-
-The BeIR nfcorpus dataset structure:
-- **corpus.jsonl**: 3,633 medical/biomedical documents (articles from PubMed)
-- **queries.jsonl**: 3,237 queries (questions)
-- **qrels/*.tsv**: Relevance judgments mapping query IDs to document IDs with scores (2=highly relevant, 1=somewhat relevant)
-
-**Important**: The dataset provides relevance judgments (which documents answer which queries) but does NOT include ground truth answers. We must generate synthetic ground truth offline.
-
-**Selected Test Queries** (5 diverse candidates):
-
-1. **PLAIN-2630**: "Alkylphenol Endocrine Disruptors and Allergies" (5 words, 21 highly relevant docs)
-2. **PLAIN-2660**: "How Long to Detox From Fish Before Pregnancy?" (8 words, 20 highly relevant docs)
-3. **PLAIN-2510**: "Coffee and Artery Function" (4 words, 16 highly relevant docs)
-4. **PLAIN-2430**: "Preventing Brain Loss with B Vitamins?" (6 words, 15 highly relevant docs)
-5. **PLAIN-2690**: "Chronic Headaches and Pork Tapeworms" (5 words, 14 highly relevant docs)
-
-**Ground Truth Generation** (offline, pre-test):
-
-Ground truth answers will be generated offline using a script that:
-1. Loads nfcorpus dataset
-2. For each selected query, extracts top 3-5 highly relevant documents
-3. Uses an LLM (ollama/anthropic) to synthesize a reference answer
-4. Stores ground truth in `tests/rag_evaluation/fixtures/ground_truth.json`
-
-```python
-# tools/generate_rag_ground_truth.py
-async def generate_ground_truth(query: str, relevant_docs: List[dict], llm: LLMProvider) -> str:
-    """Generate synthetic ground truth answer from highly relevant documents."""
-    context = "\n\n".join([
-        f"Document {i+1}:\nTitle: {doc['title']}\n{doc['text']}"
-        for i, doc in enumerate(relevant_docs[:5])
-    ])
-
-    prompt = f"""Based on the following documents, provide a comprehensive answer to this question:
-
-Question: {query}
-
-{context}
-
-Provide a factual, well-structured answer that synthesizes information from the documents.
-Focus on accuracy and completeness."""
-
-    return await llm.generate(prompt, max_tokens=500)
-```
-
-**Dataset Loading at Test Runtime** (in `nfcorpus_test_data` fixture):
-
-1. Download nfcorpus dataset (cached in pytest temp directory)
-2. Load corpus, queries, and qrels (relevance judgments)
-3. Load pre-generated ground truth from `tests/rag_evaluation/fixtures/ground_truth.json`
-4. Upload all corpus documents as Nextcloud notes
-5. Trigger vector sync to index documents
-6. Wait for indexing completion
-7. Return test cases with query, ground truth, and expected doc IDs
-
-**LLM Provider Abstraction**
-
-```python
-# tests/rag_evaluation/llm_providers.py
-class LLMProvider(Protocol):
-    async def generate(self, prompt: str, max_tokens: int = 100) -> str: ...
-
-class OllamaProvider:
-    def __init__(self, base_url: str, model: str):
-        self.base_url = base_url
-        self.model = model
-
-    async def generate(self, prompt: str, max_tokens: int = 100) -> str:
-        # Use httpx to call Ollama API
-        ...
-
-class AnthropicProvider:
-    def __init__(self, api_key: str, model: str):
-        self.client = anthropic.AsyncAnthropic(api_key=api_key)
-        self.model = model
-
-    async def generate(self, prompt: str, max_tokens: int = 100) -> str:
-        message = await self.client.messages.create(
-            model=self.model,
-            max_tokens=max_tokens,
-            messages=[{"role": "user", "content": prompt}]
-        )
-        return message.content[0].text
-```
-
-### Consequences
-
-**Positive:**
-
-* **Actionable debugging**: Separate retrieval/generation tests pinpoint failure location
-* **Industry-standard metrics**: Context Recall and Answer Correctness are recognized RAG evaluation metrics
-* **Simple initial implementation**: Binary LLM evaluation (true/false) is straightforward to implement and interpret
-* **Extensible framework**: Easy to add more metrics (faithfulness, relevance) later
-* **Standardized benchmark**: nfcorpus provides objective comparison against published RAG systems
-* **Hybrid evaluation**: Combines efficiency (heuristics for retrieval) with quality (LLM-as-judge for generation)
-* **Provider flexibility**: Supports both local (Ollama) and cloud (Anthropic) LLM evaluation
-
-**Negative:**
-
-* **Medical domain bias**: nfcorpus is medical/biomedical content, may not represent production use cases (personal notes, calendar events, etc.)
-* **Manual test execution**: Tests require external LLM access and are not integrated into CI pipeline
-* **Limited initial coverage**: Starting with only 5 queries provides limited statistical confidence
-* **Evaluation cost**: LLM-as-judge for generation evaluation incurs API costs (Anthropic) or requires local inference (Ollama)
-* **Single metric per component**: Initial scope tests only one metric per component, missing other important quality dimensions
-* **Synthetic ground truth**: Ground truth answers are LLM-generated, not human-validated, which may introduce evaluation bias
-* **Large corpus upload**: Uploading 3,633 documents at test runtime may be slow; caching strategy needed
-
-**Future Work:**
-
-* Expand to 50-100 queries for statistical significance
-* Add custom test dataset with production-representative documents (meeting notes, task lists, etc.)
-* Implement additional metrics (faithfulness, context relevance, answer relevance)
-* Create automated benchmarking dashboard to track metric trends
-* Test multi-hop reasoning (synthesis questions requiring multiple documents)
-* Evaluate out-of-scope handling ("I don't know" responses)

docs/ADR-014-bm25-search.md

@@ -1,153 +0,0 @@
-# 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 RRF fusion (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)

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

@@ -1,380 +0,0 @@
-# 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

@@ -1,338 +0,0 @@
-# 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 `@instrument_tool` for automatic metrics and trace span creation
+2. **MCP Layer**: Tools use `@trace_mcp_tool` for 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

@@ -446,7 +446,7 @@ async def app_lifespan_basic(server: FastMCP) -> AsyncIterator[AppContext]:
         # Start background tasks using anyio TaskGroup
         async with anyio.create_task_group() as tg:
             # Start scanner task
-            await tg.start(
+            tg.start_soon(
                 scanner_task,
                 send_stream,
                 shutdown_event,
@@ -457,7 +457,7 @@ async def app_lifespan_basic(server: FastMCP) -> AsyncIterator[AppContext]:
 
             # Start processor pool (each gets a cloned receive stream)
             for i in range(settings.vector_sync_processor_workers):
-                await tg.start(
+                tg.start_soon(
                     processor_task,
                     i,
                     receive_stream.clone(),
@@ -1147,7 +1147,7 @@ def get_app(transport: str = "sse", enabled_apps: list[str] | None = None):
                 # Start background tasks using anyio TaskGroup
                 async with anyio_module.create_task_group() as tg:
                     # Start scanner task
-                    await tg.start(
+                    tg.start_soon(
                         scanner_task,
                         send_stream,
                         shutdown_event,
@@ -1158,7 +1158,7 @@ def get_app(transport: str = "sse", enabled_apps: list[str] | None = None):
 
                     # Start processor pool (each gets a cloned receive stream)
                     for i in range(settings.vector_sync_processor_workers):
-                        await tg.start(
+                        tg.start_soon(
                             processor_task,
                             i,
                             receive_stream.clone(),
@@ -1523,7 +1523,7 @@ def get_app(transport: str = "sse", enabled_apps: list[str] | None = None):
 
     browser_app = Starlette(routes=browser_routes)
     browser_app.add_middleware(
-        AuthenticationMiddleware,  # type: ignore[invalid-argument-type]
+        AuthenticationMiddleware,
         backend=SessionAuthBackend(oauth_enabled=oauth_enabled),
     )
 
@@ -1613,7 +1613,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,  # type: ignore[invalid-argument-type]
+        CORSMiddleware,
         allow_origins=["*"],  # Allow all origins for development
         allow_credentials=True,
         allow_methods=["*"],
@@ -1623,7 +1623,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)  # type: ignore[invalid-argument-type]
+        app.add_middleware(ObservabilityMiddleware)
         logger.info("Observability middleware enabled (metrics and/or tracing)")
 
     # Add exception handler for scope challenges (OAuth mode only)

nextcloud_mcp_server/auth/storage.py

@@ -1310,7 +1310,7 @@ async def generate_encryption_key() -> str:
 
 # Example usage
 if __name__ == "__main__":
-    import anyio
+    import asyncio
 
     async def main():
         # Generate a key for testing
@@ -1318,4 +1318,4 @@ if __name__ == "__main__":
         print(f"Generated encryption key: {key}")
         print(f"Set this in your environment: export TOKEN_ENCRYPTION_KEY='{key}'")
 
-    anyio.run(main)
+    asyncio.run(main())

nextcloud_mcp_server/auth/token_broker.py

@@ -14,11 +14,11 @@ The Token Broker provides:
 - Session vs background token separation (RFC 8693)
 """
 
+import asyncio
 import logging
 from datetime import datetime, timedelta, timezone
 from typing import Dict, Optional, Tuple
 
-import anyio
 import httpx
 import jwt
 from cryptography.fernet import Fernet
@@ -43,7 +43,7 @@ class TokenCache:
         self._cache: Dict[str, Tuple[str, datetime]] = {}
         self._ttl = timedelta(seconds=ttl_seconds)
         self._early_refresh = timedelta(seconds=early_refresh_seconds)
-        self._lock = anyio.Lock()
+        self._lock = asyncio.Lock()
 
     async def get(self, user_id: str) -> Optional[str]:
         """Get cached token if valid."""

nextcloud_mcp_server/auth/userinfo_routes.py

@@ -676,11 +676,14 @@ async def user_info_html(request: Request) -> HTMLResponse:
             function vizApp() {{
                 return {{
                     query: '',
-                    algorithm: 'bm25_hybrid',
+                    algorithm: 'hybrid',
                     showAdvanced: false,
                     docTypes: [''],  // Default to "All Types"
                     limit: 50,
-                    scoreThreshold: 0.0,
+                    scoreThreshold: 0.7,
+                    semanticWeight: 0.5,
+                    keywordWeight: 0.3,
+                    fuzzyWeight: 0.2,
                     loading: false,
                     results: [],
 
@@ -694,6 +697,9 @@ 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 doc_types parameter (filter out empty string for "All Types")
@@ -719,11 +725,6 @@ async def user_info_html(request: Request) -> HTMLResponse:
                     }},
 
                     renderPlot(coordinates, results) {{
-                        // Calculate score range for auto-scaling
-                        const scores = results.map(r => r.score);
-                        const minScore = Math.min(...scores);
-                        const maxScore = Math.max(...scores);
-
                         const trace = {{
                             x: coordinates.map(c => c[0]),
                             y: coordinates.map(c => c[1]),
@@ -731,18 +732,11 @@ async def user_info_html(request: Request) -> HTMLResponse:
                             type: 'scatter',
                             text: results.map(r => `${{r.title}}<br>Score: ${{r.score.toFixed(3)}}`),
                             marker: {{
-                                // Multi-channel encoding: size + opacity + color for visual hierarchy
-                                // Power scaling (score^2) amplifies visual differences dramatically
-                                // score=0.0 → 6px, score=0.5 → 9.5px, score=1.0 → 20px
-                                size: results.map(r => 6 + (Math.pow(r.score, 2) * 14)),
-                                // Linear opacity scaling (0.2-1.0 range keeps all points visible)
-                                opacity: results.map(r => 0.2 + (r.score * 0.8)),
-                                // Color gradient shows score
-                                color: scores,
+                                size: 8,
+                                color: results.map(r => r.score),
                                 colorscale: 'Viridis',
                                 showscale: true,
-                                colorbar: {{ title: 'Relative Score' }},
-                                // Scores are normalized 0-1 within result set
+                                colorbar: {{ title: 'Score' }},
                                 cmin: 0,
                                 cmax: 1
                             }}

nextcloud_mcp_server/auth/viz_routes.py

@@ -11,7 +11,6 @@ All processing happens server-side following ADR-012:
 """
 
 import logging
-import time
 
 import numpy as np
 from starlette.authentication import requires
@@ -20,7 +19,9 @@ from starlette.responses import HTMLResponse, JSONResponse
 
 from nextcloud_mcp_server.config import get_settings
 from nextcloud_mcp_server.search import (
-    BM25HybridSearchAlgorithm,
+    FuzzySearchAlgorithm,
+    HybridSearchAlgorithm,
+    KeywordSearchAlgorithm,
     SemanticSearchAlgorithm,
 )
 from nextcloud_mcp_server.vector.pca import PCA
@@ -207,8 +208,10 @@ async def vector_visualization_html(request: Request) -> HTMLResponse:
                             <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 RRF)</option>
+                                    <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>
 
@@ -256,13 +259,25 @@ async def vector_visualization_html(request: Request) -> HTMLResponse:
                                 </div>
                             </div>
 
-                            <!-- Info: BM25 Hybrid uses native RRF fusion (no manual weights) -->
-                            <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> Uses Qdrant's native Reciprocal Rank Fusion (RRF)
-                                    to automatically combine dense semantic vectors with sparse BM25 keyword vectors.
-                                    No manual weight tuning required.
-                                </p>
+                            <!-- 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>
@@ -349,9 +364,12 @@ async def vector_visualization_search(request: Request) -> JSONResponse:
 
     # Parse query parameters
     query = request.query_params.get("query", "")
-    algorithm = request.query_params.get("algorithm", "bm25_hybrid")
+    algorithm = request.query_params.get("algorithm", "hybrid")
     limit = int(request.query_params.get("limit", "50"))
-    score_threshold = float(request.query_params.get("score_threshold", "0.0"))
+    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"))
 
     # Parse doc_types (comma-separated list, None = all types)
     doc_types_param = request.query_params.get("doc_types", "")
@@ -363,21 +381,68 @@ async def vector_visualization_search(request: Request) -> JSONResponse:
     )
 
     try:
-        # Start total request timer
-        request_start = time.perf_counter()
         # Get authenticated HTTP client from session
         # In BasicAuth mode: uses username/password from session
         # In OAuth mode: uses access token from session
         from nextcloud_mcp_server.auth.userinfo_routes import (
             _get_authenticated_client_for_userinfo,
         )
+        from nextcloud_mcp_server.client.notes import NotesClient
 
-        async with await _get_authenticated_client_for_userinfo(request) as http_client:  # noqa: F841
-            # Create search algorithm (no client needed - verification removed)
+        async with await _get_authenticated_client_for_userinfo(request) as http_client:
+            # Create NotesClient directly with authenticated HTTP client
+            notes_client = NotesClient(http_client, username)
+
+            # Wrap in a minimal client object for search algorithms
+            # This conforms to NextcloudClientProtocol but only implements notes
+            class MinimalNextcloudClient:
+                def __init__(self, notes_client, username):
+                    self._notes = notes_client
+                    self.username = username
+
+                @property
+                def notes(self):
+                    return self._notes
+
+                @property
+                def webdav(self):
+                    return None
+
+                @property
+                def calendar(self):
+                    return None
+
+                @property
+                def contacts(self):
+                    return None
+
+                @property
+                def deck(self):
+                    return None
+
+                @property
+                def cookbook(self):
+                    return None
+
+                @property
+                def tables(self):
+                    return None
+
+            nextcloud_client = MinimalNextcloudClient(notes_client, username)
+
+            # Create search algorithm
             if algorithm == "semantic":
                 search_algo = SemanticSearchAlgorithm(score_threshold=score_threshold)
-            elif algorithm == "bm25_hybrid":
-                search_algo = BM25HybridSearchAlgorithm(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,
+                )
             else:
                 return JSONResponse(
                     {"success": False, "error": f"Unknown algorithm: {algorithm}"},
@@ -386,7 +451,6 @@ async def vector_visualization_search(request: Request) -> JSONResponse:
 
             # Execute search (supports cross-app when doc_types=None)
             # Get unverified results with buffer for filtering
-            search_start = time.perf_counter()
             all_results = []
             if doc_types is None or len(doc_types) == 0:
                 # Cross-app search - search all indexed types
@@ -412,28 +476,13 @@ async def vector_visualization_search(request: Request) -> JSONResponse:
                 # Sort by score before verification
                 all_results.sort(key=lambda r: r.score, reverse=True)
 
-            # No verification needed for visualization - we only need Qdrant metadata
-            # (title, excerpt, doc_type) which is already in search results.
-            # Verification is only needed for sampling (LLM needs full content).
-            search_results = all_results[:limit]
-            search_duration = time.perf_counter() - search_start
+            # Verify access for all results (deduplicates and filters)
+            from nextcloud_mcp_server.search.verification import verify_search_results
 
-        # Normalize scores relative to this result set for better 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:
-            scores = [r.score for r in search_results]
-            min_score, max_score = min(scores), max(scores)
-            score_range = max_score - min_score if max_score > min_score else 1.0
-
-            logger.info(
-                f"Normalizing scores for viz: original range [{min_score:.3f}, {max_score:.3f}] "
-                f"→ [0.0, 1.0]"
+            verified_results = await verify_search_results(
+                all_results, nextcloud_client
             )
-
-            # Rescale each result's score to 0-1 within this result set
-            for r in search_results:
-                r.score = (r.score - min_score) / score_range
+            search_results = verified_results[:limit]
 
         if not search_results:
             return JSONResponse(
@@ -446,7 +495,6 @@ async def vector_visualization_search(request: Request) -> JSONResponse:
             )
 
         # Fetch vectors for matching results from Qdrant
-        vector_fetch_start = time.perf_counter()
         qdrant_client = await get_qdrant_client()
         doc_ids = [r.id for r in search_results]
 
@@ -468,7 +516,7 @@ async def vector_visualization_search(request: Request) -> JSONResponse:
                 ]
             ),
             limit=len(doc_ids) * 2,  # Account for multiple chunks per doc
-            with_vectors=["dense"],  # Only fetch dense vectors for visualization
+            with_vectors=True,
             with_payload=["doc_id"],  # Need doc_id to map vectors to results
         )
 
@@ -484,20 +532,8 @@ async def vector_visualization_search(request: Request) -> JSONResponse:
                 }
             )
 
-        # 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
+        # Extract vectors
+        vectors = np.array([p.vector for p in points if p.vector is not None])
 
         if len(vectors) < 2:
             # Not enough points for PCA
@@ -520,10 +556,8 @@ async def vector_visualization_search(request: Request) -> JSONResponse:
             )
 
         # Apply PCA dimensionality reduction (768-dim → 2D)
-        pca_start = time.perf_counter()
         pca = PCA(n_components=2)
         coords_2d = pca.fit_transform(vectors)
-        pca_duration = time.perf_counter() - pca_start
 
         # After fit, these attributes are guaranteed to be set
         assert pca.explained_variance_ratio_ is not None
@@ -556,18 +590,6 @@ async def vector_visualization_search(request: Request) -> JSONResponse:
             for r in search_results
         ]
 
-        # Calculate total request duration
-        total_duration = time.perf_counter() - request_start
-
-        # Log comprehensive timing metrics
-        logger.info(
-            f"Viz search timing: total={total_duration * 1000:.1f}ms, "
-            f"search={search_duration * 1000:.1f}ms ({search_duration / total_duration * 100:.1f}%), "
-            f"vector_fetch={vector_fetch_duration * 1000:.1f}ms ({vector_fetch_duration / total_duration * 100:.1f}%), "
-            f"pca={pca_duration * 1000:.1f}ms ({pca_duration / total_duration * 100:.1f}%), "
-            f"results={len(search_results)}, vectors={len(vectors)}"
-        )
-
         return JSONResponse(
             {
                 "success": True,
@@ -577,14 +599,6 @@ async def vector_visualization_search(request: Request) -> JSONResponse:
                     "pc1": float(pca.explained_variance_ratio_[0]),
                     "pc2": float(pca.explained_variance_ratio_[1]),
                 },
-                "timing": {
-                    "total_ms": round(total_duration * 1000, 2),
-                    "search_ms": round(search_duration * 1000, 2),
-                    "vector_fetch_ms": round(vector_fetch_duration * 1000, 2),
-                    "pca_ms": round(pca_duration * 1000, 2),
-                    "num_results": len(search_results),
-                    "num_vectors": len(vectors),
-                },
             }
         )
 

nextcloud_mcp_server/client/base.py

@@ -5,7 +5,6 @@ import time
 from abc import ABC
 from functools import wraps
 
-import anyio
 from httpx import AsyncClient, HTTPStatusError, RequestError, codes
 
 from nextcloud_mcp_server.observability.metrics import (
@@ -48,7 +47,7 @@ def retry_on_429(func):
                     # Record retry metric (extract app name from args if available)
                     if len(args) > 0 and hasattr(args[0], "app_name"):
                         record_nextcloud_api_retry(app=args[0].app_name, reason="429")
-                    await anyio.sleep(5)
+                    time.sleep(5)
                 elif e.response.status_code == 404:
                     # 404 errors are often expected (e.g., checking if attachments exist)
                     # Log as debug instead of warning

nextcloud_mcp_server/client/notes.py

@@ -40,7 +40,7 @@ class NotesClient(BaseNextcloudClient):
         seen_ids: set[int] = set()
 
         while True:
-            params: Dict[str, Any] = {"chunkSize": 100}
+            params: Dict[str, Any] = {"chunkSize": 10}
             if cursor:
                 params["chunkCursor"] = cursor
             if prune_before is not None:

nextcloud_mcp_server/embedding/__init__.py

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

nextcloud_mcp_server/embedding/bm25_provider.py

@@ -1,74 +0,0 @@
-"""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,30 +1,56 @@
-"""Embedding service with provider detection.
-
-DEPRECATED: This module is maintained for backward compatibility.
-New code should use nextcloud_mcp_server.providers.get_provider() directly.
-"""
+"""Embedding service with provider detection."""
 
 import logging
+import os
 
-from nextcloud_mcp_server.providers import get_provider
-
-from .bm25_provider import BM25SparseEmbeddingProvider
+from .base import EmbeddingProvider
+from .ollama_provider import OllamaEmbeddingProvider
+from .simple_provider import SimpleEmbeddingProvider
 
 logger = logging.getLogger(__name__)
 
 
 class EmbeddingService:
-    """
-    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.
-    """
+    """Unified embedding service with automatic provider detection."""
 
     def __init__(self):
         """Initialize embedding service with auto-detected provider."""
-        self.provider = get_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)
 
     async def embed(self, text: str) -> list[float]:
         """
@@ -83,20 +109,3 @@ 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/observability/logging_config.py

@@ -39,12 +39,7 @@ class HealthCheckFilter(logging.Filter):
         message = record.getMessage()
         return not any(
             endpoint in message
-            for endpoint in [
-                "/health/live",
-                "/health/ready",
-                "/metrics",
-                "/app/vector-sync/status",
-            ]
+            for endpoint in ["/health/live", "/health/ready", "/metrics"]
         )
 
 

nextcloud_mcp_server/observability/metrics.py

@@ -404,11 +404,10 @@ def update_vector_sync_queue_size(size: int) -> None:
 
 def instrument_tool(func):
     """
-    Decorator to automatically instrument MCP tool functions with metrics and tracing.
+    Decorator to automatically instrument MCP tool functions with metrics.
 
-    Wraps async tool functions to record execution time, success/error status, and
-    create OpenTelemetry trace spans. Compatible with @mcp.tool() and @require_scopes()
-    decorators.
+    Wraps async tool functions to record execution time and success/error status.
+    Compatible with @mcp.tool() and @require_scopes() decorators.
 
     Usage:
         @mcp.tool()
@@ -421,46 +420,24 @@ def instrument_tool(func):
         func: The async function to instrument
 
     Returns:
-        Wrapped function with metrics and tracing instrumentation
+        Wrapped function with metrics 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()
-
-        # 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
+        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

@@ -1,18 +0,0 @@
-"""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

@@ -1,97 +0,0 @@
-"""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

@@ -1,91 +0,0 @@
-"""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

@@ -1,397 +0,0 @@
-"""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

@@ -1,221 +0,0 @@
-"""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

@@ -1,126 +0,0 @@
-"""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

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

nextcloud_mcp_server/search/bm25_hybrid.py

@@ -1,206 +0,0 @@
-"""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):
-        """
-        Initialize BM25 hybrid search algorithm.
-
-        Args:
-            score_threshold: Minimum RRF score (0-1, default: 0.0 to allow RRF scoring)
-                           Note: RRF produces normalized scores, so threshold is typically lower
-        """
-        self.score_threshold = score_threshold
-
-    @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}"
-        )
-
-        # 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,
-                    ),
-                ],
-                # RRF fusion query (no additional query needed, just fusion)
-                query=models.FusionQuery(fusion=models.Fusion.RRF),
-                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 RRF fusion returned {len(search_response.points)} results "
-            f"(before deduplication)"
-        )
-
-        if search_response.points:
-            # Log top 3 RRF scores to help with threshold tuning
-            top_scores = [p.score for p in search_response.points[:3]]
-            logger.debug(f"Top 3 RRF 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,  # RRF fusion score
-                    metadata={
-                        "chunk_index": result.payload.get("chunk_index"),
-                        "total_chunks": result.payload.get("total_chunks"),
-                        "search_method": "bm25_hybrid_rrf",
-                    },
-                )
-            )
-
-            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

@@ -0,0 +1,219 @@
+"""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

@@ -0,0 +1,237 @@
+"""Hybrid search algorithm using Reciprocal Rank Fusion (RRF)."""
+
+import asyncio
+import logging
+from collections import defaultdict
+from typing import Any
+
+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})"
+        )
+
+        # Run algorithms in parallel
+        tasks = []
+        algo_names = []
+
+        if self.semantic_weight > 0:
+            tasks.append(
+                self.semantic.search(query, user_id, limit * 2, doc_type, **kwargs)
+            )
+            algo_names.append("semantic")
+
+        if self.keyword_weight > 0:
+            tasks.append(
+                self.keyword.search(query, user_id, limit * 2, doc_type, **kwargs)
+            )
+            algo_names.append("keyword")
+
+        if self.fuzzy_weight > 0:
+            tasks.append(
+                self.fuzzy.search(query, user_id, limit * 2, doc_type, **kwargs)
+            )
+            algo_names.append("fuzzy")
+
+        # Execute searches in parallel
+        results_list = await asyncio.gather(*tasks)
+
+        # 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

@@ -0,0 +1,277 @@
+"""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,7 +101,6 @@ 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,

nextcloud_mcp_server/search/verification.py

@@ -0,0 +1,122 @@
+"""Access verification for search results.
+
+This module provides centralized verification of Nextcloud access permissions
+for search results. Verification happens at the final output stage (MCP tool/viz endpoint)
+rather than within individual search algorithms, preventing redundant API calls.
+
+Key benefits:
+- Deduplication: Each document verified exactly once (even in hybrid mode)
+- Parallel execution: All verifications run concurrently via anyio task groups
+- Separation of concerns: Algorithms handle scoring, this module handles security
+"""
+
+import logging
+from dataclasses import replace
+from typing import Protocol
+
+import anyio
+
+from nextcloud_mcp_server.search.algorithms import SearchResult
+
+logger = logging.getLogger(__name__)
+
+
+class NextcloudClientProtocol(Protocol):
+    """Protocol for Nextcloud client with app-specific access."""
+
+    @property
+    def notes(self):
+        """Notes client for accessing notes API."""
+        ...
+
+
+async def verify_search_results(
+    results: list[SearchResult],
+    nextcloud_client: NextcloudClientProtocol,
+) -> list[SearchResult]:
+    """
+    Verify Nextcloud access for search results.
+
+    Deduplicates by (doc_id, doc_type), verifies in parallel using anyio task groups,
+    and filters out inaccessible documents. Maintains original result ordering.
+
+    Args:
+        results: Unverified search results from Qdrant
+        nextcloud_client: Nextcloud client for access checks
+
+    Returns:
+        Verified and accessible results (same order as input)
+
+    Example:
+        >>> unverified = await search_algo.search(query="test", limit=10)
+        >>> verified = await verify_search_results(unverified, client)
+        >>> # verified contains only documents user can access
+    """
+    # Deduplicate by (doc_id, doc_type) while preserving order
+    # This is critical for hybrid search where same doc may appear in multiple algorithm results
+    seen = set()
+    unique_results = []
+    for result in results:
+        key = (result.id, result.doc_type)
+        if key not in seen:
+            seen.add(key)
+            unique_results.append(result)
+
+    if not unique_results:
+        return []
+
+    logger.debug(
+        f"Verifying access for {len(unique_results)} unique documents "
+        f"(from {len(results)} total results)"
+    )
+
+    # Verify all unique documents in parallel using anyio task group
+    # Use list to maintain order (index-based storage)
+    verified_results = [None] * len(unique_results)
+
+    async def verify_one(index: int, result: SearchResult):
+        """
+        Verify a single document and store result at index.
+
+        Args:
+            index: Position in verified_results list
+            result: Search result to verify
+        """
+        try:
+            if result.doc_type == "note":
+                # Fetch note to verify access and get fresh metadata
+                note = await nextcloud_client.notes.get_note(result.id)
+                # Update metadata with fresh data from Nextcloud
+                updated_metadata = {**(result.metadata or {}), **note}
+                verified_results[index] = replace(result, metadata=updated_metadata)
+            # TODO: Add verification for other doc types (calendar, deck, file, etc.)
+            else:
+                # For now, assume other types are accessible
+                # In production, add proper verification for each type
+                logger.debug(
+                    f"No verification implemented for doc_type={result.doc_type}, "
+                    "assuming accessible"
+                )
+                verified_results[index] = result
+
+        except Exception as e:
+            # Document is inaccessible (403, 404, or other error)
+            # Log at debug level since this is expected for filtered results
+            logger.debug(f"Document {result.doc_type}/{result.id} not accessible: {e}")
+            verified_results[index] = None
+
+    # Run all verifications in parallel using anyio task group
+    # This provides structured concurrency with automatic cancellation on errors
+    async with anyio.create_task_group() as tg:
+        for idx, result in enumerate(unique_results):
+            tg.start_soon(verify_one, idx, result)
+
+    # Filter out None (inaccessible) and return verified results
+    accessible = [r for r in verified_results if r is not None]
+
+    logger.debug(
+        f"Verification complete: {len(accessible)} accessible, "
+        f"{len(unique_results) - len(accessible)} filtered out"
+    )
+
+    return accessible

nextcloud_mcp_server/server/semantic.py

@@ -1,8 +1,8 @@
 """Semantic search MCP tools using vector database."""
 
 import logging
+from typing import Literal
 
-import anyio
 from httpx import RequestError
 from mcp.server.fastmcp import Context, FastMCP
 from mcp.shared.exceptions import McpError
@@ -25,7 +25,12 @@ from nextcloud_mcp_server.models.semantic import (
 from nextcloud_mcp_server.observability.metrics import (
     instrument_tool,
 )
-from nextcloud_mcp_server.search.bm25_hybrid import BM25HybridSearchAlgorithm
+from nextcloud_mcp_server.search import (
+    FuzzySearchAlgorithm,
+    HybridSearchAlgorithm,
+    KeywordSearchAlgorithm,
+    SemanticSearchAlgorithm,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -41,30 +46,36 @@ def configure_semantic_tools(mcp: FastMCP):
         ctx: Context,
         limit: int = 10,
         doc_types: list[str] | None = None,
-        score_threshold: float = 0.0,
+        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,
     ) -> SemanticSearchResponse:
         """
-        Search Nextcloud content using BM25 hybrid search with cross-app support.
+        Search Nextcloud content using configurable algorithms with cross-app support.
 
-        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
+        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)
 
-        Results are automatically fused using Reciprocal Rank Fusion (RRF) 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.
+        Document types are queried from the vector database to determine what's
+        actually indexed. Currently only "note" documents are fully supported.
 
         Args:
-            query: Natural language or keyword search query
+            query: Natural language 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 RRF fusion score (0-1, default: 0.0 for RRF scoring)
+            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)
 
         Returns:
-            SemanticSearchResponse with matching documents ranked by RRF fusion scores
+            SemanticSearchResponse with matching documents and relevance scores
         """
         from nextcloud_mcp_server.config import get_settings
 
@@ -73,22 +84,42 @@ def configure_semantic_tools(mcp: FastMCP):
         username = client.username
 
         logger.info(
-            f"BM25 hybrid search: query='{query}', user={username}, "
+            f"Search: query='{query}', user={username}, algorithm={algorithm}, "
             f"limit={limit}, score_threshold={score_threshold}"
         )
 
-        # 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 BM25 hybrid search algorithm
-            search_algo = BM25HybridSearchAlgorithm(score_threshold=score_threshold)
+            # 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}")
+                )
 
             # Execute search across requested document types
             # If doc_types is None, search all indexed types (cross-app search)
@@ -122,18 +153,11 @@ def configure_semantic_tools(mcp: FastMCP):
                 # Sort combined results by score
                 all_results.sort(key=lambda r: r.score, reverse=True)
 
-            # Deduplicate results (hybrid search may return same doc from dense + sparse)
-            # Qdrant already filters by user_id for multi-tenant isolation
-            # Sampling tool will verify access when fetching full content
-            seen = set()
-            unique_results = []
-            for result in all_results:
-                key = (result.id, result.doc_type)
-                if key not in seen:
-                    seen.add(key)
-                    unique_results.append(result)
+            # Verify access for all results (deduplicates and filters)
+            from nextcloud_mcp_server.search.verification import verify_search_results
 
-            search_results = unique_results[:limit]  # Final limit after deduplication
+            verified_results = await verify_search_results(all_results, client)
+            search_results = verified_results[:limit]  # Final limit after verification
 
             # Convert SearchResult objects to SemanticSearchResult for response
             results = []
@@ -155,13 +179,13 @@ def configure_semantic_tools(mcp: FastMCP):
                     )
                 )
 
-            logger.info(f"Returning {len(results)} results from BM25 hybrid search")
+            logger.info(f"Returning {len(results)} results from {algorithm} search")
 
             return SemanticSearchResponse(
                 results=results,
                 query=query,
                 total_found=len(results),
-                search_method="bm25_hybrid",
+                search_method=algorithm,
             )
 
         except ValueError as e:
@@ -310,55 +334,35 @@ def configure_semantic_tools(mcp: FastMCP):
                 success=True,
             )
 
-        # 4. Fetch full content for notes in parallel (also verifies access)
-        # Use anyio task group for concurrent fetching with semaphore to prevent
-        # connection pool exhaustion
+        # 4. Fetch full content for notes to provide complete context to LLM
+        # Filter out inaccessible notes (deleted or permissions changed)
         client = await get_client(ctx)
-        accessible_results = [None] * len(search_response.results)
-        full_contents = [None] * len(search_response.results)
+        accessible_results = []
+        full_contents = []  # Full content for accessible notes
 
-        # Limit concurrent requests to prevent connection pool exhaustion
-        max_concurrent = 20
-        semaphore = anyio.Semaphore(max_concurrent)
-
-        async def fetch_content(index: int, result: SemanticSearchResult):
-            """Fetch full content for a single document (parallel with semaphore)."""
-            async with semaphore:
-                if result.doc_type == "note":
-                    try:
-                        note = await client.notes.get_note(result.id)
-                        # Note is accessible, store result and full content
-                        content = note.get("content", "")
-                        accessible_results[index] = result
-                        full_contents[index] = content
-                        logger.debug(
-                            f"Fetched full content for note {result.id} "
-                            f"(length: {len(content)} chars)"
-                        )
-                    except Exception as e:
-                        # Note might have been deleted or permissions changed
-                        # Leave as None to filter out later
-                        logger.debug(
-                            f"Note {result.id} not accessible: {e}. "
-                            f"Excluding from results."
-                        )
-                else:
-                    # Non-note document types (future: calendar, deck, files)
-                    # For now, keep them with excerpts
-                    accessible_results[index] = result
-                    # full_contents[index] remains None (will use excerpt)
-
-        # Run all fetches in parallel using anyio task group
-        async with anyio.create_task_group() as tg:
-            for idx, result in enumerate(search_response.results):
-                tg.start_soon(fetch_content, idx, result)
-
-        # Filter out None (inaccessible notes) while preserving order
-        final_pairs = [
-            (r, c) for r, c in zip(accessible_results, full_contents) if r is not None
-        ]
-        accessible_results = [r for r, c in final_pairs]
-        full_contents = [c for r, c in final_pairs]
+        for result in search_response.results:
+            if result.doc_type == "note":
+                try:
+                    note = await client.notes.get_note(result.id)
+                    # Note is accessible, store full content
+                    accessible_results.append(result)
+                    full_contents.append(note.get("content", ""))
+                    logger.debug(
+                        f"Fetched full content for note {result.id} "
+                        f"(length: {len(full_contents[-1])} chars)"
+                    )
+                except Exception as e:
+                    # Note might have been deleted or permissions changed
+                    # Filter it out to avoid corrupting LLM with inaccessible data
+                    logger.warning(
+                        f"Failed to fetch full content for note {result.id}: {e}. "
+                        f"Excluding from results."
+                    )
+            else:
+                # Non-note document types (future: calendar, deck, files)
+                # For now, keep them with excerpts
+                accessible_results.append(result)
+                full_contents.append(None)
 
         # Check if we filtered out all results
         if not accessible_results:
@@ -410,6 +414,7 @@ def configure_semantic_tools(mcp: FastMCP):
         )
 
         # 6. Request LLM completion via MCP sampling with timeout
+        import anyio
 
         try:
             with anyio.fail_after(30):

nextcloud_mcp_server/vector/processor.py

@@ -8,14 +8,13 @@ import time
 import uuid
 
 import anyio
-from anyio.abc import TaskStatus
 from anyio.streams.memory import MemoryObjectReceiveStream
 from httpx import HTTPStatusError
 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_bm25_service, get_embedding_service
+from nextcloud_mcp_server.embedding import get_embedding_service
 from nextcloud_mcp_server.observability.metrics import (
     record_qdrant_operation,
     record_vector_sync_processing,
@@ -35,8 +34,6 @@ async def processor_task(
     shutdown_event: anyio.Event,
     nc_client: NextcloudClient,
     user_id: str,
-    *,
-    task_status: TaskStatus = anyio.TASK_STATUS_IGNORED,
 ):
     """
     Process documents from stream concurrently.
@@ -56,13 +53,9 @@ async def processor_task(
         shutdown_event: Event signaling shutdown
         nc_client: Authenticated Nextcloud client
         user_id: User being processed
-        task_status: Status object for signaling task readiness
     """
     logger.info(f"Processor {worker_id} started")
 
-    # Signal that the task has started and is ready
-    task_status.started()
-
     while not shutdown_event.is_set():
         try:
             # Get document with timeout (allows checking shutdown)
@@ -233,21 +226,15 @@ async def _index_document(
     )
     chunks = chunker.chunk_text(content)
 
-    # Generate dense embeddings (I/O bound - external API call)
+    # Generate embeddings (I/O bound - external API call)
     embedding_service = get_embedding_service()
-    dense_embeddings = await embedding_service.embed_batch(chunks)
-
-    # Generate sparse embeddings (BM25 for keyword matching)
-    bm25_service = get_bm25_service()
-    sparse_embeddings = bm25_service.encode_batch(chunks)
+    embeddings = await embedding_service.embed_batch(chunks)
 
     # Prepare Qdrant points
     indexed_at = int(time.time())
     points = []
 
-    for i, (chunk, dense_emb, sparse_emb) in enumerate(
-        zip(chunks, dense_embeddings, sparse_embeddings)
-    ):
+    for i, (chunk, embedding) in enumerate(zip(chunks, 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}"
@@ -256,10 +243,7 @@ async def _index_document(
         points.append(
             PointStruct(
                 id=point_id,
-                vector={
-                    "dense": dense_emb,
-                    "sparse": sparse_emb,
-                },
+                vector=embedding,
                 payload={
                     "user_id": doc_task.user_id,
                     "doc_id": doc_task.doc_id,

nextcloud_mcp_server/vector/qdrant_client.py

@@ -2,7 +2,7 @@
 
 import logging
 
-from qdrant_client import AsyncQdrantClient, models
+from qdrant_client import AsyncQdrantClient
 from qdrant_client.models import Distance, VectorParams
 
 from nextcloud_mcp_server.config import get_settings
@@ -84,12 +84,7 @@ async def get_qdrant_client() -> AsyncQdrantClient:
                 f"Collection '{collection_name}' found, validating dimensions..."
             )
             collection_info = await _qdrant_client.get_collection(collection_name)
-            # 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
+            actual_dimension = collection_info.config.params.vectors.size
 
             # Validate dimension matches
             if actual_dimension != expected_dimension:
@@ -117,27 +112,17 @@ async def get_qdrant_client() -> AsyncQdrantClient:
             )
             await _qdrant_client.create_collection(
                 collection_name=collection_name,
-                vectors_config={
-                    "dense": VectorParams(
-                        size=expected_dimension,
-                        distance=Distance.COSINE,
-                    ),
-                },
-                sparse_vectors_config={
-                    "sparse": models.SparseVectorParams(
-                        index=models.SparseIndexParams(
-                            on_disk=False,
-                        )
-                    ),
-                },
+                vectors_config=VectorParams(
+                    size=expected_dimension,
+                    distance=Distance.COSINE,
+                ),
             )
             logger.info(
                 f"Created Qdrant collection: {collection_name}\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"  Dimension: {expected_dimension}\n"
+                f"  Model: {settings.ollama_embedding_model}\n"
                 f"  Distance: COSINE\n"
-                f"Background sync will index all documents with dense + sparse vectors."
+                f"Background sync will index all documents with this embedding model."
             )
 
     return _qdrant_client

nextcloud_mcp_server/vector/scanner.py

@@ -8,7 +8,6 @@ import time
 from dataclasses import dataclass
 
 import anyio
-from anyio.abc import TaskStatus
 from anyio.streams.memory import MemoryObjectSendStream
 from qdrant_client.models import FieldCondition, Filter, MatchValue
 
@@ -94,8 +93,6 @@ async def scanner_task(
     wake_event: anyio.Event,
     nc_client: NextcloudClient,
     user_id: str,
-    *,
-    task_status: TaskStatus = anyio.TASK_STATUS_IGNORED,
 ):
     """
     Periodic scanner that detects changed documents for enabled user.
@@ -108,14 +105,10 @@ async def scanner_task(
         wake_event: Event to trigger immediate scan
         nc_client: Authenticated Nextcloud client
         user_id: User to scan
-        task_status: Status object for signaling task readiness
     """
     logger.info(f"Scanner task started for user: {user_id}")
     settings = get_settings()
 
-    # Signal that the task has started and is ready
-    task_status.started()
-
     async with send_stream:
         while not shutdown_event.is_set():
             try:
@@ -182,43 +175,73 @@ async def scan_user_documents(
                 f"[SCAN-{scan_id}] Using pruneBefore={prune_before} to optimize data transfer"
             )
 
-        # Get indexed state from Qdrant first (for incremental sync)
-        indexed_docs = {}
-        if not initial_sync:
-            qdrant_client = await get_qdrant_client()
-            scroll_result = await qdrant_client.scroll(
-                collection_name=get_settings().get_collection_name(),
-                scroll_filter=Filter(
-                    must=[
-                        FieldCondition(key="user_id", match=MatchValue(value=user_id)),
-                        FieldCondition(key="doc_type", match=MatchValue(value="note")),
-                    ]
-                ),
-                with_payload=["doc_id", "indexed_at"],
-                with_vectors=False,
-                limit=10000,
-            )
+        # Fetch all notes from Nextcloud
+        notes = [
+            note
+            async for note in nc_client.notes.get_all_notes(prune_before=prune_before)
+        ]
+        logger.info(f"[SCAN-{scan_id}] Found {len(notes)} notes for {user_id}")
 
-            indexed_docs = {
-                point.payload["doc_id"]: point.payload["indexed_at"]
-                for point in scroll_result[0]
-            }
+        # Record documents scanned
+        record_vector_sync_scan(len(notes))
 
-            logger.debug(f"Found {len(indexed_docs)} indexed documents in Qdrant")
+        if initial_sync:
+            # Send everything on first sync
+            for note in notes:
+                modified_at = note.get("modified", 0)
+                await send_stream.send(
+                    DocumentTask(
+                        user_id=user_id,
+                        doc_id=str(note["id"]),
+                        doc_type="note",
+                        operation="index",
+                        modified_at=modified_at,
+                    )
+                )
+            logger.info(f"Sent {len(notes)} documents for initial sync: {user_id}")
+            return
 
-        # Stream notes from Nextcloud and process immediately
-        note_count = 0
+        # Get indexed state from Qdrant
+        qdrant_client = await get_qdrant_client()
+        scroll_result = await qdrant_client.scroll(
+            collection_name=get_settings().get_collection_name(),
+            scroll_filter=Filter(
+                must=[
+                    FieldCondition(key="user_id", match=MatchValue(value=user_id)),
+                    FieldCondition(key="doc_type", match=MatchValue(value="note")),
+                ]
+            ),
+            with_payload=["doc_id", "indexed_at"],
+            with_vectors=False,
+            limit=10000,
+        )
+
+        indexed_docs = {
+            point.payload["doc_id"]: point.payload["indexed_at"]
+            for point in scroll_result[0]
+        }
+
+        logger.debug(f"Found {len(indexed_docs)} indexed documents in Qdrant")
+
+        # Compare and queue changes
         queued = 0
-        nextcloud_doc_ids = set()
+        nextcloud_doc_ids = {str(note["id"]) for note in notes}
 
-        async for note in nc_client.notes.get_all_notes(prune_before=prune_before):
-            note_count += 1
+        for note in notes:
             doc_id = str(note["id"])
-            nextcloud_doc_ids.add(doc_id)
+            indexed_at = indexed_docs.get(doc_id)
             modified_at = note.get("modified", 0)
 
-            if initial_sync:
-                # Send everything on first sync
+            # If document reappeared, remove from potentially_deleted
+            doc_key = (user_id, doc_id)
+            if doc_key in _potentially_deleted:
+                logger.debug(
+                    f"Document {doc_id} reappeared, removing from deletion grace period"
+                )
+                del _potentially_deleted[doc_key]
+
+            # Send if never indexed or modified since last index
+            if indexed_at is None or modified_at > indexed_at:
                 await send_stream.send(
                     DocumentTask(
                         user_id=user_id,
@@ -229,38 +252,6 @@ async def scan_user_documents(
                     )
                 )
                 queued += 1
-            else:
-                # Incremental sync: compare with indexed state
-                indexed_at = indexed_docs.get(doc_id)
-
-                # If document reappeared, remove from potentially_deleted
-                doc_key = (user_id, doc_id)
-                if doc_key in _potentially_deleted:
-                    logger.debug(
-                        f"Document {doc_id} reappeared, removing from deletion grace period"
-                    )
-                    del _potentially_deleted[doc_key]
-
-                # Send if never indexed or modified since last index
-                if indexed_at is None or modified_at > indexed_at:
-                    await send_stream.send(
-                        DocumentTask(
-                            user_id=user_id,
-                            doc_id=doc_id,
-                            doc_type="note",
-                            operation="index",
-                            modified_at=modified_at,
-                        )
-                    )
-                    queued += 1
-
-        # Log and record metrics after streaming
-        logger.info(f"[SCAN-{scan_id}] Found {note_count} notes for {user_id}")
-        record_vector_sync_scan(note_count)
-
-        if initial_sync:
-            logger.info(f"Sent {queued} documents for initial sync: {user_id}")
-            return
 
         # Check for deleted documents (in Qdrant but not in Nextcloud)
         # Use grace period: only delete after 2 consecutive scans confirm absence

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nextcloud-mcp-server"
-version = "0.40.0"
+version = "0.36.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 (>=10.3.0,<12.0.0)",  # Compatible with fastembed
+    "pillow (>=12.0.0,<12.1.0)",
     "icalendar (>=6.0.0,<7.0.0)",
     "pythonvcard4>=0.2.0",
     "pydantic>=2.11.4",
@@ -22,7 +22,6 @@ dependencies = [
     "aiosqlite>=0.20.0", # Async SQLite for refresh token storage
     "authlib>=1.6.5",
     "qdrant-client>=1.7.0",
-    "fastembed>=0.4.2",  # BM25 sparse vector embeddings for hybrid search
     # Observability dependencies
     "prometheus-client>=0.21.0", # Prometheus metrics
     "opentelemetry-api>=1.28.2", # OpenTelemetry API
@@ -103,10 +102,7 @@ module-root = ""
 
 [dependency-groups]
 dev = [
-    "anthropic>=0.42.0",  # For RAG evaluation with Anthropic LLMs
-    "boto3>=1.35.0",  # For Amazon Bedrock provider (optional)
     "commitizen>=4.8.2",
-    "datasets>=3.3.0",  # For BeIR nfcorpus dataset loading
     "ipython>=9.2.0",
     "playwright>=1.49.1",
     "pytest>=8.3.5",

tests/conftest.py

@@ -255,15 +255,8 @@ async def nc_mcp_client(anyio_backend) -> AsyncGenerator[ClientSession, Any]:
 
     Note: SSE transport is being deprecated. This fixture uses SSE for compatibility testing.
     """
-
-    # async for session in create_mcp_client_session_sse(
-    # url="http://localhost:8000/sse", client_name="Basic MCP (SSE)"
-    # ):
-    # yield session
-
-    async for session in create_mcp_client_session(
-        url="http://localhost:8000/mcp",
-        client_name="Basic MCP (HTTP)",
+    async for session in create_mcp_client_session_sse(
+        url="http://localhost:8000/sse", client_name="Basic MCP (SSE)"
     ):
         yield session
 

tests/rag_evaluation/README.md

@@ -1,278 +0,0 @@
-# RAG Evaluation Tests
-
-This directory contains tests for evaluating the Retrieval-Augmented Generation (RAG) system in the Nextcloud MCP server, specifically the `nc_semantic_search_answer` tool.
-
-## Architecture
-
-The RAG system has two components that are tested independently:
-
-1. **Retrieval** - Vector sync/embedding pipeline (indexed Nextcloud documents → vector database)
-2. **Generation** - MCP client LLM synthesis (retrieved context → natural language answer)
-
-See [ADR-013](../../docs/ADR-013-rag-evaluation.md) for full architectural details.
-
-## Test Structure
-
-```
-tests/rag_evaluation/
-├── README.md                       # This file
-├── conftest.py                     # Pytest fixtures
-├── llm_providers.py                # LLM provider abstraction (Ollama/Anthropic)
-├── fixtures/
-│   └── ground_truth.json           # Pre-generated reference answers
-├── test_retrieval_quality.py       # Retrieval evaluation (Context Recall)
-└── test_generation_quality.py      # Generation evaluation (Answer Correctness)
-```
-
-## Metrics
-
-### Retrieval Evaluation
-- **Metric**: Context Recall
-- **Method**: Heuristic - Check if ground-truth document IDs appear in top-k results
-- **Target**: ≥80% recall
-
-### Generation Evaluation
-- **Metric**: Answer Correctness
-- **Method**: LLM-as-judge - Compare RAG answer vs ground truth (binary true/false)
-- **Evaluation**: External LLM evaluates semantic equivalence
-
-## Dataset
-
-**BeIR/nfcorpus** - Medical/biomedical corpus with ~3,600 documents
-
-**Test Queries** (5 selected):
-1. PLAIN-2630: "Alkylphenol Endocrine Disruptors and Allergies" (21 relevant docs)
-2. PLAIN-2660: "How Long to Detox From Fish Before Pregnancy?" (20 relevant docs)
-3. PLAIN-2510: "Coffee and Artery Function" (16 relevant docs)
-4. PLAIN-2430: "Preventing Brain Loss with B Vitamins?" (15 relevant docs)
-5. PLAIN-2690: "Chronic Headaches and Pork Tapeworms" (14 relevant docs)
-
-## Setup
-
-### 1. Install Dependencies
-
-```bash
-uv sync --group dev
-```
-
-This installs:
-- `anthropic>=0.42.0` - For Anthropic LLM evaluation
-- `click>=8.1.8` - For CLI interface
-- `datasets>=3.3.0` - For BeIR nfcorpus dataset loading
-
-### 2. Configure LLM Provider
-
-Set environment variables for your LLM provider:
-
-**Option A: Ollama (default, local/remote)**
-```bash
-export RAG_EVAL_PROVIDER=ollama
-export OLLAMA_HOST=https://ollama.example.com  # or RAG_EVAL_OLLAMA_BASE_URL
-export RAG_EVAL_OLLAMA_MODEL=llama3.2:1b
-```
-
-**Option B: Anthropic (cloud)**
-```bash
-export RAG_EVAL_PROVIDER=anthropic
-export RAG_EVAL_ANTHROPIC_API_KEY=sk-ant-...
-export RAG_EVAL_ANTHROPIC_MODEL=claude-3-5-sonnet-20241022
-```
-
-### 3. One-Time Setup: Generate Ground Truth
-
-Generate synthetic reference answers for the 5 test queries:
-
-```bash
-uv run python tools/rag_eval_cli.py generate
-```
-
-**What this does:**
-- Downloads nfcorpus dataset to `tests/rag_evaluation/fixtures/nfcorpus/` (cached locally)
-- For each of the 5 selected queries, extracts highly relevant documents
-- Uses configured LLM to synthesize a reference answer
-- Saves to `tests/rag_evaluation/fixtures/ground_truth.json`
-
-**Optional flags:**
-- `--provider ollama|anthropic` - Override LLM provider
-- `--model MODEL_NAME` - Override model name
-- `--force-download` - Re-download nfcorpus dataset
-
-### 4. One-Time Setup: Upload Corpus to Nextcloud
-
-Upload all 3,633 nfcorpus documents as Nextcloud notes:
-
-```bash
-uv run python tools/rag_eval_cli.py upload \
-    --nextcloud-url http://localhost:8000 \
-    --username admin \
-    --password admin
-```
-
-**What this does:**
-- Downloads nfcorpus dataset (if not already cached)
-- Uploads all documents as notes in Nextcloud
-- Saves document ID → note ID mapping to `tests/rag_evaluation/fixtures/note_mapping.json`
-
-**Optional flags:**
-- `--category CATEGORY` - Custom category for notes (default: `nfcorpus_rag_eval`)
-- `--force-download` - Re-download nfcorpus dataset
-- `--force` - Delete all existing notes in the target category before uploading (efficient corpus refresh)
-
-**Important:** This step requires:
-- A running Nextcloud instance with vector sync enabled
-- Notes app installed
-- Valid credentials
-
-**Duration:** ~10-15 minutes to upload 3,633 documents
-
-## Running Tests
-
-### Run All RAG Evaluation Tests
-
-```bash
-uv run pytest tests/rag_evaluation/ -v
-```
-
-### Run Specific Test Suites
-
-**Retrieval Quality Only:**
-```bash
-uv run pytest tests/rag_evaluation/test_retrieval_quality.py -v
-```
-
-**Generation Quality Only:**
-```bash
-uv run pytest tests/rag_evaluation/test_generation_quality.py -v
-```
-
-### Run Individual Tests
-
-```bash
-uv run pytest tests/rag_evaluation/test_retrieval_quality.py::test_retrieval_context_recall -v
-uv run pytest tests/rag_evaluation/test_generation_quality.py::test_answer_correctness -v
-```
-
-## Test Execution Flow
-
-**Prerequisites** (one-time setup):
-1. Generated ground truth (`tools/rag_eval_cli.py generate`)
-2. Uploaded corpus to Nextcloud (`tools/rag_eval_cli.py upload`)
-
-### Retrieval Quality Tests
-
-1. **Setup** (`nfcorpus_test_data` fixture):
-   - Loads pre-generated ground truth from `fixtures/ground_truth.json`
-   - Loads note mapping from `fixtures/note_mapping.json`
-   - Returns test cases with expected note IDs
-
-2. **Test** (`test_retrieval_context_recall`):
-   - For each query: Perform semantic search (top-10)
-   - Extract retrieved note IDs
-   - Calculate Context Recall = (expected ∩ retrieved) / expected
-   - Assert recall ≥ 80%
-
-3. **Cleanup**:
-   - None required (notes persist in Nextcloud for reuse)
-
-### Generation Quality Tests
-
-1. **Setup**:
-   - Same as retrieval tests (reuses `nfcorpus_test_data` fixture)
-   - Creates evaluation LLM provider
-
-2. **Test** (`test_answer_correctness`):
-   - For each query: Call `nc_semantic_search_answer` MCP tool
-   - Extract generated answer
-   - Use LLM-as-judge to compare vs ground truth
-   - Assert semantic equivalence (TRUE/FALSE)
-
-3. **Cleanup**:
-   - LLM provider closed
-
-## Expected Test Duration
-
-**One-time setup:**
-- **Generate ground truth**: ~5-10 minutes (5 queries with LLM generation)
-- **Upload corpus**: ~10-15 minutes (3,633 documents)
-- **Total setup**: ~15-25 minutes
-
-**Test execution** (after setup):
-- **Retrieval tests**: ~1-2 minutes (5 queries, no upload/cleanup)
-- **Generation tests**: ~5-10 minutes (RAG generation + LLM evaluation)
-- **Total per run**: ~6-12 minutes
-
-**Note**: These are NOT smoke tests and are NOT run in CI.
-
-## Limitations & Future Work
-
-**Current Limitations:**
-- Only 5 test queries (limited statistical confidence)
-- Medical domain bias (may not represent production use cases)
-- Synthetic ground truth (LLM-generated, not human-validated)
-- Manual test execution (requires external LLM access)
-
-**Future Enhancements:**
-- Expand to 50-100 queries for statistical significance
-- Add custom test dataset with production-representative documents
-- Implement additional metrics (faithfulness, context relevance, answer relevance)
-- Create automated benchmarking dashboard
-- Test multi-hop reasoning (synthesis questions)
-- Evaluate out-of-scope handling ("I don't know" responses)
-
-## Troubleshooting
-
-### Tests Fail with "Ground truth file not found"
-
-Run the generate command first:
-```bash
-uv run python tools/rag_eval_cli.py generate
-```
-
-### Tests Fail with "Note mapping file not found"
-
-Run the upload command first:
-```bash
-uv run python tools/rag_eval_cli.py upload --nextcloud-url http://localhost:8000 --username admin --password admin
-```
-
-### Tests Fail with "MCP sampling client not yet implemented"
-
-The `mcp_sampling_client` fixture is a placeholder. You need to implement MCP client creation with sampling support. See the TODO in `conftest.py`.
-
-### Upload Command Fails
-
-Common issues:
-1. **Nextcloud not running**: Ensure Nextcloud is accessible at the URL
-2. **Invalid credentials**: Verify username/password
-3. **Notes app not installed**: Install Notes app in Nextcloud
-4. **Network timeout**: Increase timeout in CLI (currently 60s)
-
-### LLM Timeout
-
-If ground truth generation times out:
-1. Increase timeout in `llm_providers.py` (currently 10 min)
-2. Use a faster model: `--model llama3.2:1b`
-3. Check Ollama/Anthropic service availability
-
-### Dataset Download Fails
-
-The nfcorpus dataset is downloaded automatically. If download fails:
-1. Check internet connection
-2. Manually download from: https://public.ukp.informatik.tu-darmstadt.de/thakur/BEIR/datasets/nfcorpus.zip
-3. Extract to `tests/rag_evaluation/fixtures/nfcorpus/`
-4. Or use HuggingFace datasets cache: `~/.cache/huggingface/datasets/BeIR___nfcorpus/`
-
-### Vector Sync Not Indexing Documents
-
-After uploading, vector sync must index the documents:
-1. Check vector sync is enabled in Nextcloud
-2. Trigger manual sync if needed
-3. Wait for background job to process all documents
-4. Verify in Qdrant that vectors exist for uploaded notes
-
-## References
-
-- [ADR-013: RAG Evaluation Testing Framework](../../docs/ADR-013-rag-evaluation.md)
-- [ADR-008: MCP Sampling for Semantic Search](../../docs/ADR-008-mcp-sampling-for-semantic-search.md)
-- [BeIR Benchmark](https://github.com/beir-cellar/beir)
-- [NFCorpus Dataset](https://www.cl.uni-heidelberg.de/statnlpgroup/nfcorpus/)

tests/rag_evaluation/__init__.py

@@ -1 +0,0 @@
-"""RAG evaluation tests for the Nextcloud MCP semantic search system."""

tests/rag_evaluation/conftest.py

@@ -1,145 +0,0 @@
-"""Pytest fixtures for RAG evaluation tests.
-
-IMPORTANT: Before running these tests, you must:
-1. Generate ground truth: uv run python tools/rag_eval_cli.py generate
-2. Upload corpus: uv run python tools/rag_eval_cli.py upload --nextcloud-url http://localhost:8000 --username admin --password admin
-
-This ensures that the ground truth and note mappings are available.
-"""
-
-import json
-from pathlib import Path
-from typing import Any
-
-import pytest
-
-from tests.rag_evaluation.llm_providers import create_llm_provider
-
-# Paths
-FIXTURES_DIR = Path(__file__).parent / "fixtures"
-GROUND_TRUTH_FILE = FIXTURES_DIR / "ground_truth.json"
-NOTE_MAPPING_FILE = FIXTURES_DIR / "note_mapping.json"
-
-
-@pytest.fixture(scope="session")
-def ground_truth_data() -> list[dict[str, Any]]:
-    """Load pre-generated ground truth data.
-
-    Returns:
-        List of test cases with query, ground truth answer, and expected doc IDs
-
-    Raises:
-        FileNotFoundError: If ground_truth.json doesn't exist
-    """
-    if not GROUND_TRUTH_FILE.exists():
-        raise FileNotFoundError(
-            f"Ground truth file not found: {GROUND_TRUTH_FILE}\n"
-            "Run: uv run python tools/rag_eval_cli.py generate"
-        )
-
-    with open(GROUND_TRUTH_FILE) as f:
-        return json.load(f)
-
-
-@pytest.fixture(scope="session")
-def note_mapping() -> dict[str, int]:
-    """Load document ID → note ID mapping.
-
-    Returns:
-        Dict mapping nfcorpus document ID to Nextcloud note ID
-
-    Raises:
-        FileNotFoundError: If note_mapping.json doesn't exist
-    """
-    if not NOTE_MAPPING_FILE.exists():
-        raise FileNotFoundError(
-            f"Note mapping file not found: {NOTE_MAPPING_FILE}\n"
-            "Run: uv run python tools/rag_eval_cli.py upload --nextcloud-url ... --username ... --password ..."
-        )
-
-    with open(NOTE_MAPPING_FILE) as f:
-        return json.load(f)
-
-
-@pytest.fixture(scope="session")
-def nfcorpus_test_data(
-    ground_truth_data: list[dict[str, Any]],
-    note_mapping: dict[str, int],
-):
-    """Prepare nfcorpus test data for evaluation.
-
-    This fixture combines ground truth answers with note mappings to create
-    test cases ready for retrieval and generation quality tests.
-
-    Args:
-        ground_truth_data: Pre-generated ground truth answers
-        note_mapping: Document ID → note ID mapping
-
-    Returns:
-        List of test cases with query, ground truth, expected doc IDs, and note IDs
-    """
-    test_cases = []
-
-    for gt in ground_truth_data:
-        # Map expected document IDs to note IDs
-        expected_note_ids = [
-            note_mapping.get(doc_id)
-            for doc_id in gt["expected_document_ids"]
-            if doc_id in note_mapping
-        ]
-
-        # Filter out None values (docs that weren't uploaded)
-        expected_note_ids = [nid for nid in expected_note_ids if nid is not None]
-
-        test_cases.append(
-            {
-                "query_id": gt["query_id"],
-                "query_text": gt["query_text"],
-                "ground_truth_answer": gt["ground_truth_answer"],
-                "expected_document_ids": gt["expected_document_ids"],
-                "expected_note_ids": expected_note_ids,
-                "highly_relevant_count": gt["highly_relevant_count"],
-            }
-        )
-
-    return test_cases
-
-
-@pytest.fixture(scope="session")
-async def evaluation_llm():
-    """Create LLM provider for evaluation (separate from MCP client).
-
-    Environment variables:
-      RAG_EVAL_PROVIDER: Provider type (ollama or anthropic)
-      RAG_EVAL_OLLAMA_BASE_URL: Ollama base URL (or OLLAMA_HOST)
-      RAG_EVAL_OLLAMA_MODEL: Ollama model name
-      RAG_EVAL_ANTHROPIC_API_KEY: Anthropic API key
-      RAG_EVAL_ANTHROPIC_MODEL: Anthropic model name
-
-    Returns:
-        LLM provider instance (OllamaProvider or AnthropicProvider)
-    """
-    llm = create_llm_provider()
-    yield llm
-    await llm.close()
-
-
-@pytest.fixture(scope="session")
-async def mcp_sampling_client():
-    """Create MCP client that supports sampling for RAG generation.
-
-    This fixture creates an MCP client configured to support sampling,
-    which is required for testing the nc_semantic_search_answer tool.
-
-    TODO: Implement MCP client with sampling support
-    For now, this is a placeholder.
-
-    Returns:
-        MCP client instance with sampling enabled
-    """
-    # TODO: Implement MCP client creation with sampling support
-    # This will require:
-    # 1. Creating an MCP client configured for sampling
-    # 2. Authenticating with Nextcloud
-    # 3. Ensuring sampling is enabled
-    pytest.skip("MCP sampling client not yet implemented")

tests/rag_evaluation/llm_providers.py

@@ -1,89 +0,0 @@
-"""LLM provider abstraction for RAG evaluation.
-
-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 nextcloud_mcp_server.providers import (
-    AnthropicProvider,
-    BedrockProvider,
-    OllamaProvider,
-    Provider,
-)
-
-
-def create_llm_provider(
-    provider: str | None = None,
-    ollama_base_url: str | None = None,
-    ollama_model: str | None = None,
-    anthropic_api_key: str | None = None,
-    anthropic_model: str | None = None,
-    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', '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.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:
-        Provider instance
-
-    Raises:
-        ValueError: If provider is invalid or required credentials are missing
-    """
-    # Get provider from args or env
-    provider = provider or os.environ.get("RAG_EVAL_PROVIDER", "ollama")
-
-    if provider == "ollama":
-        # Try RAG_EVAL_OLLAMA_BASE_URL, then OLLAMA_HOST, then default
-        base_url = (
-            ollama_base_url
-            or os.environ.get("RAG_EVAL_OLLAMA_BASE_URL")
-            or os.environ.get("OLLAMA_HOST")
-            or "http://localhost:11434"
-        )
-        model = ollama_model or os.environ.get("RAG_EVAL_OLLAMA_MODEL", "llama3.2:1b")
-        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")
-        if not api_key:
-            raise ValueError(
-                "Anthropic API key required. Set RAG_EVAL_ANTHROPIC_API_KEY environment variable."
-            )
-        model = anthropic_model or os.environ.get(
-            "RAG_EVAL_ANTHROPIC_MODEL", "claude-3-5-sonnet-20241022"
-        )
-        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', 'anthropic', or 'bedrock'."
-        )

tests/rag_evaluation/test_generation_quality.py

@@ -1,139 +0,0 @@
-"""Tests for RAG generation quality (Answer Correctness metric).
-
-These tests evaluate whether the MCP client LLM generates factually correct
-answers from retrieved context using the nc_semantic_search_answer tool.
-
-Metric: Answer Correctness
-- Measures: Is the generated answer factually correct?
-- Method: LLM-as-judge - Compare RAG answer vs ground truth (binary true/false)
-- Evaluation: External LLM evaluates semantic equivalence
-"""
-
-import pytest
-
-
-@pytest.mark.integration
-async def test_answer_correctness(
-    mcp_sampling_client,
-    evaluation_llm,
-    nfcorpus_test_data,
-):
-    """Test that RAG system generates factually correct answers.
-
-    For each test query:
-    1. Execute full RAG pipeline via nc_semantic_search_answer MCP tool
-    2. Extract generated answer from RAG response
-    3. Use LLM-as-judge to compare against ground truth (binary true/false)
-    4. Assert answer is semantically equivalent to ground truth
-
-    This tests the quality of the generation component (MCP client LLM).
-    """
-    results_summary = []
-
-    for test_case in nfcorpus_test_data:
-        query = test_case["query_text"]
-        ground_truth = test_case["ground_truth_answer"]
-
-        print(f"\n{'=' * 80}")
-        print(f"Query: {query}")
-
-        # Execute full RAG pipeline
-        print("Executing RAG pipeline...")
-        rag_result = await mcp_sampling_client.call_tool(
-            "nc_semantic_search_answer",
-            arguments={"query": query, "limit": 5},
-        )
-
-        rag_answer = rag_result["generated_answer"]
-
-        print(f"RAG Answer preview: {rag_answer[:200]}...")
-        print(f"Ground Truth preview: {ground_truth[:200]}...")
-
-        # LLM-as-judge evaluation
-        evaluation_prompt = f"""Compare these two answers and respond with only TRUE or FALSE.
-
-Question: {query}
-
-Generated Answer: {rag_answer}
-
-Ground Truth Answer: {ground_truth}
-
-Are these answers semantically equivalent (do they convey the same factual information)?
-Respond with only: TRUE or FALSE"""
-
-        print("Evaluating answer correctness...")
-        evaluation_result = await evaluation_llm.generate(
-            evaluation_prompt,
-            max_tokens=10,
-        )
-
-        is_correct = evaluation_result.strip().upper() == "TRUE"
-
-        result = {
-            "query_id": test_case["query_id"],
-            "query": query,
-            "rag_answer_length": len(rag_answer),
-            "ground_truth_length": len(ground_truth),
-            "is_correct": is_correct,
-            "evaluation_result": evaluation_result.strip(),
-        }
-        results_summary.append(result)
-
-        print(f"  Evaluation: {evaluation_result.strip()}")
-        print(f"  Status: {'✓ CORRECT' if is_correct else '✗ INCORRECT'}")
-
-        # Assert answer correctness
-        assert is_correct, (
-            f"Answer mismatch for query: {query}\n\n"
-            f"Generated Answer:\n{rag_answer}\n\n"
-            f"Ground Truth:\n{ground_truth}\n\n"
-            f"Evaluation: {evaluation_result.strip()}"
-        )
-
-    # Print summary
-    print(f"\n{'=' * 80}")
-    print("Answer Correctness Summary:")
-    print(f"  Total queries: {len(results_summary)}")
-    print(f"  Correct: {sum(r['is_correct'] for r in results_summary)}")
-    print(f"  Incorrect: {sum(not r['is_correct'] for r in results_summary)}")
-    accuracy = sum(r["is_correct"] for r in results_summary) / len(results_summary)
-    print(f"  Accuracy: {accuracy:.2%}")
-    print(f"{'=' * 80}")
-
-
-@pytest.mark.integration
-async def test_answer_contains_sources(mcp_sampling_client, nfcorpus_test_data):
-    """Test that RAG answers include source citations.
-
-    This is a basic quality check - we verify that the nc_semantic_search_answer
-    tool returns both a generated answer and source documents.
-    """
-    for test_case in nfcorpus_test_data:
-        query = test_case["query_text"]
-
-        # Execute RAG pipeline
-        rag_result = await mcp_sampling_client.call_tool(
-            "nc_semantic_search_answer",
-            arguments={"query": query, "limit": 5},
-        )
-
-        # Check response structure
-        assert "generated_answer" in rag_result, "Response missing 'generated_answer'"
-        assert "sources" in rag_result, "Response missing 'sources'"
-
-        # Check sources are provided
-        sources = rag_result["sources"]
-        assert len(sources) > 0, f"No sources returned for query: {query}"
-
-        # Check each source has required fields
-        for i, source in enumerate(sources):
-            assert "document_id" in source or "id" in source, (
-                f"Source {i} missing document ID"
-            )
-            assert "excerpt" in source or "content" in source or "text" in source, (
-                f"Source {i} missing content"
-            )
-
-        print(f"Query: {query}")
-        print(f"  Sources provided: {len(sources)}")
-        print("  Status: ✓ PASS")

tests/rag_evaluation/test_retrieval_quality.py

@@ -1,143 +0,0 @@
-"""Tests for RAG retrieval quality (Context Recall metric).
-
-These tests evaluate whether the vector sync/embedding pipeline successfully
-retrieves documents containing the answer to a query.
-
-Metric: Context Recall
-- Measures: Did we retrieve documents containing the answer?
-- Method: Heuristic - Check if ground-truth document IDs appear in top-k results
-- Target: ≥80% recall (at least 80% of expected docs in top-10 results)
-"""
-
-import pytest
-
-
-@pytest.mark.integration
-async def test_retrieval_context_recall(nc_client, nfcorpus_test_data):
-    """Test that semantic search retrieves documents containing the answer.
-
-    For each test query:
-    1. Perform semantic search (retrieval only, no generation)
-    2. Extract retrieved document IDs from top-k results
-    3. Calculate Context Recall: intersection of retrieved and expected docs
-    4. Assert recall meets threshold (≥80%)
-
-    This tests the quality of the vector sync/embedding pipeline.
-    """
-    # Top-k documents to retrieve
-    k = 10
-
-    # Minimum acceptable recall
-    min_recall = 0.8
-
-    results_summary = []
-
-    for test_case in nfcorpus_test_data:
-        query = test_case["query_text"]
-        expected_note_ids = set(test_case["expected_note_ids"])
-
-        # Perform semantic search (retrieval only)
-        search_results = await nc_client.notes.semantic_search(
-            query=query,
-            limit=k,
-        )
-
-        # Extract retrieved note IDs
-        retrieved_note_ids = {result["id"] for result in search_results}
-
-        # Calculate Context Recall
-        intersection = expected_note_ids & retrieved_note_ids
-        recall = len(intersection) / len(expected_note_ids) if expected_note_ids else 0
-
-        # Store results
-        result = {
-            "query_id": test_case["query_id"],
-            "query": query,
-            "expected_count": len(expected_note_ids),
-            "retrieved_count": len(retrieved_note_ids),
-            "intersection_count": len(intersection),
-            "recall": recall,
-            "passed": recall >= min_recall,
-        }
-        results_summary.append(result)
-
-        # Print detailed result for this query
-        print(f"\n{'=' * 80}")
-        print(f"Query: {query}")
-        print(f"  Expected docs: {len(expected_note_ids)}")
-        print(f"  Retrieved (top-{k}): {len(retrieved_note_ids)}")
-        print(f"  Intersection: {len(intersection)}")
-        print(f"  Context Recall: {recall:.2%}")
-        print(f"  Status: {'✓ PASS' if result['passed'] else '✗ FAIL'}")
-
-        # Assert recall meets threshold
-        assert recall >= min_recall, (
-            f"Context Recall {recall:.2%} below threshold {min_recall:.2%} "
-            f"for query: {query}\n"
-            f"Expected {len(expected_note_ids)} docs, found {len(intersection)} in top-{k}"
-        )
-
-    # Print summary
-    print(f"\n{'=' * 80}")
-    print("Context Recall Summary:")
-    print(f"  Total queries: {len(results_summary)}")
-    print(f"  Passed: {sum(r['passed'] for r in results_summary)}")
-    print(f"  Failed: {sum(not r['passed'] for r in results_summary)}")
-    print(
-        f"  Average recall: {sum(r['recall'] for r in results_summary) / len(results_summary):.2%}"
-    )
-    print(f"{'=' * 80}")
-
-
-@pytest.mark.integration
-async def test_retrieval_top1_precision(nc_client, nfcorpus_test_data):
-    """Test that the top-1 retrieved document is highly relevant.
-
-    This is a stricter test than context recall - we verify that
-    the single most relevant document (rank 1) is in the expected set.
-
-    This tests whether the ranking is good, not just retrieval.
-    """
-    results_summary = []
-
-    for test_case in nfcorpus_test_data:
-        query = test_case["query_text"]
-        expected_note_ids = set(test_case["expected_note_ids"])
-
-        # Perform semantic search
-        search_results = await nc_client.notes.semantic_search(
-            query=query,
-            limit=1,  # Only top-1
-        )
-
-        # Check if top result is in expected set
-        if search_results:
-            top_result_id = search_results[0]["id"]
-            is_relevant = top_result_id in expected_note_ids
-        else:
-            is_relevant = False
-
-        result = {
-            "query_id": test_case["query_id"],
-            "query": query,
-            "top_result_id": search_results[0]["id"] if search_results else None,
-            "is_relevant": is_relevant,
-        }
-        results_summary.append(result)
-
-        print(f"\nQuery: {query}")
-        print(f"  Top-1 relevant: {'✓ YES' if is_relevant else '✗ NO'}")
-
-        # This is informational - we don't assert here
-        # Some queries may have multiple valid top results
-
-    # Print summary
-    precision_at_1 = sum(r["is_relevant"] for r in results_summary) / len(
-        results_summary
-    )
-    print(f"\n{'=' * 80}")
-    print(f"Precision@1: {precision_at_1:.2%}")
-    print(
-        f"  ({sum(r['is_relevant'] for r in results_summary)}/{len(results_summary)} queries)"
-    )
-    print(f"{'=' * 80}")

tests/unit/providers/__init__.py

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

tests/unit/providers/test_bedrock.py

@@ -1,280 +0,0 @@
-"""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/test_instrument_tool.py

@@ -1,217 +0,0 @@
-"""
-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

tools/rag_eval_cli.py

@@ -1,587 +0,0 @@
-#!/usr/bin/env python3
-"""RAG Evaluation Management CLI.
-
-Commands:
-  generate - Generate ground truth answers from nfcorpus dataset
-  upload   - Upload nfcorpus documents as Nextcloud notes
-
-Usage:
-    # Generate ground truth
-    uv run python tools/rag_eval_cli.py generate
-
-    # Upload corpus to Nextcloud
-    uv run python tools/rag_eval_cli.py upload --nextcloud-url http://localhost:8000 --username admin --password admin
-"""
-
-import io
-import json
-import sys
-import zipfile
-from pathlib import Path
-from typing import Any
-
-import anyio
-import click
-import httpx
-from datasets import load_dataset
-from httpx import BasicAuth
-
-# Add parent directory to path to import from tests/
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from nextcloud_mcp_server.client import NextcloudClient
-from tests.rag_evaluation.llm_providers import create_llm_provider
-
-# Paths
-FIXTURES_DIR = Path(__file__).parent.parent / "tests" / "rag_evaluation" / "fixtures"
-CORPUS_DIR = FIXTURES_DIR / "nfcorpus"
-GROUND_TRUTH_FILE = FIXTURES_DIR / "ground_truth.json"
-NOTE_MAPPING_FILE = FIXTURES_DIR / "note_mapping.json"
-
-# Dataset URL
-NFCORPUS_URL = (
-    "https://public.ukp.informatik.tu-darmstadt.de/thakur/BEIR/datasets/nfcorpus.zip"
-)
-
-# Selected test queries (from ADR-013)
-SELECTED_QUERIES = [
-    "PLAIN-2630",  # Alkylphenol Endocrine Disruptors and Allergies
-    "PLAIN-2660",  # How Long to Detox From Fish Before Pregnancy?
-    "PLAIN-2510",  # Coffee and Artery Function
-    "PLAIN-2430",  # Preventing Brain Loss with B Vitamins?
-    "PLAIN-2690",  # Chronic Headaches and Pork Tapeworms
-]
-
-
-def ensure_corpus_downloaded(force_download: bool = False) -> Path:
-    """Ensure nfcorpus dataset is downloaded to fixtures directory.
-
-    Args:
-        force_download: Force re-download even if corpus exists
-
-    Returns:
-        Path to corpus directory
-
-    Raises:
-        RuntimeError: If download fails
-    """
-    if CORPUS_DIR.exists() and not force_download:
-        click.echo(f"Corpus already exists at {CORPUS_DIR}")
-        return CORPUS_DIR
-
-    click.echo(f"Downloading nfcorpus dataset to {CORPUS_DIR}...")
-
-    # Create fixtures directory
-    FIXTURES_DIR.mkdir(parents=True, exist_ok=True)
-
-    # Download using HuggingFace datasets library (handles caching)
-    try:
-        # Download corpus
-        click.echo("  Downloading corpus...")
-        corpus_dataset = load_dataset(
-            "BeIR/nfcorpus",
-            "corpus",
-            split="corpus",
-        )
-
-        # Download queries
-        click.echo("  Downloading queries...")
-        queries_dataset = load_dataset(
-            "BeIR/nfcorpus",
-            "queries",
-            split="queries",
-        )
-
-        # Save to local fixtures directory as JSONL
-        CORPUS_DIR.mkdir(parents=True, exist_ok=True)
-
-        # Save corpus
-        with open(CORPUS_DIR / "corpus.jsonl", "w") as f:
-            for doc in corpus_dataset:
-                f.write(json.dumps(doc) + "\n")
-
-        # Save queries
-        with open(CORPUS_DIR / "queries.jsonl", "w") as f:
-            for query in queries_dataset:
-                f.write(json.dumps(query) + "\n")
-
-        # Download qrels from BEIR directly (not available via HuggingFace)
-        click.echo("  Downloading qrels from BEIR ZIP...")
-        with httpx.Client(timeout=300.0) as client:
-            response = client.get(NFCORPUS_URL)
-            response.raise_for_status()
-
-            # Extract qrels from ZIP
-            with zipfile.ZipFile(io.BytesIO(response.content)) as zf:
-                # The qrels are in nfcorpus/qrels/test.tsv within the ZIP
-                qrels_path = "nfcorpus/qrels/test.tsv"
-                qrels_dir = CORPUS_DIR / "qrels"
-                qrels_dir.mkdir(parents=True, exist_ok=True)
-
-                qrels_content = zf.read(qrels_path).decode("utf-8")
-                with open(qrels_dir / "test.tsv", "w") as f:
-                    f.write(qrels_content)
-
-        click.echo(f"Dataset downloaded to {CORPUS_DIR}")
-        return CORPUS_DIR
-
-    except Exception as e:
-        raise RuntimeError(f"Failed to download nfcorpus dataset: {e}") from e
-
-
-def load_corpus(corpus_dir: Path) -> dict[str, dict]:
-    """Load corpus documents from local directory.
-
-    Args:
-        corpus_dir: Path to corpus directory
-
-    Returns:
-        Dict mapping document ID to document data
-    """
-    corpus = {}
-    with open(corpus_dir / "corpus.jsonl") as f:
-        for line in f:
-            doc = json.loads(line)
-            corpus[doc["_id"]] = doc
-    return corpus
-
-
-def load_queries(corpus_dir: Path) -> dict[str, dict]:
-    """Load queries from local directory.
-
-    Args:
-        corpus_dir: Path to corpus directory
-
-    Returns:
-        Dict mapping query ID to query data
-    """
-    queries = {}
-    with open(corpus_dir / "queries.jsonl") as f:
-        for line in f:
-            query = json.loads(line)
-            queries[query["_id"]] = query
-    return queries
-
-
-def load_qrels(corpus_dir: Path) -> dict[str, list[tuple[str, int]]]:
-    """Load query relevance judgments from local directory.
-
-    Args:
-        corpus_dir: Path to corpus directory
-
-    Returns:
-        Dict mapping query ID to list of (doc_id, score) tuples
-    """
-    qrels: dict[str, list[tuple[str, int]]] = {}
-    with open(corpus_dir / "qrels" / "test.tsv") as f:
-        next(f)  # Skip header
-        for line in f:
-            query_id, corpus_id, score = line.strip().split("\t")
-            if query_id not in qrels:
-                qrels[query_id] = []
-            qrels[query_id].append((corpus_id, int(score)))
-
-    # Sort by score descending
-    for query_id in qrels:
-        qrels[query_id].sort(key=lambda x: x[1], reverse=True)
-
-    return qrels
-
-
-async def generate_ground_truth_answer(
-    query_text: str, relevant_docs: list[dict[str, Any]], llm
-) -> str:
-    """Generate ground truth answer from highly relevant documents.
-
-    Args:
-        query_text: The query/question
-        relevant_docs: List of highly relevant documents (top 5)
-        llm: LLM provider instance
-
-    Returns:
-        Generated ground truth answer
-    """
-    # Construct context from documents
-    context_parts = []
-    for i, doc in enumerate(relevant_docs, 1):
-        context_parts.append(
-            f"Document {i}:\nTitle: {doc['title']}\nText: {doc['text']}\n"
-        )
-    context = "\n".join(context_parts)
-
-    # Generate ground truth
-    prompt = f"""Based on the following medical/biomedical documents, provide a comprehensive, factual answer to this question.
-
-Question: {query_text}
-
-{context}
-
-Instructions:
-- Provide a clear, well-structured answer that synthesizes information from the documents
-- Focus on accuracy and completeness
-- Use specific facts and findings from the documents
-- Keep the answer concise but informative (2-4 paragraphs)
-- Do not make up information not present in the documents
-
-Answer:"""
-
-    click.echo(f"  Generating answer for: {query_text}")
-    answer = await llm.generate(prompt, max_tokens=500)
-    click.echo(f"  Generated {len(answer)} characters")
-    return answer.strip()
-
-
-@click.group()
-def cli():
-    """RAG Evaluation Management CLI.
-
-    Manage ground truth generation and corpus upload for RAG evaluation tests.
-    """
-    pass
-
-
-@cli.command()
-@click.option(
-    "--provider",
-    type=click.Choice(["ollama", "anthropic"]),
-    default="ollama",
-    help="LLM provider to use for generation",
-)
-@click.option(
-    "--model",
-    help="Model name (default: llama3.2:1b for Ollama, claude-3-5-sonnet-20241022 for Anthropic)",
-)
-@click.option(
-    "--force-download",
-    is_flag=True,
-    help="Force re-download of nfcorpus dataset",
-)
-def generate(provider: str, model: str | None, force_download: bool):
-    """Generate ground truth answers for RAG evaluation.
-
-    This command:
-    1. Downloads nfcorpus dataset (if not already cached)
-    2. For each selected query, extracts highly relevant documents
-    3. Uses an LLM to synthesize a reference answer
-    4. Saves ground truth to fixtures/ground_truth.json
-
-    Environment variables:
-      RAG_EVAL_PROVIDER: Provider type (ollama or anthropic)
-      RAG_EVAL_OLLAMA_BASE_URL: Ollama base URL
-      RAG_EVAL_OLLAMA_MODEL: Ollama model name
-      RAG_EVAL_ANTHROPIC_API_KEY: Anthropic API key
-      RAG_EVAL_ANTHROPIC_MODEL: Anthropic model name
-    """
-
-    async def _generate():
-        click.echo("=" * 80)
-        click.echo("RAG Ground Truth Generation")
-        click.echo("=" * 80)
-
-        # Ensure corpus is downloaded
-        corpus_dir = ensure_corpus_downloaded(force_download)
-
-        # Load dataset
-        click.echo("\nLoading nfcorpus dataset...")
-        corpus = load_corpus(corpus_dir)
-        queries = load_queries(corpus_dir)
-        qrels = load_qrels(corpus_dir)
-        click.echo(f"Loaded {len(corpus)} documents, {len(queries)} queries")
-
-        # Create LLM provider
-        click.echo("\nInitializing LLM provider...")
-        try:
-            llm = create_llm_provider(
-                provider=provider,
-                ollama_model=model if provider == "ollama" else None,
-                anthropic_model=model if provider == "anthropic" else None,
-            )
-            provider_type = type(llm).__name__
-            click.echo(f"Using provider: {provider_type}")
-        except ValueError as e:
-            click.echo(f"\nError: {e}", err=True)
-            return 1
-
-        # Generate ground truth for each selected query
-        ground_truth_data = []
-
-        try:
-            for query_id in SELECTED_QUERIES:
-                if query_id not in queries:
-                    click.echo(
-                        f"\nWarning: Query {query_id} not found in dataset", err=True
-                    )
-                    continue
-
-                query = queries[query_id]
-                query_text = query["text"]
-
-                # Get highly relevant documents (score=2)
-                if query_id not in qrels:
-                    click.echo(
-                        f"\nWarning: No relevance judgments for {query_id}", err=True
-                    )
-                    continue
-
-                highly_relevant_doc_ids = [
-                    doc_id for doc_id, score in qrels[query_id] if score == 2
-                ]
-
-                if not highly_relevant_doc_ids:
-                    click.echo(
-                        f"\nWarning: No highly relevant docs for {query_id}", err=True
-                    )
-                    continue
-
-                # Get top 5 highly relevant documents
-                relevant_docs = []
-                for doc_id in highly_relevant_doc_ids[:5]:
-                    if doc_id in corpus:
-                        relevant_docs.append(corpus[doc_id])
-
-                if not relevant_docs:
-                    click.echo(
-                        f"\nWarning: Could not load documents for {query_id}", err=True
-                    )
-                    continue
-
-                # Generate ground truth answer
-                click.echo(f"\n{'-' * 80}")
-                ground_truth_answer = await generate_ground_truth_answer(
-                    query_text, relevant_docs, llm
-                )
-
-                # Store result
-                ground_truth_data.append(
-                    {
-                        "query_id": query_id,
-                        "query_text": query_text,
-                        "ground_truth_answer": ground_truth_answer,
-                        "expected_document_ids": highly_relevant_doc_ids,
-                        "highly_relevant_count": len(highly_relevant_doc_ids),
-                    }
-                )
-
-                click.echo(f"  Preview: {ground_truth_answer[:200]}...")
-
-        finally:
-            await llm.close()
-
-        # Save ground truth
-        GROUND_TRUTH_FILE.parent.mkdir(parents=True, exist_ok=True)
-        with open(GROUND_TRUTH_FILE, "w") as f:
-            json.dump(ground_truth_data, f, indent=2)
-
-        click.echo(f"\n{'=' * 80}")
-        click.echo(f"Generated {len(ground_truth_data)} ground truth answers")
-        click.echo(f"Saved to: {GROUND_TRUTH_FILE}")
-        click.echo("=" * 80)
-
-        return 0
-
-    sys.exit(anyio.run(_generate))
-
-
-@cli.command()
-@click.option(
-    "--nextcloud-url",
-    envvar="NEXTCLOUD_HOST",
-    required=True,
-    help="Nextcloud base URL (e.g., http://localhost:8000)",
-)
-@click.option(
-    "--username",
-    envvar="NEXTCLOUD_USERNAME",
-    required=True,
-    help="Nextcloud username",
-)
-@click.option(
-    "--password",
-    envvar="NEXTCLOUD_PASSWORD",
-    required=True,
-    help="Nextcloud password",
-)
-@click.option(
-    "--category",
-    default="nfcorpus_rag_eval",
-    help="Category/folder for uploaded notes",
-)
-@click.option(
-    "--force-download",
-    is_flag=True,
-    help="Force re-download of nfcorpus dataset",
-)
-@click.option(
-    "--force",
-    is_flag=True,
-    help="Delete all existing notes in the target category before uploading",
-)
-def upload(
-    nextcloud_url: str,
-    username: str,
-    password: str,
-    category: str,
-    force_download: bool,
-    force: bool,
-):
-    """Upload nfcorpus corpus documents as Nextcloud notes.
-
-    This command:
-    1. Downloads nfcorpus dataset (if not already cached)
-    2. Optionally deletes existing notes in target category (--force)
-    3. Uploads all corpus documents as Nextcloud notes
-    4. Saves document ID → note ID mapping to fixtures/note_mapping.json
-
-    The note mapping file is used by pytest tests to map expected document IDs
-    to actual note IDs in Nextcloud.
-    """
-
-    async def _upload():
-        click.echo("=" * 80)
-        click.echo("Upload nfcorpus Corpus to Nextcloud")
-        click.echo("=" * 80)
-
-        # Ensure corpus is downloaded
-        corpus_dir = ensure_corpus_downloaded(force_download)
-
-        # Load corpus
-        click.echo("\nLoading corpus...")
-        corpus = load_corpus(corpus_dir)
-        click.echo(f"Loaded {len(corpus)} documents")
-
-        # Create Nextcloud client
-        click.echo(f"\nConnecting to Nextcloud at {nextcloud_url}...")
-        nc_client = NextcloudClient(
-            base_url=nextcloud_url,
-            username=username,
-            auth=BasicAuth(username, password),
-        )
-
-        try:
-            # Delete existing notes in category if force is specified
-            if force:
-                click.echo(
-                    f"\n--force specified: Deleting existing notes in category '{category}'..."
-                )
-
-                # Collect notes to delete
-                notes_to_delete = []
-                async for note in nc_client.notes.get_all_notes():
-                    if note.get("category") == category:
-                        notes_to_delete.append(note["id"])
-
-                if not notes_to_delete:
-                    click.echo(f"No existing notes found in category '{category}'")
-                else:
-                    click.echo(f"Found {len(notes_to_delete)} notes to delete")
-
-                    deleted_count = 0
-                    delete_errors = []
-                    delete_semaphore = anyio.Semaphore(20)
-
-                    async def delete_note(note_id: int):
-                        """Delete a single note."""
-                        nonlocal deleted_count
-
-                        async with delete_semaphore:
-                            try:
-                                await nc_client.notes.delete_note(note_id)
-                                deleted_count += 1
-                                if deleted_count % 100 == 0:
-                                    click.echo(f"  Deleted {deleted_count} notes...")
-                            except Exception as e:
-                                error_msg = f"Error deleting note {note_id}: {e}"
-                                delete_errors.append(error_msg)
-                                click.echo(f"  {error_msg}", err=True)
-
-                    # Delete all notes concurrently
-                    async with anyio.create_task_group() as tg:
-                        for note_id in notes_to_delete:
-                            tg.start_soon(delete_note, note_id)
-
-                    click.echo(
-                        f"Deleted {deleted_count} existing notes in category '{category}'"
-                    )
-                    if delete_errors:
-                        click.echo(
-                            f"Encountered {len(delete_errors)} errors during deletion",
-                            err=True,
-                        )
-
-            # Upload documents concurrently
-            click.echo(f"\nUploading {len(corpus)} documents as notes (concurrent)...")
-            click.echo(f"Category: {category}")
-
-            note_mapping = {}
-            uploaded_count = 0
-            upload_errors = []
-
-            # Semaphore to limit concurrent uploads (avoid overwhelming server)
-            max_concurrent = 20
-            semaphore = anyio.Semaphore(max_concurrent)
-
-            async def upload_document(doc_id: str, doc: dict[str, Any]):
-                """Upload a single document as a note."""
-                nonlocal uploaded_count
-
-                async with semaphore:
-                    title = f"[{doc_id}] {doc['title'][:100]}"  # Truncate long titles
-                    content = doc["text"]
-
-                    try:
-                        note_data = await nc_client.notes.create_note(
-                            title=title,
-                            content=content,
-                            category=category,
-                        )
-
-                        # Store mapping
-                        note_id = note_data["id"]
-                        note_mapping[doc_id] = note_id
-
-                        uploaded_count += 1
-
-                        # Progress indicator every 100 docs
-                        if uploaded_count % 100 == 0:
-                            click.echo(
-                                f"  Uploaded {uploaded_count}/{len(corpus)} documents..."
-                            )
-
-                    except Exception as e:
-                        error_msg = f"Error uploading {doc_id}: {e}"
-                        upload_errors.append(error_msg)
-                        click.echo(f"  {error_msg}", err=True)
-
-            # Upload all documents concurrently using task group
-            async with anyio.create_task_group() as tg:
-                for doc_id, doc in corpus.items():
-                    tg.start_soon(upload_document, doc_id, doc)
-
-            click.echo(f"\nUploaded {uploaded_count} documents successfully")
-            if upload_errors:
-                click.echo(
-                    f"Encountered {len(upload_errors)} errors during upload", err=True
-                )
-
-            # Save note mapping
-            with open(NOTE_MAPPING_FILE, "w") as f:
-                json.dump(note_mapping, f, indent=2)
-
-            click.echo(f"Saved note mapping to: {NOTE_MAPPING_FILE}")
-            click.echo(f"  Mapped {len(note_mapping)} document IDs to note IDs")
-
-        finally:
-            # Close the Nextcloud client
-            await nc_client.close()
-
-        click.echo("=" * 80)
-        click.echo("Upload complete!")
-        click.echo("=" * 80)
-
-        return 0
-
-    sys.exit(anyio.run(_upload))
-
-
-if __name__ == "__main__":
-    cli()