Kennisgrafen voor militaire inlichtingen: entiteitsresolutie en linkanalyse

Door Corvus Intelligence Engineering Team · Over het team →

24 juni 2026 12 min lezen

Militaire inlichtingen draaien altijd om verbindingen: welke commandant controleert welke eenheid, welke financier financiert welke cel, welk infrastructuurknooppunt maakt welke logistieke keten mogelijk. Dit zijn graafproblemen. De gegevens die deze vragen beantwoorden — onderschepte communicatie, agentrapportages, metadata van satellietbeelden, open-bronregistraties — komen van tientallen afzonderlijke verzamelsystemen, die elk dezelfde entiteit in de werkelijkheid anders benoemen en relaties opslaan in incompatibele formaten. Kennisgrafen bieden de structurele laag die deze fragmenten samenvoegt tot een coherent, bevraagbaar beeld. Dit artikel onderzoekt hoe grafdatabases en kennisgrafen worden toegepast in militaire inlichtingenworkflows — van de fundamentele tekortkomingen van relationele benaderingen, via ontologieontwerp afgestemd op PMESII, entiteitsresolutie via multi-INT-bronnen, STIX-objectrepresentatie, selectie van grafdatabases voor geclassificeerde omgevingen, Cypher-querypatronen voor linkanalyse, tot integratie met C2- en OSINT-pijplijnen.

Waarom relationele databases falen bij militaire linkanalyse op diepte

De canonieke inlichtingenvraag is niet "vind alle records waarbij kolom X gelijk is aan waarde Y." Het is "begin bij deze entiteit, doorloop het netwerk tot diepte vijf, filter op relatietype en betrouwbaarheid, en vertel me tot welke gemeenschappen die entiteiten behoren." Relationele databases beantwoorden de eerste vraag goed. De tweede beantwoorden ze door JOIN-bewerkingen te koppelen waarvan de rekenkosten per stap oplopen.

Een JOIN over twee stappen in een entiteitstabel van tien miljoen rijen is doorgaans haalbaar — misschien een paar seconden met goede indexen. Een zelfkoppeling over vijf stappen in dezelfde tabel vereist vier opeenvolgende JOIN-bewerkingen, waarbij elke operatie de werkende dataset vermenigvuldigt met de gemiddelde vertakkingsfactor. Bij realistische inlichtingengegevens — waarbij een persoonsknooppunt vijftig communicatiecontacten kan hebben, elk met vijftig eigen contacten — kan de tussenliggende resultaatset op diepte vijf de geheugenlimieten van elke server overschrijden voordat er zelfs gefilterd is. De queryoptimizer kan dit niet vermijden omdat de relatie zelf niet in de database bestaat als een opgeslagen object: deze wordt opnieuw berekend door sleutelkolommen te matchen tijdens de uitvoering. Elke stap is een volledige herberekening.

Het probleem van entiteitsondubbelzinnigheid verergert dit verder. Een persoon verschijnt in een SIGINT-onderschepping als "Ahmed M." en in een HUMINT-rapport als "Ahmad Mansour" en in een financieel dossier als "A. Mansouri." In een relationeel schema zijn dit drie afzonderlijke rijen in drie afzonderlijke tabellen, tenzij een menselijke analist (of een deduplicatiepijplijn) ze expliciet heeft gekoppeld. Zonder die koppeling doorloopt een JOIN die begint bij de SIGINT-record nooit de weg naar de financiële record, en het netwerk dat de analist ziet is systematisch onvolledig. Relationele databases hebben geen native mechanisme om uit te drukken dat "deze twee rijen waarschijnlijk dezelfde entiteit zijn, met een betrouwbaarheid van 0,85." Die kans moet buiten het schema bestaan, in applicatielogica die doorgaans handmatig is en zelden consistent.

De JOIN-explosie en het entiteitsondubbelzinnigheidsprobleem samen verklaren waarom linkanalyse in traditionele defensie-inlichtingensystemen — gebouwd op relationele databases — gespecialiseerde analytische arbeid vereiste die een grafdatabase voor inlichtingenanalyse kan automatiseren. De graaf slaat relaties op als native edges met directe verwijzingen tussen knooppunten, zodat de doorloopkosten schalen met de lokale omgeving, niet de globale tabelgrootte. Entiteitsresolutie is eersteklas: een samenvoegbewerking vouwt meerdere records samen tot één canoniek knooppunt, en alle edges die naar een van de records verwezen, verwijzen nu naar het canonieke knooppunt. De graaf is het gegevensmodel dat is ontworpen voor het probleemdomein.

Basisprincipes van kennisgrafen voor militair gebruik

Een kennisgraaf breidt een eigenschapsgraaf uit met een gedeeld vocabulaire — een ontologie — die elk knooppunttype en randtype een gedefinieerde, afgesproken betekenis geeft. Dit gedeelde vocabulaire is wat queries samenstelbaar maakt over bronnen heen: twee afzonderlijke ingestpijplijnen die beiden het knooppuntlabel MilitaryUnit en het randtype SUBORDINATE_TO gebruiken, produceren grafen die samen doorlopen kunnen worden. Zonder de ontologie verzint elke pijplijn zijn eigen namen, en accumuleert de graaf tien synonieme labels voor hetzelfde concept.

Voor militaire inlichtingen biedt het PMESII-kader een natuurlijk ontologieskeleton. Elk van de zes dimensies — Politiek, Militair, Economisch, Sociaal, Infrastructuur, Informatie — wordt een familie van knooppuntlabels:

PMESII-dimensie	Knooppuntlabels	Belangrijkste randtypen
Politiek	Government, Official, PoliticalParty, Faction	CONTROLS, ALLIED_WITH, OPPOSES
Militair	Unit, Commander, WeaponsSystem, Base	COMMANDS, SUBORDINATE_TO, EQUIPPED_WITH, DEPLOYS_AT
Economisch	Organization, FinancialAccount, SupplyChain, Commodity	FINANCES, TRANSACTS_WITH, SUPPLIES
Sociaal	Person, Group, Community	MEMBER_OF, COMMUNICATES_WITH, RECRUITS
Infrastructuur	Facility, TransportLink, PowerGrid, NetworkNode	CONNECTS, DEPENDS_ON, OPERATED_BY
Informatie	MediaChannel, PsyopActor, NarrativeTheme	AMPLIFIES, TARGETS, DISSEMINATES

Elk knooppunt bevat een vereiste set eigenschappen: een canonieke identificator, een naam, een classificatielabel, een bronreferentie en een aanmaaktijdstempel. Elke edge bevat: type, source_ref, betrouwbaarheid (een getal tussen 0 en 1), valid_from (het vroegste moment waarop de relatie werd waargenomen), valid_until (null als nog actief), en classificatie. Deze vereiste eigenschappen maken de graaf auditeerbaar: elke afgeleide verbinding kan worden teruggevoerd naar de waarnemingen die haar ondersteunen, met hun verzamelmetadata en betrouwbaarheidsscores.

Cross-PMESII-edges zijn vaak de meest waardevolle inlichtingsdoelen. Een economisch knooppunt dat een militair knooppunt financiert, overstijgt twee dimensies; een informatieknooppunt dat een narratief verspreidt namens een politiek knooppunt, overstijgt er twee andere. Queries die specifiek zoeken naar cross-dimensiepaden — welke economische organisaties financieren deze militaire eenheid? — zijn structureel eenvoudig in een eigenschapsgraaf, omdat de edge bestaat als een native object dat de twee knooppunten verbindt.

Entiteitsresolutie via multi-INT-bronnen

Inlichtingengegevens worden verzameld door bronnen die nooit zijn ontworpen om een gemeenschappelijke entiteitsidentificator te delen. Een SIGINT-systeem identificeert een persoon via diens telefoonnummer. Een HUMINT-rapport noemt ze in lopende tekst. Een IMINT-analist labelt een voertuig in een beeldannotatie. Een open-brondatabase registreert een organisatie op basis van de wettelijke naam in een vreemd schrift. Om dit alles in één consistente graaf te krijgen, is entiteitsresolutie nodig: voor elk paar inkomende records beslissen of ze naar dezelfde entiteit in de werkelijkheid verwijzen.

De resolutiepijplijn heeft drie fasen. De eerste is normalisatie: voordat enige vergelijking gemaakt kan worden, moeten identificatoren worden gebracht naar een canonieke vorm. Telefoonnummers normaliseren naar het internationale E.164-formaat. Namen worden getranslitereerd naar een gemeenschappelijk schrift (doorgaans Latijn) met behulp van een gedefinieerde transliteratienorm (BGN/PCGN voor Slavische talen, ALA-LC voor Arabisch) en worden vervolgens verder genormaliseerd naar een basisvorm die eretitels en naamsvolgordewisselingen verwijdert. Coördinaten worden omgezet naar WGS84. Een record waarvan het telefoonnummer is opgeslagen als "0044-20-7946-0123" en een ander waarvan het nummer "+44 20 7946 0123" is, moeten beide dezelfde genormaliseerde sleutel produceren voordat enige blokkering of vergelijkingsstap plaatsvindt.

De tweede fase is blokkering: een mechanisme dat beperkt welke paren records worden vergeleken. Elk inkomend record vergelijken met elk bestaand grafknooppunt is kwadratisch in complexiteit en operationeel onhaalbaar op schaal. Blokkeringsstrategieën omvatten gesorteerde burenrijen (records gesorteerd op een blokkeringssleutel, alleen vergeleken binnen een schuivend venster), omgekeerde indexblokkering (records die minstens één token delen in een fonetische naamcodering zijn kandidaten), en MinHash-locality-sensitive hashing voor set-gewaardeerde attributen zoals bekende aliassen. Elke strategie ruilt recall in voor prestaties: een gemiste blokkeringskandidaat is een gemiste entiteitsmatch, dus blokkeringssleutels moeten worden afgesteld op een gouden standaard testset van bekende duplicaten.

De derde fase is scoren en beslissen. Kandidaatparen krijgen een gelijkenisvector over meerdere attributen: naamsgelijkenis (Jaro-Winkler of Jaccard over naamtokens), identiteitsoverlap (gedeelde telefoon, IMEI, adres), geografische nabijheid en temporele co-occurrence. Een logistieke regressie of gradient-boosted classifier produceert een samenvoegbetrouwbaarheidsscore. Paren boven een hoge drempel (doorgaans 0,90) worden automatisch samengevoegd; paren in de onzekerheidsmarge (0,65–0,90) worden in de wachtrij gezet voor analytische beoordeling; paren onder de onderste drempel blijven afzonderlijke knooppunten.

Kritische discipline: Elke samenvoeging moet worden gelogd met de bewijsvector en betrouwbaarheid die haar rechtvaardigde. Samenvoegingen moeten omkeerbaar zijn. Een onjuiste samenvoeging — twee verschillende personen samengevouwen in één knooppunt — fabriceert netwerkverbindingen die niet bestaan en kan verzameling en analyse naar het verkeerde doel sturen. Het samenvoeglogboek is geen luxe auditartefact; het is een vereiste voor elk inlichtingenproduct dat de graaf ondersteunt om analytische beoordeling te doorstaan.

De multi-sensor fusie-architectuur die spoorcoördinatie op sensorniveau afhandelt, gebruikt veel van dezelfde probabilistische principes — afbakening op positie, snelheid en identiteitsattributen — maar opereert met millisecondevertraging over gestructureerde sensorboodschappen. Entiteitsresolutie voor kennisgrafen werkt op een veel lager volume (miljoenen records in plaats van miljoenen per seconde) maar met veel ongestructureerder, ongeordender gegevens. Beide domeinen vereisen dezelfde discipline: expliciete betrouwbaarheid, omkeerbare beslissingen en auditbaarheid.

STIX-objecten weergeven in een graafopslag

STIX (Structured Threat Information eXpression) is de standaard van de NAVO en Five Eyes voor het delen van cyber-dreigingsinformatie. Een STIX-bundel bestaat uit STIX Domain Objects (SDO's) — de entiteiten: dreigingsactoren, campagnes, indicatoren, malware, kwetsbaarheden, aanvalspatronen, infrastructuur — en STIX Relationship Objects (SRO's) die gerichte relaties tussen hen uitdrukken: "DreigingsActeur X gebruikt Malware Y," "Campagne A richt zich op Sector B." Dit is een native eigenschapsgraaf. Elke SDO wordt een knooppunt; elke SRO wordt een gerichte edge.

De mapping is rechtstreeks:

// STIX SDO → Neo4j Node
MERGE (n:StixObject {stix_id: $bundle.id})
SET n.type        = $sdo.type,
    n.name        = $sdo.name,
    n.confidence  = $sdo.confidence,
    n.modified    = datetime($sdo.modified),
    n.revoked     = coalesce($sdo.revoked, false),
    n.labels      = $sdo.labels,
    n.classification = $sdo.object_marking_refs[0]

// STIX SRO → Neo4j Edge
MATCH (src:StixObject {stix_id: $sro.source_ref})
MATCH (tgt:StixObject {stix_id: $sro.target_ref})
MERGE (src)-[r:STIX_REL {stix_id: $sro.id}]->(tgt)
SET r.relationship_type = $sro.relationship_type,
    r.confidence        = $sro.confidence,
    r.valid_from        = datetime($sro.start_time),
    r.valid_until       = datetime($sro.stop_time),
    r.modified          = datetime($sro.modified),
    r.revoked           = coalesce($sro.revoked, false)

Twee STIX-specifieke complicaties vereisen expliciete afhandeling. Ten eerste, versiebeheer: STIX werkt een object bij door hetzelfde id opnieuw uit te geven met een nieuw gewijzigd tijdstempel. Het MERGE-op-stix_id-patroon hierboven verwerkt dit correct door eigenschappen ter plekke te overschrijven. Voor workflows die het inlichtingenbeeld op een specifiek moment in het verleden moeten reconstrueren — zoals een post-incidentbeoordeling — is een temporeel versioneringpatroon nodig: in plaats van overschrijven, een nieuwe knooppuntversie aanmaken en versies koppelen met HAS_VERSION-edges, waarbij het effectieve tijdstempel op elk versieknooppunt wordt opgeslagen.

Ten tweede, intrekking: een STIX-object met revoked: true moet worden uitgesloten van doorlopen maar niet verwijderd, om de audittrail te behouden. De conventie is revoked: true in te stellen op het knooppunt en een WHERE NOT n.revoked filter toe te voegen aan elke doorloopquery als standaard. Een ingetrokken edge die een relatie beweerde tussen twee dreigingsactoren moet in de database blijven zodat een analist kan zien dat de bewering werd gedaan en later ingetrokken — de intrekking is zelf inlichtingen.

STIX definieert ook Sighting-objecten, die vastleggen dat een SDO werd waargenomen in een specifieke context. Sightings worden gemapt naar edges die het waargenomen object verbinden met een waarnemende identiteit, met sighting_count- en first/last_seen-eigenschappen. Dit is het mechanisme dat abstracte dreigingsinformatie — "deze malwarefamilie" — verbindt met een specifieke operationele waarneming: "deze malware werd gezien op dit netwerk op dit tijdstip."

Selectie van grafdatabases voor militaire omgevingen

Het kiezen van een grafdatabase voor geclassificeerde militaire inzet is primair geen prestatiebeslissing. Verscheidene niet-functionele beperkingen domineren:

Engine	Air-gap	Querytaal	Native GDS-algoritmen	Opmerkingen
Neo4j Enterprise	Ja (offline licentie)	Cypher / openCypher	GDS-bibliotheek: PageRank, Louvain, Dijkstra, WCC	De meeste analytische tooling richt zich op Cypher; sterke accreditatiegeschiedenis in Five Eyes-implementaties
TigerGraph	Ja (on-prem bundel)	GSQL	Ingebouwd: centraliteit, gemeenschap, pad	Hogere doorvoer voor batchanalyse; GSQL heeft een steilere leercurve voor analisten
Amazon Neptune	Nee (clouddienst)	openCypher / Gremlin / SPARQL	Neptune ML voor grafische neurale netwerken	Alleen geschikt voor TS/SCI-cloudhuurders; niet voor echte air-gap
JanusGraph	Ja (open source)	Gremlin	Via Spark/Hadoop-backend	Volledig open-source; draait op HBase, Cassandra of RocksDB; ideaal voor edge-geïmplementeerde knooppunten met ingebedde opslag

Voor vooruitgeplaatste of edge-van-netwerk-inlichtingenknooppunten — een exploitatieteam met een laptop en een tactisch netwerk — bieden ingebedde graafopslagens ondersteund door RocksDB (JanusGraph + EmbeddedGraph) of Neo4j's ingebedde modus de kleinste footprint. Voor garnizoenanalytische netwerken met gelijktijdige toegang voor meerdere analisten bieden de geclusterde implementatie van Neo4j Enterprise of de gedistribueerde architectuur van TigerGraph de doorvoer die nodig is voor gelijktijdige linkanalysesessies. Amazon Neptune is alleen geschikt waar de classificatie-enclave al wordt gehost in een soevereine cloudtenancy op het vereiste classificatieniveau.

Een kritische operationele overweging is de multi-level security (MLS) handhavingslaag. De grafdatabase zelf is zelden MLS-bewust: ze slaat gegevens op en voert queries uit zonder inherent classificatielabels te begrijpen. De handhavingslaag bevindt zich in de querymiddelaar — een middlewarecomponent die elke inkomende Cypher-query herschrijft om een WHERE-clausule toe te voegen die filtert op de geautoriseerde classificatieset van de aanvragende gebruiker. Dit moet zorgvuldig worden geïmplementeerd: een gebruiker met SECRET-toestemming mag het bestaan van TOP SECRET-edges niet kunnen afleiden via tijdsverschillen of foutmeldingen, zelfs als ze de inhoud van de edge niet kunnen zien.

Querypatronen voor linkanalyse

Linkanalyse in Cypher reduceert tot een klein vocabulaire van patronen die samengesteld kunnen worden tot complexe analytische vragen. De volgende voorbeelden gaan uit van Neo4j en de GDS-bibliotheek, maar de patronen zijn vertaalbaar naar GSQL of Gremlin met kleine syntaxiswijzigingen.

Kortste pad tussen twee entiteiten van belang:

// Kortste pad vinden, gefilterd op betrouwbare, niet-ingetrokken edges
MATCH (a:Entity {id: $seedA}),
      (b:Entity {id: $seedB}),
      p = shortestPath((a)-[*1..6]-(b))
WHERE ALL(r IN relationships(p)
      WHERE r.confidence >= 0.6
        AND NOT coalesce(r.revoked, false)
        AND (r.valid_until IS NULL OR r.valid_until > datetime()))
RETURN p, length(p) AS hops
ORDER BY hops ASC

K-stap burenuitbreiding van een seed, met tijdvenster:

// 3-stap buren actief tijdens een operationeel venster van 30 dagen
MATCH (seed:Entity {id: $seedId})-[r*1..3]-(neighbor)
WHERE ALL(rel IN r
      WHERE rel.confidence >= 0.5
        AND rel.valid_from <= $windowEnd
        AND (rel.valid_until IS NULL OR rel.valid_until >= $windowStart))
RETURN DISTINCT neighbor, labels(neighbor) AS types
LIMIT 500

Gemeenschapsdetectie met Louvain (uitgevoerd op in-memory graafprojectie):

// Betrouwbaarheidsgewogen subgraaf projecteren, Louvain uitvoeren, gemeenschaps-ID's terugschrijven
CALL gds.graph.project(
  'intel-graph',
  ['Entity'],
  {COMMUNICATES_WITH: {properties: ['confidence']}})

CALL gds.louvain.write('intel-graph', {
  writeProperty: 'communityId',
  relationshipWeightProperty: 'confidence'
}) YIELD communityCount, modularity

// Vervolgens de gemeenschapsgenoten van de seed tonen
MATCH (seed:Entity {id: $seedId})
MATCH (peer:Entity {communityId: seed.communityId})
WHERE peer.id <> $seedId
RETURN peer ORDER BY peer.degreeCentrality DESC LIMIT 50

Temporele linkanalyse — activiteitscadans over tijd:

// Rand-activaties per kalenderweek tellen voor temporele patroonanalyse
MATCH (a:Entity {id: $seedId})-[r:COMMUNICATES_WITH]-()
WHERE r.valid_from >= $rangeStart AND r.valid_from <= $rangeEnd
WITH r,
     date.truncate('week', r.valid_from) AS week
RETURN week,
       count(r) AS contact_count,
       avg(r.confidence) AS avg_confidence
ORDER BY week ASC

Temporele linkanalyse is de brug naar patroon-van-leven-analyse in militaire inlichtingen: wanneer de cadans van de randactivaties van een knooppunt verschuift — frequentie daalt, tijden veranderen, contactpartners roteren — maakt de graaf die verschuiving zichtbaar als een structurele anomalie, zelfs voordat een gespecialiseerd gedragsmodel op de entiteit is getraind. De graafquery is de eerste-pass-detector; het gedragsmodel is de bevestigingslaag.

Een opmerking over prestaties: gemeenschapsdetectie en centraliteitsalgoritmen draaien over de volledige geprojecteerde graaf, niet slechts een subgraaf. Voor een graaf met tientallen miljoenen knooppunten moeten deze algoritmen worden gepland als achtergrond-batchjobs in plaats van interactieve queries. De resultaten — communityId en degreeCentrality teruggeschreven als knooppunteigenschappen — zijn dan beschikbaar voor directe opzoekacties in analytische queries zonder het algoritme opnieuw te hoeven uitvoeren.

Kennisgrafen integreren met C2- en OSINT-pijplijnen

Een kennisgraaf die niet is verbonden met live gegevensbronnen, is een historisch artefact in plaats van een operationeel hulpmiddel. De integratiearchitectuur heeft drie ingestkanalen en twee consumptie-eindpunten.

CTI-feed-ingest (STIX/TAXII). Een TAXII-client peilt geregistreerde verzamelingseindpunten — geallieerde CTI-deelplatforms, nationale dreigingsinformatiemeldingen — en verwerkt inkomende STIX-bundels via de SDO-naar-knooppunt / SRO-naar-edge-pijplijn die hierboven is beschreven. Bundelverwerking is idempotent: MERGE op STIX-id zorgt ervoor dat een opnieuw geleverd object eigenschappen bijwerkt in plaats van een duplicaat knooppunt aan te maken. Nieuwe objecten worden voor het vastleggen geresolveerd tegen de bestaande graaf; als een nieuwe STIX ThreatActor via probabilistische identiteitsresolutie overeenkomt met een bestaand niet-STIX Person-knooppunt, worden de twee samengevoegd en zijn alle edges uit beide records nu doorloopbaar vanuit het canonieke knooppunt.

HUMINT-rapportage-ingest. Rapporten in natuurlijke taal van menselijke bronnen worden verwerkt via een NLP-pijplijn die named entity recognition, relatie-extractie en coreference-resolutie uitvoert, en vervolgens geëxtraheerde entiteiten en relaties mapt naar het graafschema. De NLP-pijplijn is niet de graaf: het is de transformatielaag van proza naar gestructureerde grafielementen. Geëxtraheerde entiteiten gaan door dezelfde entiteitsresolutiepijplijn als elke andere bron, met een typisch lagere basisbetrouwbaarheid (prose-extractie is minder betrouwbaar dan een gestructureerde databaserecord) die wordt doorgegeven aan de edges die het HUMINT-rapport ondersteunt.

SIGINT-spoor-ingest. SIGINT-waarnemingen — een communicatie tussen twee eindpunten op een specifiek tijdstip, een apparaat dat verschijnt op een specifieke locatie — komen aan als een streamingfeed. Elke waarneming maakt of vernieuwt een edge in de graaf: een COMMUNICATES_WITH-edge tussen twee persoons- of apparaatknooppunten, of een OBSERVED_AT-edge tussen een apparaat en een locatie. De valid_from van de edge is het tijdstempel van de waarneming; valid_until is null tenzij de SIGINT-feed de waarneming expliciet afsluit. Hoge-volume streaming-ingest vereist een wachtrij-ondersteunde ingestor (Kafka of equivalent) die waarnemingen buffert en ze in batches naar graafwrites stuurt met een snelheid die de database kan absorberen zonder interactieve queries te blokkeren.

De twee consumptie-eindpunten zijn het analystenworkstation en het C2 gemeenschappelijk operationeel beeld (COP).

Het analystenworkstation biedt een linkanalyse-interface waar een analist een seed-entiteit specificeert, relatietypen en betrouwbaarheidsdrempels selecteert en een begrensde burenomgeving uitbreidt. Het resultaat wordt weergegeven als een force-directed graafindeling waarbij betrouwbaarheid wordt gecodeerd als randopaciteit en gemeenschapslidmaatschap als knooppuntkleur. Centraliteitsscores bepalen de knooppuntgrootte. De analist ziet nooit de volledige graaf — alleen de begrensde, gefilterde, query-gestuurde subgraaf die een specifieke vraag beantwoordt. Een goede interface toont het Cypher-patroon in een zijpaneel zodat de analist precies begrijpt wat er werd bevraagd en het kan verfijnen.

De C2 COP-integratie maakt graaf-afgeleide entiteitsprofielen zichtbaar — de bekende ondergeschikten van een eenheid, het gemeenschapslidmaatschap van een individu, de leveringsafhankelijkheden van een faciliteit — als pop-ups op het tactische beeld. Wanneer de operator op een gevolgde entiteit klikt, vraagt het C2-systeem de kennisgraaf op voor de netwerkcontext van die entiteit en toont de vijf meest gerelateerde entiteiten op basis van betrouwbaarheid en centraliteit. Dit transformeert de kennisgraaf van een zelfstandig analytisch hulpmiddel naar een actief onderdeel van het operationele beeld: gestructureerde relatie-inlichtingen, beschikbaar in context, zonder dat de operator een afzonderlijk hulpmiddel hoeft te openen.

Architectuurprincipe: De kennisgraaf is niet de visualisatie — het is de gegevenslaag. Investeer in ingestkwaliteit, nauwkeurigheid van entiteitsresolutie en indexprestaties. De visualisatie is de laatste mijl. Een analysteinterface gebouwd op een slecht geresolveerde graaf met lage-betrouwbaarheidsedges zal sneller en overtuigender misleiden dan elk handmatig proces dat het vervangt. De graaf verdient operationeel vertrouwen door auditbaarheid: elke weergegeven verbinding moet uitbreidbaar zijn naar de onderliggende bewijzen, met bron, verzameltijdstip en betrouwbaarheid gekoppeld.

Brengt relatie-inlichtingen in uw operationeel beeld

Corvus HEAD fuseert multi-bronnen inlichtingen tot een bevraagbare kennisgraaf — entiteitsresolutie, linkanalyse en C2-geïntegreerde netwerkvisualisatie gebouwd voor analisten die auditeerbare, betrouwbaarheidsgewogen antwoorden nodig hebben, geen onontwarbare haarbalpatronen.

Verken Corvus HEAD → Boek een briefing

Deze analyse is opgesteld door Corvus Intelligence-engineers die missiekritieke inlichtingen- en data-integratiesystemen bouwen voor defensie- en overheidsorganisaties. Meer over ons team →

Veelgestelde vragen

Waarom maken relationele JOIN-explosies ze ongeschikt voor militaire linkanalyse op diepte?

Relationele databases beantwoorden relatievragen via JOIN-bewerkingen die de werkende dataset per stap vermenigvuldigen. Een query over twee stappen vereist één zelfkoppeling; een query over vijf stappen vereist er vier, en elke koppeling vermenigvuldigt het vorige resultaat met een potentieel grote vertakkingsfactor. Bij een tabel van tien miljoen entiteitsrecords kan een doorloop over vijf stappen tussenliggende sets van biljoenen rijen produceren voordat er gefilterd wordt. Linkanalyse in inlichtingen heeft routinematig vijf of meer stappen nodig — van een onderschepte telefoon tot het netwerk boven het netwerk — waardoor relationele dieptequeries ofwel extreem traag ofwel operationeel onmogelijk zijn binnen een sessie.

Wat is het verschil tussen een eigenschapsgraaf en een RDF/OWL-kennisgraaf in een militaire context?

Een eigenschapsgraaf slaat knooppunten en edges op met getypte labels en willekeurige sleutel-waarde-eigenschappen op beide. Hij is schemaflexibel en geoptimaliseerd voor doorloopqueries. Een RDF-kennisgraaf modelleert alles als subject-predikaat-object-tripletten; OWL voegt een ontologielaag toe met formele semantiek die inferentie ondersteunt. Voor militaire inlichtingen zijn eigenschapsgrafen meer operationeel praktisch: ze verwerken herkomst- en betrouwbaarheidseigenschappen op natuurlijke wijze en integreren met Cypher-tooling die analisten al gebruiken. RDF/OWL heeft de voorkeur waar formele standaardeninteroperabiliteit belangrijk is, zoals het integreren van STIX-inhoud op de semantische laag of federeren met geallieerde kennisbasissen via linked-data-protocollen.

Hoe verschilt entiteitsondubbelzinnigheid van entiteitsresolutie in de inlichtingencontext?

Entiteitsresolutie beslist of twee gestructureerde records naar dezelfde entiteit in de werkelijkheid verwijzen en voegt ze samen. Entiteitsondubbelzinnigheid mapt een tekstvermelding — een naam in een HUMINT-rapport — naar een bestaand grafknooppunt. Beide moeten opeenvolgend worden opgelost: NLP extraheert vermeldingen, ondubbelzinnigheid koppelt ze aan kandidaatknooppunten, en resolutie beslist of kandidaten dezelfde entiteit zijn. Fouten in ondubbelzinnigheid creëren valse edges; fouten in resolutie fragmenteren of overvoegen knooppunten. Beide vereisen betrouwbaarheidsscores en omkeerbare beslissingen, met volledige auditregistratie van welk bewijs elke beslissing dreef.

Hoe ziet een STIX Relationship Object eruit als een graafrand in neo4j?

Een STIX SRO wordt een gerichte edge waarvan het type de relationship_type-string is (bijv. "uses", "targets"). De eigen STIX-id, betrouwbaarheid, aanmaak- en wijzigingsvelden van het SRO worden opgeslagen als randeigenschappen. De source_ref en target_ref lossen op naar bestaande knooppunten via hun stix_id-eigenschap. Temporele velden (valid_from, valid_until) worden geïndexeerd als randeigenschappen zodat tijdvensterbegrenste Cypher-queries kunnen filteren op relaties die actief waren tijdens een specifiek operatievenster. Ingetrokken SRO's stellen revoked: true in op de rand en worden uitgesloten van doorlopen via een standaard WHERE NOT-filter, maar worden bewaard voor audit.

Hoe verwerk je versioned STIX-objecten in een graafopslag?

STIX-versiebeheer gebruikt hetzelfde id met een nieuw gewijzigd tijdstempel. Twee strategieën zijn van toepassing. Snapshotvervanging behoudt alleen de nieuwste versie van elk knooppunt — eenvoudig maar verliest geschiedenis. Temporele knooppuntversioning maakt een nieuw knooppunt aan per gewijzigd tijdstempel en koppelt versies met HAS_VERSION-edges, waardoor tijdreisqueries elk vorig inlichtingenbeeld kunnen reconstrueren. Voor operationele inlichtingen volstaat snapshotvervanging; voor analytische workflows die moeten traceren hoe een dreigingsbeeld evolueerde voor een beslissing, is temporele versioning essentieel. Beide strategieën moeten ingetrokken objecten markeren met revoked: true en ze onderdrukken in doorlopen zonder ze te verwijderen, zodat de audittrail bewaard blijft.

Wat is het superknooppuntprobleem in militaire inlichtigengrafen?

Een superknooppunt is een knooppunt met een extreem hoge graad — een gedeelde openbare telefoonlijn, een gemeenschappelijk NAT-IP of een groot logistiek knooppunt. Doorlopen via een superknooppunt vermenigvuldigt de resultaatset met zijn graad, waardoor queries niet eindigen. In centraliteitsanalyse verschijnt het superknooppunt als de belangrijkste entiteit, terwijl het een infrastructuurartefact weerspiegelt, niet operationele betekenis. Maatregelen omvatten het begrenzen van de uitbreidingsgraad per knooppunt, het bijhouden van een uitsluitingslijst voor hubs, en het toepassen van graadgewogen randfiltering zodat randen via zeer-hoge-graad knooppunten minder bijdragen aan padscores.

Welke grafdatabase is het beste voor air-gapped militaire inlichtigenimplementaties?

Air-gapped implementaties vereisen een grafengine zonder netwerklicentieoproepen. Neo4j Enterprise met een offline licentie is de meest analysetoolcompatibele keuze. TigerGraph ondersteunt gebundelde on-premises licenties. JanusGraph is volledig open-source en draait op ingebedde RocksDB — ideaal voor edge-implementaties. Amazon Neptune is een clouddienst en ongeschikt voor echte air-gap. Voor vooruitgeplaatste edge-knooppunten biedt JanusGraph met RocksDB de kleinste footprint. Voor garnizoenanalytische netwerken biedt Neo4j Enterprise-clustering of TigerGraph-distributie de benodigde gelijktijdigheid voor meerdere analisten.

Welk Cypher-patroon vindt het kortste inlichtingenpad tussen twee entiteiten?

Het canonieke patroon is: MATCH (a:Entity {id:$seedA}),(b:Entity {id:$seedB}), p=shortestPath((a)-[*1..6]-(b)) WHERE ALL(r IN relationships(p) WHERE r.confidence>=0.6 AND NOT r.revoked AND (r.valid_until IS NULL OR r.valid_until>datetime())) RETURN p, length(p) AS hops. De grens [*1..6] voorkomt ongecontroleerde doorlopen. Voor betrouwbaarheidsgewogen kortste paden gebruikt de GDS Dijkstra-procedure met de eigenschap gewicht (1-betrouwbaarheid) om randen met hoge betrouwbaarheid te bevoordelen door ze een lagere kosten toe te wijzen.

Hoe helpt gemeenschapsdetectie analisten bij het prioriteren van doelen?

Gemeenschapsdetectie-algoritmen — Louvain, labelverspreiding, zwak verbonden componenten — verdelen de graaf in clusters van entiteiten die intern dichter verbonden zijn dan extern. In militaire inlichtingen mapt een gemeenschap doorgaans naar een functionele cel: individuen die communiceren, een logistiek netwerk dat middelen deelt, of faciliteiten verbonden door aanvoerketens. Het uitvoeren van Louvain server-side en het schrijven van communityId als een knooppunteigenschap laat analisten onmiddellijk alle gemeenschapsgenoten van een seed-entiteit zien, hoge-betweenness-brugknooppunten identificeren die anders gescheiden clusters verbinden, en verzameling prioriteren richting gemeenschapsleiders geïdentificeerd door intra-gemeenschap graadcentraliteit.

Hoe worden CTI-feeds en real-time SIGINT-sporen gereconcilieerd in een live kennisgraaf?

CTI-feeds komen aan als STIX-bundels die in batches worden verwerkt; SIGINT komt aan als een continue stroom. Een twee-fasen pijplijn reconcilieert beide. De batchfase verwerkt STIX-bundels: MERGE op STIX-id maakt knooppunten aan of werkt ze bij, SRO's worden edges. De streamingfase verwerkt SIGINT-waarnemingen via een Kafka-ondersteunde ingestor: elke waarneming wordt in bijna-realtime geresolveerd naar entiteiten en maakt een tijdsbegrensd rand. Beide fasen schrijven naar dezelfde eigenschapsgraaf, zodat Cypher-queries een unified beeld zien. De temporele randeigenschappen van de graaf isoleren het meest recente streamingvenster zonder batchgeschiedenis opnieuw te hoeven uitvoeren.