perf(stt-server): mémoire long-terme hors chemin de réponse + résilience embed (#20)

Cause de la latence 30-45s : l'endpoint d'embeddings (gpu-01:1238) peut se
geler ; recall ET remember l'attendaient ~20s chacun (timeout → dégradation
silencieuse), s'ajoutant à la réponse. Refactor :

- store (ex-remember) en BackgroundTasks → APRÈS la réponse, hors latence perçue ;
  suppression de `?wait=true` (pas d'attente du flush Qdrant)
- recall renvoie aussi le vecteur de la requête → store le réutilise (1 embed/tour
  au lieu de 2, le 2ᵉ portait sur le même texte)
- timeout recall serré (4s, STT_MEMORY_RECALL_TIMEOUT) : un embed lent/mort dégrade
  vite (souvenirs vides) au lieu de bloquer ; store tolère 20s en arrière-plan
- clients httpx persistants (pooling/keep-alive) côté brain + longterm, fermés via
  lifespan (plus de handshake TCP par appel)
- log de timing par requête (recall/gen/total/mem) pour diagnostiquer
- bump serveur 0.1.0 → 0.2.0

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

stt/server/stt_server/app.py

@@ -7,21 +7,39 @@ Endpoints :
 
 from __future__ import annotations
 
+import logging
+import time
+from contextlib import asynccontextmanager
+
 import httpx
-from fastapi import FastAPI, HTTPException
+from fastapi import BackgroundTasks, FastAPI, HTTPException
 from pydantic import BaseModel
 
 from stt_server import __version__
+from stt_server import brain
 from stt_server.brain import ask as brain_ask
 from stt_server.config import settings
 from stt_server.longterm import LongTermMemory
 from stt_server.memory import SessionStore
 
-app = FastAPI(title="STT-server", version=__version__)
+log = logging.getLogger("stt_server")
+
 sessions = SessionStore()
 longterm = LongTermMemory() if settings.memory_longterm else None
 
 
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    yield
+    # Fermeture propre des clients HTTP persistants (pooling).
+    await brain.aclose()
+    if longterm:
+        await longterm.aclose()
+
+
+app = FastAPI(title="STT-server", version=__version__, lifespan=lifespan)
+
+
 class AskRequest(BaseModel):
     text: str
     model: str | None = None      # alias LiteLLM ; défaut serveur si absent
@@ -59,7 +77,7 @@ async def v1_reset(req: AskRequest) -> dict:
 
 
 @app.post("/v1/ask", response_model=AskReply)
-async def v1_ask(req: AskRequest) -> AskReply:
+async def v1_ask(req: AskRequest, background: BackgroundTasks) -> AskReply:
     text = req.text.strip()
     if not text:
         raise HTTPException(status_code=400, detail="text vide")
@@ -69,17 +87,30 @@ async def v1_ask(req: AskRequest) -> AskReply:
             status_code=400,
             detail=f"modèle '{model}' non autorisé ; dispo : {settings.allowed_models}",
         )
+    t0 = time.perf_counter()
     history = sessions.history(req.session_id) if req.session_id else None
-    memories = await longterm.recall(text) if longterm else None
+    # recall : timeout serré, dégrade vite ; renvoie aussi le vecteur (réutilisé par store)
+    memories, qvec = await longterm.recall(text) if longterm else ([], None)
+    t_recall = time.perf_counter()
     try:
         reply = await brain_ask(text, model, history, memories)
     except httpx.HTTPError as e:
         raise HTTPException(status_code=502, detail=f"upstream LiteLLM : {e}") from e
+    t_gen = time.perf_counter()
     if req.session_id:
         sessions.add(req.session_id, "user", text)
         sessions.add(req.session_id, "assistant", reply)
+    # store : APRÈS la réponse (BackgroundTasks) → hors latence perçue, et on réutilise qvec
     if longterm:
-        await longterm.remember(req.session_id or "anon", text)
+        background.add_task(longterm.store, req.session_id or "anon", text, qvec)
+    log.info(
+        "ask model=%s recall=%.0fms gen=%.0fms total=%.0fms mem=%d",
+        model,
+        (t_recall - t0) * 1000,
+        (t_gen - t_recall) * 1000,
+        (t_gen - t0) * 1000,
+        len(memories),
+    )
     return AskReply(reply=reply, model=model)