Asistente de IA privado para pymes en GB10: mesures

#Qué contiene la pila: tres programas, 68 GB

Un asistente privado se compone de tres bloques, que instalamos en contenedores Docker en una AI TOP ATOM (referencia ATAGB10-9000, DGX OS 7.5.0). Los modelos se ejecutan con llama.cpp, build 11430.

Open WebUI 0.11.4

La interfaz web: cuentas, importación de archivos, bases de conocimiento y conversación. También es la que divide los documentos en fragmentos, de 1000 caracteres con 100 de solapamiento por defecto, y la que conserva los 5 fragmentos más cercanos a cada pregunta.

gpt-oss 120B (MXFP4)

El modelo que redacta la respuesta, servido por llama-server (el servidor incluido con llama.cpp). MXFP4 es su formato original, ya comprimido. Está configurado para 10 solicitudes en paralelo. Es un modelo MoE (mezcla de expertos): en cada token, solo usa 5,1 de sus 117 mil millones de parámetros.

bge-m3 (Q8_0)

El modelo de embeddings, usado aquí en versión Q8_0 (compresión a 8 bits). Transforma cada fragmento en una secuencia de números que representa su significado, lo que permite comparar una pregunta con los fragmentos. Es multilingüe, por lo que sirve para el francés.

El arranque completo, con la caché de disco vaciada, tardó 66 segundos hasta tener una interfaz lista. La pila ocupa 68,0 GB de memoria: el proceso gpt-oss 120B ocupa 63,6 GB en la GPU y bge-m3, 0,8 GB; el resto corresponde a Open WebUI y al sistema.

Tras el arranque, quedan 48,6 GB disponibles en la máquina. Las memorias de esta guía están en GB, tal como las muestra Linux: 1 GB = 1 024 MB. Nuestra primera guía de la serie detalla la velocidad de gpt-oss 120B: 58 tokens por segundo.

#La empresa ficticia y las 100 preguntas

Lustrelle es una pyme ficticia que inventamos: un taller, un almacén, un servicio posventa y unas oficinas. Sus 60 documentos son archivos de texto en formato Markdown (un texto sencillo con algunos signos para los títulos y las listas). Tratan sobre recursos humanos, la seguridad del taller, las copias de seguridad, las notas de gastos, las devoluciones de clientes o el plan de formación. Contienen cifras, nombres y condiciones precisos, para que cada respuesta pueda verificarse.

Para alcanzar volúmenes realistas, añadimos fichas públicas de Service-Public, tal como prevé nuestro protocolo. Así se obtienen tres bases de tamaño creciente. Los detalles metodológicos de esta guía se fijan en una adenda a nuestro protocolo, fechada el 7 de octubre de 2026, antes de la primera respuesta del asistente. El protocolo quedó fijado antes de la primera medición; el método, la lista fechada de adendas y los datos de nuestras tablas están publicados en nuestra página de metodología.

Las 100 preguntas se hacen tal cual, sin reformular. 80 de ellas tienen su respuesta en los documentos: 50 preguntas de datos, 10 de procedimiento, 10 de cifras y 10 de síntesis. 20 no tienen ninguna respuesta en los documentos: sirven para comprobar que el asistente lo admite en lugar de inventar.

Fait

¿Cuántos miembros del equipo de primera intervención contra incendios tenemos? Respuesta esperada: diez, designados entre los empleados.

Chiffre

¿Cuánto cuesta, IVA incluido, la lámpara colgante Brindille de 60 cm en roble ahumado? Respuesta esperada: 360 € IVA incluido (348 € en roble natural, más 12 € por el acabado ahumado).

Sin respuesta en los documentos

¿Lustrelle tiene la certificación ISO 9001? Respuesta esperada: el asistente indica que los documentos no lo mencionan.

#Poner en marcha la pila: los comandos

La pila cabe en tres contenedores y dos redes Docker. La primera red es «interna»: Docker no le da ningún acceso al exterior. Los dos servidores de modelos solo están conectados a ella. Open WebUI está conectado a esta red interna, para comunicarse con los modelos, y a una segunda red, a través de la cual abres la interfaz en tu navegador.

Los comandos de abajo son los de nuestras pruebas del 7 y 8 de octubre de 2026, con rutas simplificadas. llama.cpp (build 11430) se compila en la máquina para el chip GB10; el comando de compilación aparece en el tutorial 70B de esta serie.

docker network create --internal g6-interne     # réseau interne : aucun accès à l'extérieur
docker network create g6-front                 # réseau d'accès pour le navigateur

# 1. gpt-oss 120B : génération, 10 demandes en parallèle, contexte de 131 072 tokens
docker run -d --init --name g6-gen --network g6-interne --network-alias gen --gpus all --ipc=host \
  -e LD_LIBRARY_PATH=/llama -v ~/llama.cpp/build/bin:/llama:ro -v ~/models/gguf:/models:ro \
  nvcr.io/nvidia/pytorch:26.03-py3 \
  /llama/llama-server -m /models/ggml-org/gpt-oss-120b-GGUF/gpt-oss-120b-MXFP4.gguf -ngl 99 -fa on -c 131072 -np 10 \
  --jinja --host 0.0.0.0 --port 8080 -a gpt-oss-120b

# 2. bge-m3 : plongements (embeddings)
docker run -d --init --name g6-emb --network g6-interne --network-alias emb --gpus all --ipc=host \
  -e LD_LIBRARY_PATH=/llama -v ~/llama.cpp/build/bin:/llama:ro -v ~/models/gguf:/models:ro \
  nvcr.io/nvidia/pytorch:26.03-py3 \
  /llama/llama-server -m /models/ggml-org/bge-m3-Q8_0-GGUF/bge-m3-q8_0.gguf -ngl 99 --embeddings --pooling cls \
  -c 16384 -b 8192 -ub 8192 -np 2 --host 0.0.0.0 --port 8080 -a bge-m3

# 3. Open WebUI : interface, bases de connaissances, RAG
mkdir -p ~/g6/webui-data
[ -f ~/g6/secret ] || openssl rand -hex 32 > ~/g6/secret
docker run -d --name g6-webui --network g6-front -p 127.0.0.1:3100:8080 -v ~/g6/webui-data:/app/backend/data \
  -e ENABLE_OLLAMA_API=false -e OPENAI_API_BASE_URL=http://gen:8080/v1 -e OPENAI_API_KEY=local \
  -e RAG_EMBEDDING_ENGINE=openai -e RAG_EMBEDDING_MODEL=bge-m3 \
  -e RAG_OPENAI_API_BASE_URL=http://emb:8080/v1 -e RAG_OPENAI_API_KEY=local \
  -e RAG_EMBEDDING_BATCH_SIZE=32 -e RAG_TOP_K=5 -e ENABLE_API_KEYS=true -e ENABLE_PERSISTENT_CONFIG=false \
  -e OFFLINE_MODE=true -e HF_HUB_OFFLINE=1 -e ANONYMIZED_TELEMETRY=false -e DO_NOT_TRACK=true -e SCARF_NO_ANALYTICS=true \
  -e WEBUI_SECRET_KEY="$(cat ~/g6/secret)" ghcr.io/open-webui/open-webui:v0.11.4
docker network connect g6-interne g6-webui     # Open WebUI parle aux modèles par le réseau interne

La opción -np 10 abre 10 slots: diez solicitudes pueden avanzar a la vez (la guía de llama.cpp de NVIDIA prevé 4 por defecto). La opción -c 131072 fija el contexto total, que los slots se reparten. RAG_TOP_K en 5 pide cinco fragmentos por pregunta. Las variables OFFLINE_MODE, ANONYMIZED_TELEMETRY, DO_NOT_TRACK y SCARF_NO_ANALYTICS desactivan las comprobaciones de actualizaciones, las descargas desde Internet y la telemetría de Open WebUI. La fragmentación sigue siendo la predeterminada de Open WebUI, ajustable desde su interfaz.

1. 01
   Abre Open WebUI

   Ve a http://127.0.0.1:3100 y crea la cuenta de administrador. Elige gpt-oss-120b como modelo.
2. 02
   Crea una base de conocimiento

   Abre la sección Conocimiento, crea una base y añade tus archivos. Open WebUI lee cada archivo, lo divide en fragmentos y calcula sus embeddings.
3. 03
   Consulta la base

   En una conversación, escribe el signo de almohadilla seguido del nombre de la base y luego haz tu pregunta. La respuesta aparece con sus fuentes.

Nuestras mediciones pasan por la API de Open WebUI, lo que permite repetirlas mediante un script. Aquí tienes las mismas llamadas que en nuestro script de medición (escrito en Python), transcritas con curl y jq.

U=http://127.0.0.1:3100
# jeton de connexion du compte de test (adresse et mot de passe à remplacer par les vôtres)
TOKEN=$(curl -s $U/api/v1/auths/signin -H "Content-Type: application/json" \
  -d '{"email":"admin@exemple.test","password":"MOT_DE_PASSE"}' | jq -r .token)

# 1. créer la base de connaissances
KB=$(curl -s $U/api/v1/knowledge/create -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"name":"lustrelle-p500","description":"test"}' | jq -r .id)

# 2. envoyer un fichier, attendre son traitement, l'ajouter à la base
F=$(curl -s -H "Authorization: Bearer $TOKEN" -F "file=@38-evacuation-incendie-exercices.md" "$U/api/v1/files/?process=true" | jq -r .id)
until curl -s -H "Authorization: Bearer $TOKEN" $U/api/v1/files/$F/process/status | jq -e '.status=="completed" or .status=="failed"' >/dev/null; do sleep 1; done   # attend la fin du traitement
curl -s -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d "{\"file_id\":\"$F\"}" $U/api/v1/knowledge/$KB/file/add

# 3. poser une question sur cette base (réponse complète, sans flux)
curl -s $U/api/chat/completions -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d "{\"model\":\"gpt-oss-120b\",\"stream\":false,\"files\":[{\"type\":\"collection\",\"id\":\"$KB\"}],
       \"messages\":[{\"role\":\"user\",\"content\":\"On a combien d'équipiers de première intervention incendie ?\"}]}"

#Indexar 50, 500 y 5 000 páginas

Indexar consiste en leer cada archivo, dividirlo en fragmentos, calcular los embeddings con bge-m3 y guardarlo todo en la base. Nuestro script envía los archivos 4 a la vez y cronometra hasta que se procesa el último archivo. Ningún archivo falló.

5000 páginas quedan listas en poco más de 6 minutos, es decir, unos 1,9 archivos por segundo. Por tanto, reindexar un fondo de 5000 páginas lleva menos de 7 minutos. Durante esta indexación, la GPU consumió 5,4 Wh.

#¿Se encuentra el documento correcto?

Antes de evaluar la calidad de las respuestas, hay que saber si el asistente busca en el lugar correcto. Nuestro indicador automático, «documento correcto recuperado», cuenta las preguntas en las que al menos uno de los documentos esperados figura entre las fuentes devueltas por Open WebUI. Se aplica a las 80 preguntas que tienen respuesta en los documentos. Lo calcula un script; no es una calificación de calidad y no indica si la respuesta es correcta.

Con unas seis veces más archivos (701 frente a 114), el documento correcto se sigue recuperando en el 78 % de los casos. Las 100 respuestas de cada base llegaron sin errores técnicos ni respuestas vacías, cada una con la lista de sus fuentes. Esta lista permite verificar: un clic en el botón de fuentes y se ven los archivos utilizados.

#¿Cuántas personas a la vez?

Simulamos 1, 5 y luego 10 usuarios que consultan la pila al mismo tiempo. Están en un Mac conectado al ATOM mediante un túnel SSH que pasa por Tailscale, una red privada. Cada usuario hace 6 preguntas seguidas, sin pausa entre una y otra, y las respuestas llegan en streaming. Medimos el tiempo hasta la primera palabra y el tiempo de la respuesta completa, en mediana. Cada serie tiene 6, 30 o 60 solicitudes; ninguna falló.

Para una sola persona, la respuesta completa llega en 9,6 s con 500 páginas y en 10,2 s con 5000 páginas. Cuando 5 personas hacen su pregunta al mismo tiempo, la mediana sube a 38 s y 45 s. Con 10 personas, ronda el minuto: 63,5 s y 64,8 s. El tamaño de la base apenas cambia estos tiempos: de 500 a 5000 páginas, la diferencia va de 0,6 a 6,4 segundos.

La primera palabra llega tras la fase de razonamiento de gpt-oss 120B: Open WebUI muestra entonces «Razonando durante 6 segundos» o una duración similar. Esta fase se suma a la lectura de los fragmentos y se reparte entre los usuarios. Nuestra prueba es exigente: cada usuario encadena sus preguntas sin tiempo de lectura, mientras que una persona real lee la respuesta antes de hacer la siguiente.

#Dimensionar para 5 a 20 personas

Con 10 usuarios activos de forma continua, la pila completa 60 respuestas en 441 segundos sobre la base de 500 páginas: unas 8 respuestas por minuto. Este es un cálculo a partir de esa medición. Un equipo de 20 personas, en el que cada una hace de media una pregunta cada 5 minutos, genera 4 preguntas por minuto, es decir, la mitad de ese rendimiento. Es un orden de magnitud y no una medición: tu uso real puede variar.

Hasta 5 personas

Una respuesta en 10 s cuando consulta una persona; unos 40 s cuando las 5 consultan en el mismo segundo.

De 5 a 10 personas

Alrededor de un minuto para obtener una respuesta completa cuando los 10 consultan de forma continua, sin ningún error. El servidor está configurado para 10 solicitudes en paralelo.

De 10 a 20 personas

No hemos medido más de 10 usuarios simultáneos. El cálculo anterior sugiere que 20 personas con un uso habitual se mantienen por debajo del rendimiento medido.

#Confidencialidad: lo que hemos verificado

Un asistente privado solo tiene sentido si los documentos se quedan en tus instalaciones. Por eso verificamos el tráfico de red. Durante las 200 respuestas, 100 en cada base, capturamos con tcpdump los paquetes de las dos redes Docker de la pila y luego listamos todas las direcciones encontradas.

Resultado: ningún contenedor de la pila envió paquetes a una dirección externa. Las únicas direcciones encontradas son las de los contenedores y la de la puerta de enlace de la máquina anfitriona, además de direcciones de multidifusión y de difusión local (mensajes de descubrimiento de la red local). Open WebUI está conectado a una red de acceso y, aun así, no aparece ninguna dirección externa. Los dos servidores de modelos, por su parte, están en una red que Docker aísla del exterior.

#Energía: 0,15 Wh por respuesta

Registramos la potencia de la GPU una vez por segundo durante las 100 respuestas de cada base, 4 preguntas a la vez. Con 500 páginas, la GPU trabajó 18,0 minutos a 50,5 W de media, con un pico de 68,1 W: 15,2 Wh, es decir, 0,15 Wh por respuesta. Con 5 000 páginas, 50,7 W y 15,4 Wh: el mismo resultado, 0,15 Wh por respuesta.

Con la tarifa EDF Tarif Bleu Base (20,01 céntimos por kWh con impuestos incluidos, tarifas vigentes a 1 de agosto de 2026, sin contar la suscripción), 1000 respuestas suponen 0,15 kWh, es decir, 3 céntimos. Estas cifras solo cuentan la GPU, tal como la reporta el chip: según NVIDIA, la potencia que muestra nvidia-smi es la de la GPU sola. No se incluyen el procesador, la memoria, el SSD ni la fuente de alimentación. Otra guía de la serie detalla el consumo a lo largo del tiempo.

#La calidad de las respuestas, evaluadas una por una

Un indicador automático no dice si una respuesta es correcta. Por eso, las 100 respuestas obtenidas con la base de 500 páginas se evaluaron una por una. A petición del autor, esta evaluación la hizo Claude, el modelo de IA de Anthropic, y no el modelo que responde (gpt-oss 120B).

Para cada pregunta, Claude disponía de la respuesta esperada, del documento fuente y de la rúbrica que aparece a continuación. La nota va de 0 a 2 y evalúa el fondo (cifras, fechas, nombres, condiciones), no la redacción. La ausencia de una fuente no cambia la nota; en caso de duda, se aplica la nota más baja.

Las preguntas de síntesis exigen cruzar varios documentos y quedarse con la norma más reciente. El asistente las responde de forma correcta y completa 9 de cada 10 veces. La mayoría de las respuestas incorrectas se deben a la búsqueda del documento, no a la redacción.

Cuando un documento esperado figura entre las fuentes (69 preguntas de 80), 57 respuestas son correctas y completas, y la puntuación alcanza el 88 %. Cuando falta (11 preguntas), la respuesta suele ser incorrecta. Esta búsqueda depende de la configuración de Open WebUI (fragmentación de los documentos, número de fragmentos), que no hicimos variar: es la primera palanca que debes ajustar en tu instalación.

De las 20 preguntas cuya respuesta no está en los documentos, el asistente lo indica claramente 12 veces. En 5 casos, añade información que no procede de ellos: una estimación numérica, una confusión entre dos conceptos o un número mal atribuido. Abrir las fuentes que se muestran bajo la respuesta permite detectar estos casos.

Cada calificación se publica con su justificación, la pregunta y la respuesta esperada, en un archivo CSV de nuestra página de datos. Las 100 respuestas sobre la base de 5 000 páginas no están calificadas: solo se les aplica el indicador «documento correcto recuperado».

#Para quién es ATOM la opción adecuada

Una pyme de 5 a 20 personas que quiere un asistente para sus documentos

Todo cabe en una sola máquina: 68 GB de memoria, 66 segundos de arranque, 5 000 páginas indexadas en 6 minutos y una respuesta en 10 segundos cuando consulta una sola persona.

Un despacho o un departamento que maneja documentos sensibles

Durante nuestras 200 respuestas, ningún paquete salió hacia el exterior. En nuestra configuración, los documentos permanecen en la máquina.

Un equipo que quiere compartir un asistente

10 usuarios activos de forma continua recibieron todos su respuesta, en aproximadamente un minuto, sin ningún error.

Un integrador o un departamento de TI

La pila se basa en componentes abiertos: Docker, Open WebUI, llama.cpp y modelos de pesos abiertos; solo el controlador, CUDA y los contenedores de NVIDIA son propietarios. Open WebUI también ofrece una API a la que tu software puede llamar.

Separemos la plataforma del fabricante. El chip NVIDIA GB10 hace posibles estos resultados: sus 128 GB de memoria unificada alojan un modelo de 117 mil millones de parámetros (gpt-oss 120B) con su contexto y un modelo de embeddings, y su ancho de banda anunciado es de 273 GB/s.

GIGABYTE aporta su propio chasis de un litro (1,2 kg) y su refrigeración con dos ventiladores: durante las 100 respuestas sobre 5 000 páginas, la GPU se mantuvo a 66 °C de media y 72 °C como máximo, sin ningún throttling registrado.

Precios consultados el 8 de octubre de 2026 para la ATAGB10-9001 (128 GB, SSD de 4 TB en PCIe 4.0): 6346,27 € con impuestos incluidos en la tienda oficial de AORUS, donde estaba agotada; estaba disponible en Amazon.fr. Medimos la referencia ATAGB10-9000, cuyo SSD es PCIe 5.0. Los precios de las GB10 cambian cada semana: compruébalos antes de comprar.

#Lo que no hemos medido

Una calificación humana

Las respuestas las calificó Claude, un modelo de IA, y no una persona. La base de 5 000 páginas no está calificada. Cada calificación se publica con su justificación para que pueda verificarse.

Documentos reales

Nuestro corpus es ficticio, está redactado en francés y en formatos Markdown y texto. Los PDF, los documentos de Word, los escaneos y las tablas no se han medido.

Más de 10 usuarios

El servidor está configurado para 10 solicitudes en paralelo. No hemos medido más allá, ni con cuentas distintas: se utilizó una sola cuenta de prueba.

Otras configuraciones

No hicimos variar la fragmentación (configuración predeterminada de Open WebUI) ni el número de fragmentos (fijado en 5). Otras configuraciones pueden modificar la tasa de recuperación del documento correcto.

Energía

Se refiere solo a la GPU.

Actualizaciones y correcciones: calificación de las respuestas añadida el 8 de octubre de 2026; cada corrección estará fechada.

#FAQ