Struct GraphDocument 

pub struct GraphDocument {
    pub nodes: Vec<GraphNode>,
    pub edges: Vec<GraphEdge>,
    pub metadata: HashMap<String, Value>,
}

A complete graph document ready for export.

Fields

nodes: Vec<GraphNode>

Nodes (entities)

edges: Vec<GraphEdge>

Edges (relations)

metadata: HashMap<String, Value>

Document metadata

Implementations

impl GraphDocument

pub fn new() -> GraphDocument

Create an empty graph document.

pub fn from_extraction( entities: &[Entity], relations: &[Relation], _coref_chains: Option<()>, ) -> GraphDocument

Build graph document from NER/IE extraction results.

Arguments

• entities - Extracted entities (should have canonical_id set if coref was run)
• relations - Extracted relations between entities
• coref_chains - Optional coreference chains for canonical mention resolution

Returns

A GraphDocument with deduplicated nodes (by canonical_id) and edges.

pub fn from_entities_cooccurrence( entities: &[Entity], max_distance: usize, ) -> GraphDocument

Build graph from entities only, inferring co-occurrence relations.

Uses a simple heuristic: entities within max_distance characters are considered related. This is useful when no explicit relation extraction was performed.

pub fn to_cypher(&self) -> String

Export to Neo4j Cypher CREATE statements.

pub fn to_networkx_json(&self) -> String

Export to NetworkX-compatible JSON format.

This format can be loaded directly with:

import networkx as nx
import json
with open('graph.json') as f:
    data = json.load(f)
G = nx.node_link_graph(data)

pub fn to_json_ld(&self) -> String

Export to JSON-LD format (for semantic web applications).

pub fn with_metadata( self, key: impl Into<String>, value: impl Into<Value>, ) -> GraphDocument

Add metadata to the graph document.

pub fn node_count(&self) -> usize

Get node count.

pub fn edge_count(&self) -> usize

Get edge count.

pub fn is_empty(&self) -> bool

Check if graph is empty.

pub fn from_grounded_document(doc: &GroundedDocument) -> GraphDocument

Build graph document from a GroundedDocument.

Converts the Signal → Track → Identity hierarchy to a graph format suitable for RAG applications (Neo4j, NetworkX, etc.).

Arguments

• doc - The GroundedDocument to convert

Returns

A GraphDocument with nodes from entities and edges inferred from co-occurrence or track relationships.

Example

use anno_core::grounded::GroundedDocument;
use anno_core::graph::GraphDocument;

let doc = GroundedDocument::new("doc1", "Marie Curie won the Nobel Prize.");
// ... add signals, tracks, identities ...

let graph = GraphDocument::from_grounded_document(&doc);
println!("{}", graph.to_cypher());

impl GraphDocument

pub fn export(&self, format: GraphExportFormat) -> String

Export to the specified format.

Trait Implementations

impl Clone for GraphDocument

fn clone(&self) -> GraphDocument

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GraphDocument

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for GraphDocument

fn default() -> GraphDocument

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for GraphDocument

fn deserialize<__D>( __deserializer: __D, ) -> Result<GraphDocument, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for GraphDocument

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.