Technische Samenvatting: Kennisgrafieken als de Ontbrekende Data-laag voor LLM-gebaseerde Industriële Activa-Operaties

Probleemstelling

Huidige Large Language Model (LLM)-agenten voor industriële activa-operaties vertonen beperkte nauwkeurigheid bij redeneren over platte documentopslag (bijv. CouchDB, YAML, CSV). De AssetOpsBench-benchmark (Patel et al., 2026) stelde vast dat zelfs toonaangevende modellen zoals GPT-4 en GPT-4.1 een maximale taakvoltooiingsgraad van ongeveer 65% bereiken op 139 industriële onderhoudsscenario's. De studie identificeerde dat mislukkingen vaak niet te wijten zijn aan een gebrek aan redeneervermogen, maar eerder aan "mislukkingen bij data-toegang". Specifiek worstelen LLM's met bewerkingen die gestructureerde query-engines deterministisch afhandelen, zoals:

• Het tellen van gebeurtenissen over meerdere ongestructureerde documenten.
• Het correleren van data uit uiteenlopende bronnen zonder expliciete koppelingen.
• Het doorlopen van impliciete apparatuur-afhankelijkheden.
• Het vermijden van hallucinaties van apparatuuridentificatoren of sensorwaarden.

De centrale hypothese van dit artikel is dat voor gestructureerde operationele domeinen het data-model achter de tools de primaire bottleneck is, en niet het LLM-orkestratieparadigma.

Methodologie

De auteurs evalueerden drie verschillende architecturen met behulp van dezelfde 139 AssetOpsBench-scenario's, waarbij uitsluitend de datalaag en de rol van de LLM varieerden:

1. Architectuur A (Basis - Tool-verrijkte LLM):

   • Mechanisme: De LLM parseert intenties, selecteert tools, formuleert argumenten, haalt ruwe data op uit documentopslag, interpreteert resultaten en synthetiseert een antwoord.
   • Datalaag: Platte documentopslag (CouchDB, YAML, CSV).
   • LLM-rol: Voert alle redenering, datatraversie en aggregatie uit.

2. Architectuur B (NLQ + Graph):

   • Mechanisme: De LLM is beperkt tot het genereren van gestructureerde Cypher-query's op basis van een getypeerd schema. De graph-engine voert de query deterministisch uit, en de LLM synthetiseert het uiteindelijke antwoord uit de gestructureerde resultaten.
   • Datalaag: Een getypeerde Kennisgrafiek (KG) met 781 knopen, 955 randen en 16 relatie-types (uitgebreid tot 1.360 knopen en 2.500 randen in de volledige pijplijn).
   • LLM-rol: Code-generatie (Natuurlijke Taal naar Cypher).

3. Architectuur C (Deterministische Handlers):

   • Mechanisme: Vooraf geprogrammeerde handlers matchen vraagpatronen direct met Cypher-query's.
   • Datalaag: Dezelfde Kennisgrafiek.
   • LLM-rol: Geen.

Constructie van de Kennisgrafiek:
De auteurs bouwden een ETL-pijplijn die AssetOpsBench-data-bronnen transformeerde naar een graphschema met 14 knoop-labels (bijv. Site, Equipment, Sensor, FailureMode) en 21 rand-types (bijv. contains_equipment, monitors, depends_on). De grafiek omvat:

• Apparatuurhiërarchieën met ISA-95 en ISO 14224-classificaties.
• Sensor-metadata gekoppeld aan apparatuur.
• Foutmodi met 384-dimensionale Sentence-BERT-embeddings voor vector-similariteitszoekopdrachten.
• Gebeurtenislogboeken met temporele mogelijkheden.
• Een afhankelijkheidstopologie die thermische/elektrische afhankelijkheden en gedeelde infrastructuur modelleert.

De implementatie maakt gebruik van Samyama, een embedded graph-database die OpenCypher, HNSW-vectorindexering en graph-algoritmen (PageRank, NSGA-II) ondersteunt.

Belangrijkste Resultaten

Prestaties op 139 Scenario's

De studie toont een significante prestatieverbetering door de datalaag te wijzigen, zelfs wanneer het LLM-model constant wordt gehouden:

• Architectuur A (Basis): 65% slaagpercentage (91/139), overeenkomend met het plafond van de AssetOpsBench-leaderboard.
• Architectuur B (NLQ + Graph): 82–83% slaagpercentage (114–116/139) met gebruik van GPT-4, GPT-4o en GPT-4.1. Dit vertegenwoordigt een verbetering van ongeveer 17 procentpunten ten opzichte van de basis, met gebruik van dezelfde model-familie.
• Architectuur C (Deterministisch): 99% slaagpercentage (137/139). De twee mislukkingen werden toegeschreven aan mismatches in het antwoordformaat bij het bundelen van werkorders, niet aan kennishiaten.

Uitgebreide Evaluatie (467 Scenario's)

Bij evaluatie tegen de uitgebreide AssetOpsBench HuggingFace-release (467 scenario's over 6 domeinen):

• Deterministische Handlers: Bereikte een 100% slaagpercentage (467/467) met een gemiddelde score van 0,848.
• Graph-Native Capaciteiten: De auteurs introduceerden 40 nieuwe scenario's die multi-hop-afhankelijkheid, vector-similariteit en PageRank-kritikaliteit vereisten. Op deze punten bereikte de Kennisgrafiek-benadering een 100% slaagpercentage en een gemiddelde score van 0,927, vergeleken met 85% en 0,602 voor een GPT-4o-basis zonder de grafiek.

Latentie en Kosten

• Latentie: Deterministische graph-query's gemiddeld 63 ms, vergeleken met 5–11 seconden voor LLM-gebaseerde architecturen.
• Kosten: Voor 10.000 dagelijkse query's kost een volledig LLM-gedreven architectuur $300–$500, terwijl deterministische graph-query's $0 kosten na de initiële ETL.

Betekenis en Claims

Het artikel stelt dat de datalaag de primaire bottleneck is in gestructureerde operationele domeinen, en fungeert als een belangrijkere hefboom voor prestatieverbetering dan LLM-orkestratieparadigma's (Agent-As-Tool versus Plan-Execute).

De auteurs introduceren het concept van "Inverted LLM Usage":

• In plaats van de LLM te vragen om te redeneren over ruwe data (een brede, foutgevoelige taak), vraagt het systeem de LLM om gestructureerde query's te genereren vanuit een getypeerd schema (een nauwe, code-generatietaken waar LLM's uitstekend in zijn).
• De graph-engine behandelt vervolgens de "harde" delen: traversie, tellen, joinen en algoritmische uitvoering.
• Deze scheiding van verantwoordelijkheden stelt het systeem in staat om bijna perfecte nauwkeurigheid te bereiken op bekende querypatronen, terwijl de flexibiliteit van natuurlijke taalinterfaces voor nieuwe query's behouden blijft.

Het artikel concludeert dat voor gestructureerde industriële data, Kennisgrafieken fungeren als een essentiële integratielaag tussen ruwe data en LLM-gebaseerd redeneren. De resultaten suggereren dat schema-bewuste query-generatie beter presteert dan vrij-vorm data-redenering voor elk gestructureerd domein, en dat deterministische handlers bijna perfecte betrouwbaarheid kunnen bereiken voor bekende operationele patronen.

Beperkingen en Voorbehoud

De auteurs merken expliciet enkele beperkingen op:

• Aanname van Schone Data: De benchmark gebruikt schone, gestructureerde data. Real-world industriële omgevingen omvatten ruwe sensoren, gescande PDF's en inconsistente naamgeving, wat LLM's vereist op de data-inname-laag (entiteitsextractie en -oplossing) en niet alleen op de query-laag.
• Deterministisch versus Autonom: Het 99% succespercentage van Architectuur C weerspiegelt een vooraf geprogrammeerde oplossing, niet het vermogen van een autonome agent om antwoorden onafhankelijk te achterhalen.
• Structurele Beperkingen: Scenario's die ML-inferentie vereisen (bijv. tijdreeksvoorspelling, RUL-predictie) kunnen niet worden opgelost door alleen opgeslagen data te bevragen; ze vereisen externe analytische modellen.
• Niet-determinisme: De NLQ-resultaten zijn afhankelijk van stochastische LLM-generatie; de karakterisering van variantie over meerdere zaden wordt uitgesteld tot toekomstig werk.