# IA híbrida: los datos personales en local, el resto puede salir

> Monta una pasarela FastAPI que detecta DNI, IBAN o email y los envía a un modelo local; solo lo público sale fuera. Medido en una DGX Spark GB10, 2-11-2026.

- Publicado: 2026-11-02
- Autor: Jacobo González Jaspe
- Idioma: es
- Etiquetas: despliegue, privacidad, rgpd, ollama, fastapi
- URL canónica: https://vorluxai.com/blog/hybrid-ai-routing-pii-stays-local-es/
- Fuente: VORLUX AI (J4SGON S.L.), https://vorluxai.com/

---

Al terminar tendrás una pasarela HTTP delante de todas tus llamadas de IA. Cada petición pasa por un detector de datos personales y por una cabecera de sensibilidad; lo que lleva un DNI, un IBAN o un correo va siempre a un modelo en tu máquina, y solo el trabajo declarado público puede salir por una segunda vía. El modelo local ocupa unos 9 GB, así que un portátil de 16 GB con Docker y Ollama debería bastar; nosotros lo medimos en una DGX Spark.

> **En corto**
> - **Te llevas:** una pasarela de 220 líneas de Python (FastAPI) con detector de PII, dos vías y registro redactado, más un `docker-compose.yml` y un manifiesto de K3s validado.
> - **Cuesta:** solo tiempo. Todo es código abierto y no hace falta ninguna clave de API para seguir la guía.
> - **Veredicto:** **Hazlo** si hoy mandas texto con datos de clientes a una API externa "porque es lo que había". Si todo lo que procesas es público, sáltatelo: un modelo y ya.

## Qué necesitas

- **Un ordenador con 16 GB de RAM.** La vía local usa `llama3.1:8b`, que ocupó 9,2 GB cargado según `ollama ps` en nuestra máquina (Ollama 0.30.10, 1-11-2026). La pasarela en sí no llega a 100 MB.
- **Docker y Docker Compose.** Nosotros: Docker 29.2.1 y Compose v5.0.2.
- **[Ollama](https://ollama.com)** con `llama3.1:8b` descargado (`ollama pull llama3.1:8b`).
- **Un segundo endpoint compatible con la API de OpenAI** para la vía pública. En producción sería tu proveedor externo. En esta guía es un segundo modelo local (`gemma4-32k`, 25,8B en Q4_K_M) en nuestra segunda máquina, que hace de sustituto. No hemos llamado a ninguna API de pago y los números de esa vía son de un modelo local, no de la nube.
- **Tiempo:** unos 30 minutos.

Descarga el código completo: <a href="https://vorluxai.com/downloads/hybrid-routing-gateway-2026-11-01.tar.gz" download>hybrid-routing-gateway-2026-11-01.tar.gz</a> (9 KB: pasarela, detector, compose, manifiesto K3s, conjunto de prueba y script de medición).

## Paso 1: El detector de datos personales

El detector es un módulo de 98 líneas al estilo de [Presidio](https://github.com/microsoft/presidio), pero sin modelo ni red: expresiones regulares más la suma de control de cada formato. Reconoce DNI y NIE (letra de control), IBAN (módulo 97), correo, teléfono español, número de la Seguridad Social (módulo 97) y tarjeta (algoritmo de Luhn). La suma de control es lo que evita que un número de pedido de ocho cifras cuente como DNI.

```python
_DNI_LETTERS = "TRWAGMYFPDXBNJZSQVHLCKE"

def _dni_ok(num: str, letter: str) -> bool:
    return _DNI_LETTERS[int(num) % 23] == letter.upper()
```

Lo que no ve, y conviene decirlo antes de seguir: nombres, diagnósticos, direcciones. "El paciente Juan Pérez tiene diabetes tipo 2" pasa limpio. Para eso existe la cabecera del paso 2, y ese es el motivo por el que Presidio añade reconocedores de entidades por encima de las regex.

## Paso 2: La lógica de rutas

El enrutado es un reglamento, no una decisión de criterio. Tiene tres líneas, en este orden:

```python
def classify(prompt, sensitivity):
    entities = sorted({f.entity for f in detect(prompt)})
    if sensitivity is not None and sensitivity not in {"public"}:
        return "local", f"header sensitivity={sensitivity}", entities
    if entities:
        return "local", "pii detected: " + ",".join(entities), entities
    if sensitivity is None:
        return "local", "no sensitivity header (fail closed)", entities
    return "bulk", "declared public, no pii found", entities
```

Primero la cabecera `X-Sensitivity`: solo `public` puede salir; `internal`, `confidential`, `pii` y `regulated` se quedan. Después el detector: si encuentra algo, se queda aunque la cabecera diga `public`. Y sin cabecera, se queda. Salir es opcional y explícito; quedarse es el valor por defecto.

Las dos vías hablan el mismo formato (`/v1/chat/completions`), así que cambiar el sustituto por un proveedor real es cambiar dos variables de entorno: `BULK_URL` y `BULK_API_KEY`. El registro se redacta antes de escribirse: `prompt='... con DNI <ES_DNI> confirmando ...'`.

## Paso 3: Arranca y comprueba las cinco rutas

```sh
docker compose up -d --build
curl -s localhost:8600/health
```

Salida en nuestra máquina:

```text
Container hybrid-gateway-gateway-1 Started
{"status":"ok","local":"http://127.0.0.1:11434/v1","bulk":"http://bulk-host:11434/v1"}
```

Ahora las cinco peticiones que definen el comportamiento. Las tres primeras:

```sh
# 1. DNI e IBAN en el texto, sin cabecera
curl -s localhost:8600/v1/route -H 'Content-Type: application/json' \
  -d '{"prompt":"Redacta un correo para el cliente con DNI 12345678Z confirmando que su transferencia a ES91 2100 0418 4502 0005 1332 ha llegado.","max_tokens":80}'

# 2. Declarado público, sin datos personales
curl -s localhost:8600/v1/route -H 'Content-Type: application/json' -H 'X-Sensitivity: public' \
  -d '{"prompt":"Escribe tres títulos de blog sobre cómo medir tokens por segundo en un modelo local.","max_tokens":80}'

# 3. Declarado público, pero con un correo dentro
curl -s localhost:8600/v1/route -H 'Content-Type: application/json' -H 'X-Sensitivity: public' \
  -d '{"prompt":"Resume: escríbeme a maria.lopez@example.es cuando esté listo.","max_tokens":40}'
```

Respuestas, recortadas (1-11-2026):

```text
1: "route":"local", "reason":"pii detected: ES_DNI,IBAN", "model":"llama3.1:8b", "upstream_ms":1160.6
2: "route":"bulk",  "reason":"declared public, no pii found", "model":"gemma4-32k:latest", "upstream_ms":871.3
3: "route":"local", "reason":"pii detected: EMAIL", "model":"llama3.1:8b"
```

La cuarta, sin cabecera y sin datos personales (un haiku), devuelve `"reason":"no sensitivity header (fail closed)"` y se queda en local. La quinta, con `X-Sensitivity: whatever`, devuelve HTTP 422: la pasarela solo acepta los cinco valores declarados. Si el paso 1 te devuelve 502, mira `docker compose logs gateway`: casi siempre es que Ollama no está escuchando en `127.0.0.1:11434`.

Sobre n8n: no hemos puesto un webhook delante. La pasarela ya es un endpoint HTTP y un nodo "HTTP Request" de n8n la llama igual que `curl`; un webhook añadiría un salto y nada más.

## Paso 4: Mide en tu máquina

El script `tests/bench.py` del paquete lanza una petición de calentamiento y veinte seguidas por caso, con `temperature 0`, y escribe un JSON con p50, p95 y tokens por segundo:

```sh
python3 tests/bench.py http://127.0.0.1:8600 20 bench.json
python3 tests/eval_pii.py
```

La segunda línea calcula precisión y exhaustividad del detector sobre `tests/pii_testset.jsonl`, 56 frases que etiquetamos a mano (25 con datos personales, 31 sin). Añade las tuyas: cada falso negativo que encuentres es una regla que te falta.

## Paso 5: El manifiesto de K3s, solo validado

El paquete trae `k8s/gateway.yaml`: un Deployment, un Service y dos NetworkPolicy. La primera deja al pod del modelo local hablar solo con el DNS del clúster, sin ninguna otra salida. La segunda limita la pasarela a los dos servicios de modelo y al DNS.

```sh
kubeconform -strict -summary k8s/gateway.yaml
```

```text
Summary: 4 resources found in 1 file - Valid: 4, Invalid: 0, Errors: 0, Skipped: 0
```

Eso es todo lo que podemos afirmar: el YAML es válido según [kubeconform](https://github.com/yannh/kubeconform) v0.8.0. No lo hemos desplegado en un clúster, así que no te decimos que funcione en el tuyo sin probarlo.

## Qué medimos

Pasarela y vía local en nuestra NVIDIA DGX Spark GB10 (`spark-43d5`, Ubuntu 24.04, Ollama 0.30.10), con `llama3.1:8b` Q4_K_M. Vía pública: `gemma4-32k` Q4_K_M en nuestra segunda DGX Spark GB10 (`spark-7180`, Ollama 0.34.0), a través de un enlace directo. Comando: `tests/bench.py`, 1 calentamiento + 20 peticiones por caso, `max_tokens` 120, 2-11-2026. tok/s = tokens de respuesta / tiempo de la llamada al modelo, así que incluye el procesado del prompt: es un suelo, no un pico.

| Caso | Vía | Modelo | p50 (ms) | p95 (ms) | tok/s (mediana) | Tokens de respuesta |
|---|---|---|---|---|---|---|
| DNI, IBAN y teléfono en el prompt (clasificar ticket) | local | llama3.1:8b | 2.219 | 2.249 | 37,4 | 83 |
| Cabecera `confidential` (resumen en tres frases) | local | llama3.1:8b | 3.133 | 3.163 | 38,3 | 120 |
| Cabecera `public` (tres títulos) | pública (sustituto local) | gemma4-32k | 811 | 848 | 66,5 | 54 |

La pasarela añade una mediana de 1,3 a 1,6 ms por petición (tiempo total menos tiempo del modelo). El detector sobre las 56 frases: precisión 0,957 (1 falso positivo), exhaustividad 0,88 (3 falsos negativos), F1 0,917. Todas las ejecuciones, incluidas dos del 1-11-2026, están en [hybrid-routing-gateway-2026-11-02.json](https://vorluxai.com/data/measurements/hybrid-routing-gateway-2026-11-02.json).

## Lo que no te dice la ficha técnica

- **La vía compartida tiene un p95 que no controlas.** La misma vía pública, medida el 1-11-2026 mientras esa máquina servía otros dos trabajos, dio p50 3.861 ms y 14 tok/s, frente a 811 ms y 66,5 tok/s en vacío. Con un proveedor externo pasa lo mismo y no verás por qué.
- **El modelo local tiene sus propias reglas.** `llama3.1:8b` se negó a redactar el correo de la petición 1 ("no puedo generar correos electrónicos que contengan información financiera o de identificación personal"). Clasificar y resumir el mismo ticket lo hizo sin protestar. Elige la tarea, no solo el modelo.
- **El puente de Docker no llegaba al host.** `host.docker.internal:11434` daba `ConnectTimeout` en nuestro Ubuntu: el cortafuegos descarta ese tráfico. El compose usa `network_mode: host` y la pasarela escucha solo en `127.0.0.1:8600` (`ss -tln` lo confirma).
- **Los modelos que piensan devuelven `content` vacío.** `gemma4` en el endpoint `/v1` de Ollama puso 80 tokens en `reasoning` y cero en la respuesta. `"think": false` se ignora ahí; `"reasoning_effort": "none"` funciona en Ollama 0.34 y la pasarela lo envía en la vía pública.
- **Los tres fallos del detector:** un teléfono con espacio entre cada cifra, un DNI con la letra mal (la suma de control lo rechaza, pero sigue siendo el número de una persona) y el nombre con diagnóstico. El falso positivo: una lectura de contador de 12 cifras que pasa el módulo 97 de la Seguridad Social.

## Cuándo no hacerlo

Si todo lo que procesas es público, una pasarela con dos vías es complejidad sin premio: un modelo, local o externo, y ya. Y si el trabajo exige razonamiento largo sobre material público, la vía pública con un modelo grande es la elección correcta; este diseño existe para que puedas usarla sin que los datos personales viajen con ella. Antes de apuntar `BULK_URL` a un proveedor real te hacen falta tres cosas más: un contrato de encargado del tratamiento (RGPD art. 28), la clave en una variable de entorno y la NetworkPolicy aplicada de verdad, no solo validada. Hemos medido en una GB10; un portátil de 16 GB ejecuta la pasarela y `llama3.1:8b`, pero no lo hemos cronometrado ahí.

## Próximos pasos

- Pon números al coste de cada vía: [nube frente a IA local, tu punto de equilibrio](https://vorluxai.com/blog/cloud-vs-local-ai-cost-benchmarks-es/).
- El mismo principio con audio: [actas de reunión privadas con Whisper en tu hardware](https://vorluxai.com/blog/whisper-actas-reunion-privadas-tu-hardware-es/).
- Si la vía local va justa de memoria: [elige el archivo GGUF adecuado para tu máquina](https://vorluxai.com/blog/gguf-quantization-pick-the-right-file-for-your-hardware-es/).

## Trabaja con nosotros

Podemos hacer este análisis con tus datos reales antes de recomendar hardware. Una llamada gratuita de 15 minutos basta para saber si tiene sentido en tu caso: [reserva la llamada](https://vorluxai.com/contact/) o mira [cómo trabajamos en consultoría](https://vorluxai.com/consulting/).
