Crate mindgraph 

mindgraph

A structured semantic memory graph for agentic systems.

mindgraph provides a typed knowledge graph with 48 node types across 6 conceptual layers (Reality, Epistemic, Intent, Action, Memory, Agent) and 70 edge types. It is backed by CozoDB for storage and supports versioning, provenance tracking, and soft-deletion.

Quick Start

use mindgraph::*;

// Create an in-memory graph
let graph = MindGraph::open_in_memory().unwrap();

// Add a claim node
let claim = graph.add_node(
    CreateNode::new("Rust is memory safe", NodeProps::Claim(ClaimProps {
        content: "Rust is memory safe".into(),
        claim_type: Some("factual".into()),
        ..Default::default()
    }))
    .confidence(Confidence::new(0.95).unwrap())
).unwrap();

// Add supporting evidence
let evidence = graph.add_node(
    CreateNode::new("Borrow checker", NodeProps::Evidence(EvidenceProps {
        description: "Borrow checker prevents dangling pointers".into(),
        ..Default::default()
    }))
).unwrap();

// Connect them with a SUPPORTS edge
graph.add_edge(CreateEdge::new(
    evidence.uid.clone(),
    claim.uid.clone(),
    EdgeProps::Supports { strength: Some(0.9), support_type: Some("empirical".into()) },
)).unwrap();

// Update using the builder pattern
graph.update(&claim.uid)
    .confidence(Confidence::new(0.99).unwrap())
    .changed_by("agent-1")
    .reason("strong supporting evidence")
    .apply()
    .unwrap();

// Query: how many claims exist?
assert_eq!(graph.count_nodes(NodeType::Claim).unwrap(), 1);

// Traverse the reasoning chain (includes start node at depth 0)
let chain = graph.reasoning_chain(&claim.uid, 5).unwrap();
assert!(!chain.is_empty());
assert_eq!(chain[0].depth, 0);

Re-exports

pub use async_graph::AsyncAgentHandle;

pub use async_graph::AsyncMindGraph;

pub use watch::WatchStream;

pub use openai::OpenAIEmbeddings;

pub use agent::AgentHandle;

pub use embeddings::EmbeddingProvider;

pub use embeddings::AsyncEmbeddingProvider;

pub use embeddings::SyncProviderAdapter;

pub use error::Error;

pub use error::Result;

pub use events::EventFilter;

pub use events::EventKind;

pub use events::GraphEvent;

pub use events::SubscriptionId;

pub use graph::MindGraph;

pub use provenance::ExtractionMethod;

pub use provenance::ProvenanceEntry;

pub use provenance::ProvenanceRecord;

pub use query::BatchResult;

pub use query::Contradiction;

pub use query::DecayResult;

pub use query::GraphOp;

pub use query::GraphSnapshot;

pub use query::GraphStats;

pub use query::ImportResult;

pub use query::MergeResult;

pub use query::NodeFilter;

pub use query::Page;

pub use query::Pagination;

pub use query::PropCondition;

pub use query::PropOp;

pub use query::PurgeResult;

pub use query::SearchOptions;

pub use query::SearchResult;

pub use query::TombstoneResult;

pub use query::TypedImportResult;

pub use query::TypedSnapshot;

pub use query::ValidatedBatch;

pub use query::VersionRecord;

pub use query::WeakClaim;

pub use schema::edge::CreateEdge;

pub use schema::edge::GraphEdge;

pub use schema::edge_props::EdgeProps;

pub use schema::node::CreateNode;

pub use schema::node::GraphNode;

pub use schema::node_props::NodeProps;

pub use schema::CustomNodeType;

pub use schema::EdgeType;

pub use schema::Layer;

pub use schema::NodeType;

pub use traversal::Direction;

pub use traversal::PathStep;

pub use traversal::TraversalOptions;

pub use types::now;

pub use types::Confidence;

pub use types::PrivacyLevel;

pub use types::Salience;

pub use types::Timestamp;

pub use types::Uid;

pub use schema::props::action::*;

pub use schema::props::agent::*;

pub use schema::props::epistemic::*;

pub use schema::props::intent::*;

pub use schema::props::memory::*;

pub use schema::props::reality::*;

Modules

agent

Per-agent scoped graph handle for multi-agent systems.

async_graph

Async wrapper for MindGraph using tokio::task::spawn_blocking.

embeddings

error

events

graph

openai

OpenAI embedding provider (behind the openai feature flag).

provenance

query

schema

storage

traversal

Graph traversal types for multi-hop queries.

types

watch

Async filtered event stream for graph changes. Requires the async feature.

Traits

Stream

A stream of values produced asynchronously.