feat(stt): /v1/memory/health + upsert Qdrant synchrone (debug 5b) (#11)

* feat(stt): mémoire long-terme sémantique via Qdrant (5b)

Serveur : longterm.py — collection Qdrant stt-memory (embeddings Qwen3 gpu-01, dim auto,
Cosine), recall top-k injecté au prompt, remember des tours user. Tout dégrade proprement
si Qdrant/embeddings injoignables (la mémoire court-terme tient). Env STT_MEMORY_LONGTERM,
STT_QDRANT_URL, STT_EMBED_URL, STT_MEMORY_TOPK.

Testé en process : dégradation OK (Qdrant down → mem=0, pas de crash, court-terme tient).
Qdrant réparé le 17/06 (5c). Recherche sémantique réelle à valider sur cluster.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013FmcxGsyXZXogiAHQLjnZT

* feat(stt): endpoint /v1/memory/health + upsert Qdrant synchrone

- /v1/memory/health sonde activement embeddings + Qdrant + collection et
  expose les erreurs (recall/remember dégradent en silence → indébogables).
  Permet de diagnostiquer la mémoire long-terme sans kubectl exec.
- remember() : upsert avec ?wait=true → le souvenir est immédiatement
  cherchable (sans wait, Qdrant met l'écriture en file → un recall
  cross-session immédiat pouvait le rater).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013FmcxGsyXZXogiAHQLjnZT

---------

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

stt/server/README.md

@@ -9,6 +9,7 @@ STT et route l'inférence vers LiteLLM (s01) → Qwen3 (g01) / Claude.
 |---|---|---|---|
 | `GET` | `/healthz` | — | `{status, version}` |
 | `GET` | `/v1/models` | — | `{default, available[]}` |
+| `GET` | `/v1/memory/health` | — | diagnostic mémoire long-terme (embed/Qdrant/collection, erreurs exposées) |
 | `POST` | `/v1/ask` | `{text, model?, session_id?}` | `{reply, model}` |
 | `POST` | `/v1/reset` | `{session_id}` | `{status}` |
 

stt/server/stt_server/app.py

@@ -43,6 +43,14 @@ async def v1_models() -> dict:
     return {"default": settings.model, "available": settings.allowed_models}
 
 
+@app.get("/v1/memory/health")
+async def v1_memory_health() -> dict:
+    """État de la mémoire long-terme (embeddings + Qdrant + collection), erreurs exposées."""
+    if not longterm:
+        return {"enabled": False}
+    return await longterm.health()
+
+
 @app.post("/v1/reset")
 async def v1_reset(req: AskRequest) -> dict:
     if req.session_id:

stt/server/stt_server/longterm.py

@@ -66,13 +66,50 @@ class LongTermMemory:
         except Exception:  # noqa: BLE001 — dégrade silencieusement
             return []
 
+    async def health(self) -> dict:
+        """Diagnostic actif : sonde embeddings + Qdrant + collection, sans rien avaler.
+
+        Contrairement à recall/remember (qui dégradent en silence), expose les erreurs
+        pour pouvoir déboguer la mémoire long-terme sans `kubectl exec`.
+        """
+        out: dict = {
+            "enabled": True,
+            "qdrant_url": self.qdrant,
+            "embed_url": self.embed_url,
+            "collection": self.collection,
+            "embed": {"ok": False},
+            "qdrant": {"ok": False},
+        }
+        async with httpx.AsyncClient(timeout=20) as client:
+            # 1) embeddings
+            try:
+                vec = await self._embed(client, "ping mémoire")
+                out["embed"] = {"ok": True, "dim": len(vec)}
+            except Exception as e:  # noqa: BLE001 — on veut l'erreur
+                out["embed"] = {"ok": False, "error": f"{type(e).__name__}: {e}"}
+            # 2) Qdrant + collection
+            try:
+                r = await client.get(f"{self.qdrant}/collections")
+                r.raise_for_status()
+                names = [c["name"] for c in r.json().get("result", {}).get("collections", [])]
+                exists = self.collection in names
+                qdrant: dict = {"ok": True, "collections": names, "collection_exists": exists}
+                if exists:
+                    cr = await client.get(f"{self.qdrant}/collections/{self.collection}")
+                    if cr.status_code == 200:
+                        qdrant["points_count"] = cr.json().get("result", {}).get("points_count")
+                out["qdrant"] = qdrant
+            except Exception as e:  # noqa: BLE001
+                out["qdrant"] = {"ok": False, "error": f"{type(e).__name__}: {e}"}
+        return out
+
     async def remember(self, session_id: str, text: str) -> None:
         try:
             async with httpx.AsyncClient(timeout=20) as client:
                 vec = await self._embed(client, text)
                 await self._ensure_collection(client, len(vec))
                 await client.put(
-                    f"{self.qdrant}/collections/{self.collection}/points",
+                    f"{self.qdrant}/collections/{self.collection}/points?wait=true",
                     json={
                         "points": [
                             {