Octavo módulo del Curso de GPU para IA y cierre del bloque local. Tu GPU ya genera texto — pero un sistema de IA completo necesita más: buscar por significado (embeddings), escuchar (voz a texto), a veces ver o dibujar. La buena noticia: todo eso corre en la misma tarjeta. La mala: todo eso compite por la misma VRAM. Este módulo es el inventario de herramientas y el arte de repartir.

La tesis del módulo

Una GPU local no es “la máquina del chatbot”: es una plataforma de cómputo de IA. Embeddings, transcripción e imágenes son cargas más livianas que el LLM — el desafío no es correrlas, es orquestar quién vive en la VRAM y cuándo.

Embeddings locales: la pieza del RAG

Si vienes del mundo de agentes, ya sabes qué son los embeddings (si no: Embeddings y RAG primero). La noticia de hoy es que no necesitas una API para generarlos.

La vía más simple, con el Ollama que ya tienes:

ollama pull nomic-embed-text

respuesta = cliente.embeddings.create(          # el mismo cliente OpenAI
    model="nomic-embed-text",                   # del módulo 5, endpoint /v1
    input="¿Cuánta VRAM necesita un modelo 8B?",
)
vector = respuesta.data[0].embedding

Y la vía Python directa, con la librería sentence-transformers — útil cuando el pipeline de indexación es tuyo:

from sentence_transformers import SentenceTransformer

modelo = SentenceTransformer("intfloat/multilingual-e5-base")  # bueno en español
vectores = modelo.encode(["primer texto", "segundo texto"])

Dos avisos con nombre y apellido:

Elige un modelo multilingüe si tu contenido está en español: los embeddings entrenados solo en inglés degradan la búsqueda sin decírtelo.
Las dimensiones no se mezclan. Si tu base vectorial se indexó con un modelo de API (p. ej. 1536 dimensiones) y ahora generas con uno local de 768, no hay compatibilidad: re-indexas todo. Cambiar de modelo de embeddings es una migración, no un cambio de config.

Voz a texto: Whisper local

Whisper (el modelo abierto de transcripción de OpenAI) corre local con implementaciones optimizadas como faster-whisper:

from faster_whisper import WhisperModel

modelo = WhisperModel("medium", device="cuda", compute_type="int8")
segmentos, info = modelo.transcribe("reunion.mp3", language="es")
for s in segmentos:
    print(f"[{s.start:.1f}s] {s.text}")

Viene en tallas (tiny → large-v3): más grande, mejor transcripción, más VRAM y más lento. Para español conversacional, medium es el punto dulce habitual; large-v3 para audio difícil. Fíjate en el compute_type="int8": es la cuantización del Módulo 4 aplicada a otro dominio — mismos principios, otro modelo.

Imágenes: la carga pesada ocasional

Generación de imágenes local (familia Stable Diffusion y similares) también es territorio GPU: modelos tipo SDXL piden en el orden de 8–12 GB de VRAM para trabajar cómodos. Es la carga más golosa de esta lista — y la más fácil de tratar como trabajo por lotes: se carga, genera, y libera la memoria. No la dejes residente junto al LLM salvo que te sobre tarjeta.

El presupuesto: todo quiere la misma VRAM

El inventario completo sobre una GPU de 12 GB:

 una GPU de 12 GB, repartida

 ┌──────────────────────────────────────┐
 │ LLM 8B en Q4 + contexto      ~6.4 GB │
 │ embeddings (E5 base)         ~1.1 GB │
 │ whisper medium (int8)        ~1.5 GB │
 │ margen anti-OOM              resto   │
 └──────────────────────────────────────┘

LLM + embeddings + voz conviven bien en una tarjeta media — esa es la arquitectura local realista. Las estrategias cuando no alcanza:

Estrategia	Cómo
Residente vs efímero	El LLM vive en VRAM; imágenes y transcripción masiva cargan, trabajan y sueltan
Descarga automática	Ollama libera modelos tras un tiempo sin uso (ajustable con `keep_alive`)
Embeddings a CPU	Los modelos de embeddings son chicos: en CPU siguen siendo rápidos para consultas sueltas
Turnos	Transcribes el lote de audios primero, indexas después, chateas al final

Errores comunes

Sumar cargas sin sumar su VRAM. Cada proceso reserva la suya; el OOM llega cuando el tercero se sube. La cuenta del Módulo 2, ahora con varios sumandos.
Cambiar de modelo de embeddings sin re-indexar. Vectores de modelos distintos viven en espacios distintos: la búsqueda devuelve basura sin lanzar ningún error.
Whisper large para todo. Para audio limpio en español, medium transcribe casi igual en la mitad del tiempo y la mitad de la memoria.
Dejar Stable Diffusion residente “por comodidad”. Son gigas de VRAM pagando arriendo por si acaso; genera y libera.

Cierre del bloque intermedio

Ya corres el stack completo en local: LLM por tres vías (Ollama, llama.cpp, vLLM), embeddings, voz, imágenes — y sabes repartir la memoria entre ellos. Es exactamente el kit del bloque final.

La frase para llevarse

“El LLM es el inquilino principal, no el único: una GPU bien administrada es un edificio con pensionistas — los efímeros entran, trabajan y dejan la pieza libre.”

Qué viene

Arranca el bloque avanzado (Módulo 9): armamos la arquitectura local completa — agente + LLM + RAG + voz sobre tu GPU, con diagrama de la casa entera — y los criterios honestos de cuándo local le gana a la API (y cuándo no).

GPU para IA — Módulo 8: más allá del LLM — embeddings, voz e imágenes