Atareao con Linux

¿Alguna vez te has dado cuenta de que la búsqueda exacta se queda corta cuando tu base de conocimiento crece? Buscar por palabras exactas con grep o FTS5 es rápido y preciso, pero es literal y no entiende contexto ni sinónimos. Por otro lado, la búsqueda semántica pura con embeddings a veces falla con términos muy específicos como rutas de archivos o comandos exactos.
En este episodio te muestro cómo solucionar este problema combinando lo mejor de ambos mundos mediante tres técnicas avanzadas de RAG:
Búsqueda Híbrida (Hybrid Search): Cómo combinar FTS5 y embeddings semánticos utilizando un equilibrio ponderado (parámetro alpha).

Re-ranking con Cross-Encoder: Refinamiento de resultados pasando de un bi-encoder rápido a un cross-encoder preciso para priorizar la máxima relevancia.

HyDE (Hypothetical Document Embeddings): La técnica de generar un documento hipotético con un LLM local (Ollama) para encontrar notas mediante conceptos abstractos.

Además, repasamos cómo integrar todo esto en tu flujo de trabajo diario mediante herramientas CLI creadas en Python y Rust, así como la integración en Neovim con sqlite.lua.
Enlaces y recursos del episodio:
Gist con los scripts en Python (Hybrid Search, Reranker y HyDE)

Gist con la implementación del CLI en Rust (cerebro-cli)

Notas completas del episodio en: atareao.es

Este episodio va de ser vago. Pero vago en el buen sentido, eh. De esos que prefieren que una herramienta haga el trabajo pesado mientras tú te quedas con lo divertido. Resulta que hay todo un ecosistema de herramientas TUI con el prefijo "lazy" que te evitan tener que memorizar cientos de flags y opciones de comandos como git, docker, rsync o SQL. Y no, no es cutrez: son interfaces de terminal que funcionan a golpe de tecla, sin ratón, sin salir de la terminal, y encima molan.
Te cuento cómo nació todo esto, quién es Jesse Duffield (el creador de lazygit y lazydocker, con más de 80K y 52K estrellas en GitHub respectivamente) y por qué esta filosofía de "una tecla, una acción" ha enganchado a tanto linuxero. Y lo mejor: te hago demo de las cuatro herramientas principales para que veas cómo funcionan en vivo y en directo, con sus paneles, sus atajos y sus trucos.
Empezamos con lazygit, el rey indiscutible del ecosistema. 80.900 estrellas en GitHub, escrito en Go, y con una comunidad que no para de crecer. Desde stage línea a línea hasta rebase interactivo, pasando por undo/redo vía reflog. Te enseño cómo hacer commits, gestionar ramas, stash y hasta cherry-pick sin tener que acordarte de los flags raros de git.
Seguimos con lazysql, el gestor de bases de datos en terminal de Jorge Rojas. Soporta MySQL, PostgreSQL, SQLite, MongoDB, MSSQL y Oracle. Navegación por teclado, autocompletado de queries, exportación a CSV y configuración por proyecto. Ideal para cuando no te apetece abrir DataGrip o DBeaver solo para hacer una consulta rápida.
Luego viene lazyrsync, escrito en Rust con ratatui, y con una filosofía muy clara: que no se te olvide el flag ese que evita que borres todo. Perfiles reutilizables, dry-run con previsualización, protección contra --delete accidentales y paths dinámicos con variables. Perfecto para backups sin sustos.
Y cerramos con lazydocker, también de Jesse Duffield. Cuatro paneles: contenedores, métricas, imágenes y logs en vivo. Con un vistazo ves qué contenedor consume más CPU, entras en el terminal de uno con una tecla, o ejecutas docker-compose sin acordarte del comando. Y sí, también funciona con Podman.
Además te menciono otras herramientas del ecosistema: lazyssh, lazyjj para Jujutsu, lazykube, lazyprune para limpiar node_modules olvidados... Vamos, que hay lazy para todo.
Capítulos del episodio:
0:00 — Introducción: el problema de memorizar comandos
2:05 — La filosofía lazy: scripts, TUIs y el ecosistema lazy
4:30 — LazyGit: historia, filosofía "una tecla una acción" y +80K estrellas
6:45 — LazyGit: demo de paneles, stage, commits, ramas y stash
9:10 — LazySQL: Jorge Rojas, 4K estrellas y soporte multi-base de datos11:30 — LazySQL: demo con autocompletado, consultas y exportación CSV
14:00 — LazyRsync: dry-run, perfiles y protección contra errores
16:30 — LazyRsync: demo con columnas de estado y confirmación de borrado
19:10 — LazyDocker: Jesse Duffield, 52K estrellas y soporte para Podman
21:45 — Otras herramientas lazy: lazy-ssh, lazy-jj, lazy-kube, lazy-npm
23:15 — Cierre: sé un vago inteligente, valoración y despedida
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

Llevo 15 años escribiendo notas, artículos y tutoriales. El resultado: unos 5000 archivos markdown repartidos por mi disco duro. Y, como te puedes imaginar, encontrar algo ahí dentro es como buscar una aguja en un pajar. Por eso en este episodio me he puesto manos a la obra para montar un sistema RAG (Retrieval-Augmented Generation) 100% local, sin depender de APIs externas, sin enviar tus datos a la nube, y con herramientas que ya conoces: SQLite, Ollama y Python.
Este es el primero de dos episodios sobre RAG. Aquí nos centramos en construir la base de conocimiento: un pipeline que escanea tus documentos, los trocea en fragmentos manejables, extrae los metadatos del frontmatter YAML, genera embeddings con el modelo bge-m3 de Ollama, y lo guarda todo en una base de datos SQLite con búsqueda FTS5. Todo esto, además, con detección incremental de cambios: la primera ejecución tarda lo que tenga que tardar, pero las siguientes son cuestión de segundos porque solo reprocesa lo que ha cambiado.
El stack es sencillo pero potente. SQLite con FTS5 para búsqueda textual, Ollama con bge-m3 para los embeddings, y seis scripts Python que suman unas 1300 líneas. Nada de LangChain, nada de frameworks pesados. Código limpio, comentado y que entiendes de un vistazo. El chunking respeta las cabeceras markdown, usa tiktoken para contar tokens con precisión, y los embeddings se almacenan como BLOBs en la propia SQLite. En el próximo episodio (el 821) usaremos esta base de conocimiento para hacer búsqueda semántica con similitud de coseno, búsqueda híbrida combinando FTS5 con embeddings, y hasta un plugin para Neovim.
Puntos clave del episodio:
- El problema: 15 años de notas, 5000 archivos, cero capacidad de búsqueda
- La solución: RAG local con SQLite + FTS5 + Ollama, todo en tu máquina
- Chunking híbrido que respeta cabeceras markdown y usa tiktoken
- Pipeline incremental con detección de cambios mediante MD5
- Embeddings con bge-m3 (568M parámetros, 1024 dimensiones)
- Búsqueda FTS5 con snippet(), colores ANSI y sintaxis avanzada
- Errores comunes y cómo solucionarlos
Si te gusta el contenido, ya sabes: dale a seguir, compártelo con quien creas que le puede interesar, y déjame un comentario si tienes dudas o sugerencias. La semana que viene, en el episodio 821, montamos la búsqueda semántica y el plugin para Neovim. No te lo pierdas.
Capítulos del episodio:
0:00 - Introducción: RAG y base de conocimiento local
2:12 - El problema: 15 años de notas sin buscar
4:58 - La solución: SQLite + FTS5 + Ollama, 100% local
7:00 - Escaneo de archivos y extracción de front matter
10:20 - Preparación del entorno: Ollama, uv y dependencias
12:00 - Chunking: cómo trocear los documentos
15:45 - Estructura de la base de datos SQLite
17:46 - Pipeline incremental con detección de cambios
19:22 - Demo en vivo: consultas y resultados
22:44 - Errores comunes y cómo solucionarlos
24:10 - Resumen y adelanto del episodio 821
25:15 - Despedida y cierre

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

¿Tienes 5, 10 o 20 servidores SSH y no sabes cómo gestionarlos sin tener mil terminales abiertas? En este episodio te hablo de SSHub, una TUI open source escrita en Rust que unifica hosts, sesiones, túneles, SFTP y auditoría en una sola interfaz. Todo desde la terminal, sin salir de ella y sin necesidad de instalar nada más que un único binario compilado con cargo install de Rust.
Te cuento cómo pasé de un script en Bash que usaba desde 2019 para conectarme a mis servidores, a esta herramienta moderna que lee tu ~/.ssh/config y lo combina con una base de datos SQLite propia. Sin migraciones, sin complicaciones, sin tener que cambiar nada de lo que ya tienes configurado. Además la comparo con Termius y MobaXterm, que son de pago y cerradas, frente a SSHub que es gratis, multiplataforma y con licencia AGPL-3.0.
Voy paso a paso: instalación con cargo install sshub, navegación con atajos estilo Vim (teclas j/k), el cliente SFTP de doble panel con cola de transferencia y barra de progreso, la gestión de túneles con reconexión automática y backoff exponencial, el registro de auditoría que te salva de conectar al servidor equivocado, y hasta el modo broadcast para ejecutar comandos en varios servidores a la vez. También te explico cómo importar hosts desde Termius, PuTTY o mRemoteNG de forma sencilla.
Lo mejor de todo es que SSHub respeta tu configuración SSH existente. No la sustituye, la complementa. Detecta cambios al vuelo con un file watcher, así que cualquier modificación que hagas en tu config aparece al instante en la interfaz. Y si eres de los que prefiere la línea de comandos, tiene modo headless: sshub list, sshub connect, sshub sftp get/put... todo sin abrir la interfaz.
Si gestionas más de 10 servidores, usas túneles habitualmente o vienes de Termius buscando una alternativa open source, este episodio te va a interesar. Y si además te gusta hacer las cosas desde la terminal sin depender de aplicaciones gráficas, SSHub te va a encantar. Dale una oportunidad, que es gratis y no tienes nada que perder. Te espero dentro.

Capítulos del episodio:
0:00 — Introducción: el problema de gestionar múltiples servidores SSH
1:50 — El script de 2019 y la necesidad de una herramienta moderna
3:40 — SSHub: la TUI open source que lo unifica todo
5:30 — Características principales: hosts, túneles, claves y auditoría
7:30 — Instalación de SSHub con Cargo
9:30 — Navegación y atajos de teclado
11:30 — SFTP de doble panel y transferencia de archivos
13:30 — Gestión de túneles y claves SSH
15:15 — Auditoría de conexiones
17:00 — Importación, exportación y personalización
18:45 — ¿Para quién es SSHub? Despedida
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

¿Sabías que puedes convertir cualquier texto en coordenadas de 1024 dimensiones y hacer búsquedas inteligentes, clasificación automática o detección de duplicados sin depender de servicios en la nube? En este episodio te enseño a utilizar los embeddings con Ollama para potenciar tus documentos, correos y apuntes desde tu propio equipo Linux.
Los embeddings son una de las tecnologías más fascinantes de la inteligencia artificial actual. Básicamente, convierten palabras, frases o párrafos enteros en vectores numéricos que capturan su significado. Esto permite que un ordenador entienda que "gato" está más cerca de "felino" que de "nevera", y mucho más: desde búsqueda semántica hasta clasificación sin entrenamiento, pasando por deduplicación de documentos y sistemas de recomendación.
Lo mejor de todo es que no necesitas una GPU potente ni una cuenta en ningún servicio externo. Con Ollama ejecutándose en local y el modelo BGE-M3 (multilenguaje, con soporte para español), puedes generar embeddings desde la terminal con una simple llamada curl o con unas pocas líneas de Python. Y si necesitas escalar, ChromaDB te ofrece una base de datos vectorial completa con persistencia en disco y filtros por metadatos.
Capítulos del episodio:
0:00 - Introducción y concepto de embeddings
2:42 - ¿Qué son los embeddings exactamente?
5:13 - Modelos de embeddings: BGE-M3, all-MiniLM-L6-v2
7:25 - Cómo generar embeddings con Ollama y curl
8:01 - Búsqueda semántica: más allá de grep
11:57 - Búsqueda semántica con Python y NumPy
14:29 - Bases de datos vectoriales para escalar
14:53 - Clasificación sin entrenar el modelo
18:20 - Clasificación de sentimientos y categorías
20:02 - Deduplicación de documentos con embeddings
24:50 - Sistema de recomendaciones con similitud semántica
27:15 - ChromaDB: base de datos vectorial persistente
29:02 - Casos de uso y próximos episodios sobre RAG
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