Atareao con Linux

Arrancamos la serie de los sentidos de la IA por el más básico. Después de darle a tu modelo de lenguaje una memoria para buscar entre tus 6.000 o 7.000 documentos, toca darle sentidos, y el primero es el oído. Hoy te hablo de FFmpeg, la pieza que hace que lo demás funcione.
FFmpeg es la navaja suiza del audio y el vídeo: está dentro de YouTube, VLC, Blender o del vídeo que ves en el navegador. Lo instalas con un apt install o un pacman y tienes un taller multimedia en un solo binario. Convertir de MP3 a WAV o a FLAC sin pérdida te cuesta una línea.
El meollo es que Whisper no traga cualquier audio. Se entrenó con 680.000 horas de audio limpio a 16 kHz y en mono, así que espera PCM de 16 bits, un solo canal y 16 kHz, sin compresión. Si le das un MP3 a 44,1 kHz en estéreo y con silencios largos te lo puede transcribir, pero se arriesga a alucinar y a rellenar los silencios. Casi nunca el problema es el modelo, es cómo le das la entrada.
Con un alias que convierta a ese formato ya tienes medio camino. Luego están loudnorm para normalizar el volumen y el filtro que quita los silencios de más de un segundo, la causa número uno del texto inventado, y una trampa con silenceremove que te cuento con detalle. También hablamos de cortar y unir con -ss, -t y concat.
Y no solo sirve para preparar el audio que entra, también para postprocesar el que sale del TTS. Un motor local como Piper o Kokoro devuelve una voz plana, sin dinámica, que suena a robot con resaca. Con un paso alto, un compresor y un loudnorm final pasas de sonar a radio AM a sonar a FM, todo dentro de la pipeline de micrófono a altavoz con los scripts en Python.
Para cuando el audio llega muy sucio hay tres filtros que salvan la grabación: afftdn contra el ruido constante del ventilador, adeclick para chasquidos y pops, y un equalizer que sube la banda de presencia de la voz. Una grabación en una cafetería queda usable para Whisper. Limpiar siempre antes de normalizar, porque si amplificas primero también amplificas el ruido.
Sin FFmpeg, Whisper falla, el texto a voz suena a lata y la pipeline de voz no existe. Hoy hemos puesto los cimientos, y ahora llegan Whisper, el texto a voz, la visión artificial y un extra sobre OCR 😊
Capítulos
0:00 - De la memoria de tu IA a los sentidos: la nueva serie
1:33 - La serie de los sentidos y el audio sucio que llega a tu IA
3:14 - FFmpeg, la navaja suiza del audio y el vídeo
5:57 - Instalar FFmpeg y convertir formatos en una línea
7:27 - El meollo: cómo espera Whisper el audio (16 kHz, mono, 16 bits)
10:01 - El alias whisperize, loudnorm a -23 LUFS y quitar silencios
11:19 - Cortar y unir audio: -ss, -t, concat y fundidos
13:14 - Postprocesar la voz del TTS: de radio AM a FM
15:25 - La pipeline completa de voz y los scripts en Python
17:05 - Audio muy sucio: afftdn, adeclick y equalizer
18:29 - Conclusiones, despedida y comunidad
Más información y enlaces en las notas del episodio
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram 👉 https://t.me/atareao_con_linux
🦣 Mastodon 👉 https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao

Te tengo que confesar una cosa. En el episodio anterior, haciendo pruebas, me ventilé toda la información del GraphRAG y me tocó reindexarlo entero. Casi 6.300 notas otra vez, con el Slimbook echando humo. Me ha costado lo suyo, pero ya está. Y ahora toca lo bueno, porque el grafo está montado y solo falta interrogarlo. Este es el cierre de la trilogía, donde el grafo deja de ser un mueble y por fin responde.
Lo primero es por qué no basta con una sola técnica. El vector te dice qué se parece a tu pregunta, y el grafo te dice qué está conectado. Si buscas un servidor web seguro, el vector acierta de pleno con la nota de hardening. Pero la nota de Certbot no dice esas palabras, así que un RAG clásico la pierde. El grafo la rescata porque está conectada con Nginx y https. Ni grep ni ripgrep te habrían dado eso.
También te doy las cifras reales del grafo, más de 20.000 nodos, unas 6.300 notas, 15.000 entidades y 46.000 trozos con embeddings. Y la arquitectura híbrida, en tres pasos, primero lo vectorial, después el re-ranking por peso y por último la expansión por grafo, que recupera vecinos a uno o dos saltos. Todo lo modula el parámetro alfa, por defecto en 0,7, donde el significado manda y la conexión complementa.
Y lo probamos con comandos de verdad. Con graphrag search lanzas la búsqueda y ves cómo cambian los resultados al mover el alfa. Con la profundidad controlas los vecinos que recuperas, con 0 te quedas en lo vectorial y con 2 abres dos saltos de grafo. Te enseño a filtrar por peso mínimo, por metadatos y por tipo de elemento.
Después viene lo que más me gusta, graphrag ask. No te devuelve notas sueltas, te devuelve una respuesta redactada con Ollama en local y con las fuentes citadas al pie. Le preguntas cómo configurar Traefik y te da los pasos apoyándose en tus notas. Y cuando no tiene información, no se la inventa. En el ejemplo con GIMP solo encontró una nota y te lo dice tal cual. Hablo también de las comunidades y del build incremental, que solo procesa lo que has tocado, ideal para un cron.
Capítulos
0:00 - Introducción: el cierre de la trilogía GraphRAG y el reindexado del grafo
2:13 - Repaso de la trilogía: qué es un GraphRAG y para qué sirve
4:14 - Vector frente a grafo: por qué necesitas las dos cosas
6:53 - Las cifras del grafo: nodos, notas, entidades y comunidades
7:52 - La arquitectura híbrida en tres pasos y el parámetro alfa
9:17 - Primera búsqueda: cómo montar un proxy inverso y el efecto del alfa
11:21 - Profundidad de vecinos, Ollama y cómo interpretar los resultados
13:53 - Filtros: min-weight, metadatos y tipos de elemento
14:52 - graphrag ask: preguntas con fuentes citadas (cómo configuro Traefik)
16:54 - Comunidades: build incremental y automatización con cron
17:42 - Ejemplo con GIMP: búsqueda, ask y la ventaja de no alucinar
17:42 - Ejemplo con GIMP: búsqueda, ask y la ventaja de no alucinar
20:28 - Flecos pendientes: integración MCP con Neovim, bot de Obsidian y despedida
Más información y enlaces en las notas del episodio: https://atareao.es/podcast/841
🌐 Todo en https://atareao.es · ✈️ Telegram https://t.me/atareao_con_linux · 🦣 Mastodon https://mastodon.social/@atareao · 🐦 Twitter https://twitter.com/atareao · 🐙 GitHub https://github.com/atareao

Llevo varias semanas construyendo un grafo de conocimiento con GraphRAG sobre SQLite, y en ese día a día me he topado con sqlite-utils, una herramienta que se ha convertido en mi navaja suiza para trabajar con bases de datos SQLite sin complicarme la vida. Es de esas utilidades que no sabías que necesitabas hasta que la pruebas.
Te preguntarás por qué SQLite y no PostgreSQL o cualquier solución más seria. La respuesta es sencilla, porque necesito algo que quepa en mi equipo, que sea portátil y que pueda llevarme en un USB sin montar un servidor. Todo tu conocimiento, en un solo archivo que abres donde quieras.
El problema de siempre ha sido inspeccionar esas bases. Abrir DBeaver o tirar de Python solo para mirar qué hay dentro da una pereza enorme, y al final acabas dejándolo. sqlite-utils, creada por Simon Willison, resuelve justo eso, y te permite consultar, filtrar, transformar y exportar sin escribir una línea de SQL ni de Python.
Para que te hagas una idea, aquí hay dos cosas en una sola herramienta, una utilidad de línea de comandos y una librería de Python que no pretende ser un ORM. Nació dentro del ecosistema de Datasette, y busca que crear una base desde cero y poblarla con datos sea rápido y sin fricción. En mi caso ha acabado sustituyendo a los comandos sueltos de sqlite3 que tenía repartidos por las notas.
Otro terreno donde se nota la mano es la ingesta. Con insert metes un JSON que llega por la tubería, un CSV de los que exportas de cualquier sitio, o la respuesta de una API con un curl delante. Con upsert y bulk actualizas registros que ya existían o metes miles de filas de golpe, y todo eso se encadena con jq en una sola tubería.
Luego está la parte de cambiar las cosas sin dolor, renombrar una columna, borrar la que sobra o cambiar un tipo de dato. En SQL puro eso es un baile de create table, copiar los datos y borrar la tabla vieja, con el riesgo de liarla a mitad de camino. Aquí es un transform, se ejecuta dentro de una transacción y el esquema queda reescrito como si lo hubieras diseñado así desde el principio.
En este episodio te cuento cómo instalarla con uv, cómo explorar tablas y esquemas, cómo navegar los datos con rows, cómo filtrar de forma segura con parámetros con nombre y cómo montar consultas complejas con joins. Además verás el combo que más me ha enganchado, sqlite-utils encadenado con jq y con llm para pasar el contexto de tu base directamente a un modelo de lenguaje. Y de propina, los detalles de mantenimiento que marcan la diferencia, como WAL, Vacuum, Optimize y la búsqueda full-text.
Si tienes una base SQLite por ahí y nunca te has atrevido a mirar dentro, este es tu episodio 👍
Capítulos
0:00 - Presentación: sqlite-utils, la navaja suiza de SQLite
2:20 - Por qué SQLite: GraphRAG, portabilidad y contexto de la serie
4:20 - El problema de DBeaver y qué resuelve sqlite-utils
6:00 - Instalación con UV y primeros pasos
8:30 - Explorar tablas, columnas y esquemas
11:30 - Navegar los datos con rows
14:00 - Filtrar con where, ordenar y evitar inyección SQL
16:30 - Consultas complejas, joins y selects a medida
18:30 - El combo killer: sqlite-utils + jq + LLM
20:30 - Escribir y transformar: insertar, crear, exportar y renombrar
23:00 - El módulo Python y los consejos: WAL, Vacuum, Optimize y FTS
25:20 - Conclusiones y lo que viene en el 841
Más información y enlaces en las notas del episodio: https://atareao.es/podcast/840
🌐 Todo en https://atareao.es · ✈️ Telegram https://t.me/atareao_con_linux · 🦣 Mastodon https://mastodon.social/@atareao · 🐦 Twitter https://twitter.com/atareao · 🐙 GitHub https://github.com/atareao

Llevo más de 6.000 notas en Markdown acumuladas desde 2008, y siempre he estado convencido de que ahí estaba todo lo que he aprendido. Hasta que busco y no encuentro. Busco particiones y no aparece nada sobre redimensionar un volumen. Busco monitorización de red y mis notas hablan de ntopng e iftop sin usar esas palabras. El conocimiento estaba ahí, pero yo no sabía que estaba.
En el episodio 837 te conté la teoría del GraphRAG. En este 839 vamos a lo práctico, a convertir esas 6.000 notas en un grafo de conocimiento con IA 100 % local, sin nube, sin claves API y sin que ninguna nota salga de tu equipo.
Lo primero es el chunking, trocear cada nota en ideas autónomas. Y no se trocea por número de caracteres, sino por estructura. Cada sección o subcapítulo es un fragmento, el frontmatter se separa como metadatos, los bloques de código viajan enteros y lo que baja de 50 caracteres se descarta. Trocear por caracteres solo rompe un bloque de código o una lista justo por la mitad.
Después viene el NER (Named Entity Recognition), que convierte texto libre en entidades con etiqueta, tipo y confianza. Uso llama3.2:3b con Ollama y solo conservo lo que supera 0,5 de confianza. Prefiero perder una entidad dudosa antes que llenar el grafo de ruido, porque un grafo con ruido no te sirve.
Con eso se construyen nodos y aristas. La nota es el documento entero, la entidad puede ser Nginx, Certbot o SSL, y las etiquetas salen de las carpetas y del frontmatter. Hay cuatro tipos de arista y cada una lleva su peso. La co-ocurrencia usa el mínimo de las dos confianzas, no la media.
Para construir todo esto ejecutas graphrag build. No empieza de cero, cada nota guarda un hash SHA256 y solo reprocesa lo que ha cambiado. En mi caso encontró 6.333 archivos y le faltaban 81, unos seis minutos, con cuatro hilos y un único escritor sobre SQLite. Y luego están las comunidades, la visión global. El algoritmo Leiden agrupa los conceptos muy conectados entre sí, porque los amigos de mis amigos tienden a formar un grupo.
Todo esto es graphrag-search, un único binario en Rust que instalas con cargo install graphrag-search. Ni Python, ni NPM, ni servidores. Con dos modelos pequeños de Ollama, bge-m3 para embeddings y llama3.2:3b para el NER, tienes tu propio cerebro conectado para encontrar episodios y conceptos relacionados.
Capítulos del episodio:
0:00 - Introducción: convertir 6.000 notas en un cerebro conectado
2:45 - Qué veremos hoy y la trilogía GraphRAG
4:20 - Chunking: trocear las notas en ideas autónomas
7:50 - NER: extraer entidades con un modelo local
7:50 - NER: extraer entidades con un modelo local
11:20 - Etiqueta, tipo y confianza: qué guardamos de cada entidad
13:50 - Nodos y aristas: conectar tus notas con semántica
17:10 - Construir el grafo con graphrag build
20:20 - SQLite e incrementalidad: el grafo que se actualiza solo
24:10 - Comunidades con el algoritmo Leiden
27:00 - Cierre y avance del siguiente episodio

Más información y enlaces en las notas del episodio
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
🦣 Mastodon 👉 https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao

Los metadatos de tus notas son puro oro, y me da la sensación de que todavía no lo sabes. Tienes títulos, fechas de creación, etiquetas... toda esa información del front matter de cada Markdown que, la mayoría de las veces, se queda ahí muerta de risa sin que le saques partido. En los episodios 819 y 821 te conté cómo la extraía con Python para montar un grafo de conocimiento. Funcionaba, pero para cualquier consulta rápida tenías que abrir el script, tocar el código y volver a ejecutarlo. Eso no es ágil.
En este episodio te presento al dúo dinámico: jq y yq. Dos herramientas que hacen una sola cosa y la hacen de maravilla, esa vieja filosofía UNIX que tanto nos gusta. jq es el procesador de JSON de referencia desde 2012, escrito en C y presente en casi todas las distribuciones. yq es el mismo concepto para YAML, XML, INI, TOML y CSV, escrito en Go por Mike Farah y distribuido como un binario único sin dependencias. Con las dos, y sin escribir ni una línea de Python, vas a extraer, filtrar y conectar los metadatos de tus notas.
Arrancamos con lo básico de jq, sus filtros y sus cuatro funciones estrella, select, unique, map y group_by. Son las que vas a reutilizar una y otra vez. Después pasamos a yq y a su joya de la corona, el soporte nativo de front matter. Con una línea tipo yq --front-matter=extract '.tags' nota.md sacas las etiquetas de una nota, y con -i la editas in place, algo que jq no permite. Actualizar la fecha de modificación, añadir un tag nuevo o convertir de YAML a JSON y al revés sin salir de la terminal.
Y luego llega la parte divertida, los pipelines. Encadenando fd, yq y jq consigues una lista limpia de los tags de tu vault, un informe con cuántos documentos usan cada etiqueta o el grafo de conocimiento completo en JSON, con nodos y aristas, sin Python y sin IA. También te enseño a detectar esas notas viudas que no tienen etiqueta y a cerrar el círculo pasando ese JSON a un modelo local con Ollama, para que te clasifique las notas y te diga qué conexiones hay entre ellas.
Terminamos con los errores más habituales, que ya me he encontrado de todo. Que yq solo procesa el primer documento si le pasas varios ficheros, que un front matter sin los delimitadores --- no lo reconoce nadie, o que jq no tiene edición in place. Pequeños tropiezos que te ahorro para que no pierdas media tarde peleándote con la terminal.
Si tienes un vault de notas, aunque sean solo diez archivos, este episodio te va a cambiar la forma de trabajar con ellos. Y si te gusta domar tus datos con herramientas pequeñas y afiladas, más todavía. Suscríbete al podcast, déjame una valoración y compártelo con quien todavía escriba un script de Python para leer un YAML. La semana que viene, en el 839, seguimos con el grafo de conocimiento y la IA local.
Capítulos:
0:00 - Introducción: yq y jq, el dúo dinámico
3:15 - Filosofía UNIX: domar datos sin escribir Python
5:45 - Qué es jq y qué es yq
8:00 - Filtros básicos con jq
10:45 - Funciones clave de jq: select, unique, map y group_by
13:15 - yq y Front Matter: extraer metadatos
16:00 - Edición in-place y conversión YAML ↔ JSON
18:30 - Pipelines: fd + yq + jq para extraer tags
21:00 - Del Front Matter al grafo de conocimiento
22:45 - Notas viudas y pipeline con IA local
24:30 - Errores comunes, conclusiones y despedida
Encontrarás todos los comandos y las notas del episodio en atareao.es, y si quieres participar en la comunidad, tenemos el grupo de Telegram en t.me/atareao_con_linux, además de la red de podcast Sospechosos Habituales en feedpress.me/sospechososhabituales. Un saludo y nos escuchamos el próximo lunes 🐧
Más información y enlaces en las notas del episodio
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
🦣 Mastodon 👉 https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao