Refactor SRP : decoupage de main.py (Brain) en routers et du SettingsComponent (web)
Brain : main.py (1496 l.) reduit a l'assemblage (~95 l.) ; un router par responsabilite (generation, chat, tables, imports, notebooks, settings, models), factories DI dans api/deps.py, DTOs chat + mapping anti-corruption separes, auto-pull embeddings deplace en infrastructure. Chemins HTTP inchanges. Web : SettingsComponent (729 l.) recentre sur le formulaire (~330 l.) ; sous-composants standalone updates-section (MAJ + licence Patreon + switch canal) et ollama-model-manager (liste/pull/suppression de modeles). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
5
brain/app/api/routers/__init__.py
Normal file
5
brain/app/api/routers/__init__.py
Normal file
@@ -0,0 +1,5 @@
|
||||
"""Routers FastAPI du Brain, un par responsabilité métier.
|
||||
|
||||
Chemins inchangés par rapport à l'ancien main.py monolithique : le Core Java
|
||||
et le frontend ne voient AUCUNE différence.
|
||||
"""
|
||||
119
brain/app/api/routers/chat.py
Normal file
119
brain/app/api/routers/chat.py
Normal file
@@ -0,0 +1,119 @@
|
||||
"""Endpoint du chat contextuel (/chat/stream) : Structural Context + jauge tokens."""
|
||||
import json
|
||||
from typing import Annotated, AsyncIterator
|
||||
|
||||
import tiktoken
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
from fastapi.responses import StreamingResponse
|
||||
|
||||
from app.api.chat_dto import ChatStreamRequestDTO
|
||||
from app.api.chat_mapping import (
|
||||
to_campaign_context,
|
||||
to_game_system_context,
|
||||
to_lore_context,
|
||||
to_narrative_entity,
|
||||
to_page_context,
|
||||
to_session_context,
|
||||
)
|
||||
from app.api.deps import get_chat_use_case
|
||||
from app.application.chat import ChatUseCase
|
||||
from app.core.config import get_settings
|
||||
from app.domain.models import ChatMessage
|
||||
from app.domain.ports import LLMProviderError
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
# Encodeur tiktoken partagé — chargé une fois pour éviter le coût de lookup
|
||||
# à chaque requête. On utilise cl100k_base (GPT-3.5/4) comme tokenizer
|
||||
# universel approximatif : ±10% d'écart avec Llama/Gemma mais largement
|
||||
# suffisant pour une jauge visuelle à l'utilisateur.
|
||||
_TOKEN_ENCODER: tiktoken.Encoding | None = None
|
||||
|
||||
|
||||
def _count_tokens(text: str | None) -> int:
|
||||
"""Compte les tokens d'un texte via tiktoken. Null/empty → 0."""
|
||||
if not text:
|
||||
return 0
|
||||
global _TOKEN_ENCODER
|
||||
if _TOKEN_ENCODER is None:
|
||||
_TOKEN_ENCODER = tiktoken.get_encoding("cl100k_base")
|
||||
return len(_TOKEN_ENCODER.encode(text))
|
||||
|
||||
|
||||
@router.post("/chat/stream")
|
||||
async def chat_stream(
|
||||
body: ChatStreamRequestDTO,
|
||||
use_case: Annotated[ChatUseCase, Depends(get_chat_use_case)],
|
||||
) -> StreamingResponse:
|
||||
"""Chat streamé (Server-Sent Events) avec Structural Context.
|
||||
|
||||
Accepte jusqu'à 4 contextes optionnels (Lore, Page focalisée, Campagne,
|
||||
entité narrative focalisée). Au moins un contexte racine (Lore ou
|
||||
Campagne) est requis pour que la requête ait du sens.
|
||||
|
||||
Format de flux :
|
||||
- Chaque token : `data: {"token": "..."}\\n\\n`
|
||||
- Fin normale : `event: done\\ndata: {}\\n\\n`
|
||||
- Erreur LLM : `event: error\\ndata: {"message": "..."}\\n\\n`
|
||||
"""
|
||||
if not body.has_scope():
|
||||
raise HTTPException(
|
||||
status_code=422,
|
||||
detail="Au moins un des deux contextes racines (lore_context ou campaign_context) est requis.",
|
||||
)
|
||||
|
||||
messages = [ChatMessage(role=m.role, content=m.content) for m in body.messages]
|
||||
lore_context = to_lore_context(body.lore_context)
|
||||
page_context = to_page_context(body.page_context)
|
||||
campaign_context = to_campaign_context(body.campaign_context)
|
||||
narrative_entity = to_narrative_entity(body.narrative_entity)
|
||||
game_system_context = to_game_system_context(body.game_system_context)
|
||||
session_context = to_session_context(body.session_context)
|
||||
|
||||
# --- Comptage tokens pour la jauge de contexte frontend ---
|
||||
# On construit le system prompt une fois ici pour le compter — le use case
|
||||
# le reconstruira à l'identique en interne (coût négligeable : concat de str).
|
||||
# Cette duplication évite de complexifier le contrat stream() avec un
|
||||
# paramètre optionnel system_prompt précalculé.
|
||||
system_prompt_preview = use_case.build_system_prompt(
|
||||
lore_context=lore_context,
|
||||
page_context=page_context,
|
||||
campaign_context=campaign_context,
|
||||
narrative_entity=narrative_entity,
|
||||
game_system_context=game_system_context,
|
||||
session_context=session_context,
|
||||
)
|
||||
# Dernier message = "current" (souvent user), le reste = historique accumulé.
|
||||
current_msg = messages[-1] if messages else None
|
||||
history_msgs = messages[:-1] if messages else []
|
||||
settings = get_settings()
|
||||
usage_payload = {
|
||||
"system": _count_tokens(system_prompt_preview),
|
||||
"history": sum(_count_tokens(m.content) for m in history_msgs),
|
||||
"current": _count_tokens(current_msg.content) if current_msg else 0,
|
||||
# Plafond connu seulement pour Ollama (num_ctx). Pour le cloud (1min/OpenRouter)
|
||||
# on ne connaît pas la fenêtre réelle → 0 = "pas de max" (jauge sans dénominateur).
|
||||
"max": settings.llm_num_ctx if settings.llm_provider == "ollama" else 0,
|
||||
}
|
||||
|
||||
async def event_stream() -> AsyncIterator[str]:
|
||||
# Event 'usage' émis en tout premier : le frontend peut afficher la
|
||||
# jauge avant même le premier token de réponse.
|
||||
yield f"event: usage\ndata: {json.dumps(usage_payload, ensure_ascii=False)}\n\n"
|
||||
try:
|
||||
async for token in use_case.stream(
|
||||
messages,
|
||||
lore_context=lore_context,
|
||||
page_context=page_context,
|
||||
campaign_context=campaign_context,
|
||||
narrative_entity=narrative_entity,
|
||||
game_system_context=game_system_context,
|
||||
session_context=session_context,
|
||||
):
|
||||
# json.dumps avec ensure_ascii=False pour préserver les accents
|
||||
yield f"data: {json.dumps({'token': token}, ensure_ascii=False)}\n\n"
|
||||
yield "event: done\ndata: {}\n\n"
|
||||
except LLMProviderError as exc:
|
||||
yield f"event: error\ndata: {json.dumps({'message': str(exc)})}\n\n"
|
||||
|
||||
return StreamingResponse(event_stream(), media_type="text/event-stream")
|
||||
137
brain/app/api/routers/generation.py
Normal file
137
brain/app/api/routers/generation.py
Normal file
@@ -0,0 +1,137 @@
|
||||
"""Endpoints de génération « simple » : prompt libre, page de Lore, auto-titre."""
|
||||
from typing import Annotated, Literal
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from app.api.deps import get_generate_page_use_case, get_llm_provider
|
||||
from app.application.generate_page import GeneratePageUseCase
|
||||
from app.core.config import Settings, get_settings
|
||||
from app.domain.models import PageGenerationContext
|
||||
from app.domain.ports import LLMProvider, LLMProviderError
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
class GenerateRequest(BaseModel):
|
||||
prompt: str
|
||||
|
||||
|
||||
class GenerateResponse(BaseModel):
|
||||
model: str
|
||||
response: str
|
||||
|
||||
|
||||
@router.post("/generate", response_model=GenerateResponse)
|
||||
async def generate(
|
||||
body: GenerateRequest,
|
||||
settings: Annotated[Settings, Depends(get_settings)],
|
||||
llm: Annotated[LLMProvider, Depends(get_llm_provider)],
|
||||
) -> GenerateResponse:
|
||||
"""Endpoint libre : prompt → texte brut. Utile pour debug et exploration."""
|
||||
try:
|
||||
text = await llm.generate(body.prompt)
|
||||
except LLMProviderError as exc:
|
||||
raise HTTPException(status_code=502, detail=str(exc)) from exc
|
||||
|
||||
return GenerateResponse(model=settings.llm_model, response=text)
|
||||
|
||||
|
||||
class GeneratePageRequestDTO(BaseModel):
|
||||
"""Contexte envoyé par le Core Java pour remplir une page via le LLM."""
|
||||
|
||||
lore_name: str
|
||||
folder_name: str
|
||||
template_name: str
|
||||
template_fields: list[str] = Field(min_length=1)
|
||||
page_title: str
|
||||
lore_description: str | None = None
|
||||
|
||||
|
||||
class GeneratePageResponseDTO(BaseModel):
|
||||
"""Retour : une valeur textuelle par champ du template (clé = field name)."""
|
||||
|
||||
values: dict[str, str]
|
||||
|
||||
|
||||
@router.post("/generate-page", response_model=GeneratePageResponseDTO)
|
||||
async def generate_page(
|
||||
body: GeneratePageRequestDTO,
|
||||
use_case: Annotated[
|
||||
GeneratePageUseCase, Depends(get_generate_page_use_case)
|
||||
],
|
||||
) -> GeneratePageResponseDTO:
|
||||
"""Endpoint métier : contexte LoreMind → valeurs structurées par champ.
|
||||
|
||||
Branche tout le use case `GeneratePageUseCase`. Ce controller ne fait
|
||||
que le mapping DTO ↔ dataclass et la traduction d'erreur domaine → HTTP.
|
||||
"""
|
||||
context = PageGenerationContext(
|
||||
lore_name=body.lore_name,
|
||||
lore_description=body.lore_description,
|
||||
folder_name=body.folder_name,
|
||||
template_name=body.template_name,
|
||||
template_fields=body.template_fields,
|
||||
page_title=body.page_title,
|
||||
)
|
||||
|
||||
try:
|
||||
result = await use_case.execute(context)
|
||||
except LLMProviderError as exc:
|
||||
raise HTTPException(status_code=502, detail=str(exc)) from exc
|
||||
|
||||
return GeneratePageResponseDTO(values=result.values)
|
||||
|
||||
|
||||
# --- Auto-titre d'une conversation persistee --------------------------------
|
||||
|
||||
|
||||
class SummarizeTitleMessageDTO(BaseModel):
|
||||
role: Literal["user", "assistant", "system"]
|
||||
content: str
|
||||
|
||||
|
||||
class SummarizeTitleRequestDTO(BaseModel):
|
||||
"""Premiers messages d'une conversation pour auto-generer un titre court."""
|
||||
|
||||
messages: list[SummarizeTitleMessageDTO] = Field(default_factory=list)
|
||||
|
||||
|
||||
class SummarizeTitleResponseDTO(BaseModel):
|
||||
title: str
|
||||
|
||||
|
||||
_TITLE_SYSTEM_PROMPT = (
|
||||
"Tu generes un titre court (4 a 7 mots max) qui resume le sujet de la "
|
||||
"conversation ci-dessous. Reponds UNIQUEMENT par le titre, sans guillemets, "
|
||||
"sans ponctuation finale, sans prefixe type 'Titre :'. Le titre doit etre "
|
||||
"en francais et capturer le sujet metier (pas 'Conversation IA')."
|
||||
)
|
||||
|
||||
|
||||
@router.post("/summarize/conversation-title", response_model=SummarizeTitleResponseDTO)
|
||||
async def summarize_conversation_title(
|
||||
body: SummarizeTitleRequestDTO,
|
||||
llm: Annotated[LLMProvider, Depends(get_llm_provider)],
|
||||
) -> SummarizeTitleResponseDTO:
|
||||
"""Genere un titre court a partir des premiers echanges de la conversation.
|
||||
|
||||
Appele par le core apres le 1er couple user/assistant, pour remplacer le
|
||||
titre provisoire "Nouvelle conversation" par quelque chose de parlant.
|
||||
"""
|
||||
if not body.messages:
|
||||
raise HTTPException(status_code=422, detail="Au moins un message requis")
|
||||
|
||||
transcript = "\n".join(f"{m.role.upper()}: {m.content}" for m in body.messages[:6])
|
||||
prompt = f"{_TITLE_SYSTEM_PROMPT}\n\nConversation :\n{transcript}\n\nTitre :"
|
||||
try:
|
||||
raw = await llm.generate(prompt)
|
||||
except LLMProviderError as exc:
|
||||
raise HTTPException(status_code=502, detail=str(exc)) from exc
|
||||
|
||||
title = raw.strip().splitlines()[0].strip().strip('"').strip("'").rstrip(".")
|
||||
if len(title) > 80:
|
||||
title = title[:80].rstrip()
|
||||
if not title:
|
||||
title = "Nouvelle conversation"
|
||||
return SummarizeTitleResponseDTO(title=title)
|
||||
184
brain/app/api/routers/imports.py
Normal file
184
brain/app/api/routers/imports.py
Normal file
@@ -0,0 +1,184 @@
|
||||
"""Endpoints d'import/adaptation de PDF (règles, campagne) — REST + flux SSE."""
|
||||
import json
|
||||
import logging
|
||||
from typing import Annotated, AsyncIterator
|
||||
|
||||
from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile
|
||||
from fastapi.responses import StreamingResponse
|
||||
from pydantic import BaseModel
|
||||
|
||||
from app.api.common import MAX_PDF_BYTES, pdf_upload_error, sse_event
|
||||
from app.api.deps import (
|
||||
get_adapt_campaign_use_case,
|
||||
get_import_campaign_use_case,
|
||||
get_import_rules_use_case,
|
||||
)
|
||||
from app.application.adapt_campaign import AdaptCampaignUseCase
|
||||
from app.application.import_campaign import ImportCampaignUseCase
|
||||
from app.application.import_rules import ImportRulesUseCase
|
||||
from app.domain.models import ChatMessage
|
||||
from app.domain.ports import LLMProviderError, PdfExtractionError
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
class RulesImportResponseDTO(BaseModel):
|
||||
"""Proposition de sections de règles extraites d'un PDF.
|
||||
|
||||
`sections` = {titre → contenu markdown}. C'est une PROPOSITION : le Core
|
||||
et l'UI laissent l'utilisateur réviser/éditer avant toute persistance.
|
||||
`ocr_page_count` permet d'indiquer si le PDF était un scan (OCR utilisé).
|
||||
"""
|
||||
|
||||
sections: dict[str, str]
|
||||
page_count: int
|
||||
ocr_page_count: int
|
||||
|
||||
|
||||
@router.post("/import/rules", response_model=RulesImportResponseDTO)
|
||||
async def import_rules(
|
||||
use_case: Annotated[ImportRulesUseCase, Depends(get_import_rules_use_case)],
|
||||
file: UploadFile = File(...),
|
||||
) -> RulesImportResponseDTO:
|
||||
"""Import d'un PDF de règles → sections markdown structurées (proposition).
|
||||
|
||||
Extrait le texte (couche texte + repli OCR par page pour les scans), découpe,
|
||||
et demande au LLM de répartir les règles en sections thématiques. Ne persiste
|
||||
rien : renvoie la proposition au Core, qui la présente pour révision.
|
||||
"""
|
||||
content = await file.read()
|
||||
if not content:
|
||||
raise HTTPException(status_code=422, detail="Fichier PDF vide.")
|
||||
if len(content) > MAX_PDF_BYTES:
|
||||
raise HTTPException(
|
||||
status_code=413,
|
||||
detail=f"PDF trop volumineux (> {MAX_PDF_BYTES // (1024 * 1024)} Mo).",
|
||||
)
|
||||
|
||||
try:
|
||||
result = await use_case.execute(content)
|
||||
except PdfExtractionError as exc:
|
||||
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
||||
except LLMProviderError as exc:
|
||||
raise HTTPException(status_code=502, detail=str(exc)) from exc
|
||||
|
||||
return RulesImportResponseDTO(
|
||||
sections=result.sections,
|
||||
page_count=result.page_count,
|
||||
ocr_page_count=result.ocr_page_count,
|
||||
)
|
||||
|
||||
|
||||
@router.post("/import/rules/stream")
|
||||
async def import_rules_stream(
|
||||
use_case: Annotated[ImportRulesUseCase, Depends(get_import_rules_use_case)],
|
||||
file: UploadFile = File(...),
|
||||
) -> StreamingResponse:
|
||||
"""Import streamé : émet l'avancement (SSE) puis le résultat final.
|
||||
|
||||
Évènements SSE :
|
||||
- `event: extracting` → data: {} (extraction en cours)
|
||||
- `event: start` → data: {page_count, ocr_page_count, total}
|
||||
- `event: progress` → data: {current, total, new_sections:[...]}
|
||||
- `event: done` → data: {sections, page_count, ocr_page_count}
|
||||
- `event: error` → data: {message}
|
||||
"""
|
||||
content = await file.read()
|
||||
|
||||
async def event_stream() -> AsyncIterator[str]:
|
||||
upload_error = pdf_upload_error(content)
|
||||
if upload_error:
|
||||
yield sse_event("error", {"message": upload_error})
|
||||
return
|
||||
try:
|
||||
async for ev in use_case.stream(content):
|
||||
event_type = ev.pop("type")
|
||||
yield sse_event(event_type, ev)
|
||||
except PdfExtractionError as exc:
|
||||
yield sse_event("error", {"message": str(exc)})
|
||||
except LLMProviderError as exc:
|
||||
yield sse_event("error", {"message": str(exc)})
|
||||
except Exception as exc: # noqa: BLE001 — filet : une erreur inattendue ne doit
|
||||
# PAS casser le flux SSE brutalement (sinon le Core n'a qu'un message générique
|
||||
# sans détail). On la transforme en évènement `error` propre + log avec trace.
|
||||
logger.exception("Import règles : erreur inattendue dans le flux.")
|
||||
yield sse_event("error", {"message": f"Erreur inattendue du Brain : {type(exc).__name__} : {exc}"})
|
||||
|
||||
return StreamingResponse(event_stream(), media_type="text/event-stream")
|
||||
|
||||
|
||||
@router.post("/import/campaign/stream")
|
||||
async def import_campaign_stream(
|
||||
use_case: Annotated[ImportCampaignUseCase, Depends(get_import_campaign_use_case)],
|
||||
file: UploadFile = File(...),
|
||||
) -> StreamingResponse:
|
||||
"""Import streamé d'un PDF de campagne → arbre arc→chapitre→scène (SSE).
|
||||
|
||||
Évènements : `extracting`, `start` {page_count, ocr_page_count, total},
|
||||
`progress` {current, total, arc_count, chapter_count, scene_count},
|
||||
`done` {arcs:[...], page_count, ocr_page_count}, `error` {message}.
|
||||
"""
|
||||
content = await file.read()
|
||||
|
||||
async def event_stream() -> AsyncIterator[str]:
|
||||
upload_error = pdf_upload_error(content)
|
||||
if upload_error:
|
||||
yield sse_event("error", {"message": upload_error})
|
||||
return
|
||||
try:
|
||||
async for ev in use_case.stream(content):
|
||||
event_type = ev.pop("type")
|
||||
yield sse_event(event_type, ev)
|
||||
except PdfExtractionError as exc:
|
||||
yield sse_event("error", {"message": str(exc)})
|
||||
except LLMProviderError as exc:
|
||||
yield sse_event("error", {"message": str(exc)})
|
||||
except Exception as exc: # noqa: BLE001 — voir import règles : on ne laisse pas
|
||||
# une erreur inattendue casser le flux sans détail.
|
||||
logger.exception("Import campagne : erreur inattendue dans le flux.")
|
||||
yield sse_event("error", {"message": f"Erreur inattendue du Brain : {type(exc).__name__} : {exc}"})
|
||||
|
||||
return StreamingResponse(event_stream(), media_type="text/event-stream")
|
||||
|
||||
|
||||
@router.post("/adapt/campaign/stream")
|
||||
async def adapt_campaign_stream(
|
||||
use_case: Annotated[AdaptCampaignUseCase, Depends(get_adapt_campaign_use_case)],
|
||||
file: UploadFile = File(...),
|
||||
brief: str = Form(""),
|
||||
messages: str = Form("[]"),
|
||||
) -> StreamingResponse:
|
||||
"""Adaptation CONVERSATIONNELLE d'un PDF à une campagne (SSE markdown).
|
||||
|
||||
`brief` = description de la campagne (Core). `messages` = JSON de l'échange
|
||||
([{role, content}, …]) ; vide au 1er tour. Évènements : `token`, `done`, `error`.
|
||||
"""
|
||||
content = await file.read()
|
||||
|
||||
try:
|
||||
raw_messages = json.loads(messages) if messages else []
|
||||
except json.JSONDecodeError:
|
||||
raw_messages = []
|
||||
convo = [
|
||||
ChatMessage(role=str(m.get("role", "user")), content=str(m.get("content", "")))
|
||||
for m in raw_messages
|
||||
if isinstance(m, dict) and str(m.get("content", "")).strip()
|
||||
]
|
||||
|
||||
async def event_stream() -> AsyncIterator[str]:
|
||||
upload_error = pdf_upload_error(content)
|
||||
if upload_error:
|
||||
yield sse_event("error", {"message": upload_error})
|
||||
return
|
||||
try:
|
||||
async for token in use_case.stream(content, brief, convo):
|
||||
yield sse_event("token", {"token": token})
|
||||
yield sse_event("done", {})
|
||||
except PdfExtractionError as exc:
|
||||
yield sse_event("error", {"message": str(exc)})
|
||||
except LLMProviderError as exc:
|
||||
yield sse_event("error", {"message": str(exc)})
|
||||
|
||||
return StreamingResponse(event_stream(), media_type="text/event-stream")
|
||||
365
brain/app/api/routers/models.py
Normal file
365
brain/app/api/routers/models.py
Normal file
@@ -0,0 +1,365 @@
|
||||
"""Endpoints de catalogue de modèles (Ollama, OpenRouter, Mistral, Gemini, 1min.ai).
|
||||
|
||||
Proxifie les APIs des providers pour que l'UI propose des listes de modèles ;
|
||||
repli statique quand l'API est injoignable ou la clé absente (pas de 500 à l'UI).
|
||||
"""
|
||||
import json
|
||||
from typing import Annotated, AsyncIterator
|
||||
|
||||
import httpx
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
from fastapi.responses import StreamingResponse
|
||||
from pydantic import BaseModel
|
||||
|
||||
from app.core.config import Settings, get_settings
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
@router.get("/models/ollama")
|
||||
async def list_ollama_models(
|
||||
settings: Annotated[Settings, Depends(get_settings)],
|
||||
) -> dict[str, list[str]]:
|
||||
"""Liste les modeles disponibles sur le serveur Ollama configure.
|
||||
|
||||
Retourne une liste vide si Ollama est injoignable — l'UI affichera un
|
||||
message plutot qu'une 500.
|
||||
"""
|
||||
url = f"{settings.ollama_base_url}/api/tags"
|
||||
try:
|
||||
async with httpx.AsyncClient(timeout=5) as client:
|
||||
response = await client.get(url)
|
||||
response.raise_for_status()
|
||||
data = response.json()
|
||||
except httpx.HTTPError:
|
||||
return {"models": []}
|
||||
models = [m.get("name", "") for m in data.get("models", []) if m.get("name")]
|
||||
return {"models": sorted(models)}
|
||||
|
||||
|
||||
class OllamaModelInfoDTO(BaseModel):
|
||||
"""Info utile extraite de /api/show pour un modele Ollama donne.
|
||||
|
||||
`context_length` = fenetre de contexte max supportee par le modele
|
||||
(extraite des metadonnees GGUF). 0 si inconnue. Le frontend s'en sert
|
||||
pour borner le slider de num_ctx dans les Parametres.
|
||||
"""
|
||||
|
||||
context_length: int = 0
|
||||
|
||||
|
||||
@router.post("/models/ollama/info", response_model=OllamaModelInfoDTO)
|
||||
async def get_ollama_model_info(
|
||||
body: dict[str, str],
|
||||
settings: Annotated[Settings, Depends(get_settings)],
|
||||
) -> OllamaModelInfoDTO:
|
||||
"""Retourne les metadonnees d'un modele Ollama via /api/show.
|
||||
|
||||
On passe par POST (et pas GET /models/ollama/{name}) parce que les noms
|
||||
Ollama contiennent souvent un `:` (ex: `gemma3:e2b`) qui se segmente
|
||||
mal dans une URL — le body JSON evite le probleme d'escaping.
|
||||
|
||||
Le champ qui nous interesse est `model_info["<arch>.context_length"]`
|
||||
(ex: `gemma3.context_length: 131072`). L'arch varie selon le modele, on
|
||||
scanne donc tous les champs finissant par `.context_length`.
|
||||
"""
|
||||
name = (body.get("name") or "").strip()
|
||||
if not name:
|
||||
raise HTTPException(status_code=400, detail="name requis")
|
||||
url = f"{settings.ollama_base_url}/api/show"
|
||||
try:
|
||||
async with httpx.AsyncClient(timeout=5) as client:
|
||||
response = await client.post(url, json={"model": name})
|
||||
response.raise_for_status()
|
||||
data = response.json()
|
||||
except httpx.HTTPError:
|
||||
return OllamaModelInfoDTO(context_length=0)
|
||||
model_info = data.get("model_info") or {}
|
||||
for key, value in model_info.items():
|
||||
if key.endswith(".context_length") and isinstance(value, int):
|
||||
return OllamaModelInfoDTO(context_length=value)
|
||||
return OllamaModelInfoDTO(context_length=0)
|
||||
|
||||
|
||||
@router.post("/models/ollama/pull")
|
||||
async def pull_ollama_model(
|
||||
body: dict[str, str],
|
||||
settings: Annotated[Settings, Depends(get_settings)],
|
||||
) -> StreamingResponse:
|
||||
"""Telecharge un modele depuis Ollama et streame la progression.
|
||||
|
||||
Proxifie l'endpoint `/api/pull` d'Ollama qui renvoie du JSON ligne par
|
||||
ligne (NDJSON) avec le statut de chaque etape : manifest, layers,
|
||||
digest, success. On reemet ce flux tel quel au client (le front
|
||||
parsera les lignes et affichera une barre de progression).
|
||||
|
||||
Le timeout est intentionnellement tres long (60 min) car certains
|
||||
modeles font 30+ Go.
|
||||
"""
|
||||
name = (body.get("name") or "").strip()
|
||||
if not name:
|
||||
raise HTTPException(status_code=400, detail="name requis")
|
||||
url = f"{settings.ollama_base_url}/api/pull"
|
||||
|
||||
async def stream() -> AsyncIterator[bytes]:
|
||||
# On utilise un timeout long pour la lecture (60 min) mais court pour
|
||||
# la connexion (10s) — si Ollama n'est pas joignable, on echoue vite.
|
||||
timeout = httpx.Timeout(connect=10, read=3600, write=10, pool=10)
|
||||
try:
|
||||
async with httpx.AsyncClient(timeout=timeout) as client:
|
||||
async with client.stream("POST", url, json={"model": name, "stream": True}) as r:
|
||||
if r.status_code != 200:
|
||||
# Ollama renvoie un message JSON d'erreur. On le passe
|
||||
# tel quel au client en preservant le code HTTP.
|
||||
body_text = await r.aread()
|
||||
yield body_text
|
||||
return
|
||||
async for chunk in r.aiter_bytes():
|
||||
yield chunk
|
||||
except httpx.HTTPError as e:
|
||||
# Erreur reseau : on emet une ligne JSON d'erreur compatible
|
||||
# avec le format NDJSON d'Ollama.
|
||||
err = json.dumps({"error": f"Connexion a Ollama impossible : {e}"}) + "\n"
|
||||
yield err.encode("utf-8")
|
||||
|
||||
# application/x-ndjson : un objet JSON par ligne, pas de wrapping SSE.
|
||||
# C'est le format natif d'Ollama, le front le parsera ligne par ligne.
|
||||
return StreamingResponse(stream(), media_type="application/x-ndjson")
|
||||
|
||||
|
||||
@router.delete("/models/ollama/{name:path}")
|
||||
async def delete_ollama_model(
|
||||
name: str,
|
||||
settings: Annotated[Settings, Depends(get_settings)],
|
||||
) -> dict[str, str]:
|
||||
"""Supprime un modele du serveur Ollama.
|
||||
|
||||
Le `:path` dans le pattern autorise les `:` du nom (ex: `gemma4:e4b`)
|
||||
sans avoir besoin de URL-encoder cote client.
|
||||
"""
|
||||
if not name.strip():
|
||||
raise HTTPException(status_code=400, detail="name requis")
|
||||
url = f"{settings.ollama_base_url}/api/delete"
|
||||
try:
|
||||
async with httpx.AsyncClient(timeout=10) as client:
|
||||
response = await client.request("DELETE", url, json={"model": name})
|
||||
if response.status_code == 404:
|
||||
raise HTTPException(status_code=404, detail=f"Modele '{name}' introuvable")
|
||||
response.raise_for_status()
|
||||
except httpx.HTTPError as e:
|
||||
raise HTTPException(status_code=502, detail=f"Ollama injoignable : {e}")
|
||||
return {"status": "deleted", "name": name}
|
||||
|
||||
|
||||
@router.get("/models/openrouter")
|
||||
async def list_openrouter_models() -> dict[str, list[dict[str, object]]]:
|
||||
"""Catalogue DYNAMIQUE des modeles OpenRouter (API publique, sans cle).
|
||||
|
||||
Renvoie {models: [{id, name, context_length, free}]}, trie gratuits d'abord
|
||||
puis contexte decroissant. `free` = id finissant par ':free' OU prix nul.
|
||||
"""
|
||||
try:
|
||||
async with httpx.AsyncClient(timeout=20) as client:
|
||||
response = await client.get("https://openrouter.ai/api/v1/models")
|
||||
response.raise_for_status()
|
||||
data = response.json()
|
||||
except httpx.HTTPError as exc:
|
||||
raise HTTPException(status_code=502, detail=f"OpenRouter injoignable : {exc}")
|
||||
|
||||
def _is_zero(value: object) -> bool:
|
||||
try:
|
||||
return float(value) == 0.0 # type: ignore[arg-type]
|
||||
except (TypeError, ValueError):
|
||||
return False
|
||||
|
||||
models: list[dict[str, object]] = []
|
||||
for m in data.get("data", []) or []:
|
||||
mid = str(m.get("id") or "")
|
||||
if not mid:
|
||||
continue
|
||||
pricing = m.get("pricing") or {}
|
||||
is_free = mid.endswith(":free") or (
|
||||
_is_zero(pricing.get("prompt")) and _is_zero(pricing.get("completion"))
|
||||
)
|
||||
try:
|
||||
ctx = int(m.get("context_length") or 0)
|
||||
except (TypeError, ValueError):
|
||||
ctx = 0
|
||||
models.append({
|
||||
"id": mid,
|
||||
"name": str(m.get("name") or mid),
|
||||
"context_length": ctx,
|
||||
"free": is_free,
|
||||
})
|
||||
|
||||
models.sort(key=lambda x: (not x["free"], -int(x["context_length"]))) # type: ignore[index]
|
||||
return {"models": models}
|
||||
|
||||
|
||||
# Repli statique si la cle Mistral n'est pas (encore) configuree ou si l'API est
|
||||
# injoignable — l'utilisateur peut quand meme choisir un modele. Liste curee
|
||||
# (juin 2026) ; pour l'extraction de PDF, prefere `large` (fidele, 128k) ou `small`.
|
||||
_MISTRAL_FALLBACK_MODELS = [
|
||||
"mistral-large-latest",
|
||||
"mistral-medium-latest",
|
||||
"mistral-small-latest",
|
||||
"open-mistral-nemo",
|
||||
"ministral-8b-latest",
|
||||
"ministral-3b-latest",
|
||||
"magistral-medium-latest",
|
||||
"magistral-small-latest",
|
||||
"pixtral-large-latest",
|
||||
"codestral-latest",
|
||||
]
|
||||
|
||||
|
||||
@router.get("/models/mistral")
|
||||
async def list_mistral_models(
|
||||
settings: Annotated[Settings, Depends(get_settings)],
|
||||
) -> dict[str, list[dict[str, object]]]:
|
||||
"""Catalogue des modeles Mistral. Dynamique si une cle est configuree
|
||||
(GET /v1/models, qui requiert l'auth), sinon repli statique.
|
||||
|
||||
Renvoie {models: [{id}]} (tous accessibles sur le tier gratuit Experiment)."""
|
||||
key = settings.mistral_api_key
|
||||
if not key:
|
||||
return {"models": [{"id": m} for m in _MISTRAL_FALLBACK_MODELS]}
|
||||
try:
|
||||
async with httpx.AsyncClient(timeout=20) as client:
|
||||
response = await client.get(
|
||||
"https://api.mistral.ai/v1/models",
|
||||
headers={"Authorization": f"Bearer {key}"},
|
||||
)
|
||||
response.raise_for_status()
|
||||
data = response.json()
|
||||
except httpx.HTTPError:
|
||||
# Cle invalide / API down : on ne casse pas l'UI, on propose le repli.
|
||||
return {"models": [{"id": m} for m in _MISTRAL_FALLBACK_MODELS]}
|
||||
|
||||
ids = sorted({str(m.get("id")) for m in data.get("data", []) or [] if m.get("id")})
|
||||
if not ids:
|
||||
ids = _MISTRAL_FALLBACK_MODELS
|
||||
return {"models": [{"id": i} for i in ids]}
|
||||
|
||||
|
||||
# Repli statique Gemini (juin 2026). Pour l'extraction, prefere un Flash a grand
|
||||
# contexte ; `gemini-2.0-flash` a le quota gratuit le plus genereux.
|
||||
_GEMINI_FALLBACK_MODELS = [
|
||||
"gemini-2.0-flash",
|
||||
"gemini-2.0-flash-lite",
|
||||
"gemini-2.5-flash",
|
||||
"gemini-2.5-flash-lite",
|
||||
"gemini-2.5-pro",
|
||||
"gemini-1.5-flash",
|
||||
"gemini-1.5-pro",
|
||||
]
|
||||
|
||||
|
||||
@router.get("/models/gemini")
|
||||
async def list_gemini_models(
|
||||
settings: Annotated[Settings, Depends(get_settings)],
|
||||
) -> dict[str, list[dict[str, object]]]:
|
||||
"""Catalogue des modeles Gemini. Dynamique si une cle est configuree (endpoint
|
||||
OpenAI-compatible /openai/models), sinon repli statique. Renvoie {models:[{id}]}."""
|
||||
key = settings.gemini_api_key
|
||||
if not key:
|
||||
return {"models": [{"id": m} for m in _GEMINI_FALLBACK_MODELS]}
|
||||
try:
|
||||
async with httpx.AsyncClient(timeout=20) as client:
|
||||
response = await client.get(
|
||||
"https://generativelanguage.googleapis.com/v1beta/openai/models",
|
||||
headers={"Authorization": f"Bearer {key}"},
|
||||
)
|
||||
response.raise_for_status()
|
||||
data = response.json()
|
||||
except httpx.HTTPError:
|
||||
return {"models": [{"id": m} for m in _GEMINI_FALLBACK_MODELS]}
|
||||
|
||||
# Les ids peuvent arriver prefixes "models/" → on nettoie pour que la valeur
|
||||
# selectionnee soit directement utilisable dans l'appel chat. On garde les
|
||||
# modeles "gemini-*" (hors embeddings/aqa) pour ne pas noyer la liste.
|
||||
ids: set[str] = set()
|
||||
for m in data.get("data", []) or []:
|
||||
mid = str(m.get("id") or "")
|
||||
if mid.startswith("models/"):
|
||||
mid = mid[len("models/"):]
|
||||
if mid.startswith("gemini-"):
|
||||
ids.add(mid)
|
||||
clean = sorted(ids) if ids else _GEMINI_FALLBACK_MODELS
|
||||
return {"models": [{"id": i} for i in clean]}
|
||||
|
||||
|
||||
@router.get("/models/onemin")
|
||||
def list_onemin_models() -> dict[str, list[dict[str, object]]]:
|
||||
"""Catalogue statique des modeles 1min.ai, groupes par fournisseur.
|
||||
|
||||
Liste construite par probing direct de l'endpoint chat-with-ai avec
|
||||
une vraie cle API (avril 2026) : chaque ID renvoie 200, les IDs
|
||||
absents renvoient 400 UNSUPPORTED_MODEL.
|
||||
|
||||
Nota : les IDs Anthropic utilisent la nomenclature propre a 1min.ai
|
||||
(`claude-<family>-<version>`), pas la convention officielle Anthropic.
|
||||
"""
|
||||
return {
|
||||
"groups": [
|
||||
{
|
||||
"provider": "Anthropic",
|
||||
"models": ["claude-opus-4-6", "claude-sonnet-4-6"],
|
||||
},
|
||||
{
|
||||
"provider": "OpenAI",
|
||||
"models": [
|
||||
"gpt-5",
|
||||
"gpt-5-mini",
|
||||
"gpt-5-nano",
|
||||
"gpt-4.1",
|
||||
"gpt-4.1-mini",
|
||||
"gpt-4.1-nano",
|
||||
"gpt-4o",
|
||||
"gpt-4o-mini",
|
||||
"gpt-4-turbo",
|
||||
"gpt-3.5-turbo",
|
||||
"o3",
|
||||
"o3-pro",
|
||||
"o3-mini",
|
||||
"o4-mini",
|
||||
],
|
||||
},
|
||||
{
|
||||
"provider": "Google",
|
||||
"models": ["gemini-2.5-pro", "gemini-2.5-flash"],
|
||||
},
|
||||
{
|
||||
"provider": "Mistral",
|
||||
"models": [
|
||||
"mistral-large-latest",
|
||||
"mistral-medium-latest",
|
||||
"mistral-small-latest",
|
||||
"open-mistral-nemo",
|
||||
],
|
||||
},
|
||||
{
|
||||
"provider": "DeepSeek",
|
||||
"models": ["deepseek-chat", "deepseek-reasoner"],
|
||||
},
|
||||
{
|
||||
"provider": "xAI",
|
||||
"models": ["grok-3", "grok-3-mini"],
|
||||
},
|
||||
{
|
||||
"provider": "Meta",
|
||||
"models": [
|
||||
"meta/meta-llama-3.1-405b-instruct",
|
||||
"meta/meta-llama-3-70b-instruct",
|
||||
],
|
||||
},
|
||||
{
|
||||
"provider": "Alibaba",
|
||||
"models": ["qwen-plus", "qwen3-max"],
|
||||
},
|
||||
{
|
||||
"provider": "Perplexity",
|
||||
"models": ["sonar", "sonar-pro"],
|
||||
},
|
||||
]
|
||||
}
|
||||
125
brain/app/api/routers/notebooks.py
Normal file
125
brain/app/api/routers/notebooks.py
Normal file
@@ -0,0 +1,125 @@
|
||||
"""Endpoints des notebooks (atelier RAG) : indexation des sources + chats ancrés."""
|
||||
import logging
|
||||
from typing import Annotated, AsyncIterator
|
||||
|
||||
from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile
|
||||
from fastapi.responses import StreamingResponse
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from app.api.common import MAX_PDF_BYTES, sse_event
|
||||
from app.api.deps import (
|
||||
get_notebook_chat_use_case,
|
||||
get_notebook_deep_use_case,
|
||||
get_notebook_rag_use_case,
|
||||
)
|
||||
from app.application.embeddings import EmbeddingError
|
||||
from app.application.notebook_chat import NotebookChatUseCase
|
||||
from app.application.notebook_deep import NotebookDeepUseCase
|
||||
from app.application.notebook_rag import NotebookRagUseCase
|
||||
from app.core.config import Settings, get_settings
|
||||
from app.domain.models import ChatMessage
|
||||
from app.domain.ports import LLMProviderError, PdfExtractionError
|
||||
from app.infrastructure import vector_store
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
class IndexSourceResponseDTO(BaseModel):
|
||||
chunks: int
|
||||
page_count: int
|
||||
ocr_page_count: int
|
||||
|
||||
|
||||
@router.post("/index/notebook-source", response_model=IndexSourceResponseDTO)
|
||||
async def index_notebook_source(
|
||||
rag: Annotated[NotebookRagUseCase, Depends(get_notebook_rag_use_case)],
|
||||
source_id: str = Form(...),
|
||||
file: UploadFile = File(...),
|
||||
) -> IndexSourceResponseDTO:
|
||||
"""Indexe une source PDF (extraction + embeddings + stockage vectoriel)."""
|
||||
content = await file.read()
|
||||
if not content:
|
||||
raise HTTPException(status_code=422, detail="Fichier PDF vide.")
|
||||
if len(content) > MAX_PDF_BYTES:
|
||||
raise HTTPException(
|
||||
status_code=413, detail=f"PDF trop volumineux (> {MAX_PDF_BYTES // (1024 * 1024)} Mo).")
|
||||
try:
|
||||
recap = await rag.index_source(source_id, content)
|
||||
except PdfExtractionError as exc:
|
||||
raise HTTPException(status_code=422, detail=str(exc)) from exc
|
||||
except EmbeddingError as exc:
|
||||
raise HTTPException(status_code=502, detail=str(exc)) from exc
|
||||
return IndexSourceResponseDTO(**recap)
|
||||
|
||||
|
||||
@router.delete("/index/notebook-source/{source_id}")
|
||||
def delete_notebook_source(source_id: str) -> dict[str, str]:
|
||||
"""Supprime les vecteurs d'une source (au DELETE d'une source/notebook)."""
|
||||
vector_store.delete(source_id)
|
||||
return {"status": "deleted", "source_id": source_id}
|
||||
|
||||
|
||||
class NotebookChatMessageDTO(BaseModel):
|
||||
role: str
|
||||
content: str
|
||||
|
||||
|
||||
class NotebookChatRequestDTO(BaseModel):
|
||||
source_ids: list[str] = Field(default_factory=list)
|
||||
messages: list[NotebookChatMessageDTO] = Field(default_factory=list)
|
||||
context: str = Field(default="")
|
||||
|
||||
|
||||
@router.post("/chat/notebook/stream")
|
||||
async def chat_notebook_stream(
|
||||
body: NotebookChatRequestDTO,
|
||||
use_case: Annotated[NotebookChatUseCase, Depends(get_notebook_chat_use_case)],
|
||||
settings: Annotated[Settings, Depends(get_settings)],
|
||||
) -> StreamingResponse:
|
||||
"""Chat ANCRÉ sur les sources (RAG) : récupère les passages pertinents puis
|
||||
streame la réponse. Évènements SSE : `token` {token}, `done` {}, `error` {message}."""
|
||||
messages = [ChatMessage(role=m.role, content=m.content) for m in body.messages]
|
||||
top_k = max(1, min(settings.rag_top_k, 200))
|
||||
|
||||
async def event_stream() -> AsyncIterator[str]:
|
||||
try:
|
||||
async for token in use_case.stream(body.source_ids, messages, context=body.context, top_k=top_k):
|
||||
if token:
|
||||
yield sse_event("token", {"token": token})
|
||||
yield sse_event("done", {})
|
||||
except (LLMProviderError, EmbeddingError) as exc:
|
||||
yield sse_event("error", {"message": str(exc)})
|
||||
except Exception as exc: # noqa: BLE001 — filet : pas de coupure brutale du flux.
|
||||
logger.exception("Chat notebook : erreur inattendue.")
|
||||
yield sse_event("error", {"message": f"Erreur inattendue du Brain : {type(exc).__name__} : {exc}"})
|
||||
|
||||
return StreamingResponse(event_stream(), media_type="text/event-stream")
|
||||
|
||||
|
||||
@router.post("/chat/notebook/deep/stream")
|
||||
async def chat_notebook_deep_stream(
|
||||
body: NotebookChatRequestDTO,
|
||||
use_case: Annotated[NotebookDeepUseCase, Depends(get_notebook_deep_use_case)],
|
||||
) -> StreamingResponse:
|
||||
"""Analyse APPROFONDIE (map-reduce sur tout le document). Évènements SSE :
|
||||
`progress` {current,total} pendant la lecture, puis `token` {token}, puis `done`."""
|
||||
messages = [ChatMessage(role=m.role, content=m.content) for m in body.messages]
|
||||
question = next((m.content for m in reversed(messages) if m.role == "user"), "")
|
||||
|
||||
async def event_stream() -> AsyncIterator[str]:
|
||||
if not question.strip():
|
||||
yield sse_event("error", {"message": "Question vide."})
|
||||
return
|
||||
try:
|
||||
async for ev in use_case.stream(body.source_ids, messages, context=body.context):
|
||||
ev_type = ev.pop("type")
|
||||
yield sse_event(ev_type, ev)
|
||||
except (LLMProviderError, EmbeddingError) as exc:
|
||||
yield sse_event("error", {"message": str(exc)})
|
||||
except Exception as exc: # noqa: BLE001 — filet : pas de coupure brutale.
|
||||
logger.exception("Analyse approfondie : erreur inattendue.")
|
||||
yield sse_event("error", {"message": f"Erreur inattendue du Brain : {type(exc).__name__} : {exc}"})
|
||||
|
||||
return StreamingResponse(event_stream(), media_type="text/event-stream")
|
||||
115
brain/app/api/routers/settings.py
Normal file
115
brain/app/api/routers/settings.py
Normal file
@@ -0,0 +1,115 @@
|
||||
"""Endpoints de paramétrage runtime (écran Paramètres de l'UI)."""
|
||||
from typing import Annotated, Literal
|
||||
|
||||
from fastapi import APIRouter, Depends
|
||||
from pydantic import BaseModel
|
||||
|
||||
from app.core.config import Settings, get_settings
|
||||
from app.core.settings_store import save_overrides
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
class SettingsDTO(BaseModel):
|
||||
"""Vue serialisable des settings modifiables depuis l'UI.
|
||||
|
||||
Expose uniquement les champs que l'utilisateur peut changer a chaud.
|
||||
Les secrets (onemin_api_key) sont masques en lecture.
|
||||
"""
|
||||
|
||||
llm_provider: Literal["ollama", "onemin", "openrouter", "mistral", "gemini"]
|
||||
ollama_base_url: str
|
||||
llm_model: str
|
||||
onemin_model: str
|
||||
# True si une cle 1min.ai est deja configuree — pas de leak de la cle elle-meme.
|
||||
onemin_api_key_set: bool
|
||||
openrouter_model: str
|
||||
# True si une cle OpenRouter est deja configuree (cle elle-meme jamais renvoyee).
|
||||
openrouter_api_key_set: bool
|
||||
mistral_model: str
|
||||
# True si une cle Mistral est deja configuree (cle elle-meme jamais renvoyee).
|
||||
mistral_api_key_set: bool
|
||||
gemini_model: str
|
||||
# True si une cle Gemini est deja configuree (cle elle-meme jamais renvoyee).
|
||||
gemini_api_key_set: bool
|
||||
# Embeddings (RAG des ateliers) : provider + modeles + auto-pull Ollama.
|
||||
embedding_provider: Literal["ollama", "mistral"]
|
||||
ollama_embedding_model: str
|
||||
mistral_embedding_model: str
|
||||
auto_pull_embedding_model: bool
|
||||
rag_top_k: int
|
||||
# Fenetre de contexte effective passee au modele (num_ctx Ollama) — sert
|
||||
# aussi de plafond a la jauge de contexte UI.
|
||||
llm_num_ctx: int
|
||||
# Taille cible d'un morceau (tokens) pour l'import de PDF (regles/campagne).
|
||||
import_chunk_tokens: int
|
||||
# Timeout HTTP des appels LLM (s). A monter si les imports lourds expirent.
|
||||
llm_timeout_seconds: int
|
||||
|
||||
|
||||
class SettingsUpdateDTO(BaseModel):
|
||||
"""Patch partiel des settings. Tous les champs sont optionnels."""
|
||||
|
||||
llm_provider: Literal["ollama", "onemin", "openrouter", "mistral", "gemini"] | None = None
|
||||
ollama_base_url: str | None = None
|
||||
llm_model: str | None = None
|
||||
onemin_model: str | None = None
|
||||
# Chaine vide => on efface la cle. None => pas de changement.
|
||||
onemin_api_key: str | None = None
|
||||
openrouter_model: str | None = None
|
||||
openrouter_api_key: str | None = None
|
||||
mistral_model: str | None = None
|
||||
mistral_api_key: str | None = None
|
||||
gemini_model: str | None = None
|
||||
gemini_api_key: str | None = None
|
||||
embedding_provider: Literal["ollama", "mistral"] | None = None
|
||||
ollama_embedding_model: str | None = None
|
||||
mistral_embedding_model: str | None = None
|
||||
auto_pull_embedding_model: bool | None = None
|
||||
rag_top_k: int | None = None
|
||||
llm_num_ctx: int | None = None
|
||||
import_chunk_tokens: int | None = None
|
||||
llm_timeout_seconds: int | None = None
|
||||
|
||||
|
||||
def _to_settings_dto(s: Settings) -> SettingsDTO:
|
||||
return SettingsDTO(
|
||||
llm_provider=s.llm_provider,
|
||||
ollama_base_url=s.ollama_base_url,
|
||||
llm_model=s.llm_model,
|
||||
onemin_model=s.onemin_model,
|
||||
onemin_api_key_set=bool(s.onemin_api_key),
|
||||
openrouter_model=s.openrouter_model,
|
||||
openrouter_api_key_set=bool(s.openrouter_api_key),
|
||||
mistral_model=s.mistral_model,
|
||||
mistral_api_key_set=bool(s.mistral_api_key),
|
||||
gemini_model=s.gemini_model,
|
||||
gemini_api_key_set=bool(s.gemini_api_key),
|
||||
embedding_provider=s.embedding_provider,
|
||||
ollama_embedding_model=s.ollama_embedding_model,
|
||||
mistral_embedding_model=s.mistral_embedding_model,
|
||||
auto_pull_embedding_model=s.auto_pull_embedding_model,
|
||||
rag_top_k=s.rag_top_k,
|
||||
llm_num_ctx=s.llm_num_ctx,
|
||||
import_chunk_tokens=s.import_chunk_tokens,
|
||||
llm_timeout_seconds=s.llm_timeout_seconds,
|
||||
)
|
||||
|
||||
|
||||
@router.get("/settings", response_model=SettingsDTO)
|
||||
def read_settings(settings: Annotated[Settings, Depends(get_settings)]) -> SettingsDTO:
|
||||
"""Retourne la config courante (secrets masques)."""
|
||||
return _to_settings_dto(settings)
|
||||
|
||||
|
||||
@router.put("/settings", response_model=SettingsDTO)
|
||||
def update_settings(patch: SettingsUpdateDTO) -> SettingsDTO:
|
||||
"""Applique un patch partiel aux settings et persiste les overrides.
|
||||
|
||||
Toute requete HTTP suivante verra les nouvelles valeurs (pas de cache).
|
||||
"""
|
||||
overrides = {k: v for k, v in patch.model_dump().items() if v is not None}
|
||||
if overrides:
|
||||
save_overrides(overrides)
|
||||
# Relit .env + overrides fusionnes pour confirmation.
|
||||
return _to_settings_dto(get_settings())
|
||||
216
brain/app/api/routers/tables.py
Normal file
216
brain/app/api/routers/tables.py
Normal file
@@ -0,0 +1,216 @@
|
||||
"""Endpoints « outils de table » : tables aléatoires, improvisation, catalogues d'objets."""
|
||||
import re
|
||||
from typing import Annotated
|
||||
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from app.api.deps import get_llm_provider
|
||||
from app.application.llm_json import load_json_object
|
||||
from app.application.llm_retry import generate_with_retry
|
||||
from app.domain.ports import LLMProvider, LLMProviderError
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
_DICE_FORMULA_RE = re.compile(r"^\s*(\d*)\s*[dD]\s*(\d+)\s*$")
|
||||
|
||||
|
||||
def _dice_total_range(formula: str) -> tuple[int, int] | None:
|
||||
"""(min, max) des totaux possibles d'une formule NdM, ou None si invalide."""
|
||||
match = _DICE_FORMULA_RE.match(formula or "")
|
||||
if not match:
|
||||
return None
|
||||
count = int(match.group(1)) if match.group(1) else 1
|
||||
faces = int(match.group(2))
|
||||
if count < 1 or count > 100 or faces < 2 or faces > 10000:
|
||||
return None
|
||||
return count, count * faces
|
||||
|
||||
|
||||
class GenerateTableRequestDTO(BaseModel):
|
||||
description: str
|
||||
dice_formula: str = Field(default="1d20")
|
||||
# Contexte libre assemblé par le Core (nom de campagne, système, ambiance…).
|
||||
context: str = Field(default="")
|
||||
|
||||
|
||||
class GeneratedTableEntryDTO(BaseModel):
|
||||
min_roll: int
|
||||
max_roll: int
|
||||
label: str
|
||||
detail: str = ""
|
||||
|
||||
|
||||
class GenerateTableResponseDTO(BaseModel):
|
||||
name: str
|
||||
description: str = ""
|
||||
entries: list[GeneratedTableEntryDTO]
|
||||
|
||||
|
||||
@router.post("/generate/random-table", response_model=GenerateTableResponseDTO)
|
||||
async def generate_random_table(
|
||||
body: GenerateTableRequestDTO,
|
||||
llm: Annotated[LLMProvider, Depends(get_llm_provider)],
|
||||
) -> GenerateTableResponseDTO:
|
||||
"""Génère une table aléatoire (entrées par plage) couvrant la formule de dé."""
|
||||
rng = _dice_total_range(body.dice_formula)
|
||||
if rng is None:
|
||||
raise HTTPException(status_code=422, detail="Formule de dé invalide (ex. 1d20, 2d6, d100).")
|
||||
lo, hi = rng
|
||||
context_block = f"\nContexte de la campagne :\n{body.context.strip()}\n" if body.context.strip() else ""
|
||||
prompt = (
|
||||
"Tu es un assistant de jeu de rôle. Génère une TABLE ALÉATOIRE évocatrice.\n"
|
||||
f"Dé : {body.dice_formula} (résultats possibles de {lo} à {hi}).\n"
|
||||
f"Sujet : {body.description.strip()}\n"
|
||||
f"{context_block}\n"
|
||||
"Règles IMPÉRATIVES :\n"
|
||||
"- Réponds UNIQUEMENT par un objet JSON valide, sans texte autour.\n"
|
||||
'- Format : {"name": "...", "description": "...", "entries": '
|
||||
'[{"min_roll": N, "max_roll": M, "label": "résultat court", "detail": "1-2 phrases"}]}\n'
|
||||
f"- Les plages (min_roll..max_roll) doivent COUVRIR EXACTEMENT {lo}..{hi}, "
|
||||
"sans trou ni chevauchement, dans l'ordre croissant.\n"
|
||||
"- Des résultats variés, cohérents avec le sujet (et le contexte s'il est fourni).\n"
|
||||
"- En français. 'label' = résultat bref ; 'detail' = description/effet concret.\n"
|
||||
"Renvoie maintenant le JSON."
|
||||
)
|
||||
try:
|
||||
raw = await generate_with_retry(llm, prompt, output_format="json", temperature=0.7)
|
||||
except LLMProviderError as exc:
|
||||
raise HTTPException(status_code=502, detail=str(exc)) from exc
|
||||
|
||||
parsed, _ = load_json_object(raw)
|
||||
if not isinstance(parsed, dict):
|
||||
raise HTTPException(status_code=502, detail="Le modèle n'a pas renvoyé de table exploitable.")
|
||||
|
||||
entries: list[GeneratedTableEntryDTO] = []
|
||||
for e in parsed.get("entries", []) or []:
|
||||
if not isinstance(e, dict):
|
||||
continue
|
||||
try:
|
||||
mn = int(e["min_roll"])
|
||||
mx = int(e["max_roll"])
|
||||
except (KeyError, TypeError, ValueError):
|
||||
continue
|
||||
label = str(e.get("label") or "").strip()
|
||||
if not label:
|
||||
continue
|
||||
entries.append(GeneratedTableEntryDTO(
|
||||
min_roll=mn, max_roll=max(mn, mx), label=label[:200],
|
||||
detail=str(e.get("detail") or "").strip(),
|
||||
))
|
||||
if not entries:
|
||||
raise HTTPException(status_code=502, detail="Aucune entrée générée — réessaie ou reformule.")
|
||||
|
||||
name = str(parsed.get("name") or body.description).strip()[:120] or "Table générée"
|
||||
return GenerateTableResponseDTO(
|
||||
name=name,
|
||||
description=str(parsed.get("description") or "").strip(),
|
||||
entries=entries,
|
||||
)
|
||||
|
||||
|
||||
class ImproviseRollRequestDTO(BaseModel):
|
||||
table_name: str
|
||||
result_label: str
|
||||
result_detail: str = Field(default="")
|
||||
context: str = Field(default="")
|
||||
|
||||
|
||||
class ImproviseRollResponseDTO(BaseModel):
|
||||
narration: str
|
||||
|
||||
|
||||
@router.post("/improvise/table-roll", response_model=ImproviseRollResponseDTO)
|
||||
async def improvise_table_roll(
|
||||
body: ImproviseRollRequestDTO,
|
||||
llm: Annotated[LLMProvider, Depends(get_llm_provider)],
|
||||
) -> ImproviseRollResponseDTO:
|
||||
"""Brode un court récit (2-3 phrases) sur un résultat tiré, pour lancer la scène."""
|
||||
detail = f" ({body.result_detail.strip()})" if body.result_detail.strip() else ""
|
||||
context_block = f"\nContexte : {body.context.strip()}" if body.context.strip() else ""
|
||||
prompt = (
|
||||
"Tu es le Maître du Jeu. Les joueurs viennent de tirer sur la table "
|
||||
f"« {body.table_name.strip()} » et ont obtenu : « {body.result_label.strip()} »{detail}."
|
||||
f"{context_block}\n\n"
|
||||
"Décris en 2-3 phrases vivantes et immédiates ce qui se passe, pour lancer la scène. "
|
||||
"Pas de méta, pas d'options : juste la narration, en français."
|
||||
)
|
||||
try:
|
||||
raw = await llm.generate(prompt, temperature=0.8)
|
||||
except LLMProviderError as exc:
|
||||
raise HTTPException(status_code=502, detail=str(exc)) from exc
|
||||
return ImproviseRollResponseDTO(narration=raw.strip())
|
||||
|
||||
|
||||
# --- Catalogues d'objets (boutiques) : génération IA -------------------------
|
||||
|
||||
|
||||
class GenerateCatalogRequestDTO(BaseModel):
|
||||
description: str
|
||||
context: str = Field(default="")
|
||||
|
||||
|
||||
class GeneratedCatalogItemDTO(BaseModel):
|
||||
name: str
|
||||
price: str = ""
|
||||
category: str = ""
|
||||
description: str = ""
|
||||
|
||||
|
||||
class GenerateCatalogResponseDTO(BaseModel):
|
||||
name: str
|
||||
description: str = ""
|
||||
items: list[GeneratedCatalogItemDTO]
|
||||
|
||||
|
||||
@router.post("/generate/item-catalog", response_model=GenerateCatalogResponseDTO)
|
||||
async def generate_item_catalog(
|
||||
body: GenerateCatalogRequestDTO,
|
||||
llm: Annotated[LLMProvider, Depends(get_llm_provider)],
|
||||
) -> GenerateCatalogResponseDTO:
|
||||
"""Génère un catalogue d'objets (boutique, butin…) — nom, prix, catégorie, description."""
|
||||
context_block = f"\nContexte de la campagne :\n{body.context.strip()}\n" if body.context.strip() else ""
|
||||
prompt = (
|
||||
"Tu es un assistant de jeu de rôle. Génère un CATALOGUE D'OBJETS (boutique, butin, trésor…).\n"
|
||||
f"Sujet : {body.description.strip()}\n"
|
||||
f"{context_block}\n"
|
||||
"Règles IMPÉRATIVES :\n"
|
||||
"- Réponds UNIQUEMENT par un objet JSON valide, sans texte autour.\n"
|
||||
'- Format : {"name": "...", "description": "...", "items": '
|
||||
'[{"name": "Objet", "price": "ex. 50 po", "category": "ex. Armes", "description": "effet/détails"}]}\n'
|
||||
"- Des objets variés et cohérents avec le sujet (et le contexte s'il est fourni).\n"
|
||||
"- 'price' = prix court dans la monnaie du jeu ; 'category' = regroupement (Armes, Potions…) ; "
|
||||
"'description' = effet/détails en une phrase. En français.\n"
|
||||
"Renvoie maintenant le JSON."
|
||||
)
|
||||
try:
|
||||
raw = await generate_with_retry(llm, prompt, output_format="json", temperature=0.7)
|
||||
except LLMProviderError as exc:
|
||||
raise HTTPException(status_code=502, detail=str(exc)) from exc
|
||||
|
||||
parsed, _ = load_json_object(raw)
|
||||
if not isinstance(parsed, dict):
|
||||
raise HTTPException(status_code=502, detail="Le modèle n'a pas renvoyé de catalogue exploitable.")
|
||||
|
||||
items: list[GeneratedCatalogItemDTO] = []
|
||||
for it in parsed.get("items", []) or []:
|
||||
if not isinstance(it, dict):
|
||||
continue
|
||||
name = str(it.get("name") or "").strip()
|
||||
if not name:
|
||||
continue
|
||||
items.append(GeneratedCatalogItemDTO(
|
||||
name=name[:200],
|
||||
price=str(it.get("price") or "").strip(),
|
||||
category=str(it.get("category") or "").strip(),
|
||||
description=str(it.get("description") or "").strip(),
|
||||
))
|
||||
if not items:
|
||||
raise HTTPException(status_code=502, detail="Aucun objet généré — réessaie ou reformule.")
|
||||
|
||||
name = str(parsed.get("name") or body.description).strip()[:120] or "Catalogue généré"
|
||||
return GenerateCatalogResponseDTO(
|
||||
name=name,
|
||||
description=str(parsed.get("description") or "").strip(),
|
||||
items=items,
|
||||
)
|
||||
Reference in New Issue
Block a user