rust-logic-graph 0.2.0

A modular reasoning graph framework for distributed logic orchestration
Documentation

🧠 Rust Logic Graph

Rust License: MIT

A high-performance reasoning graph framework for Rust with GRL (Grule Rule Language) support. Build complex workflows with conditional execution, topological ordering, and async processing.

use rust_logic_graph::{Graph, Orchestrator, GraphIO};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let def = GraphIO::load_from_file("workflow.json")?;
    let mut graph = Graph::new(def);
    Orchestrator::execute_graph(&mut graph).await?;
    Ok(())
}

✨ Key Features

  • 🔥 GRL Support - rust-rule-engine integration with RETE algorithm
  • 🔄 Topological Execution - Automatic DAG-based node ordering
  • ⚡ Async Runtime - Built on Tokio for high concurrency
  • 📊 Multiple Node Types - RuleNode, DBNode, AINode
  • 📝 JSON Configuration - Simple workflow definitions
  • 🎯 97% Drools Compatible - Easy migration from Java

🚀 Quick Start

Installation

[dependencies]
rust-logic-graph = "0.2.0"

# With specific integrations
rust-logic-graph = { version = "0.2.0", features = ["postgres", "openai"] }

# With all integrations
rust-logic-graph = { version = "0.2.0", features = ["all-integrations"] }

Simple Example

use rust_logic_graph::{RuleEngine, GrlRule};

let grl = r#"
rule "Discount" {
    when
        cart_total > 100 && is_member == true
    then
        discount = 0.15;
}
"#;

let mut engine = RuleEngine::new();
engine.add_grl_rule(grl)?;

Run Examples

# Basic workflow
cargo run --example simple_flow

# GRL rules
cargo run --example grl_rules

# Advanced integration
cargo run --example grl_graph_flow

📚 Documentation

Document Description
Integrations Guide Database & AI integrations (NEW in v0.2.0)
GRL Guide Complete GRL syntax and examples
Use Cases 33+ real-world applications
Extending Create custom nodes and integrations
Implementation Technical details
GRL Integration Integration guide

🎯 Use Cases

Rust Logic Graph powers applications in:

  • 💰 Finance - Loan approval, fraud detection, risk assessment
  • 🛒 E-commerce - Dynamic pricing, recommendations, fulfillment
  • 🏥 Healthcare - Patient triage, clinical decisions, monitoring
  • 🏭 Manufacturing - Predictive maintenance, QC automation
  • 🛡️ Insurance - Claims processing, underwriting
  • 📊 Marketing - Lead scoring, campaign optimization
  • ⚖️ Compliance - AML monitoring, GDPR automation

View all 33+ use cases →

🏗️ Architecture

┌─────────────────────────────────────────┐
│         rust-rule-engine (GRL)          │
│        RETE Algorithm • 2-24x Faster    │
└────────────────┬────────────────────────┘
                 │
┌────────────────▼────────────────────────┐
│        Rust Logic Graph Core            │
│  • Graph Definition                     │
│  • Topological Executor                 │
│  • Context Management                   │
└────────────────┬────────────────────────┘
                 │
    ┌────────────┼────────────┐
    │            │            │
┌───▼───┐   ┌───▼───┐   ┌───▼───┐
│ Rule  │   │  DB   │   │  AI   │
│ Node  │   │ Node  │   │ Node  │
└───────┘   └───────┘   └───────┘

🔥 GRL Example

rule "HighValueLoan" salience 100 {
    when
        loan_amount > 100000 &&
        credit_score < 750
    then
        requires_manual_review = true;
        approval_tier = "senior";
}

rule "AutoApproval" salience 50 {
    when
        credit_score >= 700 &&
        income >= loan_amount * 3 &&
        debt_ratio < 0.4
    then
        auto_approve = true;
        interest_rate = 3.5;
}

Learn more about GRL →

📊 Performance

  • RETE Algorithm: Optimized pattern matching
  • 2-24x Faster: Than alternatives at 50+ rules
  • 97% Drools Compatible: Easy migration path
  • Async by Default: High concurrency support

🧪 Testing

# Run all tests
cargo test

# Run with output
cargo test -- --nocapture

# Run specific example
cargo run --example grl_rules

Result: ✅ 6/6 tests passing

📦 Project Status

Version: 0.2.0 (Beta) Status: Production-ready with real integrations

What's Working

  • ✅ Core graph execution engine
  • ✅ GRL rule engine integration
  • ✅ Three node types (Rule, DB, AI)
  • ✅ Topological sorting
  • ✅ Async execution
  • ✅ JSON I/O
  • ✅ Database integrations (PostgreSQL, MySQL, Redis, MongoDB)
  • ✅ AI integrations (OpenAI, Claude, Ollama)
  • ✅ Comprehensive documentation

Roadmap

  • Parallel node execution (v0.3.0)
  • Performance optimizations (v0.3.0)
  • GraphQL API (v0.6.0)
  • Web UI for visualization (v0.7.0)
  • Production release (v1.0.0)

See ROADMAP.md for details

🤝 Contributing

Contributions welcome! Please:

  1. Fork the repository
  2. Create your feature branch
  3. Write tests for new features
  4. Submit a pull request

📖 Examples

Example Description Lines
simple_flow.rs Basic 3-node pipeline 36
advanced_flow.rs Complex 6-node workflow 120
grl_rules.rs GRL rule examples 110
grl_graph_flow.rs GRL + Graph integration 140

🌟 Why Rust Logic Graph?

vs. Traditional Rule Engines

  • ✅ Async by default - No blocking I/O
  • ✅ Type safety - Rust's type system
  • ✅ Modern syntax - GRL support
  • ✅ Graph-based - Complex workflows

vs. Workflow Engines

  • ✅ Embedded - No external services
  • ✅ Fast - Compiled Rust code
  • ✅ Flexible - Custom nodes
  • ✅ Rule-based - Business logic in rules

📄 License

MIT License - see LICENSE for details.

🔗 Links

👥 Authors

James Vu - Initial work

🙏 Acknowledgments

Built with:

⭐ Star us on GitHub if you find this useful! ⭐

Documentation • Examples • Use Cases