Convierte 6000 notas en un cerebro conectado

Vistas: 411
0:00 / 0:00
Convierte 6000 notas en un cerebro conectado

Llevo desde 2008 escribiendo en atareao.es, y con los años he acumulado más de 6000 notas en Markdown. Toda una vida de apuntes, tutoriales y pruebas de todo tipo. Estaba convencido de que ahí dentro estaba todo lo que he aprendido, hasta que un día busqué particiones y no apareció la nota que habla de redimensionar un volumen LVM. Busqué monitorización de red y me salieron las notas de ntopng y de iftop, que no usan esa palabra por ningún lado. Y busqué alta disponibilidad sabiendo que tenía tres notas relacionadas, y me devolvió una. El conocimiento estaba ahí, el problema era que yo no sabía que estaba ahí. 😅

Y eso es exactamente lo que te quiero contar hoy. En el episodio 837 te hablé de la teoría del GraphRAG y de los tres límites del RAG clásico. En este episodio vamos un paso más allá y lo llevamos a lo material, construimos el grafo. Te voy a explicar cómo se trocea una nota, cómo se extraen entidades con un modelo local, cómo se conecta todo y cómo se ve ese grafo desde arriba. Nada de recorrer código, conceptos primero y ejemplos después.

Qué es GraphRAG y por qué el RAG clásico no llega

Antes de meterme en faena necesito que tengas claro por qué existe esta cosa. Porque si no entiendes el problema, GraphRAG suena a palabra de moda y a marketing.

El RAG clásico, el de toda la vida, lo que hace es trocear tus documentos en fragmentos, calcular un embedding de cada fragmento y guardar todos esos vectores. Cuando tú preguntas algo, convierte tu pregunta en un vector, busca los fragmentos más parecidos y se los da al modelo como contexto. Para preguntas locales funciona de maravilla. Si le preguntas cómo configuro Nginx como proxy inverso, te va a recuperar el fragmento correcto y te va a responder bien.

El problema aparece con dos cosas. La primera es que el RAG clásico no sabe que las cosas están relacionadas. Para él, Docker, Podman, Compose y Kubernetes son cuatro fragmentos sueltos que casualmente comparten vecindario vectorial. No sabe que son una familia, que todos hablan de lo mismo, de empaquetar y ejecutar aplicaciones. Y la segunda es que no tiene visión global. No hay manera de preguntarle de qué van todas mis notas y que te dé una respuesta que abarque el conjunto, porque solo sabe enseñarte fragmentos sueltos.

Ahí es donde entra el GraphRAG, que es una idea de Microsoft Research, publicada en 2024 en el paper From Local to Global, a Graph RAG Approach to Query-Focused Summarization. La propuesta es construir, además del índice vectorial, un grafo de entidades y relaciones usando un modelo de lenguaje. Y encima de ese grafo, pregenerar resúmenes de las comunidades de entidades que aparecen juntas. Cuando tú preguntas, además de recuperar fragmentos parecidos, puedes recuperar el vecindario de un nodo en el grafo y el resumen de la comunidad a la que pertenece.

Fíjate en la diferencia, porque es la clave de todo el artículo.

RAG vectorialGraphRAG
Qué indexaFragmentos y embeddingsFragmentos, embeddings y un grafo de entidades
Qué recuperaLos fragmentos más parecidosFragmentos, vecindario del grafo y resúmenes de comunidad
Responde bien aPreguntas localesPreguntas locales y también globales
Punto débilNo sabe que Docker y Kubernetes son familiaEl coste de indexar, que se paga una sola vez

En mi caso particular no estoy hablando de teoría. Llevo meses construyendo herramientas alrededor de esto, y hoy lo que te traigo ya está funcionando, con todas mis notas y sin que se salga un solo byte de mi equipo.

El pipeline, en cinco fases

Lo bonito de todo esto es que, por debajo, es un proceso encadenado en cinco fases, y cada fase alimenta a la siguiente. El orden no es arbitrario.

Primero se escanea la carpeta donde tienes las notas y se localizan todos los ficheros .md. Segundo se trocea cada nota por secciones, que es lo que llamamos chunking. Tercero se hace el NER, que es extraer las entidades de cada fragmento con el modelo. Cuarto se conecta todo creando las aristas entre los nodos. Y quinto se guarda el resultado en la base de datos.

Cinco fases y, como verás un poco más adelante, un solo comando. La herramienta que utilizo es graphrag, un proyecto en Rust que publiqué como graphrag-search en crates.io. Un único binario, sin Python, sin npm, sin servidores. Toda la inteligencia artificial pasa por Ollama, que corre en tu propia máquina. Para instalarlo,

cargo install graphrag-search

Y necesitas Ollama en marcha con dos modelos, uno pequeño para los embeddings (bge-m3) y otro para el NER y los resúmenes (llama3.2:3b). Para que no te pelees con las descargas, te he dejado un script de preparación que comprueba que Ollama responde, baja los modelos si faltan y localiza el binario. Lo tienes en este gist, gist.atareao.es/atareao/0c3f13ca721b40c0997c7abbba62f205, y lo ejecutas con dos órdenes.

chmod +x setup.sh
./setup.sh

Con eso tienes el terreno preparado. Ahora vamos con la primera fase de verdad, que es la que más gente hace mal.

Chunking, trocear por estructura y no por caracteres

Lo primero que hay que entender es que una nota grande no se puede tratar como un bloque único. Y no lo digo solo por el límite de tokens del modelo, aunque también. Lo digo por algo más profundo.

Si yo le paso a la IA un documento de dos mil líneas que habla de qué es un proxy inverso, de cómo instalar Nginx, de certificados SSL con Certbot y de balanceo de carga, lo que obtengo no es la suma de esas cuatro ideas. Obtengo una media de todo. El significado se difumina, se convierte en una sopa donde ni Nginx ni Certbot destacan. Es como preguntarle a alguien por su vida entera y que te responda que fue variada. 😅 No sirve.

Así que troceamos. Pero con criterio, y esto es lo importante. No partimos por número de caracteres, porque eso rompe bloques de código, corta listas por la mitad y le da al modelo fragmentos que no significan nada. Troceamos por estructura, aprovechando la estructura que ya tiene tu nota. Y hay cuatro reglas.

La primera, cada título de nivel uno, dos o tres, es decir, #, ## y ###, abre un fragmento nuevo. Cada sección es una idea, y cada idea es la unidad mínima de búsqueda.

La segunda, el frontmatter, el bloque YAML de arriba entre los tres guiones, no es contenido, son metadatos. Se separa y se aparta. Ese frontmatter es el que luego nos permitirá tener el título y las etiquetas de la nota, y no se mete dentro de ningún fragmento.

La tercera, y esta es sagrada, nunca jamás se rompe un bloque de código. Si una sección tiene un bloque con sus tres acentos graves y dentro hay una configuración de Nginx de treinta líneas, ese bloque viaja entero. Partirlo sería mutilarlo. Media configuración de Nginx no sirve absolutamente para nada.

Y la cuarta, los fragmentos de menos de cincuenta caracteres se descartan. Un título suelto, una línea vacía, un ver también sin nada detrás. Eso es ruido, y fuera.

Vamos con el caso real, que es lo que aclara. Coge una nota mía de ejemplo, nginx-proxy-inverso.md, con un frontmatter que declara título, fecha y etiquetas.

---
title: Nginx como proxy inverso
date: 2025-02-10
tags: nginx, redes, linux, ssl
---

El frontmatter no acaba dentro de ningún fragmento, se procesa aparte. El encabezado de nivel uno, que es el título de la nota, tampoco genera fragmento, es el encabezado y ya está. Y quedan tres secciones, y por tanto tres fragmentos. En la base de datos, esa nota es la que tiene el identificador 96 y sus fragmentos son estos.

fragmentoencabezadotamaño
24## Qué es un proxy inverso566
25## Instalación y configuración básica813
26## SSL con Nginx y Certbot621

Y lo puedes comprobar tú mismo con una consulta a la base de datos.

sqlite3 grafo.db "SELECT id, header FROM chunks WHERE note_id = 96;"

Fíjate en el detalle del fragmento de instalación. Dentro viajan dos bloques de código completos, el de apt install nginx y el de la configuración del servidor, y ninguno se corta por la mitad. El troceador reconoce las vallas de acentos graves y trata el bloque como una unidad atómica. Esto importa mucho, tanto para que la configuración te sirva de algo como porque el NER que viene después extrae mejores entidades de un bloque íntegro.

Lo que quiero que te lleves de esta fase es una idea, cada fragmento es una idea autónoma. Es la unidad mínima de búsqueda y también la unidad sobre la que trabajamos en todo lo que viene después. Tres ideas, no una media de las tres.

NER, extraer entidades con un modelo local

Vamos con la parte que parece magia y no lo es, extraer entidades. NER son las siglas de Named Entity Recognition, reconocimiento de entidades nombradas. La idea es sencilla, convertir texto libre en una lista de conceptos.

Aquí los conceptos son concretos, herramientas, lenguajes de programación, bases de datos, librerías, frameworks, conceptos, protocolos, organizaciones, sistemas operativos, formatos. En el binario hay doce categorías de tipo, y son las que el modelo puede asignar a cada entidad que encuentra.

Ahora la pregunta interesante, ¿quién hace la extracción? La respuesta corta es un modelo de lenguaje local a través de Ollama. Y la pregunta lógica es, ¿por qué un modelo de lenguaje y no un diccionario fijo de términos? Pues precisamente por la misma razón por la que falla el RAG clásico. Un diccionario solo reconoce lo que ya está en la lista. Si mañana tu nota habla de una herramienta que acaba de salir, o de una que tú llamas de una forma particular, el diccionario se queda ciego. Un modelo entiende el contexto, sabe que en la frase configuración SSL con Nginx y Certbot hay tres cosas técnicas distintas, y sabe distinguirlas de verbos y de sustantivos genéricos.

Y el criterio es este. De cada entidad extraemos tres cosas, la etiqueta, el tipo y una confianza entre cero y uno. Por ejemplo, la etiqueta sería Nginx, el tipo sería herramienta, y la confianza sería un número. Y aquí está el detalle fino, solo conservamos las entidades que igualan o superan 0.5. ¿Por qué? Porque prefiero perder una entidad dudosa que llenar el grafo de ruido. Un grafo con ruido es un grafo en el que no confías, y un grafo en el que no confías no lo usas nunca.

Vamos al ejemplo, que es lo que aclara. Coge el fragmento de la nota anterior, el de ## SSL con Nginx y Certbot. Su texto menciona Nginx, Certbot, Let’s Encrypt, SSL y TLS. El modelo devuelve esas entidades y graphrag las guarda como nodos. Este es el resultado real.

entidadtipoconfianza
Nginxframework0.8
Certbottool0.8
SSLconcept1.0
Let’s Encryptorganization0.5
TLSconcept0.5

Fíjate en el detalle, Let’s Encrypt se clasifica como organización, no como herramienta. Y TLS y SSL como conceptos. El modelo no solo detecta el nombre, también intuye qué es. Y fíjate también en las que no aparecen, configurar, servidor, con, porque no son entidades, son simplemente palabras. El filtro de confianza y el buen juicio del modelo hacen el trabajo.

El campo de metadatos guarda la confianza y el modelo que la generó, como JSON.

{"score":0.8,"source":"llama3.2:3b"}

Una cosa que podrías hacer a mano, de hecho es lo que haces en muchos de tus artículos cuando pones etiquetas al final. Esto es lo mismo, pero de forma completamente automática y sin que tú te tengas que preocupar una a una.

Y una nota de eficiencia antes de seguir, porque aquí está una de las decisiones de diseño más importantes. En lugar de llamar al modelo fragmento a fragmento, se le manda el archivo entero en una sola llamada, con marcadores que separan cada sección. Cuando te devuelve la información, ya la tienes toda junta. Menos ida y vuelta, mismo resultado, y el proceso de construcción se acelera muchísimo. Ese es el puente entre tus notas tal y como las escribes y la estructura que necesitamos después.

Nodos y aristas, cada línea significa algo

Ya tenemos fragmentos y entidades. Ahora toca conectarlo todo, y aquí está una de las partes más elegantes de todo el diseño. Porque un grafo no son puntos y líneas sin más, cada línea significa algo.

Empecemos por los nodos, que hay tres tipos. El primero es la nota, el documento completo. El segundo es la entidad, que es Nginx, Certbot o SSL. Y el tercero es el tag, que sale de dos sitios, de las carpetas donde organizas las notas y de las etiquetas que ya escribes en el frontmatter.

Y ahora las aristas, que son cuatro, y cada una responde a una pregunta distinta. Esto es lo que quiero que interiorices, las aristas tienen semántica.

La primera es mentioned_in, que se lee aparece en. Va de la entidad a la nota y responde a la pregunta, ¿dónde se menciona Nginx? Su peso es la confianza que le dio el NER. Si Nginx salió con 0.8, la arista pesa 0.8.

La segunda es co_occurs_with, coaparece con. Va de entidad a entidad y responde a, ¿qué conceptos salen juntos en el mismo fragmento? Y aquí está el detalle bonito. El peso es el mínimo de las dos confianzas. Si Nginx salió con 0.8 y Certbot con 0.8, la arista entre ellos pesa 0.8. Y ¿por qué el mínimo y no la media? Porque si una de las dos apariciones es dudosa, la relación entera es sospechosa. Usar el mínimo evita contaminar el grafo con parejas que en realidad no lo son. Es conservador a propósito.

La tercera es belongs_to, pertenece a. Va de la nota a su carpeta, con peso uno siempre. Y la cuarta es tagged_with, etiquetada con. Va de la nota al tag, también con peso uno.

Sobre el peso quiero darte una metáfora, porque creo que ayuda. Un grafo no es una lista de amistades todas igual de estrechas, no. Hay conocidos y hay amigos íntimos. El peso mide esa cercanía, y gracias a él, cuando explores el grafo, los vecinos con conexiones fuertes contarán más que los débiles. Nginx y Certbot son amigos íntimos, Nginx y un concepto genérico son un saludo de pasillo.

Vamos con el ejemplo completo. Coge otra vez nginx-proxy-inverso.md. Tú no has escrito nada de esto, y sin embargo el grafo lo genera automáticamente.

(nota:nginx-proxy-inverso) ──belongs_to──> (node:redes)
(nota:nginx-proxy-inverso) ──tagged_with──> (node:nginx)
(nginx)   ──mentioned_in──> (nota:nginx-proxy-inverso)   peso 0.8
(certbot) ──mentioned_in──> (nota:nginx-proxy-inverso)   peso 0.8
(nginx)   ──co_occurs_with──> (certbot)                  peso 0.8

Cinco aristas, cuatro tipos, cero intervención manual. El listado es una simplificación didáctica, porque en el grafo real de esa nota hay bastantes más aristas, cuatro tags y varias menciones. Pero mira lo importante, todo esto lo ha deducido la herramienta. Tú solo pusiste las etiquetas en el frontmatter y organizaste las carpetas. El resto se ha generado solo.

Y con este comando, de un vistazo, ves el vecindario de Nginx, las notas donde aparece, las entidades con las que sale y sus tags.

graphrag graph 'nginx' graph.db -d 2

La estructura ya está ahí. Lo único que faltaba era construirla.

Construir el grafo con graphrag build

Y llegamos al momento de la verdad, construir todo esto. Y la primera noticia es buena, es una orden y listo.

graphrag build ~/notas graph.db

Al ejecutar ese comando, por debajo pasa todo el pipeline del que te hablaba antes, se escanean los ficheros, se trocean, se extraen las entidades, se conectan los nodos y las aristas y se guarda todo. Cinco pasos y una sola orden. Si quieres forzar el modelo de NER, se lo indicas explícitamente.

graphrag build ~/notas graph.db --ner-model llama3.2:3b

Pero hay dos ideas que hacen que esto merezca la pena, y ninguna es evidente a primera vista.

La primera es que el build es incremental. Cada nota guarda un hash SHA256 de su contenido. Cuando vuelves a construir, graphrag compara ese hash y solo procesa las notas nuevas o modificadas. Si no has tocado una nota, no la vuelve a mirar. Y además es limpio, si borras una nota, en el siguiente build se detecta y se poda, junto con las entidades que se quedan huérfanas. Nada de fantasmas en tu grafo.

La segunda idea es que el build es paralelo. Mientras varias notas se procesan a la vez en distintos hilos, la escritura se hace de forma ordenada, en un único hilo. Y ¿por qué? Pues porque SQLite aguanta muchas lecturas a la vez pero solo una escritura. Separando el trabajo pesado, que es la extracción de entidades y que sí va en paralelo, de la escritura serial, evitamos que los hilos se peleen por el fichero. Es la receta clásica, mucho cocinero y un solo camarero. En mi equipo levanto cuatro hilos de NER y un escritor.

Mira el log real de la primera pasada sobre un corpus de prueba de 24 notas.

[INFO  graphrag::graph::build] Notas existentes en BD: 0
[INFO  graphrag::graph::build] Encontrados 24 archivos .md en ./notas-muestra
[INFO  graphrag::graph::build] Archivos a procesar (nuevos/modificados): 24
[INFO  graphrag::graph::build] Procesando con 4 hilos en paralelo (NER) + 1 escritor
...
[INFO  graphrag::graph::build] Grafo construido: 📊 Resumen del grafo:
    ├── Archivos procesados: 24
    ├── Entidades extraídas: 138
    ├── Total nodos:        201
    └── Total aristas:      495

Ese mensaje de Entidades extraídas 138 es el bruto, con repeticiones. El NER puede sacar la misma entidad en fragmentos distintos, y el grafo la deduplica al guardar. Cuando mires las estadísticas verás que las entidades únicas son menos, pero eso lo vemos en un momento.

Ahora el contraste, que es lo que quiero que recuerdes. Vuelves a lanzar el mismo comando sin tocar nada, y pasa esto.

[INFO  graphrag::graph::build] Notas existentes en BD: 24
[INFO  graphrag::graph::build] Encontrados 24 archivos .md en ./notas-muestra
[INFO  graphrag::graph::build] Archivos a procesar (nuevos/modificados): 0
[INFO  graphrag::graph::build] Procesando con 4 hilos en paralelo (NER) + 1 escritor
[INFO  graphrag::graph::build] Grafo construido: 📊 Resumen del grafo:
    ├── Archivos procesados: 0
    ├── Entidades extraídas: 0
    ├── Total nodos:        201
    └── Total aristas:      495

Archivos a procesar, cero. No se ha reescrito nada, y la segunda pasada es casi instantánea porque no vuelve a llamar al modelo. Eso es la incrementalidad en acción.

En mi caso particular tengo más de 6000 notas, y la primera construcción, con todos esos documentos, me va a llevar tranquilamente un día entero. En los archivos del proyecto hay un orden de magnitud para que sepas a qué atenerte, con un modelo pequeño y cuatro hilos son unos 0.08 ficheros por segundo, lo que para 6254 notas se traduce en unas veintidós horas. Es mucha tela, así que si tienes un volumen grande de documentos, mi consejo es que hagas esa primera pasada con GPU o, si te da igual, con un modelo en la nube. Ahora, el día a día, cuando solo has añadido o corregido unas pocas notas, lo haces perfectamente en local. Como te decía al principio, en mi caso, cuando metí ochenta notas nuevas, el build me estimó seis minutos.

Y aquí está la gran ventaja de todo esto. Esto lo puedes dejar en un proceso que se ejecute todos los días. Todos los días mira tus notas, ve si hay cambios, los procesa y los guarda. Y ahí está el premio, todo esto sin nube, sin claves de API y sin que ninguna de tus notas salga de casa.

Si quieres afinar el comportamiento, el binario lee un fichero de configuración en ~/.config/graphrag/config.toml, con este aspecto.

db = "graph.db"
ollama_url = "http://localhost:11434"
embed_model = "bge-m3:latest"
ner_model = "llama3.2:3b"
summary_model = "llama3.2:3b"
k = 5
depth = 2
alpha = 0.7
notes_dir = ""
num_threads = 4

Ahí lo tienes todo, la dirección de Ollama, los tres modelos que usa, el número de hilos, el directorio de notas y un par de parámetros de búsqueda que tocaremos en el siguiente episodio.

Un fichero SQLite que llevas en el bolsillo

Y el remate de esta fase es que todo eso acaba en un único fichero SQLite. Portátil, lo copias a un pendrive, lo llevas a otro equipo y funciona. No hay que montar un servidor, ni una base de datos en la nube, ni nada parecido. Un fichero que cabe en cualquier sitio y que no sale de tu máquina.

Para ver la foto de tu grafo en cualquier momento, este comando.

graphrag stats grafo.db

Y te devuelve esto.

📊 Estadísticas del grafo:
├── Nodos totales:     201
├── Notas:             24
├── Entidades:         125
├── Tags:              52
├── Aristas:           495
├── Chunks:            58
└── Con embeddings:    58

Ahí tienes la cuenta que manda. 201 nodos son 24 notas más 125 entidades más 52 tags. Los 58 fragmentos tienen su embedding calculado, listos para buscar por similitud. Y fíjate que las entidades únicas son 125, no las 138 que decía el resumen del build, porque el grafo deduplica. La fuente de verdad es siempre stats.

Sobre el tamaño, para que te hagas una idea, la base de datos de mis 6000 documentos ocupa unos 500 MB. Un fichero que llevas en el bolsillo y que contiene el mapa completo de todo lo que he aprendido en quince años. 🔥

Comunidades con Leiden, el grafo visto desde arriba

Y llegamos al último bloque, que es el que responde directamente a uno de los límites que le pusimos al RAG clásico, la visión global. Porque hasta ahora todo lo que hemos hecho es muy bonito, pero es local, te dice qué hay alrededor de un nodo. Lo que no te dice es cómo está organizado tu conocimiento por encima de ese detalle.

Y ahí entran las comunidades. Una comunidad es un grupo de conceptos que están muy conectados entre ellos y poco con el resto. Piensa en tu propia base de notas, seguro que hay un racimo de cosas sobre contenedores, otro sobre redes, otro sobre bases de datos. No los has organizado así a propósito, pero están ahí. El grafo lo revela.

Esto es justo lo que me pasaba a mí con el blog. Yo veía mis artículos como cosas deslavazadas, uno detrás de otro. Pero la realidad es que he ido paso a paso buscando un objetivo concreto, y hay una guía argumental que probablemente tú no conozcas porque yo la he omitido. El grafo lo saca a la luz.

¿Y cómo se detectan las comunidades? Con un algoritmo que se llama Leiden, y no te voy a contar las matemáticas porque no te hacen falta. Quédate con la intuición, los amigos de mis amigos tienden a ser un grupo. Es la misma lógica por la que en un instituto acaban formándose pandillas sin que nadie las organice. Leiden recorre el grafo y encuentra esos racimos de forma automática.

Si te interesa el rigor, Leiden viene de un paper de 2019 de Traag, Waltman y van Eck, From Louvain to Leiden, guaranteeing well-connected communities. La gracia frente al algoritmo anterior, Louvain, es que Leiden garantiza que las comunidades resultantes están bien conectadas, mientras que Louvain puede producir hasta un veinticinco por ciento de comunidades mal conectadas y un dieciséis por ciento directamente desconectadas. Y encima Leiden es bastante más rápido en redes reales. Por eso lo elegí.

Para detectar las comunidades,

graphrag community detect graph.db --resolution 0.8

Y aquí hay un aviso práctico que quiero que te lleves grabado. La resolución es la palanca que controla el grano de la partición. Valores altos prefieren racimos pequeños y exigentes, valores bajos agrupan más y hacen comunidades más gordas. Con la resolución por defecto, que es uno, Leiden tiende a fusionar demasiado en corpus pequeños y puede no encontrar ningún corte. En mi demo, con esa resolución por defecto, el resultado fue cero comunidades. Cero. 😅 No es que el grafo esté mal, es que la resolución está mal elegida para ese tamaño.

Probando valores reales sobre la misma base, sale esta tabla.

resolucióncomunidades
0.230
0.523
0.822
1.00

Hay un acantilado entre 1.0 y 0.9. De 0.9 hacia abajo sí salen comunidades, y de ahí hacia arriba, nada. La elección razonable en este corpus es 0.8, que da veintidós comunidades sin romper el grafo en trozos diminutos. Así que si lanzas el comando con el valor por defecto y te sale cero, ya sabes, baja la resolución.

Hay otro detalle que conviene que sepas, y es un pequeño desfase del propio binario. Cuando ejecutas community detect, el CLI reporta Nivel 1, cero y Nivel 2, cero, pero las comunidades sí existen. Lo que pasa es que la detección las guarda en el nivel cero y luego el comando las cuenta mirando los niveles uno y dos, con lo que te informa de ceros. La fuente de verdad es la tabla de la base de datos.

sqlite3 grafo.db "SELECT COUNT(*) FROM communities;"

Y ahí están las veintidós. Veintidós comunidades detectadas sobre solo veinticuatro notas.

Déjame que te enseñe una de verdad, la mayor de todas, que tiene nueve miembros. Se llama community_0_34 y estos son sus integrantes.

126|miapp|person
127|miusuario|person
128|/opt/miapp|path
129|network.target|concept
130|multi-user.target|concept
131|systemctl|tool
132|daemon-reload|tool
133|enable|tool
134|on-failure|protocol

Se explica solo, ¿verdad? miapp, miusuario, /opt/miapp, systemctl, daemon-reload, enable y los targets de systemd. Todo pertenece a la nota de crear un servicio con systemd. Leiden ha visto que esas nueve entidades aparecen siempre juntas y las ha agrupado.

Detectar no basta. El paso que convierte cada comunidad en algo que un modelo de lenguaje puede usar es el resumen, y ese es el segundo comando.

graphrag community summarize graph.db

Aquí le pides a la IA que lea los miembros de cada comunidad y escriba una descripción de qué va ese racimo. Mira el log real.

📝 Resumiendo comunidades con 'llama3.2:3b'...
[INFO  graphrag::community::summarize] community 250 ('community_0_3'): summarized (283 tokens)
[INFO  graphrag::community::summarize] community 251 ('community_0_6'): summarized (348 tokens)
...
[INFO  graphrag::community::summarize] community 262 ('community_0_34'): summarized (602 tokens)
...
✅ 22 comunidades resumidas (6214 tokens totales)

Y la tarjeta de presentación que el modelo le puso a community_0_34 fue esta.

A community of entities related to system administration and configuration, specifically focusing on Linux-based systems. The community appears to be centered around the management of system services, processes, and configurations, with a focus on ensuring the stability and reliability of the system.

El resumen salió en inglés, porque el modelo pequeño a veces responde en su idioma, pero la idea es exacta, administración de servicios y configuración de Linux. Eso es precisamente lo que agrupa esa comunidad.

Y fíjate en por qué esto importa de verdad. El RAG clásico te daba los fragmentos más parecidos a tu consulta, y punto. No tenía forma de saber que Docker, Podman, Compose y Kubernetes eran una familia. Ahora sí. Ahora tienes, además de la lista de conceptos, una descripción de qué va cada racimo de tu conocimiento. Eso es contexto, no una lista. Y ese contexto es el que se inyecta en las respuestas cuando preguntas algo global, para que la respuesta tenga el marco adecuado. Es la visión global que le faltaba al RAG.

Tus notas ya eran un grafo

Vamos a recapitular, porque el viaje de hoy no ha sido corto.

Hemos empezado por el chunking, por qué no puedes tratar una nota como un bloque y cómo trocearla respetando títulos, frontmatter y bloques de código, descartando los fragmentos de menos de cincuenta caracteres. Cada fragmento, una idea autónoma.

Hemos seguido con el NER, cómo un modelo local convierte texto libre en una lista de entidades con etiqueta, tipo y confianza, conservando solo las que igualan o superan 0.5, porque es mejor perder una que llenar el grafo de ruido.

Después, los nodos y las aristas, con tres tipos de nodo y cuatro tipos de conexión, cada una con su semántica y su peso, y con el mínimo de confianza como criterio conservador en las coocurrencias.

Luego, el build, una orden, incremental por hash, paralelo con escritor serial y un único fichero SQLite portátil. La primera vez tarda, las siguientes son casi instantáneas.

Y por último, las comunidades, Leiden agrupando conceptos cercanos y resumiéndolos con IA para recuperar la visión global.

Y todo esto con una herramienta que insisto en señalar por lo que representa, un único binario Rust, publicado como graphrag-search en crates.io, con toda la inteligencia artificial pasando por Ollama en tu propia máquina. Cero Python, cero npm, cero servidores, cero datos saliendo de tu equipo.

La idea que quiero que te lleves es una sola, tus notas ya contienen un grafo, lo único que hacía falta era hacerlo visible. Fragmento a fragmento, entidad a entidad, arista a arista, y al final comunidades que te cuentan la historia completa de lo que sabes.

Yo lo estoy utilizando ya para algo muy concreto. Cuando creo un episodio nuevo, le pido al grafo los episodios y los capítulos relacionados, y así quien llega a un episodio suelto tiene un contexto mayor. Es esa visión global que yo, sin querer, he ido creando durante años, pero que ahora está ahí, a la vista.

Y me queda una pregunta rondando, porque me la estoy haciendo yo desde hace días. ¿De qué sirve tener un mapa si no sabes recorrerlo? Ya tienes el grafo construido, las entidades conectadas y las comunidades resumidas. Pero a la hora de buscar, de combinar lo semántico con lo estructural, de subir por el grafo o quedarte en la superficie, de decidir cuándo mandan los vectores y cuándo las relaciones, ahí es donde se separa el hombre del niño. Eso es exactamente lo que veremos en el siguiente episodio, la búsqueda híbrida.

Mientras tanto, la tarea para casa es sencilla. Coge tus notas, lanza un graphrag build y prueba community detect con distintas resoluciones para ver qué comunidades aparecen. Te aseguro que te vas a sorprender de lo que has escrito sin darte cuenta. 😊


Más información

Ver el vídeo de este episodio
Transcripción

Hola soy lorenzo y esto es atareado con Linux episodio número 839 en este episodio te voy,

A continuar con todo esto que te estoy hablando del graf rag de un poco ampliar el concepto de,

Un rag con pues con un grafo con un con una serie de grafos que nos van a permitir enlazar todas,

Nuestras notas todas nuestras entidades conceptos de manera que no tengamos notas aisladas sino que,

Hayamos conseguido construir un mapa total de todas nuestras notas permitiéndonos desplazarnos,

Entre cada una de las notas que tenemos y esto para mí es muy importante es muy importante porque,

Claro durante todos estos años que he estado escribiendo en atareado punto es sobre todo tipo,

De conceptos pues me he dado cuenta que hasta el momento había escrito pues artículos completamente,

Deslabazados artículos que no tenían una relación entre sí bueno por lo menos teóricamente pero es,

Que la realidad es que sí la realidad es que siempre han tenido relación por ejemplo todo lo que estoy,

Ahí escribiendo ahora referente a los grafos referente al rag pues están todos relacionados,

Porque estoy hablando todo sobre el mundo de la ia y además no solamente por eso sino porque detrás,

Estoy construyendo distintas aplicaciones y distintas herramientas que me impulsan o me llevan,

A terminar en hablar de rag o de grafrag por eso claro yo lo veo desde otro punto de vista,

Completamente distinto no te estoy hablando de conceptos completamente deslabazados sino que para,

Mí son conceptos que van completamente unidos porque llevan una guía argumental que probablemente tú,

No conozcas porque yo la he omitido bueno en muchas ocasiones siempre doy un contexto pero a lo,

Mejor tú has escuchado solamente un episodio has visto solamente un episodio entonces por eso te,

Encuentras perdido y por esto la posibilidad de tener un grafo que relacione todas las entidades,

Entre sí pues tiene mucho sentido así que si en el episodio anterior te hice una introducción a grafrag en,

Este episodio pues vamos a ir un paso más allá te voy a explicar cómo está montado y cómo lo estoy,

Montando yo para que tengas un concepto mucho más claro y no solamente esto sino que lo más importante,

Si quieres y así lo consideras puedas descargarte grafrag en tu equipo darle todas tus el directorio donde,

Están todas tus notas y pasárselas para que te construya tu propio grafrag y le puedas preguntar a él,

Así que vamos directos al turrón vamos a construir el grafo con una IA local,

Y es que como te decía pues es muy probable que lleves años acumulando miles de notas en,

Markdown yo te he puesto aquí pues 500 700 pero la realidad es que son muchas más yo ahora con todo,

Esto pues me he dado cuenta que llevo más de 6000 notas en estos años tampoco es que sean tantas,

Quiero decir que estamos hablando de en los últimos,

A ver desde el 2008 2009 hasta ahora pues todos esos años tampoco son tantas notas,

Y claro después de que tengas tantas notas y tal como te decía anteriormente probablemente estás,

Convencido de que ahí está todo lo que has aprendido durante este tiempo pero sin embargo cuando tú,

Buscas pues es muy probable que no encuentres y esto ya te lo he comentado en otras ocasiones si,

Buscas particiones y aparece redimensionar pues no redimensionar un volumen no eso no va a aparecer o,

Si buscas monitorización de red y no en tus artículos sobre if top no has dicho nada de,

Monitorización pues tampoco va a aparecer o por ejemplo alta disponibilidad pues es muy probable,

Que esa justo no lo encuentras y sin embargo todo ese conocimiento está ahí el problema es que no sabes,

Exactamente qué está ahí,

De qué te voy a hablar en este episodio pues en este episodio voy a continuar un poco,

Con el episodio anterior y luego llevarlo a lo,

A lo material te voy a poner el ejemplo claro en este episodio te voy a hablar sobre chunking es decir,

Esto de trocear las notas en ideas autónomas el nerd que es extraer entidades de un,

Con un modelo local esto es decirte que básicamente todo lo que he hecho aquí son,

Con modelos locales luego te voy a hablar también de nodos y aristas y es cómo conectar todo con,

Semántica cómo construir el nodo y luego qué son las comunidades un poco un concepto general,

Primero los conceptos y luego un ejemplo y no te voy a hablar nada de código no te voy a contar cómo,

Está hecho ni nada por el estilo esto un poco ya te expliqué en el episodio anterior sino que vamos a,

Ir directamente a lo práctico así en esta trilogía te hablé un poco en el episodio 837 de entender,

Todo esto en el 839 que es este te voy a hablar de construir y en 841 te voy a hablar de cómo sacar,

Información como te decía anteriormente graph rag es un proyecto implementado en rast y que es un,

Create directamente graph rag search que lo puedes descargar es un único binario ni python ni npm ni,

Servidores ni nada todo en absolutamente local con lo cual necesitas exactamente eso una oyama por,

Ejemplo para poder correr esto podrías utilizar otra pero bueno yo en principio lo he hecho todo para,

Oyama y al final qué es lo que te da esto pues simplemente te va a dar un archivo un sq lite un sq lite,

Un archivo una base de datos que la puedes llevar donde tú quieras básicamente los vectores y esto ya,

Te lo decía en el episodio anterior los los vectores te permite saber cuándo dos conceptos son similares y,

Los grafos lo que te van a permitir es conectarlos bueno para instalar esta herramienta simplemente es,

Cargo install graph rag search y ya lo tienes decirte que esta herramienta graph rag search o graph rag,

Simplemente la he construido para esta trilogía para que veas un poco todos los conceptos y para que,

Puedas hacer un poco lo que he hecho yo es decir todos esos artículos que tienes deslavazados poder,

Unirlos de una manera sencilla bueno empezamos por la primera parte que es el chunking y no es ni más ni,

Menos que asignarle una idea a un fragmento es decir lo que vas a hacer es dividir todos tus o cada uno de,

Tus artículos en trocitos y esos trocitos les vas a darles o vas a convertirlos,

En,

En una idea no esos trocitos no es solamente el límite de tokens del modelo cuando sino que va un,

Poco más allá por ejemplo lo que yo te decía es que lo que vas a hacer es dividirlo entre los,

Capítulos para que o entre subcapítulos o subcapítulos o secciones eso como tú lo veas no pero,

Es lo importante lo importante es que consigas dividirlo de manera adecuada y además no solamente,

Esto sino que solapas un poco con los anteriores para que no esté completamente deslavazado no sólo,

Como te decía no solamente es importante el tema del límite de tokens sino exactamente lo que tienes,

Cada fragmento al final es una idea autónoma y es la unidad mínima de búsqueda y esto es lo,

Importante de todo el asunto porque cómo se relaciona un fragmento con el fragmento anterior,

Todo esto es exactamente lo que te monta el grafrag que de otra manera probablemente no lo tendrías,

Relacionado entonces partes por un número de caracteres o sea quiero decir si lo que haces es partir por,

Un número de caracteres lo que vas a hacer es romper bloques de código o cortar listas entonces lo que,

Haces es utilizar la estructura que cada nota tiene entonces cada sección o cada capítulo subcapítulo o,

Sección son fragmentos nuevos el front matter no se tiene en cuenta nunca se rompe un bloque de código,

Y los fragmentos de menos de 50 caracteres se descartan por completo básicamente esto es la,

Estructura que ya utilizamos en anteriores episodios y es que al final cada sección es un es una idea,

Como te digo el caso real bueno pues es por ejemplo yo tengo en mi front meta en mi front matter en la,

Parte superior de cada uno de mis artículos pues información como el título la fecha en la que lo,

Escribe algunas etiquetas eso no se mete dentro de ningún fragmento sino que se utiliza en la base de datos para,

Darle más contexto a cada una de las notas,

Por ejemplo el engine x como proxy inverso es el encabezado de la nota y no genera ningún fragmento,

Bueno luego tienes los distintas partes los distintos encabezados que tengas por ejemplo en,

El caso de que tengas tres secciones como puede ser que es un proxy inverso e instalación y,

Configuración básica o ssl con engines y third bot eso lo que te va a dar son tres acciones que son,

Tres fragmentos tres ideas y estas tres ideas no es una medida de las una media de las tres sino que,

Son tres ideas concretas cada una de estas ideas pues tiene un tamaño concreto por ejemplo 566 tokens,

800 Tokens lo que sea no solamente esto sino que además el encabezado viaja como con el fragmento,

Cuando buscas sabes a qué tema pertenece exactamente luego el código es otra de las partes el código nunca,

Se trocea el troceador reconoce cuando estás delante de un de un trozo de código y trata el bloque,

Como una unidad atómica y esto es claro imagínate que yo te estoy haciendo un ejemplo de un código en,

Python y lo que hago es partirlo por la mitad bueno pues evidentemente esa media mitad no vale,

Absolutamente para nada igual si te estoy dando la configuración de un engine x si te pacto la,

Configuración de un engine x a la mitad pues no te va a servir absolutamente de nada y además el nerd que,

Ahora veremos lo que es extrae mejor entidades que un bloque intero que es el nerd bueno el nerd que,

Es lo que se traduce como name entity recognition es el reconocimiento de entidades nombradas nombradas,

La idea básicamente es convertir texto libre en una lista de conceptos taxonomía herramientas lenguajes,

Bases de datos librerías frameworks conceptos protocolos organizaciones sistemas operativos,

Básicamente es el puente entre todas tus notas,

Así es esto es básicamente lo que es el nerd no es un no es un diccionario fijo de términos porque un,

Diccionario reconoce lo que ya está sino que es algo que está vivo un lm con básicamente entiende el,

Contexto no entiende no no va un poco más allá simplemente de entender palabras yo actualmente,

Para hacer todo esto lo que utilizado son dos modelos locales servidos por el llama uno que es,

Bg m3 que es para hacer todos los embeddings y el llama 3.2 de 3 billions para el nerd y los,

Resúmenes como ves son dos modelos relativamente pequeños sobre todo el bg m3 que los puedes,

Utilizar directamente con con cpu lo que pasa que a ver yo empecé haciendo esto con cpu y lo que me,

Encontré lo que realmente me encontré es que tardaba muchísimo para este ejemplo hubiera sido,

Prácticamente imposible con 5.000 documentos en este caso yo creo que lo comenté en episodios,

Anteriores aquí la gracia a lo mejor sería si tienes un gran volumen de documentos o bien hacerlos con,

Gpu o bien hacerlos con un modelo externo con un modelo en la nube y luego el día a día sí que lo,

Podrías hacer perfectamente con un modelo local y esta es una de las grandes ventajas porque todo,

Esto el tema del graph rajo del rajo como tú lo quieras montar al final la gran ventaja que tienes es,

Que solamente haces modificaciones y o pequeñas modificaciones o creas nuevos documentos pero,

Creas unos pocos nuevos documentos y esto se procesa muy rápido y la gran ventaja es que todo esto sobre,

Todo si no lo haces lo haces con tranquilidad y no utilizas nada de un servicio de terceros por lo,

Haces sin nube ni claves api y sin que ninguna de tus notas salgan de casa al final de cada entidad,

Sacamos básicamente tres cosas la etiqueta el tipo y la confianza por ejemplo la etiqueta sería,

Engine x el tipo sería herramienta concepto protocolo y la confianza sería un número entre 0 y 1 y lo,

Interesante de todo esto es que solamente vamos a conservar los que tienen una confianza superior a,

0,5 Y es que al final vale la pena tener perder una entidad que no está más o menos clara que llenar,

Tu grafo de ruido que no te va a aportar absolutamente nada un grafo con ruido es un grafo en el que no,

Vas a confiar en absoluto así por ejemplo entidades tienes engine x third bot ssl let's encrypt tls y los,

Tipos que tienen asociados por ejemplo en gen x tiene asociado framework third bot tool ssl un concepto,

Let's encrypt una organización tls un concepto y a cada uno de estos le asignas una se le asigna,

Esa valoración que te decía anteriormente 0 8 1 0 5 el modelo no solamente detecta el nombre sino que,

Intuye lo que es por eso se utiliza un modelo como te estaba diciendo el llama 3.2 billions para,

Interpretar exactamente qué es lo que hay evidentemente todo esto que te estoy contando lo,

Podrías hacer a mano de hecho pues distintas serran bueno de hecho tú lo que haces en muchos de tus,

Artículos en las etiquetas es poner etiquetas bueno pues esto sería más o menos como hacerlo de una,

Manera completamente automática sin que tú te tengas que preocupar una a una lo que seguro que no va a,

Aparecer pues van a ser conceptos o palabras como configurar servidor ni la palabra con porque al final no,

Son entidades son simplemente palabras el filtro del confianza y el buen juicio del modelo es lo que,

Hacen realmente el trabajo y lo más interesante del tema es que no llamas al modelo fragmento fragmento,

Sino lo que le mandas es un archivo completo en una sola llamada con marcadores que separan cada,

Sección y de esta manera cuando te devuelve el archivo ya tienes o sea cuando te devuelven la,

Información pues ya tienes toda la información necesaria es decir no estás enviando trocitos un,

Trocito otro trocito otro trocito sino que mandas todo el documento y él te devuelve exactamente como lo,

Quieres bueno y luego vienen los nodos y aristas cada conexión pues qué es lo que significa y esto el,

Nodo es el dio la nota es el documento completo la entidad es el engine x servot ssl y el tag sale de,

Dos sitios de las carpetas y los tags del front matter un grafo al final no son puntos y líneas y más sino que,

Cada línea significa algo y qué es lo que significa cada línea bueno pues tienes cuatro tipos de líneas o cuatro,

Tipos de aristas que son mention in concurs with belongs to itag with y son por ejemplo va de entidad,

Anota la primera entidad a entidad de nota a carpeta y de nota a estos son los los distintos y luego tienes,

Los pesos en el por ejemplo que esté mencionado va en función de la confianza del leer entidad a entidad va,

El mínimo de las dos confianzas y en los otros es siempre uno y cada una de las aristas responde una,

Pregunta distinta donde se menciona una un determinado concepto que sale junto a qué pertenece a qué,

Carpeta pertenece y con qué etiqueta con qué tag está valorado y como te decía al final un graf no es,

Única y exclusivamente una lista de amistades todas igual de estrechas sino que tienes conocidos tienes,

Amigos íntimos tienes amigos lejanos y es el peso lo que mide la distancia entre cada uno de esos,

Elementos en gine x y third bot son amigos realmente íntimos.

Y esto es importante y es lo que marca realmente pues cuando estamos buscando algo que estemos de,

Digamos en el camino más corto de un determinado grafo el detalle fino de co o course width por ejemplo en,

Gine x 0 8 más third bot 0 8 quiere decir que la lista que une entre los dos es 0 8 el mínimo no la media,

Y esto es realmente interesante bueno al final todo esto que te estoy contando la gracia de todo esto,

Es que tú no haces nada de esto o sea tú ni dices quién pertenece a quién y que está bueno las etiquetas,

Y que las vas poniendo tú pero el resto de todo esto se genera de una manera completamente automática,

Gracias a esta herramienta y esto es lo realmente interesante bueno cómo construir esto pues como te decía,

Al final para construirlo simplemente es ejecutar graph rag y build y con esto lo que va a hacer es empezar a,

Construir tu grafo pero lo interesante del caso es que no va a empezar desde cero sino que va a construir,

Sobre aquello que no tiene o actualizar aquello que se ha modificado utilizando para ello básicamente,

Un hash si ahora lo pongo en marcha lo que va a hacer primero es comparar el número de hashes me dice que ha encontrado,

6.333 Archivos en mi directorio de notas y que le faltan 81 a procesar y entonces empieza a procesar uno,

Tras otro lo trocea o sea hace todas las operaciones primero la que te comentado que es la de escanear,

Recorre todas las carpetas luego trocea a partir de cada nota es decir divide cada nota por secciones,

Extrae las entidades de cada uno de los fragmentos y luego conecta crea las aristas entre los nodos,

Y finalmente lo que hace es guardarlo lo que he hecho para acelerar un poco todo este proceso,

Básicamente ha sido levantar varios hilos yo levanto cuatro actualmente estoy levantando cuatro hilos,

Esos cuatro hilos están trabajando en paralelo y los resultados se envían a un único escritor porque,

Estoy utilizando la base de datos ese culite en modo único para evitar el tema de problemas con la base,

De datos entonces ahora él está ya trabajando ha establecido que el tiempo aproximado para resolver,

Esas 81 nuevos trozos serán seis minutos con lo cual podemos casi terminar el episodio,

Como te decía cada nota guarda un hash ese hash es el hash del contenido lo que nos va a permitir,

Determinar si efectivamente una nota o un trozo de una nota se ha modificado al reconstruir el graph,

Solamente compara y procesa las notas nuevas y si evidentemente si no has tocado una nota pues no va a,

Hacer nada con ella con ella y además es limpio si borras una nota se poda,

No solamente la nota sino las entidades huérfanas nada de fantasmas en tu grafo y como te digo,

Una la primera vez que lo haces pues la cosa es que va a tardar bueno yo te digo minutos pero realmente,

Sonoras dependiendo del tipo de yo para esto lo que estoy utilizando es la una tarjeta en media en,

Mi Slimbook y una envidia 3 4060 con 16 gigas de ram y con esto para procesar los 5000 o los 6000,

Documentos yo creo que tardé pues no sé si un día o una cosa así pero luego has visto para procesar 80,

Documentos nuevos pues simplemente tardado o va a tardar 6 minutos decirte también que lo suyo es,

Que esto lo tengas directamente en un proceso que se ejecute todos los días de manera que todos los,

Días mira a tus notas ve si hay cambios y los guarda y así lo tienes y esto se como te digo se queda,

Guardado en la base de datos que la base de datos actualmente para los 6000 documentos son unos 500,

Megas o una cosa así bueno al final de todo esto el nerf es lo que es realmente caro porque para,

Obtener cada uno de los nerf lo que hace es el fragmento lo procesa o llama y para esto hay que,

Esperar realmente los fragmentos cada uno de los fragmentos son independientes y lo que como te,

Decías los procesos de forma simultánea y,

Y como te dije como te decía anteriormente esto lo estoy haciendo en paralelo para evitar o para ir un,

Poco más rápido porque al final,

El grave inconveniente que puede ser o sea digamos que el cuello de botella lo tienes en o llama no lo,

Tienes en escribir en la base de datos o del leer de la base de datos una vez terminado ahora cuando,

Termine de hacer el proceso pues simplemente te va a dar información de lo que ha sucedido con tu,

Proceso cuántos archivos han procesado cuántas entidades han se han extraído el número de nodos y el,

Número de aristas eso es lo que te da el resumen por ejemplo lo que te va a decir es un número de,

Aristas pero en las estadísticas lo que te va a dar es exactamente el número de estadísticas de,

De líneas únicas el nerf se repite repite entidades y el grafo las de duplica al guardar es decir tú,

Puedes tener evidentemente distintas esto lo veremos ahora en cuanto termine bueno le queda todavía un,

Poquito con stats lo que vas a ver como te decía es todas las estadísticas correspondientes al grafo,

Y al final lo que obtienes y esto es verdaderamente interesante es un archivo una base de datos ese,

Culite esa base de datos que es un archivo único lo puedes copiar en un usb y llevártelo donde,

Quieras y lo vas a poder utilizar en cualquier momento es decir que toda tu información va a ir,

Contigo es incremental y en paralelo y claro actualizarlo día a día no cuesta prácticamente,

Nada y nos queda el tema de las comunidades hasta el momento todo era muy local te dice que hay,

Que cosas hay alrededor de un nodo pero lo que no te dice es exactamente cómo está organizado todo tu,

Conocimiento no te da una visión global y ahí es donde entran las comunidades es exactamente el tercer,

Límite que le pusimos al rag clásico la visión global un grupo de conceptos muy conectados entre,

Sí y poco con el resto eso es básicamente lo que una lo que se define como una comunidad seguro que,

Tienes racimos contenedores redes bases de datos no lo organizaste al final tú no lo organizas pero,

Están ahí que es un poco lo que te decía en la introducción del episodio aunque tú veas mis episodios,

O puedas ver un episodio concreto puedes pensar que está completamente deslavazado del resto pero la,

Realidad no es esa la realidad es que yo he ido paso a paso por cada uno de los episodios en busca de un,

Objetivo concreto no es que lo haya organizado así pero es que es lo que realmente el grafo va a,

Revelar el algoritmo que se utiliza para construir esto de las comunidades es el algoritmo leyden y no hace,

Falta matemáticas sino que quédate simplemente con la con lo que es la intuición de lo que sucede,

Los amigos de mis amigos tienden a ser un grupo eso es básicamente lo que es una comunidad y para,

Montar las comunidades lo que tienes es grafrag he creado un par de entradas en la aplicación que,

Lo que te permiten es construir detectar cada una de las comunidades y luego generar un resumen de las,

Comunidades la primera de las la primera el primero de las de los comandos el detect lo que detecta son,

Las distintas comunidades y la segunda lo que hace es conseguir un resumen de cada una de las,

Comunidades luego dependiendo del valor que le pongas pues vas a tener más o menos comunidades en,

Función del tipo de resolución que establezcas yo actualmente por defecto le he puesto uno y ya sale,

Mil comunidades o una cosa así sale bastante,

Y yo creo que con esto es un poco todo lo que te quería contar luego luego en el siguiente episodio,

Pues veremos cómo después de todo lo que hemos montado aparte del chunking de todo lo que te,

He ido contando pues veremos cómo extraer información porque como te decía en este episodio lo único que,

Hemos hecho ha sido construirlo de hecho todavía está esto en construcción me quedan todavía.

A ver le queda todavía 30 episodios 60 episodios un poco menos de 60 episodios pero claro esto es,

Bastante bueno en este episodio un poco te contado lo que era el chunking te contado lo que son los nerds,

Los nodos y aristas los hemos empezado a construir esos 80 documentos que me quedaban y has visto un poco,

Lo que son las comunidades no te muestro el resumen de ya porque claro son mil comunidades y va a tardar bastante,

Pero si lo haces con un ejemplo básico con una demo de las que hay directamente en el en la propia,

Aplicación lo vas a ver muy fácil y esto es un poco como te digo lo que te quería contar es un episodio un,

Poco denso pero bueno es que estamos construyendo todo este toda esta información con tus con tus notas de,

Una manera relativamente sencilla y rápida y poco más que decirte espero que te haya gustado este nuevo,

Episodio que va a haber disfrutado tanto como lo disfruto yo construyéndolo ya sabes si puedes,

Pues simplemente descárgate graph research en crates ejecútalo con tus notas o simplemente ejecuta la demo,

Que tienes y y pruébalo y a ver qué es lo que te sale y lo que no te sale como te digo en el siguiente,

Episodio lo que vamos a hacer es un ejemplo ya práctico de cómo consultar todos los datos y cómo,

Extraer cómo seguir el grafo y qué cosas podemos hacer básicamente esto lo puedes utilizar para,

Lo que es cuando generas un nuevo documento todos aquellos documentos relacionados por ejemplo yo lo,

Estoy utilizando actualmente para cuando creo un nuevo episodio añadir episodios relacionados o,

Capítulos relacionados para que tengas un contexto un poco mayor básicamente lo que te decía,

Prácticamente al principio del episodio esa esa visión global que yo sin querer he ido creando pero que,

Está ahí y nada más espero que te haya gustado este nuevo episodio y que lo hayas disfrutado tanto como,

Disfruto yo recordarte que este es un podcast de la red de podcast de sospechosos habituales donde puedes,

Encontrar fantásticos y maravillosos podcast puedes participar en esta red entrando en telegram en,

Tablet info y de la misma manera si quieres participar el grupo de atareado con Linux simplemente,

Tienes que buscar atareado con Linux en telegram y allí nos vas a encontrar pues hablando ahora,

Un poco de ya bueno ahora bastante de de ya sobre todo de modelos de qué es lo que estamos haciendo,

Cada uno pero en general de Linux y del mundo del open source y poco más que decirte recordarte que la,

Vida son dos días y uno ya ha pasado así que disfruta como si no hubiera mañana y si puede ser con Linux y en,

Este caso con grafrag mejor que mejor un saludo y nos escuchamos el próximo jueves hasta luego.

1 comentario en “Convierte 6000 notas en un cerebro conectado”

  1. Dieciocho años ya de publicaciones, wow. No recuerdo desde cuando comencé a tener a Atareao entre mis blogs de cabecera, pero no fue mucho después.
    Así que aprovecho para darte las gracias por compartir tu experiencia y sabiduría.
    Hay ocasiones en las que el nivel de tus posts me deja atrás, pero hasta en esos casos disparan mi curiosidad y me hacen aprender cosas nuevas, y son muchas las cosas de mi día a día que he solventado gracias a tus sugerencias y tus tutoriales.
    De nuevo, muchas gracias y bienvenido a la mayoría de edad, que dieciocho años son muchos años

Deja una respuesta