Allow list para modelos locales configurables por el usuario

CLAUDE.md

@@ -61,7 +61,7 @@ User clicks "Análisis IA"
 - **`frontend/src/main.ts`** — Orquestación: carga los JSON, cablea eventos del formulario, dispara el análisis, exporta PDF.
 - **`frontend/src/ui.ts`** — Tab navigation (8 panels, 4 exam sub-tabs), swipe gestures, mobile/desktop field sync, collapsible panels.
 - **`frontend/src/pdf-parser.ts`** — Client-side PDF extraction using PDF.js. 47 regex patterns to identify analytes in Spanish/English. Runs fully in the browser.
-- **`backend/app/ai/hf_space.py`** — Cliente del HF Space (Gradio) donde vive medGemma. **Es la única ruta que NO da salida estructurada**: el Space devuelve texto libre, así que `limpiar_respuesta()` mantiene la limpieza de tokens del modelo y se envuelve en el campo `interpretacion`.
+- **`backend/app/ai/hf_space.py`** — Cliente del HF Space (Gradio) donde vive medGemma. El Space devuelve texto libre, así que va por la ruta de prosa: `ai/prosa.py` limpia los tokens del modelo, detecta salida defectuosa (razonamiento filtrado, bucle, frase cortada) y envuelve el resultado en el campo `interpretacion`. Es la ruta por defecto sin salida estructurada; un modelo local declarado `=prosa` usa la misma.
 - **`backend/app/ai/claude.py`** — Ruta Claude vía tool use forzado: el `input_schema` es el JSON Schema de `InterpretacionClinica`, así que valida contra Pydantic sin regex.
 - **`data/valores_referencia.json`** — Reference ranges for 90 analytes per species.
 - **`data/alteraciones.json`** — 78 clinical entities used to enrich AI prompts with etiologic context.
@@ -74,6 +74,21 @@ La selección de ruta se aplica **en el servidor** (`MORPHOS_IA_BACKEND_DEFECTO`
 `MORPHOS_MEDGEMMA_BASE_URL`. Ambas rutas aceptan hasta 4 imágenes (validadas en servidor:
 número, mime y tamaño).
 
+**Modelos locales elegibles desde la UI.** `MORPHOS_MODELOS_LOCALES` declara una lista blanca
+(`nombre[=prosa]`, vacía por defecto → selector oculto). Si el usuario elige uno, ese modelo
+manda sobre el Space y recibe **exactamente el mismo tratamiento**: RAG, prompt endurecido,
+atribución de citas y suelos de seguridad viven en `ai/service.py`, no en los clientes, así que
+son agnósticos del modelo. Dos invariantes que no se tocan:
+
+- **Nombres, nunca URLs.** La base_url se queda en `medgemma_base_url`; aceptar una del cliente
+  convierte `/api/interpret` en un SSRF. El nombre se valida contra la lista blanca en el
+  esquema (`PeticionInterpretacion`, → 422) y otra vez en `_crear_cliente` (para las evals).
+- **El modo de salida se declara, no se infiere.** `=prosa` manda el modelo por
+  `ai/prosa.py` (limpieza + envoltura) en vez de por la decodificación restringida de Ollama.
+  Existe porque qwen2.5:7b acepta el `format` y devuelve JSON válido con `hallazgos_clave`,
+  `diferenciales` y `siguientes_pruebas` vacíos. `cliente.prosa` —no el nombre del cliente— es
+  lo que el servicio consulta para elegir system prompt y suplir `requiere_derivacion`.
+
 Para la ruta Claude el modelo por defecto es `claude-opus-5`. No cambiar a `claude-fable-5`:
 cuesta el doble, exige retención de datos de 30 días (incompatible con el posicionamiento de
 privacidad) y sus clasificadores pueden rechazar trabajo clínico legítimo con

backend/.env.example

@@ -24,6 +24,15 @@ MORPHOS_IA_BACKEND_DEFECTO=medgemma   # medgemma | claude
 MORPHOS_MEDGEMMA_BASE_URL=http://localhost:11434
 MORPHOS_MEDGEMMA_MODEL=medgemma:latest
 
+# Modelos locales que el usuario puede ELEGIR en la UI (lista blanca; vacía = selector oculto).
+# Formato `nombre[=prosa|=estructurado]`; sin sufijo se asume estructurado. Ponle `=prosa` al
+# modelo que acepta el `format` de Ollama pero devuelve los campos estructurados en hueco.
+# El modelo elegido recibe el mismo RAG, prompt y suelos de seguridad que el HF Space, y manda
+# sobre él. NO hay variable de URL por petición a propósito: la base_url es la de arriba, del
+# lado servidor (aceptar una del cliente convertiría /api/interpret en un SSRF). Déjala vacía
+# donde no haya un Ollama alcanzable desde el servidor, como el HF Space.
+# MORPHOS_MODELOS_LOCALES=medgemma1.5:latest,qwen2.5:7b=prosa
+
 # Claude (ruta híbrida opcional). NO usar claude-fable-5: cuesta el doble, exige retención de
 # datos de 30 días y sus clasificadores pueden rechazar trabajo clínico legítimo. Ver el
 # comentario en app/config.py.

backend/app/ai/base.py

@@ -46,6 +46,13 @@ class ErrorModelo(Exception):
 
 class ClienteModelo(Protocol):
     nombre: str
+    modelo: str
+    # True si el cliente devuelve TEXTO libre envuelto en `interpretacion` en vez de rellenar
+    # los campos estructurados. El servicio lo consulta para elegir el system prompt, para no
+    # exigir campos que esta ruta no puede rellenar y para suplir `requiere_derivacion` desde
+    # el motor determinista. Antes se deducía del nombre del cliente, que dejó de bastar en
+    # cuanto la prosa pudo venir también de un modelo local.
+    prosa: bool
 
     async def interpretar(
         self,

backend/app/ai/claude.py

@@ -40,6 +40,7 @@ def _bloques_imagen(imagenes: list[str]) -> list[dict]:
 
 class ClaudeClient:
     nombre = "claude"
+    prosa = False
 
     def __init__(self) -> None:
         cfg = obtener_config()
@@ -52,6 +53,7 @@ class ClaudeClient:
 
         self._cliente = AsyncAnthropic(api_key=cfg.anthropic_api_key)
         self._modelo = cfg.claude_model
+        self.modelo = cfg.claude_model
 
     async def interpretar(
         self, sistema: str, mensaje_usuario: str, imagenes: list[str]

backend/app/ai/hf_space.py

@@ -20,115 +20,18 @@ from ..config import obtener_config
 from ..schemas import InterpretacionClinica, esquema_estructurado
 from .base import ErrorModelo
 
-_DATA_URL = re.compile(r"^data:(image/[\w+]+);base64,(.+)$", re.DOTALL)
-
-# medGemma es un modelo con "pensamiento": de forma intermitente emite una cadena de
-# razonamiento en inglés (etiquetada `thought` / "thinking process") en lugar de responder,
-# y a veces degenera en un bucle de repetición que agota el presupuesto de tokens sin llegar
-# a la respuesta. Estos marcadores permiten detectar y descartar esa salida defectuosa.
-_MARCADOR_PENSAMIENTO = re.compile(
-    r"(?im)^\s*(thought|thinking)\s*:?\s*$"
-    r"|here'?s\s+(a|my)\s+thinking\s+process"
-    r"|thinking\s+process\s+to\s+arrive"
-    r"|proceso\s+de\s+(pensamiento|razonamiento)"
+# La higiene de la prosa vive en `prosa.py` desde que también la usan los modelos locales
+# declarados como `prosa` en la lista blanca. Se reexporta aquí porque era la API pública de
+# este módulo (y lo que importan sus tests de regresión).
+from .prosa import (  # noqa: F401
+    _cortar_bucle_lineas,
+    interpretacion_defectuosa,
+    interpretacion_desde_prosa,
+    interpretacion_truncada,
+    limpiar_respuesta,
 )
 
-
-def limpiar_respuesta(text: str) -> str:
-    """Versión compacta de la limpieza que antes vivía en ia.js (limpiarRespuesta).
-
-    Sólo se aplica a la ruta HF Space (texto crudo de medGemma); las rutas Ollama/Claude
-    usan salida estructurada y no la necesitan.
-    """
-    if "<start_of_turn>model" in text:
-        text = text.split("<start_of_turn>model")[-1]
-    if "<end_of_turn>" in text:
-        text = text[: text.index("<end_of_turn>")]
-    if "<unused95>" in text:
-        text = text.split("<unused95>")[-1]
-    elif "<unused94>" in text:
-        text = "".join(text.split("<unused94>")[1:]).strip()
-    text = re.sub(r"<unused\d+>", "", text)
-    text = re.sub(r"<start_of_turn>\w+\n?", "", text)
-    text = re.sub(r"^\d+\s+(medical assistant|assistant|model)\s*", "", text, flags=re.I)
-    # LaTeX y bloques matemáticos
-    text = re.sub(r"\$\\boxed\{[^}]*\}\$", "", text)
-    text = re.sub(r"\\[a-zA-Z]+(\{[^}]*\})?", "", text)
-    text = re.sub(r"\$[^$]*\$", "", text)
-    text = re.sub(r"\n{3,}", "\n\n", text).strip()
-    text = _cortar_bucle_lineas(text)
-    # Corta al primer párrafo repetido (bucle del modelo)
-    vistos: set[str] = set()
-    sin_rep = []
-    for p in re.split(r"\n\n+", text):
-        clave = p.strip()[:80]
-        if clave in vistos:
-            break
-        vistos.add(clave)
-        sin_rep.append(p)
-    return "\n\n".join(sin_rep).strip() or "Sin respuesta del modelo."
-
-
-def _cortar_bucle_lineas(text: str) -> str:
-    """Trunca en cuanto una línea sustantiva se repite por 3.ª vez (bucle a nivel de viñeta,
-    que la deduplicación por párrafos `\\n\\n` no detecta)."""
-    conteo: dict[str, int] = {}
-    salida: list[str] = []
-    for linea in text.split("\n"):
-        clave = linea.strip()
-        if len(clave) > 15:
-            conteo[clave] = conteo.get(clave, 0) + 1
-            if conteo[clave] >= 3:
-                break
-        salida.append(linea)
-    return "\n".join(salida)
-
-
-# Caracteres que pueden ir DESPUÉS del punto final sin que la frase esté cortada: énfasis
-# markdown, comillas y cierres de paréntesis.
-_ADORNOS_FINALES = "*_`\"'”»)]}"
-_FIN_DE_FRASE = ".!?…:"
-# Una línea final corta puede ser un ítem de lista o un encabezado legítimos sin puntuación
-# ("- Ecografía abdominal"). Sólo una línea larga sin cierre delata una frase interrumpida.
-_LARGO_MINIMO_TRUNCADO = 40
-
-
-def interpretacion_truncada(text: str) -> bool:
-    """True si la respuesta se corta a mitad de frase.
-
-    El Space puede devolver una interpretación cortada en seco (visto en producción:
-    «…los diferenciales incluyen la lip», justo antes de nombrar el diferencial clave). La
-    limpieza no la toca —el corte viene de arriba— y el resto de comprobaciones no la ven:
-    el texto es largo, no repite y no filtra razonamiento. Sin esto, una interpretación
-    incompleta llega al veterinario con aspecto de completa, callando justo lo que importa.
-    """
-    limpio = text.rstrip()
-    if not limpio:
-        return True
-    ultima_linea = limpio.split("\n")[-1].strip()
-    if len(ultima_linea) < _LARGO_MINIMO_TRUNCADO:
-        return False
-    return limpio.rstrip(_ADORNOS_FINALES)[-1:] not in _FIN_DE_FRASE
-
-
-def interpretacion_defectuosa(text: str) -> bool:
-    """True si la salida limpiada no es una interpretación válida: demasiado corta, cadena de
-    razonamiento filtrada, bucle de repetición o frase cortada. Se usa para forzar un
-    reintento."""
-    if len(text.strip()) < 40:
-        return True
-    if _MARCADOR_PENSAMIENTO.search(text[:500]):
-        return True
-    if interpretacion_truncada(text):
-        return True
-    conteo: dict[str, int] = {}
-    for linea in text.split("\n"):
-        clave = linea.strip()
-        if len(clave) > 15:
-            conteo[clave] = conteo.get(clave, 0) + 1
-            if conteo[clave] >= 3:
-                return True
-    return False
+_DATA_URL = re.compile(r"^data:(image/[\w+]+);base64,(.+)$", re.DOTALL)
 
 
 class HFSpaceClient:
@@ -143,7 +46,9 @@ class HFSpaceClient:
     def __init__(self) -> None:
         cfg = obtener_config()
         self.estructurado = cfg.hf_space_estructurado
+        self.prosa = not self.estructurado
         self.nombre = "medgemma-hf-json" if self.estructurado else "medgemma-hf"
+        self.modelo = "hf-space"
         if not cfg.hf_space_url:
             raise ErrorModelo(
                 "MORPHOS_HF_SPACE_URL no configurada para la ruta HF Space.", reintentable=False
@@ -248,32 +153,7 @@ class HFSpaceClient:
         if self.estructurado:
             return self._parsear_estructurado(texto)
 
-        limpio = limpiar_respuesta(texto)
-        # Salida defectuosa (razonamiento filtrado / bucle / frase cortada) → error
-        # reintentable: el servicio vuelve a muestrear una vez y suele obtener una respuesta
-        # correcta. Se distingue el motivo porque una respuesta truncada se ve completa y el
-        # mensaje genérico despistaría al diagnosticar.
-        if interpretacion_defectuosa(limpio):
-            truncada = interpretacion_truncada(limpio)
-            motivo = (
-                "la respuesta llegó cortada a mitad de frase"
-                if truncada
-                else "el modelo devolvió razonamiento o texto repetido, no la interpretación"
-            )
-            raise ErrorModelo(
-                f"Respuesta inutilizable del modelo: {motivo}.", truncado=truncada
-            )
-
-        # `requiere_derivacion=True` es un marcador de posición conservador, NO una lectura del
-        # modelo: en esta ruta el Space devuelve prosa y no puede rellenar campos estructurados.
-        # Quien le pone valor real es el servicio, desde el motor determinista
-        # (`_derivacion_en_ruta_de_prosa`). Dejarlo constante hacía que `acierto_derivacion`
-        # midiera este default y no al modelo, y contradecía al propio texto en un panel normal.
-        return InterpretacionClinica(
-            interpretacion=limpio,
-            requiere_derivacion=True,
-            idioma="es",
-        )
+        return interpretacion_desde_prosa(texto)
 
     @staticmethod
     def _parsear_estructurado(texto: str) -> InterpretacionClinica:

backend/app/ai/medgemma.py

@@ -18,6 +18,7 @@ import httpx
 from ..config import obtener_config
 from ..schemas import InterpretacionClinica, esquema_estructurado
 from .base import ErrorModelo
+from .prosa import interpretacion_desde_prosa
 
 _DATA_URL = re.compile(r"^data:image/(?:jpeg|png|gif|webp);base64,(.+)$", re.DOTALL)
 
@@ -32,12 +33,22 @@ def _base64_imagenes(imagenes: list[str]) -> list[str]:
 
 
 class MedGemmaClient:
-    nombre = "medgemma"
+    """Cliente de Ollama. `modelo` lo puede fijar el usuario desde la UI, pero SÓLO con un
+    nombre ya validado contra la lista blanca (`PeticionInterpretacion.modelo_local`); la
+    base_url nunca sale de la configuración del servidor.
 
-    def __init__(self) -> None:
+    `prosa` desactiva la decodificación restringida para los modelos que la aceptan pero la
+    rellenan en hueco (ver `config.modelos_locales`). El nombre distinto NO es cosmético: el
+    servicio decide por `prosa` si usa el system prompt de prosa, si exige campos
+    estructurados y si suple `requiere_derivacion`.
+    """
+
+    def __init__(self, modelo: str | None = None, *, prosa: bool = False) -> None:
         cfg = obtener_config()
         self._url = cfg.medgemma_base_url.rstrip("/")
-        self._modelo = cfg.medgemma_model
+        self.modelo = modelo or cfg.medgemma_model
+        self.prosa = prosa
+        self.nombre = "medgemma-prosa" if prosa else "medgemma"
         self._timeout = cfg.medgemma_timeout_s
         self._esquema = esquema_estructurado()
 
@@ -50,13 +61,14 @@ class MedGemmaClient:
             mensaje_user["images"] = b64
 
         payload = {
-            "model": self._modelo,
+            "model": self.modelo,
             "messages": [{"role": "system", "content": sistema}, mensaje_user],
-            "format": self._esquema,  # salida estructurada nativa de Ollama
             "stream": False,
             "think": False,
             "options": {"temperature": 0.2, "num_predict": 1500},
         }
+        if not self.prosa:
+            payload["format"] = self._esquema  # salida estructurada nativa de Ollama
 
         try:
             async with httpx.AsyncClient(timeout=self._timeout) as cliente:
@@ -83,7 +95,9 @@ class MedGemmaClient:
             )
 
         contenido = resp.json().get("message", {}).get("content", "")
+        if self.prosa:
+            return interpretacion_desde_prosa(contenido)
         try:
             return InterpretacionClinica.model_validate_json(contenido)
         except Exception as exc:  # noqa: BLE001
-            raise ErrorModelo(f"Salida de medGemma no valida el esquema: {exc}") from exc
+            raise ErrorModelo(f"Salida de {self.modelo} no valida el esquema: {exc}") from exc

backend/app/ai/prosa.py

@@ -0,0 +1,158 @@
+"""Higiene de la salida de los modelos que devuelven TEXTO libre.
+
+Vivía dentro de `hf_space.py` cuando el Space era la única ruta de prosa. Ahora también la
+usa `medgemma.py` cuando el modelo local elegido está declarado como `prosa` en la lista
+blanca: no todo modelo que corre en Ollama sabe respetar una decodificación restringida
+—medido con qwen2.5:7b, que devolvía JSON válido con los tres campos estructurados
+vacíos—, y para ésos es mejor pedir prosa y envolverla que aceptar un objeto hueco.
+
+Los marcadores de `<unused95>` y `<start_of_turn>` son de la familia Gemma, pero el resto
+(razonamiento filtrado, bucle de repetición, frase cortada) son modos de fallo genéricos de
+cualquier modelo pequeño, así que se aplican a las dos rutas por igual.
+"""
+
+from __future__ import annotations
+
+import re
+
+from ..schemas import InterpretacionClinica
+from .base import ErrorModelo
+
+# medGemma es un modelo con "pensamiento": de forma intermitente emite una cadena de
+# razonamiento en inglés (etiquetada `thought` / "thinking process") en lugar de responder,
+# y a veces degenera en un bucle de repetición que agota el presupuesto de tokens sin llegar
+# a la respuesta. Estos marcadores permiten detectar y descartar esa salida defectuosa.
+_MARCADOR_PENSAMIENTO = re.compile(
+    r"(?im)^\s*(thought|thinking)\s*:?\s*$"
+    r"|here'?s\s+(a|my)\s+thinking\s+process"
+    r"|thinking\s+process\s+to\s+arrive"
+    r"|proceso\s+de\s+(pensamiento|razonamiento)"
+)
+
+
+def limpiar_respuesta(text: str) -> str:
+    """Versión compacta de la limpieza que antes vivía en ia.js (limpiarRespuesta).
+
+    Sólo se aplica a las rutas de PROSA (texto crudo del modelo); las rutas con salida
+    estructurada validan contra el esquema y no la necesitan.
+    """
+    if "<start_of_turn>model" in text:
+        text = text.split("<start_of_turn>model")[-1]
+    if "<end_of_turn>" in text:
+        text = text[: text.index("<end_of_turn>")]
+    if "<unused95>" in text:
+        text = text.split("<unused95>")[-1]
+    elif "<unused94>" in text:
+        text = "".join(text.split("<unused94>")[1:]).strip()
+    text = re.sub(r"<unused\d+>", "", text)
+    text = re.sub(r"<start_of_turn>\w+\n?", "", text)
+    text = re.sub(r"^\d+\s+(medical assistant|assistant|model)\s*", "", text, flags=re.I)
+    # LaTeX y bloques matemáticos
+    text = re.sub(r"\$\\boxed\{[^}]*\}\$", "", text)
+    text = re.sub(r"\\[a-zA-Z]+(\{[^}]*\})?", "", text)
+    text = re.sub(r"\$[^$]*\$", "", text)
+    text = re.sub(r"\n{3,}", "\n\n", text).strip()
+    text = _cortar_bucle_lineas(text)
+    # Corta al primer párrafo repetido (bucle del modelo)
+    vistos: set[str] = set()
+    sin_rep = []
+    for p in re.split(r"\n\n+", text):
+        clave = p.strip()[:80]
+        if clave in vistos:
+            break
+        vistos.add(clave)
+        sin_rep.append(p)
+    return "\n\n".join(sin_rep).strip() or "Sin respuesta del modelo."
+
+
+def _cortar_bucle_lineas(text: str) -> str:
+    """Trunca en cuanto una línea sustantiva se repite por 3.ª vez (bucle a nivel de viñeta,
+    que la deduplicación por párrafos `\\n\\n` no detecta)."""
+    conteo: dict[str, int] = {}
+    salida: list[str] = []
+    for linea in text.split("\n"):
+        clave = linea.strip()
+        if len(clave) > 15:
+            conteo[clave] = conteo.get(clave, 0) + 1
+            if conteo[clave] >= 3:
+                break
+        salida.append(linea)
+    return "\n".join(salida)
+
+
+# Caracteres que pueden ir DESPUÉS del punto final sin que la frase esté cortada: énfasis
+# markdown, comillas y cierres de paréntesis.
+_ADORNOS_FINALES = "*_`\"'”»)]}"
+_FIN_DE_FRASE = ".!?…:"
+# Una línea final corta puede ser un ítem de lista o un encabezado legítimos sin puntuación
+# ("- Ecografía abdominal"). Sólo una línea larga sin cierre delata una frase interrumpida.
+_LARGO_MINIMO_TRUNCADO = 40
+
+
+def interpretacion_truncada(text: str) -> bool:
+    """True si la respuesta se corta a mitad de frase.
+
+    El Space puede devolver una interpretación cortada en seco (visto en producción:
+    «…los diferenciales incluyen la lip», justo antes de nombrar el diferencial clave). La
+    limpieza no la toca —el corte viene de arriba— y el resto de comprobaciones no la ven:
+    el texto es largo, no repite y no filtra razonamiento. Sin esto, una interpretación
+    incompleta llega al veterinario con aspecto de completa, callando justo lo que importa.
+    """
+    limpio = text.rstrip()
+    if not limpio:
+        return True
+    ultima_linea = limpio.split("\n")[-1].strip()
+    if len(ultima_linea) < _LARGO_MINIMO_TRUNCADO:
+        return False
+    return limpio.rstrip(_ADORNOS_FINALES)[-1:] not in _FIN_DE_FRASE
+
+
+def interpretacion_defectuosa(text: str) -> bool:
+    """True si la salida limpiada no es una interpretación válida: demasiado corta, cadena de
+    razonamiento filtrada, bucle de repetición o frase cortada. Se usa para forzar un
+    reintento."""
+    if len(text.strip()) < 40:
+        return True
+    if _MARCADOR_PENSAMIENTO.search(text[:500]):
+        return True
+    if interpretacion_truncada(text):
+        return True
+    conteo: dict[str, int] = {}
+    for linea in text.split("\n"):
+        clave = linea.strip()
+        if len(clave) > 15:
+            conteo[clave] = conteo.get(clave, 0) + 1
+            if conteo[clave] >= 3:
+                return True
+    return False
+
+
+def interpretacion_desde_prosa(texto: str) -> InterpretacionClinica:
+    """Limpia el texto crudo y lo envuelve en el contrato estructurado, o lanza ErrorModelo.
+
+    Salida defectuosa (razonamiento filtrado / bucle / frase cortada) → error reintentable:
+    el servicio vuelve a muestrear una vez y suele obtener una respuesta correcta. Se
+    distingue el motivo porque una respuesta truncada se ve completa y el mensaje genérico
+    despistaría al diagnosticar.
+
+    `requiere_derivacion=True` es un marcador de posición conservador, NO una lectura del
+    modelo: en esta ruta el modelo devuelve prosa y no puede rellenar campos estructurados.
+    Quien le pone valor real es el servicio, desde el motor determinista
+    (`_derivacion_en_ruta_de_prosa`). Dejarlo constante hacía que `acierto_derivacion`
+    midiera este default y no al modelo, y contradecía al propio texto en un panel normal.
+    """
+    limpio = limpiar_respuesta(texto)
+    if interpretacion_defectuosa(limpio):
+        truncada = interpretacion_truncada(limpio)
+        motivo = (
+            "la respuesta llegó cortada a mitad de frase"
+            if truncada
+            else "el modelo devolvió razonamiento o texto repetido, no la interpretación"
+        )
+        raise ErrorModelo(f"Respuesta inutilizable del modelo: {motivo}.", truncado=truncada)
+
+    return InterpretacionClinica(
+        interpretacion=limpio,
+        requiere_derivacion=True,
+        idioma="es",
+    )

backend/app/ai/service.py

@@ -98,15 +98,32 @@ def _derivacion_en_ruta_de_prosa(pet: PeticionInterpretacion) -> bool:
     return bool(pet.hallazgos or pet.patrones)
 
 
-def _crear_cliente(backend: str) -> ClienteModelo:
+def _crear_cliente(backend: str, modelo_local: str | None = None) -> ClienteModelo:
     if backend == "claude":
         from .claude import ClaudeClient
 
         return ClaudeClient()
 
-    # Ruta 'medgemma': por defecto el HF Space (donde vive medGemma); si no hay Space
-    # configurado, cae a Ollama local.
     cfg = obtener_config()
+
+    # Modelo local elegido por el usuario. El nombre ya viene validado contra la lista blanca
+    # por `PeticionInterpretacion`; aquí se revalida porque este camino también lo usan las
+    # evals, que pueden construir la petición de otras formas. Tiene prioridad sobre el Space:
+    # elegir un modelo en la UI y que el servidor llamara igualmente al Space sería mentirle al
+    # usuario. Todo lo demás —RAG, prompt endurecido, atribución y suelos de seguridad— es
+    # idéntico, porque vive en este servicio y no en el cliente.
+    if modelo_local:
+        permitidos = cfg.modelos_locales_permitidos()
+        if modelo_local not in permitidos:
+            raise ErrorModelo(
+                f"Modelo local no permitido: {modelo_local!r}.", reintentable=False
+            )
+        from .medgemma import MedGemmaClient
+
+        return MedGemmaClient(modelo_local, prosa=permitidos[modelo_local])
+
+    # Ruta 'medgemma' por defecto: el HF Space (donde vive medGemma); si no hay Space
+    # configurado, cae a Ollama local.
     if cfg.hf_space_url:
         from .hf_space import HFSpaceClient
 
@@ -152,8 +169,8 @@ async def interpretar(pet: PeticionInterpretacion) -> RespuestaInterpretacion:
 
     # 2-3) Prompt endurecido con contexto recuperado y llamada al modelo, con un reintento
     # ante salida malformada. El HF Space devuelve texto libre → system prompt de prosa.
-    cliente = _crear_cliente(backend)
-    es_prosa = cliente.nombre == "medgemma-hf"
+    cliente = _crear_cliente(backend, pet.modelo_local)
+    es_prosa = cliente.prosa
     sistema = SISTEMA_PROSA if es_prosa else SISTEMA
     # Los fragmentos ENVIADOS pueden ser menos que los recuperados —por presupuesto de prompt
     # aquí, o por el recorte del reintento más abajo— y son ésos, no los recuperados, los que
@@ -242,12 +259,10 @@ async def interpretar(pet: PeticionInterpretacion) -> RespuestaInterpretacion:
         log.warning("El modelo no marcó derivación con hallazgos graves; se fuerza.")
         resultado.requiere_derivacion = True
 
-    if backend == "claude":
-        etiqueta = cfg.claude_model
-    elif cliente.nombre.startswith("medgemma-hf"):
-        etiqueta = "hf-space"
-    else:
-        etiqueta = cfg.medgemma_model
+    # La etiqueta sale del propio cliente y no de la configuración: con un modelo elegido en la
+    # UI, `cfg.medgemma_model` ya no es el que respondió, y la línea "Modelo:" de la tarjeta
+    # clínica es lo único que le dice al veterinario con qué se generó lo que está leyendo.
+    etiqueta = cliente.modelo
 
     return RespuestaInterpretacion(
         resultado=resultado,

backend/app/config.py

@@ -9,9 +9,10 @@ from __future__ import annotations
 
 from functools import lru_cache
 from pathlib import Path
+from typing import Annotated
 
 from pydantic import AliasChoices, Field, field_validator
-from pydantic_settings import BaseSettings, SettingsConfigDict
+from pydantic_settings import BaseSettings, NoDecode, SettingsConfigDict
 
 # Raíz del repo (…/morphos). La BD y el índice RAG viven FUERA del directorio servido.
 RAIZ_REPO = Path(__file__).resolve().parents[2]
@@ -54,6 +55,29 @@ class Configuracion(BaseSettings):
     # cuantizado tarda minutos en frío y luego responde en segundos. Con 120 s la primera
     # llamada se caía por timeout y las evals lo veían como "no se pudo conectar".
     medgemma_timeout_s: int = Field(default=300)
+    # Modelos locales que el usuario puede ELEGIR desde la UI. Lista blanca cerrada: vacía por
+    # defecto, lo que deja el selector oculto y el comportamiento de siempre (la ruta 'medgemma'
+    # la decide el servidor). Formato de cada entrada: `nombre[=prosa|=estructurado]`.
+    #
+    #   MORPHOS_MODELOS_LOCALES="medgemma1.5:latest, qwen2.5:7b=prosa"
+    #
+    # Por qué una lista blanca y no un campo de texto libre: el nombre viaja del navegador al
+    # servidor y de ahí a Ollama, así que un campo libre deja al cliente decidir qué pesos se
+    # descargan en la máquina que aloja el servicio. Y por eso NO hay campo de URL: la base_url
+    # se queda en `medgemma_base_url`, del lado servidor. Aceptar una URL del cliente convierte
+    # /api/interpret en un SSRF (el servidor haría peticiones a donde diga el navegador).
+    #
+    # El sufijo declara si el modelo sabe emitir salida ESTRUCTURADA (decodificación restringida
+    # por JSON Schema) o hay que pedirle prosa y envolverla. No se infiere: qwen2.5:7b acepta el
+    # `format` de Ollama y devuelve JSON válido con `hallazgos_clave`, `diferenciales` y
+    # `siguientes_pruebas` VACÍOS, que valida el esquema y deja al veterinario sin lo que vino a
+    # buscar. Por defecto se asume `estructurado`, que es lo que hace medGemma.
+    #
+    # Sólo tiene sentido donde el servicio tiene un Ollama alcanzable: "local" es local al
+    # SERVIDOR, no al navegador. En el HF Space se deja vacía.
+    # `NoDecode`: sin él, la fuente de entorno intenta json.loads() del valor ANTES de que corra
+    # `_dividir_lista` y la forma separada por comas revienta el arranque con SettingsError.
+    modelos_locales: Annotated[list[str], NoDecode] = Field(default_factory=list)
     hf_space_url: str = Field(default="https://blackmistcode-morphos-medgemma.hf.space/gradio_api")
     # Salida ESTRUCTURADA del Space: se le manda el JSON Schema de InterpretacionClinica y el
     # Space restringe la decodificación a producirlo (como `format` en Ollama). Es la corrección
@@ -102,8 +126,11 @@ class Configuracion(BaseSettings):
     # fragmentos (~3.600 caracteres) la respuesta se cortaba a mitad de frase en ~220 tokens,
     # con 2 salía completa en ~950. Medido contra el Space el 2026-07-27.
     #
-    # No se aplica a Ollama ni a Claude: ahí el razonamiento va desactivado o no comparte
-    # presupuesto con la respuesta, y más contexto sólo mejora la fundamentación.
+    # No se aplica a las rutas con salida estructurada (Ollama por defecto, Claude): ahí el
+    # razonamiento va desactivado o no comparte presupuesto con la respuesta, y más contexto
+    # sólo mejora la fundamentación. Sí se aplica a un modelo local declarado `prosa` en
+    # `modelos_locales`: es el mismo modo de fallo (un modelo pequeño razonando en voz alta
+    # dentro del mismo presupuesto de generación), aunque no se haya medido caso por caso.
     rag_max_chars_prompt: int = Field(default=1800)
     rag_habilitado: bool = Field(default=True)
     # Idioma de la consulta de recuperación. "en" (por defecto) traduce el vocabulario clínico
@@ -191,18 +218,49 @@ class Configuracion(BaseSettings):
     # --- Integración de analizadores de laboratorio ---
     # Claves de API de los puentes locales (dispositivos headless). Autoriza /api/lab/ingesta.
     # Si está vacía, la ingesta queda DESHABILITADA (falla cerrado con 503). Acepta lista JSON
-    # o cadena separada por comas en MORPHOS_LAB_API_KEYS.
-    lab_api_keys: list[str] = Field(default_factory=list)
+    # o cadena separada por comas en MORPHOS_LAB_API_KEYS (`NoDecode`, ver `modelos_locales`:
+    # sin él la forma con comas fallaba al arrancar pese a estar documentada).
+    lab_api_keys: Annotated[list[str], NoDecode] = Field(default_factory=list)
     # Persistencia opcional de resultados en SQLite (sólo útil con volumen persistente).
     lab_persistir: bool = Field(default=False)
 
-    @field_validator("lab_api_keys", mode="before")
+    @field_validator("lab_api_keys", "modelos_locales", mode="before")
     @classmethod
-    def _dividir_keys(cls, v):
+    def _dividir_lista(cls, v):
+        """Acepta lista JSON o cadena separada por comas.
+
+        El decodificado JSON lo hacía antes la fuente de entorno, pero se ejecutaba ANTES que
+        este validador y hacía fallar el arranque con la forma de comas (que es la documentada).
+        Con `NoDecode` el valor llega crudo y se decide aquí: JSON si lo parece, comas si no.
+        """
         if isinstance(v, str):
-            return [k.strip() for k in v.split(",") if k.strip()]
+            crudo = v.strip()
+            if crudo.startswith("["):
+                import json
+
+                try:
+                    return json.loads(crudo)
+                except json.JSONDecodeError:
+                    pass
+            return [k.strip() for k in crudo.split(",") if k.strip()]
         return v
 
+    def modelos_locales_permitidos(self) -> dict[str, bool]:
+        """Lista blanca parseada: nombre del modelo → si hay que pedirle PROSA.
+
+        Se separa por '=' y no por ':' porque el nombre de un modelo de Ollama ya lleva ':'
+        (`medgemma1.5:latest`). Un sufijo desconocido se trata como `estructurado`, que es el
+        valor por defecto; no se lanza, para que una errata en el .env no impida arrancar el
+        servicio entero por un selector opcional.
+        """
+        permitidos: dict[str, bool] = {}
+        for entrada in self.modelos_locales:
+            nombre, _, modo = entrada.partition("=")
+            nombre = nombre.strip()
+            if nombre:
+                permitidos[nombre] = modo.strip().lower() == "prosa"
+        return permitidos
+
     def validar_prod(self) -> None:
         """Requisitos que sólo aplican en producción; falla cerrado si faltan."""
         if self.entorno != "prod":

backend/app/routers/interpret.py

@@ -42,6 +42,21 @@ def _validar_imagenes(imagenes: list[str]) -> None:
             raise HTTPException(status.HTTP_413_REQUEST_ENTITY_TOO_LARGE, "Imagen demasiado grande.")
 
 
+@router.get("/modelos")
+async def get_modelos(_sesion: dict = Depends(usuario_actual)) -> dict:
+    """Modelos locales que el usuario puede elegir, para poblar el selector de la UI.
+
+    Devuelve sólo NOMBRES: la URL de Ollama no sale del servidor ni entra desde el cliente.
+    Lista vacía = el selector no se muestra y la ruta la sigue decidiendo el servidor, que es
+    el caso de la instancia pública (allí no hay Ollama que valga).
+    """
+    cfg = obtener_config()
+    return {
+        "locales": sorted(cfg.modelos_locales_permitidos()),
+        "defecto": cfg.medgemma_model,
+    }
+
+
 @router.post("/interpret", response_model=RespuestaInterpretacion)
 @limiter.limit(obtener_config().limite_interpret)
 # Segundo límite, con clave por usuario: el de arriba (por IP) frena ráfagas puntuales, éste

backend/app/schemas.py

@@ -62,12 +62,37 @@ class PeticionInterpretacion(BaseModel):
     signos_clinicos: str = Field(default="", max_length=2000)
     imagenes: list[str] = Field(default_factory=list)  # data URLs de citología
     backend: Literal["medgemma", "claude"] = "medgemma"
+    # Modelo local elegido por el usuario en la UI. Sólo se acepta si está en la lista blanca
+    # `MORPHOS_MODELOS_LOCALES`; si lo está, sustituye a la ruta que el servidor usaría por
+    # defecto para 'medgemma' (Space u Ollama). None = decide el servidor, como siempre.
+    modelo_local: str | None = Field(default=None, max_length=100)
 
     @field_validator("imagenes")
     @classmethod
     def _limitar_imagenes(cls, v: list[str]) -> list[str]:
         return v[:4]
 
+    @field_validator("modelo_local")
+    @classmethod
+    def _validar_lista_blanca(cls, v: str | None) -> str | None:
+        """Rechaza cualquier modelo fuera de la lista blanca.
+
+        Se valida en el ESQUEMA y no en el router para que valga igual para las evals, que
+        llaman a `interpretar()` sin pasar por HTTP, y para que FastAPI conteste 422 (error del
+        cliente) en vez del 502 al que el router traduce los ErrorModelo.
+        """
+        if v is None:
+            return None
+        from .config import obtener_config
+
+        permitidos = obtener_config().modelos_locales_permitidos()
+        if v not in permitidos:
+            disponibles = ", ".join(sorted(permitidos)) or "ninguno"
+            raise ValueError(
+                f"Modelo local no permitido: {v!r}. Configurados: {disponibles}."
+            )
+        return v
+
 
 # --- Salida estructurada del modelo ---
 

backend/tests/test_api.py

@@ -76,6 +76,30 @@ def test_flujo_registro_login_e_interpret(cliente, monkeypatch):
     assert ok.json()["resultado"]["idioma"] == "es"
 
 
+def test_modelos_requiere_sesion(cliente):
+    """La lista de modelos describe la configuración del servidor: no es pública."""
+    assert cliente.get("/api/modelos").status_code == 401
+
+
+def test_interpret_rechaza_modelo_fuera_de_la_lista_blanca(cliente):
+    """422 (error del cliente) y no 502: la petición es inválida, el modelo ni se llama."""
+    reg = cliente.post(
+        "/api/auth/registro",
+        json={"nombre": "Leo", "apellido": "Vet", "email": "leo@example.com", "password": "clave-segura-1"},
+    )
+    csrf = reg.json()["csrf"]
+
+    assert cliente.get("/api/modelos").json()["locales"] == []  # nada declarado por defecto
+
+    r = cliente.post(
+        "/api/interpret",
+        json={"paciente": {"especie": "canino"}, "modelo_local": "llama3:70b"},
+        headers={"X-CSRF-Token": csrf},
+    )
+    assert r.status_code == 422, r.text
+    assert "no permitido" in r.text
+
+
 def test_registro_rechaza_password_corta(cliente):
     r = cliente.post(
         "/api/auth/registro",

backend/tests/test_modelos_locales.py

@@ -0,0 +1,161 @@
+"""Lista blanca de modelos locales elegibles desde la UI.
+
+Lo que aquí se fija es la frontera de confianza: el navegador puede decir CUÁL de los modelos
+declarados por el servidor responde, y nada más. Ni una URL (sería un SSRF: el servidor haría
+peticiones a donde diga el cliente) ni un nombre arbitrario (elegiría qué pesos se descargan en
+la máquina que aloja el servicio). Y el modelo elegido recorre exactamente el mismo camino que
+el Space: RAG, prompt endurecido, atribución y suelos de seguridad.
+"""
+
+from __future__ import annotations
+
+import pytest
+from pydantic import ValidationError
+
+from app.ai import service
+from app.config import Configuracion, obtener_config
+from app.schemas import InterpretacionClinica, PeticionInterpretacion
+
+PETICION = {
+    "paciente": {"especie": "canino"},
+    "hallazgos": [
+        {
+            "clave": "hct",
+            "nombre": "Hematocrito",
+            "valor": 22.0,
+            "unidad": "%",
+            "direccion": "bajo",
+            "gravedad": "grave",
+        }
+    ],
+    "patrones": [{"nombre": "Anemia", "descripcion": "…", "gravedad": "grave"}],
+    "imagenes": [],
+}
+
+
+@pytest.fixture
+def lista_blanca(monkeypatch):
+    """Config con dos modelos declarados: uno estructurado y otro de prosa."""
+    cfg = obtener_config().model_copy(
+        update={"modelos_locales": ["medgemma1.5:latest", "qwen2.5:7b=prosa"]}
+    )
+    # El validador del esquema importa `obtener_config` perezosamente desde `app.config`;
+    # el servicio lo tiene ya resuelto en su propio espacio de nombres. Hay que parchear ambos.
+    monkeypatch.setattr("app.config.obtener_config", lambda: cfg)
+    monkeypatch.setattr(service, "obtener_config", lambda: cfg)
+    return cfg
+
+
+def test_parseo_de_la_lista_blanca():
+    cfg = Configuracion(modelos_locales="medgemma1.5:latest, qwen2.5:7b=prosa , vacio=raro")
+    permitidos = cfg.modelos_locales_permitidos()
+    # El nombre lleva ':' propio, por eso el modo se separa con '='.
+    assert permitidos == {
+        "medgemma1.5:latest": False,
+        "qwen2.5:7b": True,
+        "vacio": False,  # sufijo desconocido → estructurado, sin reventar el arranque
+    }
+
+
+def test_sin_lista_blanca_no_se_acepta_ningun_modelo():
+    """Estado por defecto (instancia pública): el selector no existe y nada se cuela."""
+    with pytest.raises(ValidationError, match="no permitido"):
+        PeticionInterpretacion.model_validate({**PETICION, "modelo_local": "medgemma1.5:latest"})
+
+
+def test_modelo_fuera_de_la_lista_se_rechaza(lista_blanca):
+    with pytest.raises(ValidationError, match="no permitido"):
+        PeticionInterpretacion.model_validate({**PETICION, "modelo_local": "llama3:70b"})
+
+
+def test_no_hay_forma_de_inyectar_una_url(lista_blanca):
+    """El campo sólo admite nombres de la lista; una URL nunca llega a httpx."""
+    for intento in ("http://attacker.example/api", "http://169.254.169.254/latest/meta-data"):
+        with pytest.raises(ValidationError):
+            PeticionInterpretacion.model_validate({**PETICION, "modelo_local": intento})
+
+
+def test_cliente_estructurado_para_el_modelo_declarado_asi(lista_blanca, monkeypatch):
+    monkeypatch.setattr("app.ai.medgemma.obtener_config", lambda: lista_blanca)
+    cliente = service._crear_cliente("medgemma", "medgemma1.5:latest")
+    assert cliente.modelo == "medgemma1.5:latest"
+    assert cliente.prosa is False
+
+
+def test_cliente_de_prosa_para_el_modelo_declarado_prosa(lista_blanca, monkeypatch):
+    monkeypatch.setattr("app.ai.medgemma.obtener_config", lambda: lista_blanca)
+    cliente = service._crear_cliente("medgemma", "qwen2.5:7b")
+    assert cliente.modelo == "qwen2.5:7b"
+    assert cliente.prosa is True
+
+
+def test_el_modelo_local_gana_al_hf_space(lista_blanca, monkeypatch):
+    """Con Space configurado, elegir un modelo en la UI debe llevar a Ollama igualmente.
+
+    Si no, el selector mentiría: el veterinario cree estar usando su modelo y responde el Space.
+    """
+    assert lista_blanca.hf_space_url  # el defecto trae Space
+    monkeypatch.setattr("app.ai.medgemma.obtener_config", lambda: lista_blanca)
+    cliente = service._crear_cliente("medgemma", "medgemma1.5:latest")
+    assert cliente.nombre.startswith("medgemma")
+    assert "hf" not in cliente.nombre
+
+
+def test_sin_modelo_local_decide_el_servidor(lista_blanca):
+    """None = comportamiento de siempre; la lista blanca no cambia la ruta por defecto."""
+    cliente = service._crear_cliente("medgemma", None)
+    assert cliente.nombre == "medgemma-hf"
+
+
+async def test_el_modelo_elegido_recibe_rag_y_se_reporta_en_la_respuesta(
+    lista_blanca, monkeypatch
+):
+    """El punto de todo el ejercicio: un modelo local ve la misma literatura recuperada."""
+    from app.rag.retriever import Fragmento
+
+    fragmento = Fragmento(
+        texto="La anemia arregenerativa en el perro…",
+        libro="Fundamentals",
+        edicion="7",
+        capitulo="Anemia",
+        pagina="120",
+        score=1.0,
+    )
+    for nombre in ("recuperar", "recuperar_multi"):
+        monkeypatch.setattr(service, nombre, lambda *_a, **_k: [fragmento])
+
+    visto: dict = {}
+
+    class ClienteLocal:
+        nombre = "medgemma"
+        prosa = False
+        modelo = "medgemma1.5:latest"
+
+        async def interpretar(self, _sistema, mensaje_usuario, _imagenes):
+            visto["mensaje"] = mensaje_usuario
+            return InterpretacionClinica(
+                interpretacion="ok " * 20,
+                hallazgos_clave=[
+                    {
+                        "analito": "Hematocrito",
+                        "direccion": "bajo",
+                        "gravedad": "grave",
+                        "comentario": "anemia",
+                    }
+                ],
+                diferenciales=[
+                    {"nombre": "IMHA", "probabilidad": "alta", "evidencia": ["hct bajo"]}
+                ],
+                requiere_derivacion=True,
+            )
+
+    monkeypatch.setattr(service, "_crear_cliente", lambda *_: ClienteLocal())
+    pet = PeticionInterpretacion.model_validate(
+        {**PETICION, "modelo_local": "medgemma1.5:latest"}
+    )
+    resp = await service.interpretar(pet)
+
+    assert "anemia arregenerativa" in visto["mensaje"].lower()
+    assert resp.fuentes_rag == 1
+    # La etiqueta debe nombrar el modelo QUE RESPONDIÓ, no el de la configuración.
+    assert resp.modelo == "medgemma:medgemma1.5:latest"

backend/tests/test_prescripcion.py

@@ -61,6 +61,8 @@ def test_el_encuadre_no_se_duplica():
 
 class ClientePrescriptor:
     nombre = "medgemma-hf"
+    prosa = True
+    modelo = "hf-space"
 
     async def interpretar(self, *_a, **_k):
         return InterpretacionClinica(
@@ -77,7 +79,7 @@ async def test_el_servicio_encuadra_y_deriva(monkeypatch):
 
     for nombre in ("recuperar", "recuperar_multi"):
         monkeypatch.setattr(S, nombre, lambda *_a, **_k: [])
-    monkeypatch.setattr(S, "_crear_cliente", lambda _b: ClientePrescriptor())
+    monkeypatch.setattr(S, "_crear_cliente", lambda *_: ClientePrescriptor())
 
     pet = PeticionInterpretacion(
         paciente={"especie": "canino"},

backend/tests/test_prompt_y_rag.py

@@ -130,11 +130,13 @@ async def test_el_servicio_elige_la_ruta_de_recuperacion_segun_la_bandera(monkey
 
     class ClienteQueNoResponde:
         nombre = "medgemma"
+        prosa = False
+        modelo = "medgemma:test"
 
         async def interpretar(self, *_a, **_k):
             raise ErrorModelo("no importa: sólo se mira la recuperación", reintentable=False)
 
-    monkeypatch.setattr(service, "_crear_cliente", lambda _b: ClienteQueNoResponde())
+    monkeypatch.setattr(service, "_crear_cliente", lambda *_: ClienteQueNoResponde())
     with pytest.raises(ErrorModelo):
         await service.interpretar(_peticion())
 

backend/tests/test_reintentos.py

@@ -35,6 +35,8 @@ PETICION = {
 
 class ClienteFalso:
     nombre = "medgemma-hf"
+    prosa = True
+    modelo = "hf-space"
 
     def __init__(self, error: ErrorModelo | None, exito_en: int | None = None):
         self.error = error
@@ -56,7 +58,7 @@ def sin_rag(monkeypatch):
 
 
 async def _interpretar_con(cliente, monkeypatch):
-    monkeypatch.setattr(service, "_crear_cliente", lambda _b: cliente)
+    monkeypatch.setattr(service, "_crear_cliente", lambda *_: cliente)
     return await service.interpretar(PeticionInterpretacion.model_validate(PETICION))
 
 
@@ -96,6 +98,8 @@ class ClienteProsa:
     """Ruta HF Space: devuelve prosa con marcadores [n], sin `diferenciales`."""
 
     nombre = "medgemma-hf"
+    prosa = True
+    modelo = "hf-space"
 
     def __init__(self, texto: str):
         self.texto = texto
@@ -129,6 +133,8 @@ class ClienteTruncaConContexto:
     siempre; sin ella (o con poca) sale completa."""
 
     nombre = "medgemma-hf"
+    prosa = True
+    modelo = "hf-space"
 
     def __init__(self, umbral_fragmentos: int):
         self.umbral = umbral_fragmentos
@@ -166,6 +172,8 @@ class ClienteEstructuraVacia:
     """Reproduce lo medido con qwen2.5:7b: JSON válido con los campos estructurados vacíos."""
 
     nombre = "medgemma"
+    prosa = False
+    modelo = "medgemma:test"
 
     def __init__(self, llenar_en: int | None = None):
         self.llenar_en = llenar_en
@@ -205,6 +213,8 @@ async def test_la_ruta_de_prosa_no_exige_campos_estructurados(sin_rag, monkeypat
 
 class ClienteSinDerivacion:
     nombre = "medgemma"
+    prosa = False
+    modelo = "medgemma:test"
 
     async def interpretar(self, *_a, **_k):
         return InterpretacionClinica(
@@ -224,6 +234,8 @@ async def test_la_derivacion_no_la_decide_el_modelo(sin_rag, monkeypatch):
 
 class ClienteProsaSimple:
     nombre = "medgemma-hf"
+    prosa = True
+    modelo = "hf-space"
 
     async def interpretar(self, *_a, **_k):
         # Igual que el cliente del Space: sólo prosa, con el default del esquema.
@@ -233,7 +245,7 @@ class ClienteProsaSimple:
 async def test_prosa_sin_alteraciones_no_deriva(sin_rag, monkeypatch):
     """El default del esquema hacía que un panel normal pidiera derivación contradiciendo su
     propio texto; el juez lo penalizó como incoherencia (2026-07-31, `normal-canino`)."""
-    monkeypatch.setattr(service, "_crear_cliente", lambda _b: ClienteProsaSimple())
+    monkeypatch.setattr(service, "_crear_cliente", lambda *_: ClienteProsaSimple())
     pet = PeticionInterpretacion(paciente={"especie": "canino"}, hallazgos=[], patrones=[])
 
     resp = await service.interpretar(pet)
@@ -242,7 +254,7 @@ async def test_prosa_sin_alteraciones_no_deriva(sin_rag, monkeypatch):
 
 
 async def test_prosa_con_alteraciones_sigue_derivando(sin_rag, monkeypatch):
-    monkeypatch.setattr(service, "_crear_cliente", lambda _b: ClienteProsaSimple())
+    monkeypatch.setattr(service, "_crear_cliente", lambda *_: ClienteProsaSimple())
 
     resp = await service.interpretar(PeticionInterpretacion.model_validate(PETICION))
 
@@ -255,6 +267,8 @@ async def test_la_ruta_estructurada_conserva_la_opinion_del_modelo(sin_rag, monk
 
     class ClienteEstructurado:
         nombre = "medgemma"
+        prosa = False
+        modelo = "medgemma:test"
 
         async def interpretar(self, *_a, **_k):
             return InterpretacionClinica(
@@ -264,7 +278,7 @@ async def test_la_ruta_estructurada_conserva_la_opinion_del_modelo(sin_rag, monk
                 requiere_derivacion=True,
             )
 
-    monkeypatch.setattr(service, "_crear_cliente", lambda _b: ClienteEstructurado())
+    monkeypatch.setattr(service, "_crear_cliente", lambda *_: ClienteEstructurado())
     pet = PeticionInterpretacion(paciente={"especie": "canino"}, hallazgos=[], patrones=[])
 
     resp = await service.interpretar(pet)

css/styles.css

@@ -1293,16 +1293,19 @@ footer {
     outline-offset: 1px;
 }
 
-#ia-ollama-url,
-#ia-ollama-model {
-    color: var(--color-placeholder);
-}
-
 .ia-model-input {
     max-width: 130px;
     flex: 0 0 auto;
 }
 
+/* `display: flex` de las reglas de arriba gana al `display: none` del agente de usuario, así
+   que sin esto el atributo `hidden` que pone ia.ts no ocultaba nada. Se resuelve con
+   especificidad ([hidden] añade un selector de atributo), no con !important. */
+.ia-backend-config[hidden],
+.ia-ollama-fields[hidden] {
+    display: none;
+}
+
 .ia-hf-fields {
     width: 100%;
 }

frontend/src/ia.ts

@@ -7,19 +7,62 @@
 import type { Hallazgo, Paciente, Patron } from './tipos.js';
 
 const BACKEND_KEY = 'mx-ia-backend';
+const MODELO_LOCAL_KEY = 'mx-ia-modelo-local';
 
-// Inicializa el panel de ajustes de backend. En el nuevo diseño el servidor decide la
-// ruta self-hosted concreta (Ollama vs Space) por configuración, así que las opciones
-// "local"/"hf" del formulario se colapsan en 'medgemma'; 'claude' queda como ruta híbrida.
-export function inicializarConfigBackend(): void {
+// Modelos locales que el servidor admite. Se pide una vez al arrancar; lista vacía = la
+// instancia no tiene Ollama alcanzable y el selector entero se queda oculto.
+let modelosLocales: string[] = [];
+
+// Modelo local elegido, o null si se usa la ruta que decide el servidor. Se lee al enviar la
+// petición: es lo único que el cliente puede decir sobre qué modelo responde, y aun así el
+// servidor lo revalida contra su lista blanca.
+function modeloLocalSeleccionado(): string | null {
+  const radioLocal = document.getElementById('ia-backend-local') as HTMLInputElement | null;
+  if (!radioLocal?.checked) return null;
+  const guardado = localStorage.getItem(MODELO_LOCAL_KEY);
+  return guardado && modelosLocales.includes(guardado) ? guardado : (modelosLocales[0] ?? null);
+}
+
+// Inicializa el panel de ajustes de backend. La ruta ('medgemma' | 'claude') la decide el
+// servidor; lo único que el usuario elige aquí es CUÁL de los modelos locales declarados
+// responde. No hay campo de URL: la de Ollama vive en la configuración del servidor.
+export async function inicializarConfigBackend(): Promise<void> {
   const guardado = localStorage.getItem(BACKEND_KEY);
   if (guardado !== 'claude' && guardado !== 'medgemma') {
     localStorage.setItem(BACKEND_KEY, 'medgemma');
   }
 
+  const contenedor = document.getElementById('ia-backend-config') as HTMLElement | null;
   const radioLocal = document.getElementById('ia-backend-local') as HTMLInputElement | null;
   const radioHF = document.getElementById('ia-backend-hf') as HTMLInputElement | null;
   const camposOllama = document.getElementById('ia-ollama-fields') as HTMLElement | null;
+  const selector = document.getElementById('ia-modelo-local') as HTMLSelectElement | null;
+
+  try {
+    const res = await fetch('/api/modelos', { credentials: 'same-origin' });
+    if (res.ok) modelosLocales = (await res.json()).locales ?? [];
+  } catch {
+    modelosLocales = [];  // sin lista, el selector no aparece y todo sigue como antes
+  }
+
+  if (!modelosLocales.length) return;
+  if (contenedor) contenedor.hidden = false;
+
+  if (selector) {
+    const previo = localStorage.getItem(MODELO_LOCAL_KEY);
+    selector.replaceChildren(
+      ...modelosLocales.map((m) => {
+        const opcion = document.createElement('option');
+        opcion.value = m;
+        opcion.textContent = m;
+        opcion.selected = m === previo;
+        return opcion;
+      }),
+    );
+    selector.addEventListener('change', () => {
+      localStorage.setItem(MODELO_LOCAL_KEY, selector.value);
+    });
+  }
 
   const aplicar = () => {
     if (camposOllama) camposOllama.hidden = !(radioLocal?.checked);
@@ -166,6 +209,7 @@ export async function llamarIA(
     signos_clinicos: signos,
     imagenes: getImagenes().slice(0, 4),
     backend,
+    modelo_local: modeloLocalSeleccionado(),
   };
 
   try {

frontend/src/main.ts

@@ -169,7 +169,7 @@ elId<HTMLSelectElement>('pt-edad-unidad').addEventListener('change', evaluar);
 elId<HTMLSelectElement>('pt-sexo').addEventListener('change', evaluar);
 
 inicializarSincMob(evaluar);
-inicializarConfigBackend();
+void inicializarConfigBackend();  // pide la lista de modelos al servidor; no bloquea el arranque
 inicializarParserPdf(evaluar);
 inicializarImportLab(evaluar);
 inicializarModalPapers();

index.html

@@ -1030,13 +1030,16 @@
             <div class="seccion-resultado">
                 <h3 class="titulo-seccion-resultado">Interpretación IA</h3>
                 <div id="salida-ia">Envía todas las analíticas y citologías al modelo medGemma para obtener una evaluación integrada...</div>
-                <div class="ia-backend-config">
+                <!-- Selector de entorno. Se muestra sólo si el servidor declara modelos locales
+                     en MORPHOS_MODELOS_LOCALES; si no, lo oculta ia.ts. La URL de Ollama NO se
+                     configura aquí a propósito: la fija el servidor (aceptar una del cliente
+                     convertiría /api/interpret en un SSRF). -->
+                <div class="ia-backend-config" id="ia-backend-config" hidden>
                     <span class="ia-backend-label">Entorno IA</span>
-                    <label class="ia-backend-opt"><input type="radio" name="ia-backend" value="hf" id="ia-backend-hf" checked>HugginFace</label>
+                    <label class="ia-backend-opt"><input type="radio" name="ia-backend" value="hf" id="ia-backend-hf" checked>Alojado</label>
                     <label class="ia-backend-opt"><input type="radio" name="ia-backend" value="local" id="ia-backend-local">Local</label>
                     <div class="ia-ollama-fields" id="ia-ollama-fields">
-                        <input type="url" id="ia-ollama-url" class="ia-text-input" placeholder="http://localhost:11434" value="http://localhost:11434" aria-label="URL de Ollama">
-                        <input type="text" id="ia-ollama-model" class="ia-text-input ia-model-input" placeholder="medgemma1.5:latest" value="medgemma1.5:latest" aria-label="Modelo Ollama">
+                        <select id="ia-modelo-local" class="ia-text-input" aria-label="Modelo local"></select>
                     </div>
                 </div>
             </div>