feat(stt-server): grounding RAG — le cerveau répond depuis la doc Funk (#27)

Sans contexte, le modèle (qwen3-8b) hallucinait sur le homelab (« stockage
décentralisé », « worker nodes »…) car il ignore tout du cluster réel. Le
cerveau interroge désormais la collection funk-docs (la doc admin/ indexée) et
injecte les passages pertinents au prompt → il répond à partir de la vraie doc.

Coût ~nul : funk-docs et stt-memory partagent le même embedder nomic (:1238,
768 dim) → le vecteur de requête calculé pour le recall mémoire est réutilisé
pour la recherche doc (une embed, deux recherches). Dégrade en silence si
Qdrant/embed down (réponse sans doc plutôt qu'échec).

Module knowledge.py (STT_DOCS_RAG, TOPK=6, MIN_SCORE=0.45). Log /v1/ask
expose docs=<n>. Serveur 0.2.1 → 0.3.0.

Validé : « c'est quoi le nom des nœuds ? » → avant « worker/master nodes »
(inventé) ; après « Kubernetes ; nœuds storage-01, compute-01, compute-02 »
(tiré de la doc).

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

stt/server/stt_server/knowledge.py

@@ -0,0 +1,81 @@
+"""RAG documentaire — ancre les réponses dans la doc Funk (collection `funk-docs`).
+
+Recherche sémantique dans Qdrant pour injecter des passages de la documentation `admin/`
+dans le prompt → le cerveau répond à partir de la **vraie doc du homelab** plutôt que de
+connaissances générales (sinon il hallucine : « stockage décentralisé », « worker nodes »…).
+
+Même embedder que la mémoire long-terme (`nomic-embed-text`, gpu-01 `:1238`, dim 768) → le
+vecteur de requête déjà calculé par `LongTermMemory.recall` est **réutilisé** ici (pas de 2ᵉ
+embed). Dégrade proprement : si Qdrant/embeddings sont injoignables, renvoie `[]` et le cerveau
+répond sans contexte doc plutôt que d'échouer.
+"""
+
+from __future__ import annotations
+
+import httpx
+
+from stt_server.config import settings
+
+
+class Knowledge:
+    def __init__(self) -> None:
+        self.qdrant = settings.qdrant_url.rstrip("/")
+        self.collection = settings.docs_collection
+        self.embed_url = settings.embed_url
+        self.embed_model = settings.embed_model
+        self.top_k = settings.docs_top_k
+        self.min_score = settings.docs_min_score
+        self.timeout = settings.docs_timeout
+        # Client persistant : pooling + keep-alive (évite un handshake TCP par appel).
+        self._http: httpx.AsyncClient | None = None
+
+    def _client(self) -> httpx.AsyncClient:
+        if self._http is None or self._http.is_closed:
+            self._http = httpx.AsyncClient()
+        return self._http
+
+    async def aclose(self) -> None:
+        if self._http is not None and not self._http.is_closed:
+            await self._http.aclose()
+
+    async def search(self, text: str, vec: list[float] | None = None) -> list[str]:
+        """Passages de doc pertinents pour `text`.
+
+        `vec` : embedding nomic de la requête, réutilisé depuis le recall mémoire (même
+        modèle/dim) → évite un 2ᵉ embed. Absent (mémoire off / recall échoué) → on embed ici.
+        Timeout serré, dégrade en `[]` (jamais d'exception sur le chemin de réponse).
+        """
+        try:
+            client = self._client()
+            if vec is None:
+                r = await client.post(
+                    self.embed_url,
+                    json={"model": self.embed_model, "input": text},
+                    timeout=self.timeout,
+                )
+                r.raise_for_status()
+                vec = r.json()["data"][0]["embedding"]
+            r = await client.post(
+                f"{self.qdrant}/collections/{self.collection}/points/search",
+                json={
+                    "vector": vec,
+                    "limit": self.top_k,
+                    "with_payload": True,
+                    "score_threshold": self.min_score,
+                },
+                timeout=self.timeout,
+            )
+            if r.status_code == 404:  # collection absente (RAG pas ingéré) → pas de contexte
+                return []
+            r.raise_for_status()
+            out: list[str] = []
+            for p in r.json().get("result", []):
+                payload = p.get("payload", {})
+                txt = payload.get("text")
+                if not txt:
+                    continue
+                src = payload.get("file", "")
+                out.append(f"[{src}] {txt}" if src else txt)
+            return out
+        except Exception:  # noqa: BLE001 — dégrade silencieusement (réponse sans doc)
+            return []