langgraph_rb 0.1.0

data/examples/simple_test.rb

@@ -0,0 +1,266 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/langgraph_rb'
+
+def simple_workflow_test
+  puts "=== Simple LangGraphRB Test ==="
+  
+  # Create a simple linear workflow
+  graph = LangGraphRB::Graph.new do
+    node :start_process do |state|
+      puts "🚀 Starting process with input: #{state[:input]}"
+      { 
+        step: 1, 
+        message: "Process started",
+        processed_input: state[:input]&.upcase
+      }
+    end
+
+    node :analyze_data do |state|
+      puts "🔍 Analyzing: #{state[:processed_input]}"
+      sleep(0.1)  # Simulate work
+      
+      analysis_result = case state[:processed_input]&.downcase
+                       when /hello/
+                         'greeting_detected'
+                       when /help/
+                         'help_request' 
+                       when /goodbye/
+                         'farewell_detected'
+                       else
+                         'general_input'
+                       end
+      
+      {
+        step: 2,
+        analysis: analysis_result,
+        message: "Analysis complete: #{analysis_result}"
+      }
+    end
+
+    node :generate_response do |state|
+      puts "💭 Generating response for: #{state[:analysis]}"
+      
+      response = case state[:analysis]
+                when 'greeting_detected'
+                  "Hello! Nice to meet you!"
+                when 'help_request'
+                  "I'm here to help! What do you need assistance with?"
+                when 'farewell_detected' 
+                  "Goodbye! Have a great day!"
+                else
+                  "I understand. Tell me more about that."
+                end
+      
+      {
+        step: 3,
+        final_response: response,
+        message: "Response generated",
+        completed: true
+      }
+    end
+
+    node :generate_response_2 do |state|
+      puts "💭 Generating response for: #{state[:analysis]}"
+      {
+        step: 4,
+        final_response: "Response generated",
+        message: "Response generated",
+        completed: true
+      } 
+    end
+
+    # Define simple linear flow
+    set_entry_point :start_process
+    edge :start_process, :analyze_data
+    edge :analyze_data, :generate_response
+    edge :analyze_data, :generate_response_2
+    set_finish_point :generate_response
+  end
+
+  # Compile the graph
+  graph.compile!
+  
+  puts "\n📊 Graph structure:"
+  puts graph.to_mermaid
+  puts
+
+  # Test with different inputs
+  test_inputs = [
+    "Hello there!",
+    "I need help",
+    "Goodbye everyone",
+    "Just a regular message"
+  ]
+
+  test_inputs.each_with_index do |input, i|
+    puts "\n--- Test #{i + 1}: '#{input}' ---"
+    
+    result = graph.invoke({ input: input })
+    
+    puts "✅ Final response: #{result[:final_response]}"
+    puts "   Steps completed: #{result[:step]}"
+    puts "   Status: #{result[:completed] ? 'Complete' : 'Incomplete'}"
+  end
+  
+  puts "\n✅ Simple workflow test completed!"
+end
+
+def conditional_routing_test
+  puts "\n=== Conditional Routing Test ==="
+  
+  graph = LangGraphRB::Graph.new do
+    node :router do |state|
+      input = state[:input]&.to_s&.downcase || ""
+      puts "🔄 Routing input: #{input}"
+      
+      {
+        input_type: case input
+                   when /urgent/, /emergency/
+                     'urgent'
+                   when /question/, /help/
+                     'question'
+                   when /feedback/, /complaint/
+                     'feedback'
+                   else
+                     'general'
+                   end,
+        original_input: input
+      }
+    end
+
+    node :handle_urgent do |state|
+      puts "🚨 Handling urgent request"
+      {
+        response: "Your urgent request has been escalated to our priority team!",
+        priority: "high"
+      }
+    end
+
+    node :handle_question do |state|
+      puts "❓ Handling question"
+      {
+        response: "Thank you for your question. Let me help you with that.",
+        priority: "medium"
+      }
+    end
+
+    node :handle_feedback do |state|
+      puts "💬 Handling feedback"
+      {
+        response: "We appreciate your feedback and will review it carefully.",
+        priority: "medium"
+      }
+    end
+
+    node :handle_general do |state|
+      puts "📝 Handling general request"
+      {
+        response: "Thank you for contacting us. We'll get back to you soon.",
+        priority: "normal"
+      }
+    end
+
+    # Set up routing
+    set_entry_point :router
+    
+    conditional_edge :router, ->(state) { state[:input_type] }, {
+      'urgent' => :handle_urgent,
+      'question' => :handle_question,
+      'feedback' => :handle_feedback,
+      'general' => :handle_general
+    }
+
+    # All handlers go to finish
+    set_finish_point :handle_urgent
+    set_finish_point :handle_question  
+    set_finish_point :handle_feedback
+    set_finish_point :handle_general
+  end
+
+  graph.compile!
+  
+  puts "\n📊 Conditional routing graph:"
+  puts graph.to_mermaid
+  puts
+
+  # Test different routing scenarios
+  test_cases = [
+    "URGENT: System is down!",
+    "I have a question about your service",
+    "I want to give some feedback",
+    "Just saying hello"
+  ]
+
+  test_cases.each_with_index do |input, i|
+    puts "\n--- Routing Test #{i + 1}: '#{input}' ---"
+    
+    result = graph.invoke({ input: input })
+    
+    puts "📋 Response: #{result[:response]}"
+    puts "🎯 Priority: #{result[:priority]}"
+  end
+  
+  puts "\n✅ Conditional routing test completed!"
+end
+
+def streaming_test
+  puts "\n=== Streaming Execution Test ==="
+  
+  graph = LangGraphRB::Graph.new do
+    node :step_1 do |state|
+      puts "  ⚙️  Step 1: Initialize"
+      sleep(0.3)
+      { step: 1, data: "initialized", progress: 25 }
+    end
+
+    node :step_2 do |state|
+      puts "  ⚙️  Step 2: Process"
+      sleep(0.3)
+      { step: 2, data: state[:data] + " -> processed", progress: 50 }
+    end
+
+    node :step_3 do |state|
+      puts "  ⚙️  Step 3: Validate"
+      sleep(0.3)
+      { step: 3, data: state[:data] + " -> validated", progress: 75 }
+    end
+
+    node :step_4 do |state|
+      puts "  ⚙️  Step 4: Finalize"
+      sleep(0.3)
+      { step: 4, data: state[:data] + " -> finalized", progress: 100 }
+    end
+
+    set_entry_point :step_1
+    edge :step_1, :step_2
+    edge :step_2, :step_3
+    edge :step_3, :step_4
+    set_finish_point :step_4
+  end
+
+  graph.compile!
+
+  puts "📡 Streaming execution progress:"
+  start_time = Time.now
+  
+  result = graph.stream({ input: "test_data" }) do |step_result|
+    elapsed = (Time.now - start_time).round(2)
+    puts "  📊 [#{elapsed}s] Step #{step_result[:step]}: #{step_result[:active_nodes]}"
+    if step_result[:state][:progress]
+      puts "      Progress: #{step_result[:state][:progress]}%"
+    end
+  end
+  
+  puts "\n🏁 Final result: #{result[:state][:data]}"
+  puts "⏱️  Total time: #{(Time.now - start_time).round(2)}s"
+  
+  puts "\n✅ Streaming test completed!"
+end
+
+# Run tests
+if __FILE__ == $0
+  #simple_workflow_test
+  conditional_routing_test
+  #streaming_test
+end 

data/langgraph_rb.gemspec

@@ -0,0 +1,43 @@
+require_relative 'lib/langgraph_rb/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "langgraph_rb"
+  spec.version       = LangGraphRB::VERSION
+  spec.authors       = ["Julian Toro"]
+  spec.email         = ["fulit103@gmail.com"]
+
+  spec.summary       = "A Ruby library for building stateful, multi-actor applications with directed graphs"
+  spec.description   = <<~DESC
+    LangGraphRB is a Ruby library inspired by LangGraph for building stateful, multi-actor applications 
+    using directed graphs. It provides a framework for orchestrating complex workflows with support for 
+    parallel execution, checkpointing, human-in-the-loop interactions, and map-reduce operations.
+  DESC
+  spec.homepage      = "https://github.com/fulit103/langgraph_rb"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{\A(?:test|spec|features)/})
+    end
+  end
+  
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Runtime dependencies
+  spec.add_dependency "json", "~> 2.0"
+
+  # Development dependencies
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry", "~> 0.14"
+  spec.add_development_dependency "rubocop", "~> 1.0"
+end 

data/lib/langgraph_rb/command.rb

@@ -0,0 +1,132 @@
+module LangGraphRB
+  # Command combines a state update with a routing decision
+  class Command
+    attr_reader :update, :goto
+
+    def initialize(update: nil, goto: nil)
+      @update = update || {}
+      @goto = goto
+    end
+
+    def self.update(state_delta)
+      new(update: state_delta)
+    end
+
+    def self.goto(destination)
+      new(goto: destination)
+    end
+
+    def self.update_and_goto(state_delta, destination)
+      new(update: state_delta, goto: destination)
+    end
+
+    def to_s
+      parts = []
+      parts << "update: #{@update.inspect}" unless @update.empty?
+      parts << "goto: #{@goto}" if @goto
+      "#<Command #{parts.join(', ')}>"
+    end
+
+    def inspect
+      to_s
+    end
+  end
+
+  # Send creates a new parallel execution branch with specific payload
+  class Send
+    attr_reader :to, :payload
+
+    def initialize(to:, payload: {})
+      @to = to.to_sym
+      @payload = payload || {}
+    end
+
+    def to_s
+      "#<Send to: #{@to}, payload: #{@payload.inspect}>"
+    end
+
+    def inspect
+      to_s
+    end
+  end
+
+  # MultiSend creates multiple parallel execution branches
+  class MultiSend
+    attr_reader :sends
+
+    def initialize(*sends)
+      @sends = sends.flatten
+    end
+
+    def self.to_multiple(destinations, payload = {})
+      sends = destinations.map { |dest| Send.new(to: dest, payload: payload) }
+      new(sends)
+    end
+
+    def self.fan_out(node, payloads)
+      sends = payloads.map { |payload| Send.new(to: node, payload: payload) }
+      new(sends)
+    end
+
+    def to_s
+      "#<MultiSend #{@sends.map(&:to_s).join(', ')}>"
+    end
+
+    def inspect
+      to_s
+    end
+  end
+
+  # Interrupt execution and wait for human input
+  class Interrupt
+    attr_reader :message, :data
+
+    def initialize(message: "Human input required", data: {})
+      @message = message
+      @data = data
+    end
+
+    def to_s
+      "#<Interrupt: #{@message}>"
+    end
+
+    def inspect
+      to_s
+    end
+  end
+
+  # Helper module for creating commands
+  module Commands
+    def self.update(state_delta)
+      Command.update(state_delta)
+    end
+
+    def self.goto(destination)
+      Command.goto(destination)
+    end
+
+    def self.update_and_goto(state_delta, destination)
+      Command.update_and_goto(state_delta, destination)
+    end
+
+    def self.send_to(destination, payload = {})
+      Send.new(to: destination, payload: payload)
+    end
+
+    def self.send_to_multiple(destinations, payload = {})
+      MultiSend.to_multiple(destinations, payload)
+    end
+
+    def self.fan_out(node, payloads)
+      MultiSend.fan_out(node, payloads)
+    end
+
+    def self.interrupt(message: "Human input required", data: {})
+      Interrupt.new(message: message, data: data)
+    end
+
+    def self.end_execution(final_state = {})
+      Command.update_and_goto(final_state, Graph::FINISH)
+    end
+  end
+end 

data/lib/langgraph_rb/edge.rb

@@ -0,0 +1,141 @@
+module LangGraphRB
+  # Simple edge connecting two nodes
+  class Edge
+    attr_reader :from, :to
+
+    def initialize(from, to)
+      @from = from.to_sym
+      @to = to.to_sym
+    end
+
+    def route(state, context: nil)
+      [@to]
+    end
+
+    def to_s
+      "#{@from} -> #{@to}"
+    end
+
+    def inspect
+      "#<Edge: #{to_s}>"
+    end
+
+    def ==(other)
+      other.is_a?(Edge) && @from == other.from && @to == other.to
+    end
+  end
+
+  # Conditional edge that uses a router function to determine destination(s)
+  class ConditionalEdge
+    attr_reader :from, :router, :path_map
+
+    def initialize(from, router, path_map = nil)
+      @from = from.to_sym
+      @router = router
+      @path_map = path_map || {}
+    end
+
+    # Route based on the router function result
+    def route(state, context: nil)
+      result = case @router.arity
+               when 0
+                 @router.call
+               when 1
+                 @router.call(state)
+               else
+                 @router.call(state, context)
+               end
+
+      # Convert result to destinations
+      destinations = case result
+                    when Array
+                      result
+                    when String, Symbol
+                      [result]
+                    when Hash
+                      # Support for multiple destinations with different states
+                      result.keys
+                    else
+                      [result]
+                    end
+
+      # Map through path_map if provided
+      destinations.map do |dest|
+        mapped = @path_map[dest.to_s] || @path_map[dest.to_sym] || dest
+        mapped.to_sym
+      end
+    end
+
+    def to_s
+      "#{@from} -> [conditional]"
+    end
+
+    def inspect
+      "#<ConditionalEdge: #{to_s}>"
+    end
+  end
+
+  # Fan-out edge that creates multiple parallel executions
+  class FanOutEdge
+    attr_reader :from, :destinations
+
+    def initialize(from, destinations)
+      @from = from.to_sym
+      @destinations = destinations.map(&:to_sym)
+    end
+
+    def route(state, context: nil)
+      @destinations
+    end
+
+    def to_s
+      "#{@from} -> #{@destinations.inspect}"
+    end
+
+    def inspect
+      "#<FanOutEdge: #{to_s}>"
+    end
+  end
+
+  # Helper class for building conditional routing
+  class Router
+    def self.build(&block)
+      new.tap { |r| r.instance_eval(&block) }
+    end
+
+    def initialize
+      @conditions = []
+    end
+
+    def when(condition, destination)
+      @conditions << [condition, destination]
+      self
+    end
+
+    def otherwise(destination)
+      @default = destination
+      self
+    end
+
+    def call(state, context = nil)
+      @conditions.each do |condition, destination|
+        result = case condition.arity
+                when 0
+                  condition.call
+                when 1
+                  condition.call(state)
+                else
+                  condition.call(state, context)
+                end
+        
+        return destination if result
+      end
+
+      @default || raise("No matching condition and no default specified")
+    end
+
+    def to_proc
+      method(:call).to_proc
+    end
+  end
+end