narrative-graph 0.1.2

Turn prose into candidate relational facts — entity detection, relation labeling, confidence scoring, entirely local.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use clap::Parser;
use narrative_graph::{extract_candidate_triples, Options};
use std::fs;
use std::io::{self, Read};

#[derive(Parser, Debug)]
#[command(name = "narrative-graph")]
#[command(about = "Extract relational facts from prose")]
#[command(version)]
struct Args {
    #[command(subcommand)]
    command: Command,
}

#[derive(Parser, Debug)]
enum Command {
    /// Extract candidate triples from a file
    Extract {
        /// Input file (or - for stdin)
        #[arg(value_name = "FILE")]
        input: String,

        /// Minimum confidence threshold (0.0-1.0)
        #[arg(long, default_value = "0.0")]
        min_confidence: f32,

        /// Output format: json or text
        #[arg(long, default_value = "text")]
        format: String,
    },
}

fn main() -> anyhow::Result<()> {
    let args = Args::parse();

    match args.command {
        Command::Extract {
            input,
            min_confidence,
            format,
        } => {
            // Read input
            let text = if input == "-" {
                let mut buffer = String::new();
                io::stdin().read_to_string(&mut buffer)?;
                buffer
            } else {
                fs::read_to_string(&input)?
            };

            // Extract
            let opts = Options {
                aliases: Default::default(),
                min_confidence: if min_confidence > 0.0 {
                    Some(min_confidence)
                } else {
                    None
                },
                ontology: Default::default(),
            };

            let candidates = extract_candidate_triples(&text, &opts)?;

            // Output
            match format.as_str() {
                "json" => {
                    let json = serde_json::to_string_pretty(&candidates)?;
                    println!("{}", json);
                }
                _ => {
                    for candidate in candidates {
                        println!(
                            "{} --{}--> {} {:.2} [{}..{}]",
                            candidate.subject,
                            candidate.relation,
                            candidate.object,
                            candidate.confidence,
                            candidate.span[0],
                            candidate.span[1]
                        );
                    }
                }
            }

            Ok(())
        }
    }
}