Lecciones del grafo de conocimiento on-device de Apple
El grafo de conocimiento on-device de Apple enseña a lanzar ML privado y local-first. Cinco errores habituales y cómo corregirlos.

Dile a tu Mac que « envíale un mensaje a mi hermano » y lo hace sin más. Sin spinner, sin búsqueda visible, sin viaje de ida y vuelta a la red: ya sabe cuál de las cientos de personas de tu agenda es tu hermano. Esto funciona porque desde macOS Ventura todos los Mac ejecutan en silencio un grafo de conocimiento on-device: un par de daemons que leen tus Contactos, los grupos de caras de Fotos, los asistentes de Calendario, los metadatos de Mail y Mensajes, los patrones de ubicación y los datos de Tiempo de uso. Luego fusionan todo eso en un almacén consultable sobre quién eres, a quién conoces y cómo se relacionan esas personas contigo y entre ellas.
Investigadores de seguridad han descubierto hace poco hasta dónde llega esto. Los dos daemons, knowledgeconstructiond e intelligenceplatformd, mantienen un directorio de 51 bases de datos SQLite en ~/Library/IntelligencePlatform. La pieza central, graph.db, es un almacén de triples escrito con un vocabulario de 181 clases de entidades y 278 predicados, que incluye relaciones de parentesco inferidas que nadie escribió nunca en una tarjeta de contacto. El debate más ruidoso sobre este hallazgo gira en torno al consentimiento, y es un debate legítimo. Pero yo llevo años construyendo funcionalidades de ML para vivir, y cuando leí el análisis mi primera reacción fue otra: se trata de una de las piezas de ingeniería de ML local-first más instructivas jamás desplegadas a gran escala. Así que, en lugar de reabrir el debate ético, quiero repasar los cinco errores que cometen los profesionales al construir sistemas como este, y lo que los ingenieros de Apple hicieron bien y mal, para que no tengas que aprenderlo por las malas.
Error 1: Recurrir a un modelo grande en lugar de clasificadores pequeños
Lo primero que piensan la mayoría de equipos cuando oyen « el sistema operativo entiende a tu familia » es que debe de haber un modelo de lenguaje grande detrás. No lo hay, y ahí está la lección. La inferencia de parentesco que salió en los titulares, es decir, que el sistema decida que este contacto es tu madre y aquel tu jefe, la hacen clasificadores estrechos y especializados que procesan señales estructuradas: pertenencia y edades en Compartir en familia, los campos de nombres relacionados de Contactos, los patrones de coasistencia en el calendario, la frecuencia y direccionalidad de las comunicaciones y la coaparición de caras en Fotos. Cada clasificador responde bien a una pregunta pequeña, y el grafo une las respuestas.
Esto importa por una razón muy práctica: el presupuesto. Un daemon que funciona de forma continua, con batería, junto a todo lo demás que hace el sistema, no puede permitirse un paso hacia delante de un transformer por cada evento. Los clasificadores pequeños tardan microsegundos en la Neural Engine, son lo bastante deterministas como para testearlos unitariamente y, cuando uno falla, puedes reentrenar solo ese sin tocar el resto. He visto equipos gastar trimestres enteros intentando que un modelo general haga lo que un árbol de gradiente boosting con treinta variables bien elegidas hace mejor. Ya hablamos de este fenómeno en visión: las CNN especializadas superan de forma habitual a los LLM de frontera en clasificación de imágenes a una fracción del coste. El patrón se cumple en todas partes. Las funcionalidades de personalización casi nunca necesitan un modelo general: necesitan un buen esquema y un montón de clasificadores aburridos y excelentes.
El otro beneficio, poco valorado, es la degradación elegante. Si el pipeline de reconocimiento facial nunca se ejecuta porque el usuario no usa Fotos, el clasificador de parentesco sigue teniendo Compartir en familia y Contactos con los que trabajar. Los modelos monolíticos se degradan de forma catastrófica cuando cambia la distribución de sus entradas; un conjunto de clasificadores específicos por señal simplemente pierde un voto. Cuando diseñes tu próxima funcionalidad on-device, enumera primero las señales independientes y luego pregúntate cómo es el modelo más pequeño para cada una. Reserva el LLM para la última milla de la interacción en lenguaje natural, que es donde realmente encaja.

Error 2: Guardar hechos sin procedencia ni posibilidad de retracción
Hay un detalle del análisis que la mayoría de la cobertura pasó por alto, y es la parte que más elegante me parece. Una arista de este grafo, « esta persona trabaja en esta organización », no es una sola fila. Son dos filas que comparten un relationshipId: una fila nombra el tipo de relación y la otra apunta a la entidad relacionada. Existen 46 clases de tipo de relación cuyo único propósito es transportar esta indirección. Eso se llama reificación, y la razón para hacerlo es que la arista en sí pueda llevar propiedades (una puntuación de confianza, una fuente, una marca de tiempo) y que pueda retractarse después sin fingir que nunca existió.
Este es el error que más veo en los sistemas de personalización caseros: hechos guardados como columnas planas. user.employer = "Acme". Funciona hasta que alguien cambia de trabajo, se divorcia o la inferencia simplemente estaba mal, y entonces o bien sobrescribes un historial que necesitabas para depurar, o bien dejas datos obsoletos porque borrarlos rompe algo aguas abajo. Los hechos personales caducan rápido: la gente se muda, las relaciones terminan, los empleos cambian. Un almacén que no puede expresar « creímos esto con confianza 0,7, procedente de los asistentes del calendario, retractado el 3 de marzo » se llenará en silencio de fantasmas. El esquema que lo resuelve se parece a esto:
-- A reified edge: two rows share one relationship id,
-- so the edge itself can carry confidence and provenance.
CREATE TABLE triples (
subject TEXT NOT NULL, -- an entity id
predicate TEXT NOT NULL, -- e.g. 'relationshipType', 'relatedEntity'
object TEXT NOT NULL, -- a value or another entity id
rel_id TEXT, -- groups the rows forming one edge
confidence REAL, -- how sure are we?
source TEXT, -- which signal produced this fact
created INTEGER NOT NULL,
retracted INTEGER -- soft delete: facts decay, history stays
);
-- One edge, two rows:
-- ('person:8f2a', 'relationshipType', 'employerOf', 'rel:91', 0.82, 'calendar', ...)
-- ('person:8f2a', 'relatedEntity', 'org:acme', 'rel:91', 0.82, 'calendar', ...)
Fíjate también en lo que la elección de implementación te dice: todo esto vive en SQLite puro. Nada de base de datos de grafos exótica ni motor de almacenamiento a medida, solo tablas que puedes consultar con la base de datos embebida más probada del planeta. Si te tienta usar un almacén de grafos dedicado para un número de aristas de pocos millones en un solo dispositivo, no lo hagas. Ya escribimos sobre dónde las bases de datos de grafos embebibles se ganan su sitio más allá de SQLite, y la respuesta honesta es que la mayoría de las aplicaciones nunca llegan a ese punto. Triples en SQLite, con una indexación disciplinada por sujeto y predicado, te llevarán sorprendentemente lejos. Gasta tu presupuesto de complejidad en la procedencia y la semántica de retracción: ahí es donde estos sistemas realmente se rompen.
Error 3: Tratar la resolución de entidades como un detalle resuelto
He leído decenas de documentos de diseño de sistemas como este con un punto que dice « luego unificamos las entidades », como si fuera un trabajo de una tarde. Es, con mucha diferencia, la parte más difícil de todo el pipeline. Tus Contactos dicen « James Whitfield ». Fotos tiene un grupo de caras sin nombre. El calendario tiene un asistente « j.whitfield@company.com ». Mensajes tiene un identificador « +1-415-555-0142 ». El valor del grafo depende por completo de si esas cuatro observaciones se convierten en una sola persona, y de si se evita fusionarlas con el otro James, el del club de running.
La arquitectura pragmática es un clustering incremental con costes de error asimétricos. Una fusión falsa, es decir, decidir que dos personas distintas son una, envenena toda inferencia posterior y es muy desagradable de deshacer, porque los hechos de dos personas reales quedan enredados en un mismo nodo. Una división falsa solo significa que el grafo sabe un poco menos hasta que llegan más pruebas. Así que pones el umbral de fusión alto y dejas que los identificadores fuertes compartidos (un número de teléfono que aparece en dos fuentes) hagan la mayor parte del trabajo, con señales blandas como la similitud de nombres o la coaparición solo para desempatar. El bucle central es deliberadamente aburrido:
# Incremental entity resolution: precision over recall.
# A false merge corrupts everything downstream; a false split
# just means you learn slower. So merge only on strong evidence.
HARD_SIGNALS = {"phone", "email", "contact_id"} # near-certain identity
MERGE_THRESHOLD = 0.95 # soft-signal bar, set high
def ingest(observation, graph):
candidate = find_candidate(observation, graph)
if candidate is None:
return graph.new_entity(observation)
if shares_hard_signal(observation, candidate, HARD_SIGNALS):
return graph.merge(observation, candidate, confidence=1.0)
score = soft_match_score(observation, candidate) # name sim, co-occurrence
if score >= MERGE_THRESHOLD:
return graph.merge(observation, candidate, confidence=score)
return graph.new_entity(observation) # when in doubt, split
Dos reglas adicionales que te ahorrarán problemas. Primero, cada decisión de fusión es en sí misma un hecho con procedencia: registra qué señales la justificaron, porque cuando un usuario diga « esa no es mi hermana, es mi compañera de trabajo », necesitas deshacer la fusión quirúrgicamente, no borrar el nodo. Segundo, nunca dejes que la salida de un único clasificador fusione entidades por sí solo; exige corroboración de una señal independiente. Una de las cosas discretamente impresionantes del diseño de Apple es precisamente esta: las aristas de parentesco, empleo y comunicación cuelgan todas de la entidad resuelta, así que un error de resolución queda contenido en lugar de amplificarse, siempre que la resolución se hiciera bien desde el principio. Reserva la mitad de tu calendario para esto. Lo vas a necesitar.
Error 4: Suponer que « on-device » significa que el trabajo de privacidad ya está hecho
Ahora viene la parte en la que dejo de alabar la ingeniería. La defensa habitual de esta arquitectura, que dominó la reacción pública, es « nunca sale de tu dispositivo, así que no pasa nada ». Eso es medio argumento. El ML local-first resuelve de verdad el problema de la residencia de los datos: no hay una copia en el servidor que filtrar en masa, ni un pipeline de adtech que absorba tu grafo social, ni un objetivo de citación judicial de cien millones de usuarios a la vez. Es una victoria real y significativa frente a cómo hacen personalización todas las demás empresas de plataformas, y la defiendo.
Pero la agregación es un multiplicador de riesgo propio, y el almacenamiento local no hace nada al respecto. Cualquier fuente aislada (tus contactos, tu calendario, los metadatos de tus mensajes) es sensible de forma acotada. El grafo fusionado, que conoce tu empleador, tu árbol familiar con edades, la frecuencia de tu comunicación con cada persona, tus patrones de movimiento y tus actividades diarias, es cualitativamente más valioso que cualquiera de sus entradas. Y este almacén concreto está en SQLite en texto plano, protegido solo por el Acceso Total al Disco, sin documentar salvo por una página de manual de dos frases, sin conmutador por funcionalidad y sin una forma evidente de darse de baja. Las herramientas forenses ya leen la copia de iOS. Los investigadores que hicieron el análisis plantearon el experimento mental obvio: entrega ese almacén a un malware, o a una pareja abusiva que conozca la contraseña del dispositivo, y tienes un dosier listo para usar: con quién hablas, con qué frecuencia, adónde vas, quiénes son tus hijos.
El local-first resuelve el problema de la residencia de los datos. No hace nada por el problema de la agregación: un dosier fusionado en disco sigue siendo un dosier.

Las soluciones no son exóticas, y por eso su ausencia duele. Cifra el almacén en reposo con una clave ligada a la presencia del usuario. Ofrece un conmutador visible, no un « Siri Intelligence » monolítico, sino un control granular sobre qué señales alimentan el grafo. Documenta el esquema. Y trata los hechos inferidos como más sensibles que los brutos, no menos: nadie consintió en « este sistema deduce la edad de tu hija », aunque técnicamente concediera acceso a las entradas que lo hicieron posible. Si construyes ML local-first, repítete esta frase en la revisión de diseño: que no podamos ver los datos no significa que nadie vaya a verlos nunca. Planifica el día en que el dispositivo sea comprometido, incautado o vendido, porque algo de eso le pasará a una fracción de tu flota.
Error 5: Lanzar inferencia sin una vía de inspección
Piensa en cómo sabemos que todo esto existe. No por la documentación: la descripción oficial es esa página de manual tan escueta. Lo sabemos porque investigadores independientes hicieron ingeniería inversa de las bases de datos y construyeron un panel de código abierto para que los usuarios puedan leer su propio grafo, y un responsable de una herramienta forense enseñó a la suya a analizar la versión de iOS. Los usuarios descubrieron etiquetas de parentesco inferidas sobre sus propias familias ejecutando código de terceros en sus propias máquinas. Eso es un modo de fallo, y en él caen los equipos de ingeniería con los ojos abiertos: el sistema produce conclusiones sobre una persona, y la persona no tiene ninguna vía oficial para verlas, corregirlas o borrarlas.
Esto no es solo una casilla ética; también es operativo. Si no puedes ver el grafo, no puedes depurarlo. Cuando un usuario informa de que « tu asistente cree que mi ex es mi mujer », la única manera de responder por qué es rastrear la arista hasta la señal que la produjo, a través de la procedencia. Los equipos que construyen pronto la vía de lectura (un visor interno, un botón de exportación, una opción de « explicar esto » en cada hecho inferido) lanzan mejores modelos, porque las inferencias erróneas se convierten en informes de error visibles en lugar de resentimiento silencioso. Los que no lo hacen acaban con usuarios haciendo capturas de paneles diseñados por ingeniería inversa y publicándolas en redes sociales, una imagen bastante peor que cualquier página de ajustes habría dado.
Mi regla general, aprendida por las malas: en cualquier funcionalidad que saque conclusiones sobre un usuario, la interfaz de inspección no es un extra que llega en una versión posterior. Se lanza en la misma versión o la funcionalidad no se lanza. El coste es un panel de ajustes y una exportación en JSON. El beneficio es una confianza que no tienes que suplicar en un comunicado de prensa. Y, en la práctica, los reguladores ya están rodeando exactamente este hueco: los sistemas que infieren atributos sensibles sobre las personas les deben visibilidad, y « es on-device » no será una defensa válida para la invisibilidad.
Qué copiar para tu próxima funcionalidad de ML local-first
Quitando la polémica, esta es la arquitectura que le daría a cualquier equipo que construya personalización sin poder llamar a casa; y, sinceramente, la mayor parte de la personalización no debería llamar a casa. El plano, resumido:
- Muchos clasificadores pequeños en lugar de un modelo grande. Uno por señal, cada uno testeable de forma independiente, reentrenable y lo bastante barato como para funcionar con batería indefinidamente.
- Un almacén de triples con aristas reificadas. Cada hecho lleva confianza, fuente y marcas de tiempo; cada hecho puede retractarse sin borrar el historial. SQLite basta.
- Resolución de entidades ajustada a la precisión. Las fusiones falsas son el error catastrófico; las divisiones falsas solo te frenan. Corrobora antes de unificar.
- Ingeniería de privacidad que va más allá de la residencia. Cifrado en reposo, consentimiento granular, límites de retención, porque la agregación crea un objetivo que ninguna entrada individual era.
- Una vía de inspección desde el primer día. Si el sistema concluye cosas sobre el usuario, el usuario debe poder verlas, corregirlas y borrarlas.
Si quieres un punto de partida concreto para la parte de servicio, ya escribimos sobre cómo construir funcionalidades con LLM que funcionan totalmente sin conexión, y la misma disciplina se aplica aquí: asume que la red no existe, que el presupuesto de energía es pequeño y que el usuario no te debe nada. La coda incómoda es que los ingenieros de Apple construyeron algo genuinamente admirable y luego lo socavaron con el silencio. Los clasificadores, el esquema, la contención de hacer la inferencia localmente en lugar de enviarlo todo a un centro de datos: esa es la parte que merece copiarse. La postura sin documentar, siempre activa y con desactivación solo mediante un comando de terminal es la parte que conviene evitar. Construye el grafo. Dile al usuario que está ahí. Ambas mitades son ingeniería, y la segunda no es opcional.


