4.5 Paso a paso #3: tu buddy local con nombre, cara y voz

Contenido detallado

🎯 El objetivo: un buddy de verdad

Ya tienes las piezas repartidas por el curso: un modelo en ejecución (3.1), una API local (3.5), memoria con RAG (3.6) y una red privada con Tailscale (2.4). Este paso a paso lo une todo en un compañero personal — con un nombre, una forma de hablar, una pantalla para conversar y una voz que te responde en voz alta. Nada sale de tu máquina.

🆕 ¿Eres nuevo por aquí?

"System prompt" es una instrucción fija que el modelo lee antes de cualquier conversación: define quién es, el tono y las reglas. Es la personalidad del buddy. "TTS" = text-to-speech (texto → habla) y "STT" = speech-to-text (habla → texto): ambos también funcionan localmente, sin enviar tu audio a nadie.

🔑 Las cuatro piezas del buddy

Un buddy = cuatro cosas que ya viste, combinadas:

•Personalidad: un system prompt en el Modelfile con nombre, tono y reglas.
•Interfaz: una interfaz — Open WebUI (3.2) o una página HTML mínima.
•Voz y oídos: Piper (TTS) para hablar y whisper.cpp (STT) para escuchar.
•Memoria + alcance: RAG (3.6) para que te recuerde y Tailscale (2.4) para usarlo desde el celular.

✓ Buddy local

✓Personalidad y reglas 100 % bajo tu control
✓Conversación, voz y memoria sin salir de la máquina
✓Uso ilimitado: habla todo el día, solo pagas la energía
✓Accesible desde el celular por tu red privada

✗ Asistente en la nube

✗Personalidad limitada a lo que permite la plataforma
✗Tu audio y tus conversaciones pasan por terceros
✗La voz y el uso intensivo cuestan por minuto/token
✗Desaparece si te cortan el acceso, cambian el precio o la región

Nombre

system prompt

Interfaz

interfaz

Voz

Piper TTS

Memoria

RAG + red

🪪 Personalidad mediante system prompt

La personalidad no viene de «entrenar» nada — viene de una instrucción fija. En Ollama guardas esa instrucción en un Modelfile (la receta que viste en el módulo 3.1) y crea un modelo con nombre a partir de ella. Cambia el texto de SYSTEM y tú cambias quién es el buddy.

⌨️ Copy-run: dale nombre y tono a "Hermes"

Objetivo: crear un modelo local llamado hermes con personalidad definida. Guárdalo como Modelfile y ejecuta los comandos.

# Modelfile — define a "Hermes", tu buddy local

FROM qwen2.5:7b-instruct

# el system prompt = la personalidad fija del buddy

SYSTEM """

Eres Hermes, el asistente personal local de Nei.

Tono: directo, cálido y con buen humor. Dirígete a la persona con "tú".

Reglas: respuestas breves por defecto; pregunta antes de suponer;

nunca inventes datos; si no sabes, dilo. Responde en PT-BR.

"""

# ajusta el comportamiento

PARAMETER temperature 0.6

PARAMETER num_ctx 8192

# crea el modelo a partir de la receta y conversa

ollama create hermes -f Modelfile

ollama run hermes

Cómo verificar: pregunta "¿quién eres?". Debe presentarse como Hermes, con el tono definido, y respetar las reglas (breve, sin inventar). ¿No te gustó? Edita el SYSTEM y ejecuta ollama create de nuevo.

💡 Consejo práctico

Un buen system prompt tiene cuatro partes: quién es (nombre/rol), cómo habla (tono), qué puede/no puede hacer (reglas) y el idioma. Evita los párrafos enormes: el modelo sigue mejor las instrucciones breves y específicas que un manual. Empieza de forma sencilla y ve ajustándolo según sus respuestas.

Rol

quién es

Tono

cómo habla

Reglas

qué vale

Idioma

PT-BR

🖥️ Una interfaz: interfaz dedicada

"Darle una cara" es solo apuntar una interfaz a tu modelo. Hay dos caminos: el listo — reutilizar Open WebUI (3.2), que ya tiene chat con historial — o el conciso: una página HTML de 20 líneas que se comunica directamente con la API local (3.5). Empieza por la más sencilla para entender el circuito; después pasa a Open WebUI cuando quieras historial y archivos adjuntos.

⌨️ Copy-run: una "cara" mínima en HTML

Objetivo: una página que envía tu pregunta al endpoint local y muestra la respuesta. Guarda como buddy.html.

<!doctype html><meta charset="utf-8">

<h2>🤝 Hermes</h2>

<button onclick="send()">Enviar</button>

async function send(){

const q = document.getElementById('q').value;

const r = await fetch(

'http://localhost:11434/v1/chat/completions',{

method:'POST', headers:{'Content-Type':'application/json'},

body: JSON.stringify({ model:'hermes',

messages:[{role:'user', content:q}] }) });

const j = await r.json();

document.getElementById('out').textContent =

j.choices[0].message.content;

}

</script>

Cómo verificar: abre el archivo en el navegador, escribe una pregunta y haz clic en Enviar: la respuesta de tu modelo local aparece en la pantalla. Es tu buddy con personalidad propia.

⚠️ Atención: CORS

Si el navegador bloquea la llamada (error de CORS al abrir mediante file://), permite el origen en Ollama: ejecútalo con OLLAMA_ORIGINS=* (ej.: OLLAMA_ORIGINS=* ollama serve). Para el buddy de verdad, prefiere el Open WebUI en http://localhost:3000 — él ya se encarga de eso y te ofrece historial, cambio de modelo y RAG de documentos.

✓ Open WebUI (listo)

✓Historial de conversaciones y múltiples chats
✓Cambio de modelo y RAG de documentos integrado
✓Listo para usar desde el celular mediante la tailnet

📄 HTML mínimo (didáctico)

•Muestra todo el circuito en 20 líneas
•Fácil de personalizar con el «aspecto» que quieras
•Sin historial ni archivos adjuntos: es solo la estructura básica

🔊 Dar voz: TTS local (Piper)

La voz es lo que transforma un chat en un buddy. En vez de solo leer en pantalla, habla. Para eso usamos un motor de TTS que funciona en tu máquina: el Piper — y envía la respuesta del modelo directamente al altavoz.

🆕 ¿Eres nuevo por aquí?

"TTS" = text-to-speech: transforma texto a voz. O Piper es un TTS local, liviano y rápido (funciona incluso en CPU), con varias voces, incluso en PT-BR. Cada voz es un archivo .onnx; cambia el archivo y el buddy cambia de voz.

La ruta de voz es un pipeline corto — el texto entra por un lado y el sonido sale por el otro:

La respuesta se convierte en texto

El modelo local responde a través de una API (3.5). Solo tomas el texto de la respuesta.

Piper sintetiza el habla

El texto entra en Piper con una voz .onnx; genera un archivo de audio .wav.

El sistema reproduce el audio

Un reproductor simple (aplay en Linux, afplay en macOS) reproduce el .wav. El buddy "habló".

⌨️ Copy-run: el buddy dice una frase

Objetivo: instalar Piper y convertir un texto en sonido en el altavoz. Pégalo en la terminal.

# instalar Piper (TTS local)

pip install piper-tts # o descarga el binario del repo

# descarga una voz PT-BR (.onnx) del repositorio de Piper

# texto -> Piper -> archivo .wav -> altavoz

echo "Olá, eu sou o Hermes." \

| piper --model pt_BR-faber-medium.onnx \

--output_file fala.wav

aplay fala.wav # macOS: afplay fala.wav

Cómo verificar: tú oye la frase. Cambiaste el .onnx? La voz cambia. Ese mismo piper ... | aplay es la pieza de voz del ciclo del tema 6.

🎤 Escuchar: STT local (opcional)

Darle voz ya es la mitad del camino. La otra mitad es darle oídos: poder hablar con el buddy en vez de escribir. Es opcional, pero con STT local el ciclo queda completo (hablas → entiende → responde → te habla).

🆕 ¿Eres nuevo por aquí?

"STT" = speech-to-text: transforma habla en texto (lo opuesto al TTS). El whisper.cpp es una implementación local y ligera del modelo Whisper que funciona en CPU: graba el micrófono, transcribe y devuelve el texto, sin enviar tu audio a la nube.

⌨️ Copy-run: transcribe tu voz localmente

Objetivo: grabar 5 segundos del micrófono y ver el texto de lo que dijiste. Todo sin conexión.

# whisper.cpp = STT local (voz -> texto), funciona en CPU

git clone https://github.com/ggerganov/whisper.cpp

cd whisper.cpp && make

./models/download-ggml-model.sh small # baja el modelo

# graba 5s del micrófono y transcribe en PT-BR

arecord -d 5 -f S16_LE -r 16000 fala.wav

./main -m models/ggml-small.bin -l pt -f fala.wav

Cómo verificar: el texto de lo que dijiste aparece en la terminal. Ese texto es exactamente lo que pasarías como content en la llamada a la API — cerrando el ciclo de voz.

✓ Vale la pena escuchar cuando

✓Quieres usarlo con las manos libres (en la cocina, al conducir)
✓Hablar es más rápido que escribir en tu caso
✓Quieres un asistente de voz 100 % privado

✗ Quédate con el texto si

✗El hardware es limitado — STT + LLM + TTS juntos consumen muchos recursos
✗Un entorno ruidoso dificulta la transcripción
✗Por ahora solo quieres el buddy de texto (empieza de forma sencilla)

🧠 Memoria, voz y celular: todo junto

Falta encajar las dos últimas piezas y poner el motor en marcha. Memoria: con RAG (3.6), el buddy te recuerda — tus preferencias, proyectos y conversaciones anteriores — al buscar esos fragmentos e incorporarlos al contexto antes de responder. Alcance: al ejecutarlo detrás de Tailscale (2.4), puedes comunicarte con él desde el celular, desde cualquier lugar, como si estuvieras en casa. Mira cómo se integra todo:

Lee como una ecuación: cara + cerebro + voz + memoria (las piezas en cian que montaste en el curso) suman un buddy local completo (en ámbar). Quita cualquier parte y seguirá funcionando; solo será menos buddy.

💡 Memoria + celular, en la práctica

Memoria (RAG, 3.6): guarda tus notas (preferencias, hechos, historial) en un vector store y, con cada pregunta, busca los fragmentos relevantes y pégalos en el prompt — así Hermes «recuerda» sin reentrenar nada. Celular (Tailscale, 2.4): con OLLAMA_HOST=0.0.0.0 y la app Tailscale en el teléfono, cambia localhost por la IP 100.x de tu máquina y habla con el buddy desde cualquier lugar, sin exponer nada a la internet pública.

⌨️ Copy-run principal: el loop del buddy que habla

Objetivo: el circuito completo en un archivo — pregunta → API local → respuesta → Piper habla. Guárdalo como buddy-voz.sh.

#!/usr/bin/env bash

# buddy-voz.sh — pregunta -> API local -> respuesta -> Piper habla

while true; do

read -rp "tú: " pregunta

[ "$pergunta" = "sair" ] && break

# 1) envía a la API local (Ollama, compatible con OpenAI)

resposta=$(curl -s http://localhost:11434/v1/chat/completions \

-d "{\"model\":\"hermes\",\"messages\":[{\"role\":\"user\",

\"content\":\"$pergunta\"}]}" \

| jq -r '.choices[0].message.content')

echo "hermes: $resposta"

# 2) Piper dice la respuesta

echo "$resposta" \

| piper --model pt_BR-faber-medium.onnx --output_file r.wav

aplay r.wav

done

Cómo verificar: ejecuta bash buddy-voz.sh, pregunta algo y oye la respuesta de tu buddy. Escribe salir para finalizar. Requiere curl, jq, piper e aplay. ¿También quieres que te escuche? Cambia el read mediante la transcripción de whisper.cpp (tema 5).

✓ Buddy bien hecho

✓System prompt corto, claro y probado
✓Todo local: voz, memoria y datos en tu máquina
✓Acceso solo por la tailnet, nunca a la Internet abierta

✗ Errores comunes

✗Exponer directamente el puerto 11434 en internet
✗System prompt enorme que el modelo ignora
✗Apilar STT+LLM+TTS en hardware que no lo soporta

Autoevaluación (opcional): ¿qué le da a tu buddy local la personalidad — ¿nombre, tono y reglas?

Nombre

SYSTEM

Interfaz

UI / HTML

Voz

Piper / Whisper

Siempre

RAG + tailnet

📌 Resumen del módulo

✓

Personalidad = system prompt — nombre, tono y reglas en el SYSTEM del Modelfile, creados con ollama create.

✓

Interfaz = interfaz — Open WebUI listo para usar o una página HTML mínima que se comunica con la API local.

✓

Voz y oídos = TTS + STT local — Piper habla, whisper.cpp escucha, todo sin conexión.

✓

Memoria + alcance — RAG (3.6) para que te recuerde y Tailscale (2.4) para usarlo desde el celular.

Siguiente módulo:

4.6 — Rendimiento, escalabilidad y troubleshooting

← Módulo anterior Volver a la trilha Siguiente módulo →