Mi Segundo Cerebro Digital

¿Cuántas veces has guardado un artículo, una receta o una nota técnica solo para olvidar que existía semanas después? Hoy en dia, tengo muchos sistemas de gestión de conocimiento, estáticos (wikis), acumulativos (correos) y un ecosistema que solo crece, diverge y que hace imposible poder consultar informacion de manera rapida y precisa sobre ellos (bueno, hay avances enterprise con agentes, pero no todos tienen acceso a eso, no?).

En este artículo, te mostraré cómo construir un Segundo Cerebro Digital. No se trata de un simple almacén de notas estáticas, sino de un sistema dinámico que interactúa contigo, entiende el contexto de tu conocimiento y responde tus preguntas en tiempo real utilizando RAG (Retrieval-Augmented Generation) de forma 100% local y privada.

No busco hacer una solución megarobusta, si no una aproximación suficiente para poder gestionar mi propia información (Grafos de conocimiento por ahora no).

Arquitectura General

El sistema propuesto considera estos componentes (que puedes alterar a placer, no afecta el resultado final):

Github – Repositorio para almacenamiento persistente
Obsidian – Editor de notas con archivos Markdown locales
Qdrant – Base de datos vectorial para búsquedas semánticas
Ollama – Servidor de embeddings locales con EmbeddingGemma
Hermes Agent – Agente para procesar requerimientos de cliente
Telegram – Interface de comunicacion
LLM – Modelo de lenguaje extenso (Para la generacion aumentada)

Metodo PARA

¿Qué es el Método PARA?

Antes de aplicar algoritmos, necesitamos orden. El Método PARA (creado por Tiago Forte) organiza la información digital en función de su usabilidad y nivel de acción, no de su temática.

El cerebro humano está diseñado para procesar y crear ideas, no para almacenarlas estáticamente. Al clasificar tus notas según su urgencia o aplicación práctica, reduces significativamente la carga cognitiva.

Se divide en cuatro carpetas:

P – Proyectos: Tareas activas con fecha límite y un objetivo concreto (ej. «Lanzar nueva web»).
A – Áreas: Responsabilidades continuas sin fecha de término (ej. «Finanzas» o «Salud»).
R – Recursos: Temas de interés y material de referencia para el futuro (ej. «Guías de código»).
A – Archivos: El historial inactivo. Todo lo completado o pausado se guarda aquí para despejar la mente.

Estructura PARA

Para organizar mi vault use la siguiente estructura:

Obsidian/Brain/
├── Proyectos/
│   ├── Desarrollo
├── Areas/
│   ├── Salud/
│   ├── Finanzas/
│   └── Carrera/
├── Recursos/
│   ├── Programacion/
│   ├── DevOps/
│   └── Cocina/
├── Archive/
├── Templates/
└── index.md

Esta estructura mantiene todo organizado sin complicarse.

Stack Tecnológico

Obsidian

Es una base de conocimiento local que funciona como un «IDE para tu pensamiento», permitiéndo conectar ideas de forma orgánica.

Sus tres pilares fundamentales son:

Local-First (Privacidad absoluta): Tus notas se guardan en tu propio equipo como archivos de texto plano (.md). Eres el dueño real de tus datos; no dependes de la nube ni de servidores ajenos.
Enlaces bidireccionales ([[Conexiones]]): Te permite enlazar notas entre sí fácilmente. Al hacerlo, creas una red de ideas interconectadas que imita la sinapsis del cerebro humano.
Extensible y Hackeable: Mediante plugins comunitarios, puedes transformarlo en lo que necesites: desde un simple diario hasta un gestor de proyectos con bases de datos o un motor de IA local.

Qdrant

Qdrant es una base de datos vectorial de código abierto ultra optimizada. Para levantarla de forma rápida y persistente, utilizamos el siguiente archivo de configuración:

# docker-compose.yml
version: '3.8'

services:
  qdrant:
    image: qdrant/qdrant:latest
    ports:
      - "6333:6333"
      - "6334:6334"
    volumes:
      - qdrant_data:/qdrant/storage
    restart: unless-stopped

volumes:
  qdrant_data:

Ollama + Gemma

Utilizamos Ollama para ejecutar modelos de forma local en nuestra CPU/GPU. Usaremos el modelo embeddinggemma:300m, que genera vectores matemáticos compactos pero de excelente calidad.

# Verificar modelos instalados
ollama list

# Descargar modelo de embeddings
ollama pull embeddinggemma:300m

El modelo genera vectores de 768 dimensiones, suficiente para capturar semántica de texto técnico.

Implementación

Paso 1: Segmentación Inteligente (Chunking)

Para que la búsqueda semántica sea precisa, no podemos indexar un documento gigante completo. Debemos dividirlo en fragmentos (chunks) más pequeños utilizando una técnica de superposición (overlap) para evitar pérdidas de contexto en las fronteras de los textos.

def chunk_text(text: str, max_chars: int = 1000, overlap: int = 200) -> list[str]:
    """Divide texto en chunks superpuestos."""
    chunks = []
    start = 0
    while start < len(text):
        end = start + max_chars
        chunk = text[start:end]
        if chunk.strip():
            chunks.append(chunk.strip())
        start = end - overlap
    return chunks

El overlap de 200 caracteres asegura que no se pierda contexto entre chunks.

Paso 2: Generación de Embeddings

Cada fragmento generado es enviado a Ollama para convertirse en una representación numérica (vector de 768 dimensiones).

def get_embedding(text: str) -> list[float]:
    """Obtiene embedding de Ollama."""
    resp = requests.post(
        f"{OLLAMA_URL}/api/embeddings",
        json={"model": EMBED_MODEL, "prompt": text}
    )
    resp.raise_for_status()
    return resp.json()["embedding"]

Paso 3: Indexación y Almacenamiento en Qdrant

Estructuramos la información en Qdrant guardando tanto el vector (para la búsqueda matemática) como un payload de metadatos (para rastrear el origen de la nota).

point = {
    "id": point_id,
    "vector": embedding,
    "payload": {
        "text": chunk,
        "path": doc["path"],
        "title": doc["title"],
        "chunk_index": j,
        "modified": doc["modified"]
    }
}

Paso 4: Recuperación de Información (Retrieval)

Cuando hacemos una consulta, la transformamos en un vector y buscamos los 5 fragmentos más similares en nuestra base de datos.

def search(query: str, limit: int = 5) -> list[dict]:
    """Busca chunks similares en Qdrant."""
    embedding = get_embedding(query)

    resp = requests.post(
        f"{QDRANT_URL}/collections/{COLLECTION}/points/search",
        json={
            "vector": embedding,
            "limit": limit,
            "with_payload": True
        }
    )
    resp.raise_for_status()

    return resp.json()["result"]

Integración con Hermes Agent

El componente clave de este sistema es Hermes Agent, un agente de IA que actúa como capa de inteligencia sobre la infraestructura vectorial.

Cómo funciona

Hermes no es solo un chatbot – es un agente con acceso directo a:

Qdrant vía API REST (puerto 6333)
Ollama para generar embeddings de queries
Tu vault para mantener contexto

Cuando le haces una pregunta, Hermes:

Convierte tu pregunta a un vector usando Embedinggemma
Busca los chunks más similares en Qdrant
Recupera el contexto relevante de tu vault
Genera una respuesta basada en esa información

Ejemplo de uso

Tú: "¿Qué proyectos tengo activos?"

Hermes ejecuta:
  python3 rag.py "proyectos activos"

Resultado del vault:
  [MOC - Proyectos]
  - SecondBrain
  - MiAwsomeProject  
  - SQLForDummies

Hermes responde:
  "Tienes 3 proyectos activos: SecondBrain (app para un segundo cerebro digital),
   MiAwsomeProject (orquestador Bash con agy), y SQLForDummies (Interfaz inteligente SQL)."

Capacidades

Si bien, no me interesa describir en profundidad como funciona por debajo, hay que entender en general lo siguiente:

Búsqueda semántica – No necesita palabras exactas, entiende el significado
Contexto automático – Recupera información sin que busques manualmente
Respuestas aumentadas – Combina lo que sabe con lo que hay en tu vault
Aprendizaje continuo – Cada vez que ingresas notas nuevas, el sistema las incorpora

Scripts disponibles

# Búsqueda directa
python3 query.py "tu búsqueda"

# RAG completo (busca y prepara contexto)
python3 rag.py "tu pregunta"

# Re-ingestar después de cambios
python3 ingest.py

Ejemplo práctico

Si preguntas «¿Cómo preparar pizza?», Hermes hará lo siguiente:

Busca en Qdrant: python3 rag.py "preparar pizza"
Encuentra tu receta en Recursos/Cocina/Pizza.md
Recupera los ingredientes y pasos
Te da una respuesta completa y contextualizada

Esto convierte tu vault de Obsidian en un cerebro consultivo, no solo un almacén de notas.

Mantenimiento

Mantener tu segundo cerebro es sumamente sencillo gracias a que todo reside en tu máquina local.

Re-ingestar después de cambios

python3 ingest.py  # Lee de ~/Obsidian/Brain

Verificar estado

# Dashboard de Qdrant
http://localhost:6333/dashboard

# Modelos de Ollama
curl http://localhost:11434/api/tags

Conclusiones

Un segundo cerebro digital con RAG ofrece:

Búsqueda semántica – Encuentra información por significado, no solo por palabras clave
Contexto automático – Recupera la información relevante sin buscar manualmente
Escalabilidad – Crece con tu conocimiento
Privacidad – Todo corre localmente, sin dependencias externas

La combinación de Obsidian + Qdrant + Gemma es una solución potente, privada y escalable para gestión de conocimiento personal.

Recursos

Repositorio

Para que puedan probar yaa, sin concursos ni sorteos:

https://github.com/metalback/obsidian-rag

Saludos.

Tags: genai hermesagent rag secondbrain