Lehren aus Apples On-Device-Wissensgraph
Apples lokaler Wissensgraph zeigt, wie man privates, lokal-first ML baut. Fünf typische Fehler und die Lösungen, die wirklich funktionieren.

Sag deinem Mac „Schreib meinem Bruder“, und er erledigt es einfach. Kein Ladesymbol, keine sichtbare Suche, kein Netzwerk-Roundtrip – er weiß bereits, welcher der Hunderte Kontakte in deinem Adressbuch dein Bruder ist. Das funktioniert, weil seit macOS Ventura jeder Mac still und leise einen On-Device-Wissensgraphen betreibt: ein Paar von Daemons, die Kontakte, Gesichtscluster aus Fotos, Kalendereinladungen, Metadaten aus Mail und Nachrichten, Standortmuster und Bildschirmzeit-Daten auslesen und all das zu einem abfragbaren Speicher verschmelzen – wer du bist, wen du kennst und wie diese Personen dich und einander betreffen.
Sicherheitsforscher haben kürzlich enthüllt, wie tief das geht. Die beiden Daemons – knowledgeconstructiond und intelligenceplatformd – pflegen ein Verzeichnis mit 51 SQLite-Datenbanken unter ~/Library/IntelligencePlatform. Das Herzstück, graph.db, ist ein Triple-Store, der in einem Vokabular aus 181 Entitätsklassen und 278 Prädikaten geschrieben ist, einschließlich abgeleiteter Verwandtschaftsbeziehungen, die niemand jemals in eine Kontaktkarte eingetragen hat. Die lauteste Debatte um diese Entdeckung dreht sich um Einwilligung, und das ist eine berechtigte Debatte. Aber ich habe jahrelang beruflich ML-Features ausgeliefert, und als ich die Analyse las, war meine erste Reaktion eine andere: Das ist eines der lehrreichsten Beispiele für lokal-first ML-Engineering, die je in großem Maßstab ausgeliefert wurden. Statt die Ethik noch einmal aufzurollen, möchte ich deshalb die fünf Fehler durchgehen, die Praktiker beim Bau solcher Systeme machen – und was Apples Ingenieure nachweislich richtig und falsch gemacht haben, damit du es nicht auf die harte Tour lernen musst.
Fehler 1: Ein großes Modell statt vieler kleiner Klassifikatoren
Die erste Reaktion vieler Teams, wenn sie „Das Betriebssystem versteht deine Familie“ hören, ist die Annahme, dass irgendwo ein großes Sprachmodell im Spiel ist. Ist es nicht, und genau darin liegt die Lehre. Die Verwandtschaftsinferenz, die für Schlagzeilen sorgte – das System entscheidet, dass dieser Kontakt deine Mutter ist und jener dein Chef –, wird von schmalen, spezialisierten Klassifikatoren erledigt, die strukturierte Signale verarbeiten: Mitgliedschaft in der Familienfreigabe und Alter, die Felder für verwandte Namen in den Kontakten, Muster gemeinsamer Termine im Kalender, Kommunikationshäufigkeit und -richtung, gemeinsames Auftreten von Gesichtern in Fotos. Jeder Klassifikator beantwortet eine kleine Frage gut, und der Graph fügt die Antworten zusammen.
Das ist aus einem ganz praktischen Grund wichtig: Budget. Ein Daemon, der kontinuierlich läuft, mit dem Akku auskommen muss und neben allem anderen, was das Betriebssystem tut, arbeitet, kann sich keinen Transformer-Durchlauf pro Ereignis leisten. Kleine Klassifikatoren laufen in Mikrosekunden auf der Neural Engine, sind deterministisch genug für Unit-Tests, und wenn einer falsch liegt, kannst du genau diesen einen neu trainieren, ohne den Rest anzufassen. Ich habe erlebt, wie Teams Quartale verbrannten, um ein allgemeines Modell dazu zu bringen, etwas zu tun, das ein Gradient-Boosted-Tree über dreißig gut gewählte Features besser kann. Dasselbe Phänomen hatten wir schon im Bereich Bildverarbeitung: spezialisierte CNNs schlagen Frontier-LLMs bei der Bildklassifikation regelmäßig, und das zu einem Bruchteil der Kosten. Das Muster gilt überall. Personalisierungsfeatures brauchen fast nie ein allgemeines Modell – sie brauchen ein gutes Schema und einen Haufen langweiliger, exzellenter Klassifikatoren.
Der andere unterschätzte Vorteil ist die sanfte Degradierung. Wenn die Gesichtserkennung nie läuft, weil der Nutzer Fotos nicht verwendet, hat der Verwandtschaftsklassifikator trotzdem Familienfreigabe und Kontakte zur Verfügung. Monolithische Modelle degradieren katastrophal, wenn sich ihre Eingabeverteilung verschiebt; ein Ensemble signalspezifischer Klassifikatoren verliert einfach eine Stimme. Wenn du dein nächstes On-Device-Feature entwirfst, liste zuerst die unabhängigen Signale auf und frage dann, wie das kleinste Modell pro Signal aussieht. Spare dir das LLM für die letzte Meile der natürlichsprachlichen Interaktion, wo es tatsächlich hingehört.

Fehler 2: Fakten speichern ohne Herkunftsnachweis oder Zurückziehung
Ein Detail im Analysebericht, das die meisten Berichte übergangen haben, ist für mich der elegantste Teil. Eine Kante in diesem Graphen – „diese Person arbeitet bei dieser Organisation“ – ist keine einzelne Zeile. Es sind zwei Zeilen mit einer gemeinsamen relationshipId: Eine Zeile nennt den Beziehungstyp, die andere verweist auf die verbundene Entität. Es gibt 46 Beziehungstyp-Klassen, die allein dazu dienen, diese Indirektion zu tragen. Das nennt man Reifizierung, und der Grund dafür ist, dass die Kante selbst Eigenschaften tragen kann – einen Konfidenzwert, eine Quelle, einen Zeitstempel – und dass sie später zurückgezogen werden kann, ohne so zu tun, als hätte es sie nie gegeben.
Das ist der Fehler, den ich bei selbstgebauten Personalisierungssystemen am häufigsten sehe: Fakten als flache Spalten gespeichert. user.employer = "Acme". Das funktioniert, bis jemand den Job wechselt, sich scheiden lässt oder die Schlussfolgerung einfach falsch war – und dann überschreibst du entweder eine Historie, die du zum Debuggen brauchst, oder lässt veraltete Fakten stehen, weil ihr Löschen etwas weiter unten kaputt macht. Persönliche Fakten veralten schnell. Menschen ziehen um, Beziehungen enden, Arbeitgeber wechseln. Ein Speicher, der nicht ausdrücken kann „wir hielten das mit einer Konfidenz von 0,7 für wahr, Quelle Kalender-Teilnehmer, am 3. März zurückgezogen“, füllt sich still und leise mit Geistern. Das Schema, das dieses Problem löst, sieht ungefähr so aus:
-- 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', ...)
Beachte außerdem, was die Implementierung verrät: Das Ganze lebt in schlichtem SQLite. Keine exotische Graphdatenbank, keine eigene Storage-Engine – nur Tabellen, die du mit der wohl am besten erprobten eingebetteten Datenbank der Welt abfragen kannst. Wenn du versucht bist, für eine Kantenmenge im niedrigen Millionenbereich auf einem einzelnen Gerät zu einem dedizierten Graphspeicher zu greifen, lass es. Wir haben geschrieben, wo einbettbare Graphdatenbanken jenseits von SQLite ihre Existenzberechtigung verdienen, und die ehrliche Antwort lautet, dass die meisten Anwendungen diesen Punkt nie erreichen. Triples in SQLite mit sauberer Indizierung auf Subjekt und Prädikat bringen dich erstaunlich weit. Investiere deine Komplexität lieber in Herkunfts- und Zurückziehungssemantik – dort brechen diese Systeme tatsächlich.
Fehler 3: Entity-Resolution als gelöstes Detail behandeln
Jedes Design-Dokument, das ich je zu einem solchen System gelesen habe, enthält einen Aufzählungspunkt „dann vereinheitlichen wir die Entitäten“, als wäre das eine Arbeit für einen Nachmittag. Es ist mit großem Abstand der schwierigste Teil der gesamten Pipeline. Deine Kontakte sagen „James Whitfield“. Fotos hat einen Gesichtscluster ohne Namen. Der Kalender hat einen Teilnehmer „j.whitfield@company.com“. Nachrichten hat ein Handle „+1-415-555-0142“. Der Wert des Graphen hängt vollständig davon ab, ob diese vier Beobachtungen zu einer Person werden – und ob sie korrekt nicht mit dem anderen James verschmelzen, dem aus deinem Laufclub.
Die pragmatische Architektur ist inkrementelles Clustering mit asymmetrischen Fehlerkosten. Eine falsche Verschmelzung – die Entscheidung, zwei verschiedene Personen seien eine – vergiftet jede nachgelagerte Inferenz und ist furchtbar rückgängig zu machen, weil Fakten von beiden realen Personen nun an einem Knoten verheddert sind. Eine falsche Trennung bedeutet nur, dass der Graph etwas weniger weiß, bis mehr Evidenz eintrifft. Also setzt du deinen Verschmelzungsschwellenwert hoch und lässt gemeinsame harte Identifikatoren (eine Telefonnummer, die in zwei Quellen auftaucht) den Großteil der Arbeit erledigen, während weiche Signale wie Namensähnlichkeit und Gleichzeitigkeit nur Unentschieden auflösen. Die Kernschleife ist bewusst langweilig:
# 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
Zwei Folgeregeln, die dir später Zeit sparen. Erstens ist jede Verschmelzungsentscheidung selbst ein Fakt mit Herkunftsnachweis – halte fest, welche Signale sie begründet haben, denn wenn ein Nutzer sagt „Das ist nicht meine Schwester, das ist meine Kollegin“, musst du chirurgisch entkoppeln, statt den Knoten zu löschen. Zweitens lass nie zu, dass die Ausgabe eines einzelnen Klassifikators allein Entitäten verschmilzt; verlange Bestätigung durch ein unabhängiges Signal. Eines der still beeindruckenden Merkmale in Apples Design ist genau das: Verwandtschafts-, Beschäftigungs- und Kommunikationskanten hängen alle an der aufgelösten Entität, sodass ein Auflösungsfehler eingedämmt statt verstärkt wird – vorausgesetzt, die Auflösung war von Anfang an richtig. Plane die Hälfte deines Zeitrahmens dafür ein. Du wirst sie brauchen.
Fehler 4: Annehmen, „On-Device“ bedeute, dass die Datenschutzarbeit erledigt ist
Jetzt kommt der Teil, in dem ich aufhöre, die Technik zu loben. Die Standardverteidigung dieser Architektur – und sie hat die öffentliche Reaktion dominiert – lautet „Es verlässt nie dein Gerät, also ist es in Ordnung.“ Das ist ein halbes Argument. Lokal-first ML löst das Problem der Datenresidenz tatsächlich: Es gibt keine serverseitige Kopie, die man massenhaft kompromittieren könnte, keine Ad-Tech-Pipeline, die deinen Social Graphen abschöpft, kein Gerichtsbeschluss, der hunderte Millionen Nutzer auf einmal betrifft. Das ist ein echter, bedeutender Gewinn gegenüber dem, wie jede andere Plattformfirma Personalisierung betreibt, und dafür werde ich einstehen.
Aber Aggregation ist ein eigener Risikomultiplikator, und lokale Speicherung ändert daran nichts. Jede einzelne Quelle – deine Kontakte, dein Kalender, deine Nachrichten-Metadaten – ist auf begrenzte Weise sensibel. Der fusionierte Graph, der deinen Arbeitgeber, deinen Stammbaum mit Altersangaben, deine Kommunikationsfrequenz mit jeder Person, deine Bewegungsmuster und deine täglichen Aktivitäten kennt, ist kategorisch wertvoller als jede seiner Eingaben. Und dieser Speicher liegt als Klartext-SQLite vor, geschützt nur durch den vollen Festplattenzugriff, undokumentiert bis auf eine zweizeilige Man-Page, ohne Schalter pro Funktion und ohne offensichtlichen Weg, sich abzumelden. Forensik-Tools lesen die iOS-Version bereits aus. Die Forscher hinter der Analyse haben das naheliegende Gedankenexperiment durchgespielt: Gib diesen Speicher an Malware oder an einen missbräuchlichen Partner mit dem Gerätepasswort, und du hast ein fertiges Dossier – mit wem du redest, wie oft, wohin du gehst, wer deine Kinder sind.
Lokal-first löst das Problem der Datenresidenz. Für das Aggregationsproblem tut es nichts – ein fusioniertes Dossier auf der Festplatte ist immer noch ein Dossier.

Die Gegenmaßnahmen sind nicht exotisch, und genau das macht ihr Fehlen so schmerzhaft. Verschlüssele den Speicher im Ruhezustand mit einem Schlüssel, der an die Anwesenheit des Nutzers gebunden ist. Liefere einen sichtbaren Schalter aus – nicht „Siri Intelligence“ als Monolith, sondern eine granulare Steuerung, welche Signale in den Graphen einfließen. Dokumentiere das Schema. Und behandle abgeleitete Fakten als sensibler denn Rohdaten, nicht weniger sensibel: Niemand hat zugestimmt, dass „dieses System das Alter deiner Tochter abgeleitet hat“, auch wenn man technisch die Eingaben freigegeben hat, die das ermöglichten. Wenn du lokal-first ML baust, sag dir in der Design-Review diesen Satz: Dass wir die Daten nicht sehen können, heißt nicht, dass nie jemand sie sehen wird. Plane für den Tag, an dem das Gerät kompromittiert, beschlagnahmt oder verkauft wird, denn genau das wird einem Teil deiner Flotte passieren.
Fehler 5: Inferenz ausliefern ohne Möglichkeit zur Einsicht
Denk darüber nach, wie wir überhaupt wissen, dass all das existiert. Nicht aus der Dokumentation – die offizielle Beschreibung ist diese knappe Man-Page. Wir wissen es, weil unabhängige Forscher die Datenbanken reverse-engineert und ein Open-Source-Dashboard gebaut haben, mit dem Nutzer ihren eigenen Graphen lesen können, und weil ein Forensik-Entwickler sein Tool beigebracht hat, die iOS-Version zu parsen. Nutzer entdeckten abgeleitete Verwandtschaftsbezeichnungen über ihre eigenen Familien, indem sie Drittanbieter-Code auf ihren eigenen Geräten ausführten. Das ist ein Fehlermodus, und in ihn laufen Engineering-Teams mit offenen Augen hinein: Das System produziert Schlussfolgerungen über eine Person, und die Person hat keinen Erstanbieter-Weg, diese zu sehen, zu korrigieren oder zu löschen.
Das ist nicht nur ein ethischer Haken, sondern auch ein operativer. Wenn du den Graphen nicht sehen kannst, kannst du ihn nicht debuggen. Wenn ein Nutzer meldet „Dein Assistent hält meinen Ex für meinen Mann“, geht die Antwort auf die Frage nach dem Warum nur, indem du die Kante über den Herkunftsnachweis bis zum Signal zurückverfolgst, das sie erzeugt hat. Teams, die den Lesepfad früh bauen – einen internen Viewer, einen Exportbutton, eine „Erkläre das“-Funktion bei jedem abgeleiteten Fakt –, liefern bessere Modelle, weil falsche Schlussfolgerungen zu sichtbaren Fehlerberichten werden statt zu stillem Ärger. Teams, die das nicht tun, landen dabei, dass Nutzer reverse-engineerte Dashboards in sozialen Netzwerken screenshotten, was deutlich schlechter aussieht als jede Einstellungsseite es je hätte tun können.
Meine Faustregel, auf die harte Tour gelernt: Für jede Funktion, die Schlüsse über einen Nutzer zieht, ist die Inspektionsoberfläche kein nettes Extra, das in einem späteren Release folgt. Sie wird im selben Release ausgeliefert, oder die Funktion wird nicht ausgeliefert. Die Kosten sind ein Einstellungsbereich und ein JSON-Export. Der Nutzen ist Vertrauen, das du nicht in einer Pressemitteilung erbetteln musst. Und praktisch gesehen schauen Aufsichtsbehörden genau auf diese Lücke – Systeme, die sensible Merkmale über Menschen ableiten, sind diesen Menschen Sichtbarkeit schuldig, und „es ist auf dem Gerät“ wird nicht als Verteidigung für Unsichtbarkeit anerkannt werden.
Was du für dein nächstes lokal-first ML-Feature übernehmen solltest
Entfernt man die Kontroverse, ist das die Architektur, die ich jedem Team empfehlen würde, das Personalisierung baut, die nicht nach Hause telefonieren kann – und ehrlich gesagt sollte die meiste Personalisierung auch nicht nach Hause telefonieren. Die Blaupause, verdichtet:
- Viele kleine Klassifikatoren statt eines großen Modells. Einer pro Signal, jeweils einzeln testbar, neu trainierbar und günstig genug, um dauerhaft mit dem Akku zu laufen.
- Ein Triple-Store mit reifizierten Kanten. Jeder Fakt trägt Konfidenz, Quelle und Zeitstempel; jeder Fakt kann zurückgezogen werden, ohne die Historie zu löschen. SQLite genügt.
- Entity-Resolution, optimiert auf Präzision. Falsche Verschmelzungen sind der katastrophale Fehler; falsche Trennungen bremsen dich nur aus. Bestätige, bevor du vereinheitlichst.
- Datenschutztechnik, die über Datenresidenz hinausgeht. Verschlüsselung im Ruhezustand, granulare Einwilligung, Aufbewahrungslimits – denn Aggregation erzeugt ein Ziel, das keine einzelne Eingabe je war.
- Ein Einsichtspfad vom ersten Tag an. Wenn das System Schlüsse über den Nutzer zieht, soll der Nutzer diese Schlüsse sehen, korrigieren und löschen können.
Wenn du einen konkreten Startpunkt für die Serving-Seite suchst, haben wir darüber geschrieben, wie man LLM-Funktionen baut, die vollständig offline funktionieren, und dieselbe Disziplin gilt hier – geh davon aus, dass das Netzwerk weg ist, das Energiebudget klein ist und der Nutzer dir nichts schuldet. Die unbequeme Coda ist, dass Apples Ingenieure etwas wirklich Bewundernswertes gebaut und es dann durch Schweigen untergraben haben. Die Klassifikatoren, das Schema, die Zurückhaltung, Inferenz lokal zu betreiben, statt alles in ein Rechenzentrum zu schicken: Das ist der Teil, den es sich abzuschauen lohnt. Die undokumentierte, immer aktive, nur per Terminalbefehl abschaltbare Haltung ist der Teil, den man vermeiden sollte. Bau den Graphen. Sag dem Nutzer, dass er existiert. Beide Hälften sind Engineering, und die zweite ist nicht optional.


