test(search): 56 tests unitaires + intégration + README

- test_search.py: embedder (singleton, norme L2, batch), extract (payload,
  catégories, stars), Qdrant (filtre cat/tags, ordre scores, pertinence),
  tools MCP (courses, teacher, reading path tous niveaux)
- test_api.py: tous endpoints FastAPI (search, courses, teachers, reading-path)
  validation params (limit max, level pattern, min_length query)
- pytest.ini: mark integration enregistré
- README.md: setup complet, endpoints, tools MCP, réindexation

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Lsh0x

search/README.md

@@ -0,0 +1,165 @@
+# Buddhist University — Moteur de recherche vectoriel + MCP Server
+
+Recherche sémantique dans **4 494 ressources bouddhistes** (textes canoniques, articles académiques, AV, cours) via une base vectorielle [Qdrant](https://qdrant.tech/) et le modèle d'embeddings `all-MiniLM-L6-v2`.
+
+Expose les résultats via une **API REST FastAPI** et un **serveur MCP** branché directement sur Claude.
+
+---
+
+## Architecture
+
+```
+_content/         ← 4494 fichiers markdown (source de vérité Jekyll)
+search/
+├── ingestion/    ← Pipeline: extraction → embeddings → Qdrant
+│   ├── extract.py        réutilise website.py + frontmatter
+│   ├── embedder.py       sentence-transformers/all-MiniLM-L6-v2
+│   └── ingest.py         pipeline principal (batch 100, ~25s)
+├── api/          ← FastAPI REST (port 8001)
+│   ├── main.py           app + CORS + routes
+│   ├── search.py         GET /search, GET /reading-path
+│   ├── courses.py        GET /courses, GET /courses/{id}, GET /teachers/{slug}
+│   └── models.py         Pydantic models
+├── server/       ← MCP Server (5 tools pour Claude)
+│   ├── mcp_server.py     FastMCP + déclaration des tools
+│   └── tools.py          fonctions Qdrant partagées API + MCP
+├── tests/        ← 56 tests (unit + integration)
+│   ├── test_search.py
+│   ├── test_api.py
+│   └── pytest.ini
+├── docker-compose.yml    Qdrant
+├── requirements.txt
+└── README.md
+.mcp.json         ← Config MCP pour Claude Code (racine du projet)
+```
+
+---
+
+## Setup (première fois)
+
+### 1. Créer l'environnement Python
+
+```bash
+cd buddhist-uni.github.io
+uv venv search/.venv --python 3.12
+uv pip install --python search/.venv/bin/python -r search/requirements.txt
+```
+
+### 2. Démarrer Qdrant
+
+```bash
+cd search && docker-compose up -d
+# Vérifier : curl localhost:6333/healthz
+# Dashboard : http://localhost:6333/dashboard
+```
+
+### 3. Indexer les 4494 documents (~25 secondes)
+
+```bash
+PYTHONPATH=$(pwd) search/.venv/bin/python -m search.ingestion.ingest
+```
+
+Options :
+```bash
+# Test sur 100 fichiers
+--limit 100
+
+# Réindexer entièrement
+--recreate
+
+# Requête de test après ingestion
+--test-query "impermanence nibbana"
+```
+
+---
+
+## Utilisation
+
+### API REST (FastAPI)
+
+```bash
+PYTHONPATH=$(pwd) search/.venv/bin/uvicorn search.api.main:app --port 8001 --reload
+```
+
+**Docs interactives** → http://localhost:8001/docs
+
+| Endpoint | Exemple |
+|---|---|
+| `GET /search` | `/search?q=meditation+breath&limit=8` |
+| `GET /search` (filtres) | `/search?q=nibbana&category=canon&min_stars=4` |
+| `GET /search` (tags) | `/search?q=compassion&tags=metta&tags=karuna` |
+| `GET /reading-path` | `/reading-path?topic=anatta&level=beginner` |
+| `GET /courses` | `/courses` |
+| `GET /courses/{id}` | `/courses/mn` · `/courses/pali-primer` |
+| `GET /teachers/{slug}` | `/teachers/bodhi` · `/teachers/thanissaro` |
+| `GET /health` | État de Qdrant |
+
+**Paramètres `/search`** :
+- `q` — requête en langage naturel (obligatoire)
+- `category` — `articles` `canon` `av` `booklets` `essays` `monographs` `papers` `excerpts` `reference`
+- `tags` — tags multiples (ex: `&tags=metta&tags=meditation`)
+- `course` — slug de cours (ex: `mn`, `abhidhamma`)
+- `min_stars` — qualité minimale 1–5
+- `limit` — 1–20 (défaut 8)
+
+**Paramètres `/reading-path`** :
+- `topic` — sujet à explorer
+- `level` — `beginner` · `intermediate` · `advanced`
+- `limit` — 1–20 (défaut 10)
+
+### MCP Server (Claude Code)
+
+Le fichier `.mcp.json` est déjà configuré à la racine du projet.
+**Ouvre un nouveau Claude Code dans ce dossier** — les 5 tools sont disponibles automatiquement.
+
+| Tool MCP | Description |
+|---|---|
+| `search_dharma(query, tags?, category?, limit?)` | Recherche sémantique |
+| `get_course(course_id)` | Curriculum complet d'un cours |
+| `list_courses()` | Liste des 16 cours structurés |
+| `find_by_teacher(teacher_slug)` | Ressources par enseignant |
+| `get_reading_path(topic, level, limit)` | Parcours de lecture guidé |
+
+**Cours disponibles** : `an` `buddha` `buddhism` `chinese-primer` `ebts` `ethics` `form` `function` `imagery` `mn` `nibbana` `nibbana-mind-stilled` `pali-new-course` `pali-primer` `philosophy` `tranquility-and-insight`
+
+**Enseignants** (exemples) : `bodhi` `thanissaro` `ajahn-chah` `ajahn-brahm` `analayo` `sujato` `nanavira`
+
+---
+
+## Tests
+
+```bash
+# Tests unitaires (pas besoin de Qdrant)
+PYTHONPATH=$(pwd) search/.venv/bin/pytest search/tests/ -m "not integration" -v
+
+# Tests complets (Qdrant requis)
+PYTHONPATH=$(pwd) search/.venv/bin/pytest search/tests/ -v
+
+# Résultat attendu : 56 passed
+```
+
+---
+
+## Réindexation
+
+Si tu ajoutes du nouveau contenu dans `_content/` :
+
+```bash
+# Réindexation incrémentale (upsert, safe)
+PYTHONPATH=$(pwd) search/.venv/bin/python -m search.ingestion.ingest
+
+# Réindexation complète (repart de zéro)
+PYTHONPATH=$(pwd) search/.venv/bin/python -m search.ingestion.ingest --recreate
+```
+
+---
+
+## Stack technique
+
+| Composant | Technologie | Raison |
+|---|---|---|
+| Vector DB | **Qdrant** (Docker) | Filtres metadata natifs, HNSW, open-source |
+| Embeddings | **all-MiniLM-L6-v2** | 384 dims, local, rapide (~500 docs/s), gratuit |
+| API | **FastAPI** + uvicorn | Async, autodoc OpenAPI, Pydantic v2 |
+| MCP | **FastMCP** (Anthropic SDK) | Stdio transport, compatible Claude Code |
+| Extraction | **python-frontmatter** | Réutilise le pipeline Jekyll existant |

search/pytest.ini

@@ -0,0 +1,3 @@
+[pytest]
+markers =
+    integration: tests requiring Qdrant running with indexed collection

search/tests/test_api.py

@@ -0,0 +1,180 @@
+"""
+Tests d'intégration FastAPI — tous les endpoints.
+
+Usage:
+    PYTHONPATH=/path/to/buddhist-uni.github.io pytest search/tests/test_api.py -v
+"""
+
+import pytest
+from fastapi.testclient import TestClient
+from search.api.main import app
+
+client = TestClient(app)
+
+
+class TestHealth:
+    def test_root(self):
+        r = client.get("/")
+        assert r.status_code == 200
+        data = r.json()
+        assert data["name"] == "Buddhist University Search API"
+        assert "endpoints" in data
+
+    def test_health_ok(self):
+        r = client.get("/health")
+        assert r.status_code == 200
+        data = r.json()
+        assert data["status"] == "ok"
+        assert data["indexed_documents"] >= 4000
+
+
+@pytest.mark.integration
+class TestSearchEndpoint:
+    def test_basic_search(self):
+        r = client.get("/search?q=meditation+mindfulness")
+        assert r.status_code == 200
+        data = r.json()
+        assert data["query"] == "meditation mindfulness"
+        assert data["total"] > 0
+        assert len(data["results"]) > 0
+
+    def test_search_with_limit(self):
+        r = client.get("/search?q=nibbana&limit=3")
+        assert r.status_code == 200
+        data = r.json()
+        assert len(data["results"]) <= 3
+
+    def test_search_limit_max(self):
+        r = client.get("/search?q=nibbana&limit=25")
+        assert r.status_code == 422  # limit max=20
+
+    def test_search_result_fields(self):
+        r = client.get("/search?q=impermanence")
+        data = r.json()
+        result = data["results"][0]
+        assert "score" in result
+        assert "title" in result
+        assert "category" in result
+        assert "url" in result
+        assert "tags" in result
+
+    def test_search_filter_category(self):
+        r = client.get("/search?q=anatta&category=canon")
+        assert r.status_code == 200
+        data = r.json()
+        for result in data["results"]:
+            assert result["category"] == "canon"
+
+    def test_search_filter_multiple_tags(self):
+        r = client.get("/search?q=compassion&tags=metta&tags=meditation")
+        assert r.status_code == 200
+        assert r.json()["total"] >= 0  # peut être 0 si pas de match exact
+
+    def test_search_missing_query(self):
+        r = client.get("/search")
+        assert r.status_code == 422
+
+    def test_search_short_query(self):
+        r = client.get("/search?q=a")
+        assert r.status_code == 422  # min_length=2
+
+    def test_search_scores_ordered(self):
+        r = client.get("/search?q=pali+grammar&limit=8")
+        data = r.json()
+        scores = [res["score"] for res in data["results"]]
+        assert scores == sorted(scores, reverse=True)
+
+
+@pytest.mark.integration
+class TestReadingPath:
+    def test_basic_path(self):
+        r = client.get("/reading-path?topic=karuna+compassion")
+        assert r.status_code == 200
+        data = r.json()
+        assert len(data) > 0
+        assert data[0]["path_order"] == 1
+
+    def test_path_ordered(self):
+        r = client.get("/reading-path?topic=meditation&level=beginner&limit=8")
+        data = r.json()
+        orders = [item["path_order"] for item in data]
+        assert orders == list(range(1, len(data) + 1))
+
+    def test_path_level_field(self):
+        for level in ["beginner", "intermediate", "advanced"]:
+            r = client.get(f"/reading-path?topic=nibbana&level={level}")
+            assert r.status_code == 200
+            for item in r.json():
+                assert item["level"] == level
+
+    def test_path_invalid_level(self):
+        r = client.get("/reading-path?topic=nibbana&level=expert")
+        assert r.status_code == 422
+
+    def test_path_missing_topic(self):
+        r = client.get("/reading-path")
+        assert r.status_code == 422
+
+
+@pytest.mark.integration
+class TestCoursesEndpoint:
+    def test_list_courses(self):
+        r = client.get("/courses")
+        assert r.status_code == 200
+        data = r.json()
+        assert len(data) >= 10
+        ids = [c["id"] for c in data]
+        assert "mn" in ids
+        assert "pali-primer" in ids
+
+    def test_list_courses_fields(self):
+        r = client.get("/courses")
+        for course in r.json():
+            assert "id" in course
+            assert "title" in course
+
+    def test_get_course_mn(self):
+        r = client.get("/courses/mn")
+        assert r.status_code == 200
+        data = r.json()
+        assert "Majjhima" in data["title"]
+        assert data["content_count"] > 0
+        assert len(data["content"]) > 0
+
+    def test_get_course_pali(self):
+        r = client.get("/courses/pali-primer")
+        assert r.status_code == 200
+        data = r.json()
+        assert "Pāl" in data["title"] or "Pali" in data["title"]
+
+    def test_get_course_not_found(self):
+        r = client.get("/courses/nonexistent-xyz")
+        assert r.status_code == 404
+
+    def test_course_content_fields(self):
+        r = client.get("/courses/mn")
+        data = r.json()
+        item = data["content"][0]
+        assert "title" in item
+        assert "category" in item
+        assert "url" in item
+
+
+@pytest.mark.integration
+class TestTeachersEndpoint:
+    def test_get_teacher_bodhi(self):
+        r = client.get("/teachers/bodhi")
+        assert r.status_code == 200
+        data = r.json()
+        assert len(data) > 0
+
+    def test_get_teacher_not_found(self):
+        r = client.get("/teachers/nobody-xyz-unknown")
+        assert r.status_code == 404
+
+    def test_teacher_result_fields(self):
+        r = client.get("/teachers/bodhi?limit=3")
+        for item in r.json():
+            assert "title" in item
+            assert "url" in item
+            assert "category" in item