#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ 01 — Todo cabe en un solo fichero ================================= Episodio «¿Cómo se le da memoria a una IA?» — Punto 6 del guion, «Las tres decisiones» (acto III — El relato y lo que lo sostiene). La idea del episodio -------------------- Todos los recuerdos de un asistente con memoria pueden vivir en **un único fichero** en tu propia máquina: lo que dijiste, las fichas de lo que pasó, cómo eres, qué pasó y cuándo, y la bitácora del día. Consecuencias: * Tus recuerdos **no salen de tu casa**: no hay nube a la que subir nada. * Lo copias a un *pendrive* y tienes tu memoria entera en el bolsillo. * Lo borras y no queda rastro en ningún sitio. * Lo abres y lees qué sabe el asistente de ti. Qué hace este ejemplo --------------------- Crea ese fichero único —un `.json` con las cinco capas dentro—, lo enseña por pantalla, lo copia como si fuera a un *pendrive* y comprueba que la copia contiene exactamente lo mismo. Los recuerdos que trae son **fragmentos reales de una instancia de Valet en producción**, generalizados para publicarlos: sin nombres de terceros, sin lugares y sin datos que permitan identificarla. La gracia no es el formato, es que **cabe todo junto y es tuyo**. No necesita nada instalado (solo Python 3, que ya viene en casi cualquier Linux). Uso: python3 01-un-solo-fichero.py # escribe ./memoria-demo.json python3 01-un-solo-fichero.py /ruta/mi-memoria.json """ import json import os import shutil import sys # ───────────────────────────────────────────────────────────────────────────── # Las cinco capas del episodio, dentro de un solo diccionario. Son fragmentos # reales de una instancia de Valet en producción, generalizados para publicar. # Capa A: lo que dijiste (la grabación en bruto) # Capa B: lo que pasó (fichas con el sentido de la conversación) # Capa C: cómo eres (tu retrato + el tono del asistente; en producción, 19 normas) # Capa D: qué y cuándo (hechos sueltos con fecha) # Capa E: la bitácora (el relato del día, escrito solo) # ───────────────────────────────────────────────────────────────────────────── MEMORIA_DE_EJEMPLO = { "A_lo_que_dijiste": [ {"quien": "tú", "texto": "Resúmeme los artículos de RSS que tengo pendientes."}, { "quien": "asistente", "texto": "Hecho. Te dejo por aquí los temas y las decisiones que saco en limpio.", }, ], "B_lo_que_paso": [ { "fecha": "2026-10-24", "temas": [ "RSS", "Docker Compose", "cifrado de disco", "monitorización de servidores", "alternativas a Dropbox", ], # Fragmento real de la ficha (≈257 tokens en producción). "sintesis": "Resumen y selección de artículos de RSS pendientes; " "el usuario pidió un resumen y una selección de lo más relevante.", } ], "C_como_eres": { # El retrato: verdades que se destilan con el tiempo, no hechos de un día. "quien_eres": [ "Sales a correr con regularidad y te gusta anotar distancias y ritmos.", "Prefieres resolver las cosas por la mañana.", ], # Las normas de casa: cómo quieres que se comporte tu asistente. # Estas tres están citadas tal cual; en producción hay 19. "normas_de_casa": [ "No inventes ni rellenes contenidos no disponibles; informa con " "honestidad sobre limitaciones de acceso.", "Verifica antes y después de crear recordatorios o eventos.", "No registres afirmaciones subjetivas o no verificables como hechos " "en el timeline.", ], }, "D_que_y_cuando": [ { # Cambiado de 2026-10-20 a 2026-10-17: el 20 es una de las jornadas # de la bitácora (18, 19 y 20) y no puede llevar dos cifras distintas. # El 17 no colisiona con ningún día de la bitácora y mantiene el # orden ascendente de la línea del tiempo (17 · 21 · 22). "fecha": "2026-10-17", "hecho": "Corrí 9,00 km con 119 m de desnivel y ritmo medio de 6:44 min/km.", }, {"fecha": "2026-10-21", "hecho": "Cené fuera."}, {"fecha": "2026-10-22", "hecho": "Corregí el nombre en la ficha de Valet."}, ], "E_la_bitacora": [ { "fecha": "2026-10-18", "relato": "Hoy ha sido un día de esos en los que la lluvia y las " "decisiones se entrelazan de manera inesperada.", "animo": "buen día", "logros": [ "Ajustar el plan de entrenamiento a la lluvia", "Decidir una tirada de 40 min en vez de 13 km", ], "dificultades": ["Condiciones adversas"], "etiquetas": ["entrenamiento", "meteorología", "decisiones"], } ], } def ruta_por_defecto(): return os.path.join(os.getcwd(), "memoria-demo.json") def main(): ruta = sys.argv[1] if len(sys.argv) > 1 else ruta_por_defecto() # 1) Escribir el fichero único. with open(ruta, "w", encoding="utf-8") as f: json.dump(MEMORIA_DE_EJEMPLO, f, ensure_ascii=False, indent=2) print("=" * 68) print(" UN SOLO FICHERO CON TODA LA MEMORIA") print("=" * 68) print(f"\n Fichero: {ruta}") print(f" Tamaño : {os.path.getsize(ruta)} bytes (ocupa nada, ya lo ves)") # 2) Enseñar las cinco capas que viven dentro, sin entrar en tripas. print("\n Dentro de ese único fichero:\n") etiquetas = { "A_lo_que_dijiste": "A · lo que dijiste", "B_lo_que_paso": "B · lo que pasó", "C_como_eres": "C · cómo eres", "D_que_y_cuando": "D · qué y cuándo", "E_la_bitacora": "E · la bitácora", } for clave, etiqueta in etiquetas.items(): contenido = MEMORIA_DE_EJEMPLO[clave] n = len(contenido) if isinstance(contenido, list) else len(contenido.keys()) print(f" • {etiqueta:<20} → {n} elemento(s)") # 3) "Copiarlo al pendrive": es un fichero, se copia y punto. destino = ruta + ".copia-pendrive.json" shutil.copyfile(ruta, destino) iguales = open(ruta, "rb").read() == open(destino, "rb").read() print(f"\n Copia al pendrive: {destino}") print(f" ¿La copia es idéntica? {'sí ✔' if iguales else 'no ✘'}") # 4) "Abrirlo y leer qué sabe de ti": aquí lo enseñamos en crudo. print("\n Y si lo abres, esto es lo que el asistente sabe de ti:") print(" " + "-" * 64) perfil = MEMORIA_DE_EJEMPLO["C_como_eres"]["quien_eres"] for verdad in perfil: print(f" · {verdad}") print(" " + "-" * 64) print("\n Lo borras y no queda rastro en ningún sitio. Eso es la gracia.\n") if __name__ == "__main__": main()

#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ 02 — Buscar por significado, no por palabra ============================================ Episodio «¿Cómo se le da memoria a una IA?» — Punto 3 del guion, «Lo que dijiste, lo que pasó y cuándo» (acto II — Los hechos y el retrato). La idea del episodio -------------------- Cuando le preguntas algo, el asistente no busca el libro que se titula literalmente como tu pregunta. Busca **ideas**. Si tú preguntas por «coche» y la ficha dice «automóvil», un buscador normal no lo encuentra; este sí. En el mundo real, el sistema traduce el texto a números (lo que llaman *búsqueda semántica* o RAG) y compara esos números. Aquí no vamos a meter un modelo: lo imitamos con un diccionario de conceptos hecho a mano, para que se vea la diferencia sin instalar nada. Qué hace este ejemplo --------------------- 1. Compara un **buscador por palabra** (cuenta letras en común) con un **buscador por significado** (compara conceptos). Misma pregunta, mismos recuerdos, resultados distintos. 2. Busca «quiero algo sobre el miedo a hablar en público» y enseña cómo el buscador de significado trae la ficha que habla de «ansiedad antes de una presentación», aunque no compartan ni una palabra. 3. De propina, reproduce el caso «coche / automóvil». No necesita nada instalado (solo Python 3). Uso: python3 02-buscar-por-significado.py """ import math import re import unicodedata # ───────────────────────────────────────────────────────────────────────────── # El "traductor a significado" de juguete. # # En un sistema real, un modelo convierte cada texto en una lista de números # (un vector) de forma que los textos que hablan de lo mismo acaban con números # parecidos. Aquí no hay modelo: definimos a mano unos cuantos CONCEPTOS y # decimos qué palabras activan cada uno. Es una maqueta, pero enseña la idea. # ───────────────────────────────────────────────────────────────────────────── CONCEPTOS = { "miedo_escenario": [ "miedo", "panico", "nervios", "ansiedad", "presentacion", "presentar", "publico", "escenario", "hablar en publico", "audiencia", "examen", ], "vehiculo": [ "coche", "automovil", "carro", "turismo", "vehiculo", "conducir", "volante", ], "comida": [ "comida", "cena", "receta", "cocina", "carbonara", "restaurante", "ingrediente", ], "salud": ["dentista", "medico", "salud", "diente", "muela", "consulta", "revision"], "tecnologia": [ "disco", "duro", "ordenador", "backup", "copia", "linux", "programa", ], } # Palabras vacías del castellano: las que aparecen en todas partes y no # significan nada por sí solas. Un buscador serio las ignora; si no, cualquier # pregunta haría "coincidir" con cualquier recuerdo solo por compartir un «el». STOPWORDS = { "el", "la", "los", "las", "un", "una", "unos", "unas", "de", "del", "a", "al", "en", "y", "o", "u", "que", "por", "para", "con", "sin", "se", "su", "sus", "mi", "mis", "me", "te", "tu", "tus", "lo", "es", "son", "fue", "fui", "soy", "era", } def normalizar(texto): """Minúsculas y sin acentos, para que 'público' y 'publico' se encuentren.""" texto = unicodedata.normalize("NFKD", texto.lower()) return "".join(c for c in texto if not unicodedata.combining(c)) def palabras_con_peso(texto): """Trocea un texto en palabras con significado, tirando las vacías (stopwords).""" todas = re.findall(r"\w+", normalizar(texto)) return {p for p in todas if p not in STOPWORDS} def pluralizar(n, singular, plural): """'1 palabra' / 'N palabras'.""" return f"{n} {singular if n == 1 else plural}" def vector_de_conceptos(texto): """Convierte un texto en una pequeña lista de números: cuánto toca cada concepto.""" limpio = normalizar(texto) vector = [] for palabras in CONCEPTOS.values(): cuenta = sum(1 for p in palabras if p in limpio) vector.append(float(cuenta)) return vector def similitud_coseno(a, b): """Cuánto se parecen dos listas de números. Va de 0 (nada) a 1 (idénticas).""" producto = sum(x * y for x, y in zip(a, b)) norma_a = math.sqrt(sum(x * x for x in a)) norma_b = math.sqrt(sum(y * y for y in b)) if norma_a == 0 or norma_b == 0: return 0.0 return producto / (norma_a * norma_b) def buscar_por_palabra(pregunta, recuerdos): """Buscador clásico: cuenta cuántas palabras CON SIGNIFICADO comparten.""" palabras_pregunta = palabras_con_peso(pregunta) puntuaciones = [] for r in recuerdos: comunes = palabras_pregunta & palabras_con_peso(r) puntuaciones.append(len(comunes)) return puntuaciones def buscar_por_significado(pregunta, recuerdos): """Buscador moderno: compara el 'significado' (los conceptos) de cada texto.""" v_pregunta = vector_de_conceptos(pregunta) return [similitud_coseno(v_pregunta, vector_de_conceptos(r)) for r in recuerdos] def batalla(pregunta, recuerdos): print("=" * 68) print(" BUSCAR POR SIGNIFICADO, NO POR PALABRA") print("=" * 68) print(f"\n Pregunta: «{pregunta}»\n") print(" Recuerdos disponibles:") for i, r in enumerate(recuerdos, 1): print(f" {i}. {r}") por_palabra = buscar_por_palabra(pregunta, recuerdos) por_significado = buscar_por_significado(pregunta, recuerdos) mejor_palabra = max(range(len(recuerdos)), key=lambda i: por_palabra[i]) mejor_sig = max(range(len(recuerdos)), key=lambda i: por_significado[i]) print("\n ── Buscador por PALABRA ─────────────────────────────────────") if max(por_palabra) == 0: print(" ✗ No encuentra nada: ningún recuerdo comparte palabras con") print(" la pregunta. Aquí se queda sin respuesta.") else: for i, r in enumerate(recuerdos): marca = " ← el primero" if i == mejor_palabra else "" etiqueta = pluralizar( por_palabra[i], "palabra en común", "palabras en común" ) print(f" {etiqueta} · {r}{marca}") print("\n ── Buscador por SIGNIFICADO ─────────────────────────────────") for i, r in enumerate(recuerdos): marca = " ← el primero" if i == mejor_sig else "" print(f" {por_significado[i]:.2f} de parecido · {r}{marca}") print("\n Fíjate: el buscador de significado trae la ficha que HABLA DE LO") print(" MISMO aunque no comparta ni una palabra con tu pregunta. Eso es") print(" lo que hace que el asistente parezca que te recuerda.\n") def main(): # Caso 1: el ejemplo estrella del episodio. batalla( "quiero algo sobre el miedo a hablar en público", [ "Ansiedad antes de una presentación y consejos para respirar.", "Receta de carbonara para la cena del sábado.", "El martes fui al dentista por la mañana.", ], ) # Caso 2: el «coche / automóvil» que cuenta el episodio. batalla( "¿qué te conté del coche?", [ "Hablamos de comprar un automóvil de segunda mano.", "Ayer preparé una carbonara bastante decente.", ], ) print(" Nota: en Valet esto es de verdad, con un modelo que traduce el") print(" texto a números. Aquí es una maqueta para que se vea la idea.\n") if __name__ == "__main__": main()

#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ 03 — La Bitácora: la memoria que se escribe sola ================================================ Episodio «¿Cómo se le da memoria a una IA?» — Punto 5 del guion, «El diario que se escribe solo» (acto III — El relato y lo que lo sostiene), la Capa E. La idea del episodio -------------------- La quinta pregunta no es «qué hiciste», es «¿cómo fue el día?». No pide una lista: pide un **relato**. Y lo mejor es que **se escribe sola**: una vez al día, de madrugada, el asistente coge lo del día (los hechos, los mensajes y el diario de ayer para no repetirse) y escribe **una entrada por día**. Con un detalle de otro nivel: puede decidir que **ese día no hay nada que contar**. Ese «no escribo» no es un error; es una respuesta válida. Qué hace este ejemplo --------------------- Lee un fichero con el «material del día» y hace lo mismo que haría Valet: * Si el día trae algo que merece memoria → escribe una entrada en `bitacora/AAAA-MM-DD.md`, en primera persona, y le añade los matices (ánimo, logros, dificultades, etiquetas). * Si el día está vacío → **no escribe nada** y lo dice en voz alta. Y respeta la regla de oro: **una sola entrada por día**. Si ya existe, no la duplica. En Valet el relato lo escribe un modelo. Aquí lo montamos a base de plantilla, sin instalar nada, porque lo que queremos enseñar no es la prosa, sino el **mecanismo**: recoger el día, decidir, y escribir una única entrada. Uso: python3 03-la-bitacora.py # enseña los días de ejemplo python3 03-la-bitacora.py datos/dia-2026-10-18.json """ import json import os import sys # Dónde se guardan las entradas, como en un diario real: un fichero por día. CARPETA_BITACORA = "bitacora" def dia_vacio(material): """Un día sin hechos, sin mensajes y sin nada que contar no merece entrada.""" return not material.get("hechos") and not material.get("mensajes") def componer_relato(material): """ Escribe el relato del día, en primera persona y con nuestras palabras. El episodio lo pide así: «no enumeres los hechos otra vez, descríbelos con tus palabras. Describe en vez de diagnosticar.» Aquí, sin modelo, hacemos una versión sencilla de esa idea: unimos los hechos en un párrafo que suene a cómo lo contarías tú, no a un informe. """ hechos = material.get("hechos", []) frases = [] # Abrimos con el primer hecho como arranque del día. if hechos: frases.append("Hoy " + hechos[0].rstrip(".").lower() + ".") # Y seguimos con el resto, enganchándolos con naturalidad. for hecho in hechos[1:]: frases.append("También " + hecho.rstrip(".").lower() + ".") if material.get("mensajes"): frases.append("Entre medias he ido hablando con el asistente de lo de siempre.") return " ".join(frases) def escribir_entrada(ruta, material): fecha = material["fecha"] os.makedirs(CARPETA_BITACORA, exist_ok=True) destino = os.path.join(CARPETA_BITACORA, f"{fecha}.md") # Regla de oro: una sola entrada por día. if os.path.exists(destino): print(f" {fecha}: ya había una entrada, no se duplica → {destino}") return relato = componer_relato(material) animo = material.get("animo", "sin determinar") logros = material.get("logros", []) dificultades = material.get("dificultades", []) etiquetas = material.get("etiquetas", []) lineas = [ f"# {fecha}", "", relato, "", f"- **Ánimo:** {animo}", ] if logros: lineas.append("- **Logros:** " + "; ".join(logros)) if dificultades: lineas.append("- **Dificultades:** " + "; ".join(dificultades)) if etiquetas: lineas.append("- **Etiquetas:** " + ", ".join(etiquetas)) lineas.append("") with open(destino, "w", encoding="utf-8") as f: f.write("\n".join(lineas)) print(f" {fecha}: se escribe la entrada → {destino}") print(" " + "-" * 62) for linea in lineas: print(" " + linea) print(" " + "-" * 62) def procesar(material): fecha = material.get("fecha", "sin fecha") print(f"\n Material del día {fecha}:") print(f" hechos : {len(material.get('hechos', []))}") print(f" mensajes : {len(material.get('mensajes', []))}") if dia_vacio(material): # Este es el «no escribo» explícito: una respuesta válida, no un error. print(" → NO se escribe entrada: ese día no hay nada que merezca memoria.") return escribir_entrada(CARPETA_BITACORA, material) def main(): print("=" * 68) print(" LA BITÁCORA: LA MEMORIA QUE SE ESCRIBE SOLA") print("=" * 68) if len(sys.argv) > 1: with open(sys.argv[1], encoding="utf-8") as f: procesar(json.load(f)) else: # Sin argumentos, enseña los días de ejemplo que trae el episodio: # dos jornadas reales (18 y 20 de octubre) y un día vacío, para ver # el «no escribo» en acción. aqui = os.path.dirname(os.path.abspath(__file__)) carpeta = os.path.join(aqui, "datos") for nombre in sorted(os.listdir(carpeta)): if nombre.startswith("dia-") and nombre.endswith(".json"): with open(os.path.join(carpeta, nombre), encoding="utf-8") as f: procesar(json.load(f)) print("\n Y así, sin que se lo pidas, el asistente te lleva el diario.") print(" De madrugada, una vez al día, decide y escribe. O decide no escribir.\n") if __name__ == "__main__": main()

#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ 04 — El olvido y el eco ======================= Episodio «¿Cómo se le da memoria a una IA?» — Punto 7 del guion, «No hay botón de olvidar» (acto IV — Lo que falta) y cierre. La idea del episodio -------------------- Lo que el asistente **no puede olvidar**. Hoy no hay un botón de «olvida esto»: no existe forma de decirle «aquello del dentista, bórralo». La memoria solo crece. El único botón para empezar de nuevo es brutal: borra **todo**. Entre «lo recuerdo absolutamente todo» y «no recuerdo nada de ti» no hay término medio. Y hay un hallazgo precioso en el tramo final del episodio: cuando el sistema borra, borra el texto… pero a veces **el eco se queda**. Una huella que el buscador todavía puede «oler» pero que ya no tiene texto detrás. Como esa palabra en la punta de la lengua: sabes que estaba ahí, no la alcanzas. Qué hace este ejemplo --------------------- Monta una memoria de juguete con unos recuerdos y una lista de «huellas» (lo que el buscador tiene anotado para poder encontrarlos) y prueba tres cosas: 1. Intentar olvidar **un** recuerdo → no existe ese botón. Se niega. 2. Un borrado chapucero que se lleva el texto pero deja la huella → aparece **el eco**: el buscador lo huele, pero no hay nada que leer. 3. El botón brutal de «empezar de nuevo» → borra todo de verdad. No necesita nada instalado (solo Python 3). Uso: python3 04-el-olvido-y-el-eco.py """ # ───────────────────────────────────────────────────────────────────────────── # La memoria de juguete. Cada recuerdo tiene su texto… y el buscador guarda # aparte una "huella" para poder encontrarlo por significado (como en el # ejemplo 02). Texto y huella viven juntos pero no son lo mismo: ahí está la # trampa del eco. # ───────────────────────────────────────────────────────────────────────────── class Memoria: def __init__(self): self.recuerdos = { 1: { "texto": "Corrí 9,00 km con 119 m de desnivel y ritmo medio de 6:44 min/km.", "huella": "deporte running entrenamiento kilómetros", }, 2: { "texto": "Cené fuera.", "huella": "social cena fuera", }, 3: { "texto": "Corregí el nombre en la ficha de Valet.", "huella": "sistema asistente ficha nombre", }, } def buscar(self, consulta): """Buscador de andar por casa: mira las huellas, no el texto.""" resultados = [] for rid, r in self.recuerdos.items(): if consulta.lower() in r["huella"].lower(): resultados.append((rid, r)) return resultados def titulo(texto): print("\n" + "=" * 68) print(f" {texto}") print("=" * 68) def main(): memoria = Memoria() titulo("1. Intentar olvidar UN recuerdo concreto") print("\n Le pedimos: «olvida lo de la salida de ayer, bórralo».\n") print(" …") print(" No hay un botón de «olvida esto». No existe.") print(" La memoria solo crece: lo único que caduca solo son las estadísticas.") print(" Y el único botón para empezar de nuevo borra TODO, no un recuerdo.") titulo("2. El eco: borrar el texto y dejar la huella") print("\n Imaginemos un borrado chapucero: se lleva el texto del recuerdo,") print(" pero la huella del buscador se queda. Mirad lo que pasa.\n") # Borrado chapucero: quitamos el texto pero dejamos la huella. del memoria.recuerdos[1]["texto"] print(" Recuerdo 1 después del borrado chapucero:") print(f" texto : {memoria.recuerdos[1].get('texto', '(ya no hay texto)')}") print(f" huella : {memoria.recuerdos[1]['huella']}") print("\n Ahora el buscador intenta encontrarlo por «running»:\n") for rid, r in memoria.buscar("running"): print( f" · recuerdo {rid}: huele a «{r['huella']}»… " f"pero texto = {r.get('texto', '(nada que leer)')}" ) print("\n Ahí está el eco: una huella que el buscador puede oler, pero que") print(" ya no tiene texto detrás. Un recuerdo al que has dejado de poder") print(" llegar, pero que sabes que estaba ahí.") print(" Como la palabra en la punta de la lengua.") titulo("3. El botón brutal: empezar de nuevo") print("\n No hay término medio. El único «empezar de nuevo» borra la memoria") print(" entera. Como si acabaras de instalar el asistente y nunca le") print(" hubieras contado nada.\n") memoria.recuerdos.clear() print(f" Recuerdos que quedan: {len(memoria.recuerdos)}.") print(" Ni el eco: nada. Eso sí es olvidar… demasiado.") titulo("Para llevarse") print("\n Un asistente que lo recuerda todo pero no sabe olvidar nada no es") print(" un buen asistente: es alguien que nunca te perdona nada.") print(" Y si esto algún día sale de tu máquina, el primer cambio no sería") print(" una capa nueva: sería un botón de OLVIDAR DE VERDAD.\n") if __name__ == "__main__": main()

# Ejemplos — «¿Cómo se le da memoria a una IA?» Material de apoyo para la web y para el oyente curioso. Acompaña al episodio de *atareao con Linux* que cuenta —sin una palabra de programación— cómo se le da memoria a un modelo de lenguaje, usando [`valet-ai`](https://github.com/atareao/valet-ai) como caso de estudio. Los ejemplos de aquí no son «de laboratorio»: son **fragmentos reales de una instancia de Valet en producción**, generalizados para poder publicarlos. Se han quitado nombres de terceros, lugares, restaurantes, proyectos internos y el nombre propio del asistente; se ha mantenido el resto —incluidas las cifras y los ejemplos de *running*— tal cual. > **Ojo:** aquí **no se instala ni se despliega Valet**. Eso es el episodio > siguiente, *«Podman, IPs reales y La Liga»*. Esto de aquí es solo para > **asomarse a las ideas**: cuatro ejemplos autocontenidos que se ejecutan con > Python 3 y no tocan nada de nadie. --- ## La estructura del episodio: 7 puntos, 4 actos El guión va de lo mecánico a lo humano en siete puntos, agrupados en cuatro actos. **Solo cuatro de esos puntos llevan demo**; los otros tres se apoyan en una imagen, un diagrama o un dato. Este es el orden de emisión, con el ejemplo que se ejecuta en cada punto que lo tiene: | Acto | Punto | Título | Qué se ve | Ejemplo | |---|---|---|---|---| | **I · El cajón** | 1 | Un buscador con modales | imagen | — | | **I · El cajón** | 2 | La memoria vive alrededor | diagrama | — | | **II · Los hechos y el retrato** | 3 | Lo que dijiste, lo que pasó y cuándo | **demo** | `02-buscar-por-significado.py` | | **II · Los hechos y el retrato** | 4 | El retrato | dato (19 normas) | — | | **III · El relato y lo que lo sostiene** | 5 | El diario que se escribe solo | **demo** | `03-la-bitacora.py` | | **III · El relato y lo que lo sostiene** | 6 | Las tres decisiones | **demo** | `01-un-solo-fichero.py` | | **IV · Lo que falta** | 7 | No hay botón de olvidar | **demo** | `04-el-olvido-y-el-eco.py` | Fíjate en que los nombres de los ficheros **no son `demo-01`, `demo-02`…**: se referencian por el nombre con el que el guión, la escaleta y la presentación los citan. El número del fichero es solo una etiqueta de taller, no el orden de emisión: el `01` se emite en el punto 6, el `02` en el punto 3, el `03` en el punto 5 y el `04` en el punto 7. --- ## Las cinco capas del episodio Todo el programa gira alrededor de cinco preguntas, que en Valet son cinco capas: **A · B · C · D · E**. De lo mecánico a lo humano. | Capa | Pregunta | Qué guarda | Ejemplo de aquí | |---|---|---|---| | **A** | ¿Qué guardo? | Lo que dijiste, tal cual. La grabación en bruto. | `01` | | **B** | ¿Cómo lo encuentro? | Fichas con el sentido de la conversación, buscadas **por significado**. | `01`, `02` | | **C** | ¿Cómo sé cómo eres? | Tu retrato: verdades sobre ti + cómo quieres que se comporte. | `01` | | **D** | ¿Qué pasó, y cuándo? | Hechos sueltos con fecha: tu línea del tiempo. | `01` | | **E** | ¿Cómo fue el día? | **La Bitácora**: el relato del día, escrito solo. | `01`, `03` | Y tres decisiones que atraviesan todas las capas: 1. **Todo cabe en un solo fichero**, en tu máquina → `01`. 2. **Una sola transacción**: las cuatro capas de la vida, de golpe → se cuenta en el episodio; el problema del «eco» se ve en `04`. 3. **La edad no borra, reordena** → se cuenta con la imagen de la biblioteca en el episodio. --- ## Cifras reales de la instancia Medido sobre la instancia de producción de Valet el **25 de octubre de 2026**. | Capa / actividad | Qué hay | Cifra | |---|---|---| | **Conversación** | Mensajes totales (268 usuario / 247 asistente), desde el 6-oct | **515** | | **A · indexado** | Mensajes ya procesados por el asistente | **503** | | **B · fichas** | Resúmenes de conversación guardados | **81** | | **C · persistente** | Una sola ficha, con normas de casa | **1 fila · 19 normas** | | **D · timeline** | Hechos con fecha (8 deporte, 1 social, 1 sistema) | **10** | | **E · bitácora** | Entradas (18–24 oct; 5 con ánimo «buen día», 1 «neutro») | **6** | | **Llamadas al modelo** | Chat 654 · router 237 · consolidador 192 · archivista 111 · timeline 74 · journal 6 | **1.274** | Procedencia: **instancia de producción de Valet, 25-oct-2026**, consultada en solo lectura. Las cifras se mantienen íntegras; lo único que se ha generalizado es lo identificable (nombres propios, lugares y proyectos). --- ## Los ficheros | Fichero | Necesita | Qué enseña | |---|---|---| | `01-un-solo-fichero.py` | nada (Python 3) | Cómo las cinco capas caben en **un único fichero** que es tuyo, con fragmentos reales de las capas A–E. Lo copias al pendrive, lo abres y lees qué sabe de ti. | | `02-buscar-por-significado.py` | nada (Python 3) | La diferencia entre buscar **por palabra** y buscar **por significado** (el bibliotecario de ideas del episodio). | | `03-la-bitacora.py` | nada (Python 3) | La Capa E: una entrada **por día**, escrita sola… o el «no escribo» cuando el día no da para nada. | | `04-el-olvido-y-el-eco.py` | nada (Python 3) | Que no hay botón de «olvida esto», que el único «empezar de nuevo» borra todo, y el **eco** de un recuerdo mal borrado. | | `datos/` | — | Tres jornadas de ejemplo para el `03`: el 18 y el 20 de octubre (reales) y un día vacío, para ver el «no escribo». | Todos son de **solo lectura** sobre el mundo exterior: crean sus ficheros de juguete en una carpeta de trabajo y no llaman a ninguna nube. --- ## Cómo probarlos ```bash cd ejemplos-la-memoria-de-valet python3 01-un-solo-fichero.py python3 02-buscar-por-significado.py python3 03-la-bitacora.py python3 04-el-olvido-y-el-eco.py ``` El `03` escribe sus entradas en una carpeta `bitacora/` del directorio donde lo ejecutes. Bórrala cuando quieras: así se ve, de paso, que borrar es borrar. --- ## Para qué sirve cada uno, contado en lenguaje llano **`02` — El bibliotecario que entiende ideas** *(punto 3)*. Un buscador normal te trae el libro que se titula literalmente como tu pregunta. El de Valet te trae **el libro que habla de lo mismo**, aunque no comparta ni una palabra. En el ejemplo (que es una maqueta, sin modelo) se ve cómo «quiero algo sobre el miedo a hablar en público» encuentra la ficha de «ansiedad antes de una presentación», y cómo «coche» encuentra «automóvil». **`03` — Alguien llevándote el diario** *(punto 5)*. La quinta capa no cataloga: cuenta. Le das el material de un día y decide si merece una entrada. Si el día está vacío, **no escribe nada**, y eso es una respuesta válida. Si escribe, es **una sola entrada por día**, con el relato y sus matices (ánimo, logros, dificultades, etiquetas). Los días de ejemplo son reales: el 18 de octubre (lluvia, plan de entrenamiento ajustado, tirada de 40 min en vez de 13 km) y el 20 de octubre (7,51 km en 51:42). **`01` — Tu memoria en un fichero** *(punto 6)*. Todo lo que sabe tu asistente —lo que le dijiste, lo que pasó, cómo eres, tu línea del tiempo y el diario— vive en **una sola caja fuerte** que está en tu casa. La copias a un pendrive y la llevas en el bolsillo. La abres y lees lo que sabe de ti. La borras y no queda rastro. Este ejemplo lo enseña con contenido real: una ficha de resumen de artículos de RSS, tres de las normas de casa, tres hechos de la línea del tiempo (una salida a correr de 9,00 km, una cena fuera y una corrección del nombre de Valet) y una entrada de bitácora del 18 de octubre. **`04` — La pregunta difícil** *(punto 7)*. Pedirle que olvide un recuerdo concreto no funciona: ese botón no existe. Solo hay uno, y es brutal: borra todo. Y en medio, el **eco** —una huella que el buscador todavía huele, pero sin texto detrás—, que es la mejor metáfora de lo que es la memoria, incluso la humana. Los recuerdos usados son los tres hechos reales del timeline. --- ## Lo que se cuenta en el episodio y no se ve aquí Para que no haya sorpresas a quien venga buscando trucos: - **La instalación y el despliegue de Valet no están en este episodio.** Llegan en el siguiente, *Podman, IPs reales y La Liga*. - La **búsqueda por significado** de verdad usa un modelo que traduce el texto a números. El `02` lo imita con un diccionario a mano para que puedas ejecutarlo sin instalar nada. - La **Bitácora** de verdad la escribe un modelo a partir de tus hechos y mensajes. El `03` reproduce el **mecanismo** (recoger el día, decidir, escribir una única entrada), no la prosa. ## El repositorio - **Valet** — <https://github.com/atareao/valet-ai> (público, licencia MIT)

{ "fecha": "2026-10-18", "hechos": [ "Ajusté el plan de entrenamiento a la lluvia.", "Decidí una tirada de 40 min en vez de 13 km." ], "mensajes": [ "Con esta lluvia, ¿qué me recomiendas para el entrenamiento de hoy?", "Apúntame que al final he cambiado la tirada larga por 40 minutos." ], "animo": "buen día", "logros": [ "Ajustar el plan de entrenamiento a la lluvia", "Decidir una tirada de 40 min en vez de 13 km" ], "dificultades": ["Condiciones adversas"], "etiquetas": ["entrenamiento", "meteorología", "decisiones"] }

{ "fecha": "2026-10-19", "hechos": [], "mensajes": [], "animo": "sin determinar", "logros": [], "dificultades": [], "etiquetas": [] }

{ "fecha": "2026-10-20", "hechos": [ "Finalmente pude salir a correr tras varios días de lluvia.", "Completé 7,51 km en 51:42." ], "mensajes": [ "¿Cómo llevo la semana de entrenamiento?", "Apunta la salida de hoy: 7,51 km en 51:42." ], "animo": "buen día", "logros": ["Retomar el entrenamiento tras la lluvia"], "dificultades": [], "etiquetas": ["entrenamiento", "running"] }