Instalar Whisper y Piper en un VPS para voz a texto

Conversión de voz a texto y TTS autohospedada, en resumen

La conversión de voz a texto y TTS (texto a voz) autohospedada es el tipo de IA más económico que puede ejecutar en un servidor propio. La transcripción utiliza Whisper a través del entorno de ejecución faster-whisper. La síntesis utiliza Piper. Ambos funcionan en un VPS con CPU convencional sin necesidad de GPU. El modelo pequeño de Whisper requiere aproximadamente 484 MB de disco, y una voz de Piper es un archivo de menos de 150 MB.

Por eso el audio es el punto de partida ideal. Un generador de imágenes autohospedado y la generación de vídeo autohospedada requieren una GPU para ser utilizables. El audio no.

Esta guía cubre ambas direcciones y la capa que las une. Whisper convierte audio en texto. Piper convierte texto en audio. Un servidor HTTP compatible con OpenAI frente a ambos permite que un cliente existente apunte a su servidor sin cambiar nada más que la URL base.

Todas las versiones mencionadas aquí estaban vigentes en agosto de 2026.

Por qué faster-whisper y no el paquete de referencia Whisper

El paquete whisper de OpenAI ejecuta el modelo en PyTorch. faster-whisper ejecuta los mismos pesos del modelo en CTranslate2, un motor de inferencia escrito específicamente para modelos transformer. Los pesos son idénticos, por lo que la transcripción es la misma. La diferencia radica totalmente en el entorno de ejecución.

CTranslate2 cuantiza los pesos mientras los carga, razón por la cual compute_type="int8" es un argumento y no un paso de conversión independiente. Tampoco tiene dependencia de PyTorch. pip install faster-whisper descarga CTranslate2, un tokenizador y PyAV para la decodificación de audio, por lo que el entorno virtual ocupa cientos de megabytes en lugar de varios gigabytes. En un VPS con un disco de 40 GB, esa diferencia es lo que separa un entorno cómodo de uno limitado.

Aquí están las cifras publicadas por el propio proyecto para el modelo small en CPU. El benchmark transcribe 13 minutos de audio usando 8 hilos en un Intel Core i7-12700K. La columna x_realtime es el resultado de dividir esos 13 minutos entre el tiempo medido: 7.6 significa que una grabación de 13 minutos finalizó en poco más de 1 minuto y 40 segundos.

[
  {
    "label": "openai/whisper, fp32",
    "x_realtime": 1.9,
    "seconds": 418,
    "memory_mb": "2,335"
  },
  {
    "label": "whisper.cpp, fp32",
    "x_realtime": 6.2,
    "seconds": 125,
    "memory_mb": "1,049"
  },
  {
    "label": "faster-whisper, fp32",
    "x_realtime": 5.0,
    "seconds": 157,
    "memory_mb": "2,257"
  },
  {
    "label": "faster-whisper, int8",
    "x_realtime": 7.6,
    "seconds": 102,
    "memory_mb": "1,477"
  },
  {
    "label": "faster-whisper, int8, batch 8",
    "x_realtime": 15.3,
    "seconds": 51,
    "memory_mb": "3,608"
  }
]

Lea la segunda fila con atención. En fp32, whisper.cpp es más rápido que faster-whisper en esta CPU, 6.2x frente a 5.0x, y lo hace utilizando menos de la mitad de la memoria. Es la misma familia ggml que sustenta el lado de llama.cpp de la pila de LLM local. faster-whisper toma la delantera una vez que se activan int8 y el procesamiento por lotes, alcanzando 15.3x, y consume 3,608 MB de RAM para ello. Por lo tanto: elija faster-whisper para la API de Python y el procesamiento por lotes, elija whisper.cpp cuando la RAM sea la restricción que no puede superar.

La primera fila es el punto central de esta sección. El paquete de referencia alcanza 1.9x en tiempo real en la misma máquina, lo que significa que una hora de audio requiere media hora de CPU.

¿Cuánto espacio en disco requieren los pesos del modelo Whisper?

[
  {
    "label": "tiny",
    "weights_mb": 75.5
  },
  {
    "label": "base",
    "weights_mb": 145
  },
  {
    "label": "small",
    "weights_mb": 484
  },
  {
    "label": "medium",
    "weights_mb": "1,530"
  },
  {
    "label": "large-v3",
    "weights_mb": "3,090"
  }
]

Estos son los pesos convertidos para CTranslate2, en formato float16. Tenga en cuenta lo que compute_type="int8" no hace: no reduce el tamaño de la descarga. Los pesos llegan en float16 y CTranslate2 los cuantiza en memoria al momento de la carga, por lo que large-v3 ocupa 3,090 MB en disco, independientemente de si lo ejecuta en float16 o int8. El formato int8 le ahorra RAM y mejora la velocidad, pero no espacio en disco.

Los modelos se descargan durante el primer uso en ~/.cache/huggingface/hub. En un VPS con un volumen raíz pequeño, dirija esta ruta a un lugar con espacio suficiente mediante el argumento download_root o la variable de entorno HF_HOME; de lo contrario, la primera ejecución llenará el disco y el proceso fallará a mitad de la descarga.

Instalar faster-whisper sin alterar el Python del sistema

Ubuntu 24.04 y Debian 13 marcan el Python del sistema como gestionado externamente. Ejecutar pip install faster-whisper fuera de un entorno virtual se detiene inmediatamente con:

error: externally-managed-environment

Esto es el sistema de paquetes protegiendo los archivos que posee apt. Utilice un entorno virtual.

sudo apt update
sudo apt install -y python3-venv ffmpeg
python3 -m venv ~/stt
~/stt/bin/pip install --upgrade pip
~/stt/bin/pip install faster-whisper==1.2.1

La versión 1.2.1 es la versión actual, publicada en octubre de 2025. faster-whisper decodifica audio mediante PyAV, que incluye sus propias bibliotecas ffmpeg, por lo que lee un archivo mp3 o m4a sin necesidad de un binario ffmpeg independiente. El paquete ffmpeg anterior es para el procesamiento de vídeo que se realizará más adelante en esta guía.

Compruebe la instalación antes de descargar tres gigabytes de pesos:

~/stt/bin/python -c "from faster_whisper import WhisperModel; print('ok')"

Una línea que muestra ok significa que los wheels se instalaron correctamente. Un ImportError que menciona ctranslate2 significa que el wheel para su arquitectura no se instaló, lo cual ocurre en imágenes ARM de 32 bits.

Transcribir una grabación de reunión o una nota de voz

Guarde esto como transcribe.py:

from faster_whisper import WhisperModel

model = WhisperModel("small", device="cpu", compute_type="int8", cpu_threads=4)
segments, info = model.transcribe("meeting.m4a", beam_size=5, vad_filter=True)

print("language: %s (%.2f)" % (info.language, info.language_probability))
for segment in segments:
    print("[%.2fs -> %.2fs] %s" % (segment.start, segment.end, segment.text))

Ejecútelo con ~/stt/bin/python transcribe.py. La primera ejecución descarga los pesos, por lo que no se imprime nada durante un tiempo. Después de eso, el modelo se carga desde la caché en unos pocos segundos.

segments es un generador, por lo que la transcripción no comienza hasta que itera sobre él. La gente mide el tiempo de la llamada transcribe(), ve que devuelve el resultado al instante y piensa que algo está roto. No hay nada roto. El trabajo ocurre en el bucle.

vad_filter=True ejecuta primero Silero VAD (detección de actividad de voz) y descarta los tramos de silencio antes de que Whisper los procese. En una grabación de reunión con pausas largas, esta es la mayor mejora de velocidad disponible, ya que Whisper no pierde tiempo en audio que no contiene voz. También suprime los bucles de frases repetidas que Whisper produce cuando se le suministra silencio e intenta encontrar palabras en él.

Establezca cpu_threads en el número de núcleos que realmente tiene. Configurarlo por encima de su número de vCPU hace que la transcripción sea más lenta, porque los hilos adicionales compiten por el mismo núcleo y el planificador paga el coste de cada cambio de contexto.

Subtítulos para una biblioteca de Jellyfin

Jellyfin lee archivos de subtítulos externos que se encuentran junto al vídeo y comparten su nombre, por lo que Movie (2019).en.srt junto a Movie (2019).mkv aparece como una pista en inglés sin transcodificación y sin necesidad de reconstruir la biblioteca.

Extraiga primero el audio. Whisper remuestrea todo internamente a 16 kHz mono, por lo que suministrarle 16 kHz mono reduce la carga de trabajo en ambos extremos:

ffmpeg -i "Movie (2019).mkv" -vn -ac 1 -ar 16000 -c:a pcm_s16le "Movie (2019).wav"

faster-whisper no incluye un generador de SRT, por lo que debe formatear los segmentos usted mismo. Guarde esto como srt.py:

import sys
from faster_whisper import WhisperModel

def ts(seconds):
    ms = int(round(seconds * 1000))
    hours, ms = divmod(ms, 3600000)
    minutes, ms = divmod(ms, 60000)
    secs, ms = divmod(ms, 1000)
    return "%02d:%02d:%02d,%03d" % (hours, minutes, secs, ms)

model = WhisperModel("small", device="cpu", compute_type="int8")
segments, info = model.transcribe(sys.argv[1], vad_filter=True)

with open(sys.argv[2], "w", encoding="utf-8") as out:
    for index, segment in enumerate(segments, start=1):
        out.write("%d\n" % index)
        out.write("%s --> %s\n" % (ts(segment.start), ts(segment.end)))
        out.write("%s\n\n" % segment.text.strip())

A continuación, recorra la biblioteca:

for f in /srv/media/films/*.mkv; do
  ffmpeg -nostdin -y -i "$f" -vn -ac 1 -ar 16000 -c:a pcm_s16le "${f%.mkv}.wav"
  nice -n 15 ~/stt/bin/python srt.py "${f%.mkv}.wav" "${f%.mkv}.en.srt"
  rm -f "${f%.mkv}.wav"
done

-nostdin no es un adorno. Sin él, ffmpeg lee desde la entrada estándar del bucle, consume el resto de la lista de archivos y el bucle se detiene tras la primera película sin mostrar ningún mensaje de error.

Calcule el tiempo necesario antes de empezar. Con la cifra de 7.6x en tiempo real indicada arriba, una película de 100 minutos requiere aproximadamente 13 minutos de CPU, por lo que una biblioteca de cincuenta películas es una tarea para toda la noche. En un plan de vCPU compartida es más lento, que es para lo que sirve nice: la generación de subtítulos cede entonces los recursos a cualquier otra tarea que el servidor esté realizando.

Conversión de texto a voz con Piper

Piper es un motor neuronal de conversión de texto a voz que ejecuta un modelo de voz ONNX en la CPU. Integra espeak-ng para convertir texto en fonemas, por lo que no es necesario instalar un fonemizador por separado. La versión actual es la 1.6.0, publicada en julio de 2026.

python3 -m venv ~/tts
~/tts/bin/pip install piper-tts==1.6.0
~/tts/bin/python -m piper.download_voices en_US-lessac-medium
~/tts/bin/python -m piper -m en_US-lessac-medium -f test.wav -- 'This is a test.'

download_voices escribe dos archivos en el directorio de trabajo: los pesos .onnx y un archivo de configuración .onnx.json que contiene la frecuencia de muestreo y la lista de hablantes. Deben permanecer juntos. Si almacena las voces en una ubicación fija, pase --data-dir a ambos comandos, ya que de lo contrario el reproductor buscará en el directorio de trabajo y no encontrará la voz si no está allí.

El -- antes del texto también es importante. Sin él, cualquier oración que comience con un guion se interpreta como una opción de línea de comandos.

Las voces se distribuyen en varios niveles de calidad. Una voz en inglés de calidad media ocupa aproximadamente 60 MB y una de alta calidad aproximadamente el doble. Una mayor calidad implica un modelo más grande y un mayor consumo de CPU por segundo de voz, no un hablante diferente.

No llame a la CLI en un bucle. Carga el modelo en cada invocación, y la carga del modelo domina el coste de una oración corta. Ejecute el servidor HTTP en su lugar:

~/tts/bin/pip install 'piper-tts[http]==1.6.0'
~/tts/bin/python -m piper.http_server -m en_US-lessac-medium --host 127.0.0.1 --port 5000

curl -X POST -H 'Content-Type: application/json' \
  -d '{ "text": "This is a test." }' \
  -o test.wav localhost:5000/synthesize

Un test.wav que pueda reproducir significa que funciona. Ese endpoint tiene el formato propio de Piper, no el de OpenAI, por lo que un cliente que espere /v1/audio/speech no podrá comunicarse con él. La siguiente sección soluciona esto.

Manténgalo en ejecución con un archivo de unidad en lugar de una terminal que cerrará:

[Unit]
Description=Piper text to speech HTTP server
After=network-online.target

[Service]
User=piper
ExecStart=/home/piper/tts/bin/python -m piper.http_server -m en_US-lessac-medium --data-dir /home/piper/voices --host 127.0.0.1 --port 5000
Restart=on-failure

[Install]
WantedBy=multi-user.target

sudo systemctl enable --now piper lo inicia y lo restaura tras un reinicio. Si el comando curl anterior no devuelve nada, journalctl -u piper -n 50 contiene el motivo, siendo la falta de un archivo de voz la causa habitual.

La estructura del servidor compatible con OpenAI

La mayoría del software que procesa audio ya utiliza la API de audio de OpenAI: un POST multipart a /v1/audio/transcriptions para un archivo, y un POST JSON a /v1/audio/speech para una frase. Si usted sirve esas dos rutas, el cliente solo requiere un cambio: su URL base.

Speaches es un servidor que gestiona ambas direcciones. Ejecuta faster-whisper para transcripción y Piper o Kokoro para voz, bajo las rutas de OpenAI. La versión actual es v0.9.0-rc.3 de diciembre de 2025; al ser anterior a 1.0, fije la etiqueta de su imagen y lea las notas de la versión antes de actualizar.

curl --silent --remote-name https://raw.githubusercontent.com/speaches-ai/speaches/master/compose.yaml
curl --silent --remote-name https://raw.githubusercontent.com/speaches-ai/speaches/master/compose.cpu.yaml
export COMPOSE_FILE=compose.cpu.yaml
docker compose up --detach

El formato de contenedor único, si prefiere no mantener archivos compose:

docker run --rm --detach --publish 8000:8000 --name speaches \
  --volume hf-hub-cache:/home/ubuntu/.cache/huggingface/hub \
  ghcr.io/speaches-ai/speaches:latest-cpu

El volumen con nombre es el componente que los usuarios suelen olvidar. Sin él, la caché del modelo reside dentro del contenedor, por lo que cada reinicio descarga gigabytes de pesos antes de responder a la primera solicitud.

Speech necesita una voz descargada antes de que /v1/audio/speech pueda responder:

uvx speaches-cli model download speaches-ai/Kokoro-82M-v1.0-ONNX

Después de eso, cualquier cliente de OpenAI funciona cambiando la URL base:

from pathlib import Path
from openai import OpenAI

openai = OpenAI(base_url="http://localhost:8000/v1", api_key="cant-be-empty")
res = openai.audio.speech.create(
    model="speaches-ai/Kokoro-82M-v1.0-ONNX",
    voice="af_heart",
    input="Hello, world!",
    response_format="mp3",
    speed=1,
)
with Path("output.mp3").open("wb") as f:
    f.write(res.response.read())

El marcador de posición api_key es obligatorio porque la biblioteca cliente de OpenAI rechaza enviar una solicitud sin uno. El servidor ignora su valor hasta que usted configure una clave real.

vox-box es el otro proyecto que merece mención aquí. Es un paquete de Python en lugar de un contenedor, y sirve las mismas rutas utilizando Whisper, FunASR, Bark, Dia o CosyVoice. La versión 0.0.21 es la actual, de diciembre de 2025, y requiere Python 3.10 o superior.

python3 -m venv ~/voice
~/voice/bin/pip install vox-box==0.0.21
~/voice/bin/vox-box start --huggingface-repo-id Systran/faster-whisper-small \
  --data-dir ~/voice/data --host 127.0.0.1 --port 8010

El ejemplo del proyecto utiliza el puerto 80, lo cual requiere root. Un puerto alto detrás de un reverse proxy es la mejor configuración en un servidor que realice otras tareas. vox-box start admite un modelo, por lo que cubrir ambas direcciones implica una segunda instancia en un segundo puerto con un ID de repositorio de voz.

Pregunte al servidor qué cargó y luego use ese ID en el campo model:

curl http://127.0.0.1:8010/v1/models

curl http://127.0.0.1:8010/v1/audio/transcriptions \
  -H "Content-Type: multipart/form-data" \
  -F file="@voice-note.m4a" \
  -F model="faster-whisper-small"

Un cuerpo JSON con el formato {"text": "..."} significa que toda la ruta funciona. Un error 404 en el nombre del modelo significa que usted adivinó en lugar de leer la salida de /v1/models.

Ninguno de estos servidores activa la autenticación de forma predeterminada. Enlácelos a 127.0.0.1 y acceda a ellos a través de una VPN o un reverse proxy que solicite credenciales. Un /v1/audio/transcriptions abierto en una IP pública es CPU gratuita para quien lo encuentre, y lo encontrarán.

Un front-end de voz para un asistente autohospedado

Una vez que ambas direcciones responden en las rutas de OpenAI, un front-end de chat puede gestionarlas. Open WebUI y sus alternativas aceptan una URL base compatible con OpenAI para audio en sus ajustes, por lo que un solo equipo puede ejecutar un LLM local con Ollama y cerrar el bucle de voz en ambos extremos.

Calcule la latencia de forma realista, ya que esos tres pasos se ejecutan uno tras otro en los mismos núcleos. Una pregunta de 10 segundos tarda aproximadamente 1.3 segundos en transcribirse según la cifra de 7.6x anterior, y eso es antes de que el modelo haya leído un solo token. Añada la generación de tokens por CPU y el tiempo de ida y vuelta es lo suficientemente lento como para que los usuarios crean que se ha bloqueado. La transcripción por lotes es cómoda en CPU. La conversación no lo es, y ese es el punto donde un VPS con GPU empieza a justificar su coste.

¿Cuándo merece realmente la pena la GPU?

[
  {
    "label": "openai/whisper, fp16",
    "x_realtime": 5.5,
    "seconds": 143,
    "memory_mb": "4,708"
  },
  {
    "label": "faster-whisper, fp16",
    "x_realtime": 12.4,
    "seconds": 63,
    "memory_mb": "4,525"
  },
  {
    "label": "faster-whisper, int8",
    "x_realtime": 13.2,
    "seconds": 59,
    "memory_mb": "2,926"
  },
  {
    "label": "faster-whisper, int8, batch 8",
    "x_realtime": 48.8,
    "seconds": 16,
    "memory_mb": "4,500"
  }
]

En la GPU, el modelo grande en int8 se ejecuta a 13.2x tiempo real dentro de 2,926 MB de VRAM, y el procesamiento por lotes lo lleva a 48.8x. Observe con atención lo que no dicen las dos tablas. Ejecutan modelos distintos: las filas de GPU son large-v2, las filas de CPU son small. Una GPU no hace que el modelo small sea seis veces más rápido. Hace que el modelo preciso sea utilizable.

Un plan de vCPU compartido no alcanzará las cifras de la CPU. Ese benchmark disponía de 8 hilos de un procesador de escritorio rápido para sí mismo. Considere 7.6x como un límite máximo, luego mida su propio equipo con time en una grabación real antes de planificar nada en torno a ello.

Cuatro reglas generales que se mantienen en la práctica:

• Transcripción ocasional de sus propias grabaciones: CPU, small, int8. Dos vCPU dedicadas son suficientes.
• Trabajo por lotes nocturno, como la generación de subtítulos: CPU, small o medium, int8, envuelto en nice.
• Cualquier tarea interactiva, o una biblioteca completa en una sola tarde: GPU.
• Piper: CPU, siempre. Un modelo de voz de este tamaño casi no obtiene beneficios de una GPU.

Si está calculando qué más podría soportar el mismo hardware, la cuestión más amplia de qué modelos de IA puede autohospedar cubre los tamaños que caben y los que no.

Modos de fallo y mensajes asociados

error: externally-managed-environment durante la instalación. El Python del sistema está protegido por la distribución. Cree un entorno virtual como se muestra arriba.

Desajuste de cuDNN en un equipo con GPU. El fallo se muestra así:

Unable to load any of {libcudnn_ops.so.9.1.0, libcudnn_ops.so.9.1, libcudnn_ops.so.9, libcudnn_ops.so}
Invalid handle. Cannot load symbol cudnnCreateTensorDescriptor

CTranslate2 4.5.0 y versiones posteriores requieren cuDNN 9 para CUDA 12, pero el host tiene cuDNN 8. Instale cuDNN 9 o fije el tiempo de ejecución anterior con pip install --force-reinstall ctranslate2==4.4.0. Elija una de las dos opciones. Hacer ambas le dejará en la misma situación inicial.

This CTranslate2 package was not compiled with CUDA support es un error distinto con síntomas similares. El paquete instalado es la versión exclusiva para CPU. Reconstruya el entorno virtual en el host con GPU y permita que pip seleccione el paquete correcto de nuevo.

Frases repetidas en la transcripción. Una oración que se repite diez veces casi siempre indica que el silencio o la música se están interpretando como voz. Active primero vad_filter=True. Si el problema persiste, escuche el segmento: el audio casi silencioso no ofrece a Whisper ninguna referencia y este repite su última predicción con confianza.

Idioma detectado incorrectamente. Whisper realiza la predicción basándose únicamente en los primeros 30 segundos. Un valor de info.language_probability muy inferior a 1.0 indica incertidumbre, lo cual ocurre cuando una grabación comienza con música o conversaciones cruzadas. Utilice language="en" cuando ya conozca el idioma.

El proceso imprime Killed y se detiene. Se trata del gestor de memoria del kernel (OOM killer) y dmesg mostrará la línea de cierre por falta de memoria correspondiente. El modelo large-v3 requiere más de 3 GB solo para los pesos, antes de considerar la memoria de trabajo. En un VPS de 2 GB, el modelo small en formato int8 es el más grande que puede ejecutarse.

Piper no encuentra la voz. El reproductor busca en el directorio de trabajo a menos que utilice --data-dir. Ejecute ls en el directorio esperado y confirme que tanto .onnx como .onnx.json están presentes, ya que la ausencia de uno de ellos provoca un fallo igual que si faltaran ambos.

FAQ

¿Puedo ejecutar conversión de voz a texto en un VPS sin GPU?

Sí, y para procesamiento por lotes es la opción más sensata. Usando faster-whisper con el modelo small en int8, el benchmark publicado del proyecto transcribe 13 minutos de audio en 102 segundos utilizando 8 hilos de un i7 de escritorio, aproximadamente 7.6x el tiempo real, con 1,477 MB de RAM. Un plan con vCPU compartida funcionará más lento, así que mida el rendimiento en su propio servidor. La conversión de texto a voz con Piper es aún más sencilla y no requiere GPU bajo ninguna circunstancia.

¿Qué tamaño de modelo de Whisper debo usar?

Empiece con small en int8. Ocupa 484 MB en disco y maneja bien el habla grabada con claridad. Pase a medium cuando los acentos o el ruido de fondo causen errores inaceptables, y a large-v3 solo cuando la precisión sea lo más importante, ya que requiere 3,090 MB de disco y más de 3 GB de memoria. En el otro extremo, tiny con 75.5 MB es útil para detección de idioma y para probar un flujo de trabajo, no para transcripciones que una persona vaya a leer.

¿Por qué faster-whisper es más rápido que el paquete original de Whisper?

El modelo es el mismo. El motor de ejecución no. El paquete de referencia ejecuta Whisper en PyTorch, mientras que faster-whisper ejecuta los mismos pesos sobre CTranslate2, un motor diseñado para inferencia de transformadores que cuantiza los pesos al cargar y no requiere instalar PyTorch. En el benchmark de CPU publicado, el paquete de referencia alcanza 1.9x el tiempo real frente a 7.6x de faster-whisper en int8, consumiendo menos memoria.

¿Por qué mi transcripción repite la misma frase una y otra vez?

Whisper está interpretando silencios o música como voz y recurre a su última predicción con confianza. Configure vad_filter=True en la llamada a transcribe(), la cual ejecuta primero la detección de actividad de voz Silero y elimina los tramos de silencio antes de que el modelo los procese. Si sigue repitiendo, verifique el nivel de audio, ya que una grabación casi silenciosa no ofrece al modelo información con la que trabajar.

¿Cómo obtengo un endpoint de audio compatible con OpenAI en mi propio servidor?

Ejecute un servidor que implemente POST /v1/audio/transcriptions y POST /v1/audio/speech, y luego apunte el cliente hacia él mediante una nueva URL base. Speaches es una opción, publicada como imagen de contenedor con una compilación para CPU, que utiliza faster-whisper para transcripción y Piper o Kokoro para voz. vox-box es otra, instalada con pip install vox-box e iniciada con vox-box start --huggingface-repo-id, la cual sirve un modelo por proceso. Ninguna habilita autenticación por defecto, así que vincúlelas a localhost y coloque un proxy o una VPN delante.