Crea un asistente de voz completamente offline en 2026: Whisper + LLM + Piper (paso a paso)

Datos rápidos

• Capa STT: whisper.cpp (mejor para Apple Silicon y hardware embebido), faster-whisper (mejor para pipelines Python con GPU NVIDIA).
• Capa LLM: Ollama con Llama 3.1 8B (recomendado), Phi-4 (más ligero, buena calidad) o Mistral 7B (calidad comparable a Llama 3.1 8B).
• Capa TTS: Piper (más rápido, solo CPU, tiempo real en Pi), Coqui TTS (mejor calidad, requiere GPU).
• Opciones de palabra de activación: OpenWakeWord (MIT, completamente offline), Porcupine (nivel gratuito, 1 palabra de activación personalizada).
• Hardware mínimo: Raspberry Pi 5 con 8 GB de RAM (~$100) para una latencia de 5–8 segundos.
• Hardware recomendado: Mac Mini M5 24 GB (~$600) o escritorio con RTX 3060 12 GB (~$800) para 1–2 segundos de latencia.
• Idiomas: Whisper admite 99 idiomas. Piper admite más de 20 paquetes de voces. El rendimiento del LLM varía según el idioma.

¿Por qué construir un asistente de voz local?

• Privacidad: Ningún audio sale de tu casa. No se almacena audio de la palabra de activación en la nube. Sin historial de conversaciones en servidores de terceros. Fundamental para profesionales de la salud, abogados, periodistas y cualquier persona con trabajo sensible.
• Costo: Sin suscripción. Alexa+ cuesta $4,99/mes. Google One cuesta entre $1,99 y $9,99/mes. Un asistente local es un costo único de hardware.
• Personalización: Elige tu palabra de activación, personalidad, system prompt y funcionalidades. Añade comandos personalizados, conecta sistemas de domótica local e integra APIs locales.
• Funcionamiento offline: Funciona sin internet. Un corte de luz (con SAI) + un corte de internet: tu asistente local sigue funcionando. Útil en cabañas, ubicaciones remotas y para preparación ante emergencias.
• Lo que pierdes: Búsqueda web, integración de domótica con nubes propietarias, sincronización de calendarios con servicios en la nube y los años de ajuste con RLHF que hacen que Alexa/Siri sean fluidos en casos límite.

La arquitectura de tres capas

• Capa 1 — STT (reconocimiento de voz): whisper.cpp o faster-whisper. Convierte el audio del micrófono en texto. Funciona offline, sin red.
• Capa 2 — LLM (razonamiento): Ollama sirviendo Llama 3.1 8B, Phi-4 o Mistral 7B. Toma el texto transcrito + historial de conversación + system prompt y genera una respuesta. Funciona offline, sin red.
• Capa 3 — TTS (síntesis de voz): Piper o Coqui TTS. Convierte el texto de respuesta del LLM en audio y lo reproduce por el altavoz. Funciona offline, sin red.
• Orquestador: Un script Python que conecta los tres: captura el audio del micrófono → lo pasa al STT → pasa la transcripción al LLM → pasa la respuesta al TTS → reproduce el audio.
• Palabra de activación opcional: Un detector ligero siempre activo (OpenWakeWord, Porcupine) que activa el pipeline completo solo cuando se detecta la frase de activación. Sin esto, el orquestador ejecuta whisper.cpp continuamente — consumiendo más CPU y generando más falsos positivos.

Requisitos de hardware

Paso 1: Configurar el reconocimiento de voz

• Instalar whisper.cpp: git clone https://github.com/ggerganov/whisper.cpp && cd whisper.cpp && make -j4
• Descargar el modelo: bash ./models/download-ggml-model.sh small (small = 3,4 % WER, buen equilibrio entre velocidad y precisión)
• Probar la transcripción: ./main -m models/ggml-small.bin -f test.wav — debe producir una salida de texto precisa.
• Activar Metal en Mac: make -j4 WHISPER_COREML=1 y luego bash models/generate-coreml-model.sh small
• Selección del modelo Whisper: base para Raspberry Pi (1 GB de RAM, baja latencia), small para el equilibrio óptimo (2 GB de RAM, 3,4 % WER), large-v3 para máxima precisión (10 GB de VRAM/RAM).
• Configurar la supresión de silencio: Añade las flags --no-speech-threshold 0.6 --suppress-blank para evitar transcribir el silencio como texto alucinado.
• Probar con una grabación de 10 segundos: Graba una frase de prueba y verifica que Whisper la transcribe correctamente. Comprueba tanto en condiciones de ruido como con voz tranquila.

Paso 2: Configurar el LLM local

• Instalar Ollama: Descarga desde ollama.com. Disponible para macOS, Linux y Windows. Se instala en menos de 2 minutos.
• Descargar el modelo: ollama pull llama3.1:8b (recomendado) o ollama pull phi4 (más ligero, adecuado para sistemas con 16 GB de RAM).
• Probar: ollama run llama3.1:8b "What is the capital of France?" — verifica que la respuesta es precisa y rápida.
• System prompt para voz: Usa un system prompt corto y directivo: "Eres un asistente de voz útil. Mantén las respuestas concisas — máximo 1–3 oraciones. Nunca uses listas, markdown ni formato. Habla de forma natural como en una conversación."
• Temperatura: Establece la temperatura en 0,3–0,5 para respuestas más predecibles y factuales. Una temperatura más baja reduce las alucinaciones en las respuestas de voz.
• Máximo de tokens: Limita la longitud de respuesta con --num-predict 150 — las respuestas largas requieren más tiempo de TTS y resultan artificiales en la interacción de voz.

Paso 3: Configurar la síntesis de voz

• Instalar Piper: pip install piper-tts
• Descargar una voz: piper --download-dir voices --update-voices --voice en_US-lessac-medium (o cualquier voz de la página de voces de Piper en Hugging Face).
• Probar: echo "Hello, how can I help you today?" | piper --model voices/en_US-lessac-medium.onnx --output-raw | aplay -r 22050 -f S16_LE -c 1
• Salida de audio: Piper genera PCM sin procesar o WAV. Redirige a aplay (Linux), afplay (Mac), o usa la librería Python sounddevice para reproducción multiplataforma.
• Alternativa (mejor calidad): Backend Coqui VITS — instala pip install TTS, usa tts --model_name tts_models/en/vctk/vits. Requiere ~2 GB de VRAM; 2–3× más lento que Piper pero notablemente más natural.
• Selección de voz: Para asistentes de voz, elige una voz de calidad media en lugar de alta — las voces medias son más rápidas y la diferencia es insignificante a través de un altavoz.

Paso 4: Conectar el pipeline

#!/usr/bin/env python3
"""Minimal offline voice assistant: Whisper STT + Ollama LLM + Piper TTS."""

import subprocess
import tempfile
import sounddevice as sd
import soundfile as sf
import numpy as np
import requests
import json

SAMPLE_RATE = 16000
RECORD_SECONDS = 5
OLLAMA_URL = "http://localhost:11434/api/generate"
WHISPER_BIN = "./whisper.cpp/main"
WHISPER_MODEL = "./whisper.cpp/models/ggml-small.bin"
PIPER_BIN = "piper"
PIPER_VOICE = "voices/en_US-lessac-medium.onnx"
SYSTEM_PROMPT = (
    "You are a helpful voice assistant. Keep responses to 1-3 sentences. "
    "Never use markdown, bullet points, or formatting. Speak naturally."
)

conversation_history = []

def record_audio(seconds: int = RECORD_SECONDS) -> np.ndarray:
    print("Listening...")
    audio = sd.rec(int(seconds * SAMPLE_RATE), samplerate=SAMPLE_RATE, channels=1, dtype="int16")
    sd.wait()
    return audio

def transcribe(audio: np.ndarray) -> str:
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        sf.write(f.name, audio, SAMPLE_RATE)
        result = subprocess.run(
            [WHISPER_BIN, "-m", WHISPER_MODEL, "-f", f.name, "--no-timestamps", "--no-prints"],
            capture_output=True, text=True
        )
    return result.stdout.strip()

def ask_llm(text: str) -> str:
    conversation_history.append({"role": "user", "content": text})
    response = requests.post(OLLAMA_URL, json={
        "model": "llama3.1:8b",
        "system": SYSTEM_PROMPT,
        "messages": conversation_history,
        "stream": False,
    })
    reply = response.json()["message"]["content"]
    conversation_history.append({"role": "assistant", "content": reply})
    return reply

def speak(text: str) -> None:
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        subprocess.run(
            f'echo "{text}" | {PIPER_BIN} --model {PIPER_VOICE} --output_file {f.name}',
            shell=True, check=True
        )
        data, sr = sf.read(f.name)
        sd.play(data, sr)
        sd.wait()

def main():
    print("Voice assistant ready. Press Ctrl+C to stop.")
    while True:
        audio = record_audio()
        transcript = transcribe(audio)
        if not transcript or len(transcript) < 3:
            continue
        print(f"You: {transcript}")
        response = ask_llm(transcript)
        print(f"Assistant: {response}")
        speak(response)

if __name__ == "__main__":
    main()

Paso 5: Detección de palabra de activación

• OpenWakeWord (licencia MIT): Completamente open-source, funciona en CPU, admite palabras de activación personalizadas mediante fine-tuning con tu propia frase. Instalación: pip install openwakeword. Funciona en Raspberry Pi. La mejor opción para configuraciones completamente offline y open-source.
• Porcupine (Picovoice): Propietario pero con nivel gratuito para uso personal. Las palabras de activación predefinidas incluyen "Alexa", "Hey Siri", "Ok Google" y opciones personalizadas como "Hey Jarvis". Muy preciso con baja tasa de falsos positivos. Instalación: pip install pvporcupine.
• Patrón de integración: Ejecuta OpenWakeWord/Porcupine en un bucle. Cuando se detecta la palabra de activación, reproduce un sonido "ding" (retroalimentación al usuario), activa el pipeline Whisper + LLM + TTS para una consulta y vuelve a escuchar la palabra de activación tras la reproducción del TTS.
• Consumo en funcionamiento continuo: La detección de palabra de activación usa ~2–5 % de CPU en una Raspberry Pi 5 — insignificante. Puedes dejar el asistente funcionando 24/7 con un consumo mínimo.
• Palabras de activación personalizadas (OpenWakeWord): Genera 500 ejemplos de audio positivos y 500 negativos de tu frase de activación usando síntesis de voz, luego ajusta OpenWakeWord en menos de 30 minutos en CPU. La precisión es comparable a Porcupine para palabras comunes en inglés.

Optimización de latencia

• Optimización del STT (~0,2–0,5 s): Usa Whisper small en lugar de large-v3. Usa VAD para recortar el silencio antes de pasar el audio a Whisper — audio más corto = transcripción más rápida.
• Optimización del LLM (~0,5–1,5 s primer token): Precarga el modelo al inicio (Ollama lo hace automáticamente). Usa cuantización Q4_K_M para el mejor equilibrio entre velocidad y calidad. Establece --num-predict 100–150 para limitar la longitud de la respuesta.
• Streaming LLM → TTS: Transmite la salida del LLM token a token. Inicia el TTS en cada oración completa (detectada por punto o signo de interrogación). Esto reduce la latencia percibida en 0,3–0,7 segundos — el usuario escucha el inicio de la respuesta mientras el LLM sigue generando el final.
• Optimización del TTS (~0,1–0,3 s): Piper genera el primer audio en 50 ms. Inicializa Piper al arranque. Usa --output-raw para transmitir el audio mientras se genera en lugar de esperar el archivo completo.
• Mantener los modelos en memoria: Ollama mantiene los modelos calientes en la VRAM automáticamente. whisper.cpp cargado en modo stream permanece en memoria. Evita recargar los modelos entre consultas.
• Latencia objetivo por nivel de hardware: Pi 5: 5–8 s (aceptable para uso no conversacional). Mini PC CPU: 3–5 s (límite para conversación). GPU de escritorio: 1–2 s (natural). Mac M5: 1–1,5 s (excelente).

Privacidad y seguridad

• Verifica con Wireshark: Ejecuta Wireshark en tu interfaz de red durante una conversación con el asistente. No deberías ver ningún paquete proveniente del proceso del asistente. Cualquier tráfico inesperado indica una mala configuración — comprueba que la API externa de Ollama esté desactivada si tienes una IP pública.
• Sin almacenamiento de audio: Ni whisper.cpp ni faster-whisper escriben archivos de audio por defecto — procesan en memoria. El orquestador Python de esta guía escribe un archivo WAV temporal para whisper.cpp, que se elimina tras la transcripción.
• Sin historial de conversaciones almacenado: El historial de conversaciones del script de ejemplo está solo en memoria y se reinicia al reiniciar el programa. Para historial persistente, implementa un almacenamiento explícito con una base de datos local y cifrado en reposo.
• Cumplimiento del RGPD: Dado que todo el procesamiento es local y ningún dato abandona tu red, un asistente de voz local para uso interno no requiere un acuerdo de tratamiento de datos. No existe una relación responsable/encargado del tratamiento con un tercero.
• Aislamiento de red: Para máxima privacidad, añade una regla de firewall que bloquee el tráfico de salida del proceso del asistente. Ollama y whisper.cpp funcionarán con normalidad — no requieren acceso a la red una vez descargados los modelos.

Preguntas frecuentes

Fuentes

• whisper.cpp en GitHub — Código fuente, instrucciones de compilación, documentación del modo stream.
• Ollama en ollama.com — Instalación, biblioteca de modelos, referencia de API.
• Piper TTS en GitHub — Código fuente, descarga de paquetes de voces, guía de configuración para Raspberry Pi.
• OpenWakeWord en GitHub — Código fuente, guía de entrenamiento de palabras de activación personalizadas, arquitecturas compatibles.
• Porcupine de Picovoice — SDK de palabra de activación, condiciones del nivel gratuito, documentación del SDK de Python.
• Picovoice Console — Crea una clave de API gratuita para Porcupine en uso personal.

Lectura relacionada

• Reconocimiento de voz local 2026: Whisper.cpp vs faster-whisper — Análisis en profundidad de la capa STT de este pipeline.
• TTS local y clonación de voz 2026: Piper vs Coqui vs XTTS v2 — Análisis en profundidad de la capa TTS y las opciones de clonación de voz.
• Pipeline de IA multimodal local 2026 — Amplía este pipeline de voz con soporte para modelos de visión.
• Cómo instalar Ollama — Instalación de Ollama y gestión de modelos.
• Guía de hardware para LLM local 2026 — Selección de hardware para el pipeline completo de voz + LLM.
• Construye un asistente de voz local en tu teléfono — La versión móvil de esta guía (iPhone + Android).