LanggraphRB Rails

gem 'langgraphrb_rails'

class ChatController < ApplicationController
  def create
    result = ChatGraph.invoke(input: params[:message])
    render json: { response: result[:response] }
  end
  
  def stream
    response.headers['Content-Type'] = 'text/event-stream'
    response.headers['Last-Modified'] = Time.now.httpdate
    
    ChatGraph.stream(input: params[:message]) do |step_result|
      response.stream.write("data: #{step_result.to_json}\n\n")
      
      if step_result[:completed]
        response.stream.close
      end
    end
  end
end

# config/initializers/langgraphrb_rails.rb

LanggraphrbRails.configure do |config|
  # Configure the store adapter
  config.store_adapter = :active_record
  config.store_options = { model: 'LanggraphRun' }
  
  # Configure job settings
  config.job_queue = :langgraph
  config.error_policy = :retry
  config.max_retries = 3
  
  # Add observers (optional)
  if defined?(LangsmithrbRails) && ENV['LANGSMITH_API_KEY'].present?
    config.observers << LangsmithrbRails::Observer.new(
      api_key: ENV['LANGSMITH_API_KEY'],
      project_name: ENV['LANGSMITH_PROJECT'] || 'langgraphrb-rails'
    )
  end
end

# Add app/langgraphs to autoload paths
Rails.autoloaders.main.push_dir(Rails.root.join('app', 'langgraphs'))

# Start a new graph run
run = LanggraphrbRails.start!(
  graph: "ProposalDraftGraph",
  context: { "user_id" => current_user.id },
  state: {}
)

# Later, resume the run
LanggraphrbRails.resume!(run.thread_id)

# Or find and resume by thread_id
LanggraphrbRails.resume!(thread_id: "some-thread-id")

# Find recent runs
LanggraphRun.recent

# Find expired runs
LanggraphRun.expired

# Find runs by status
LanggraphRun.queued
LanggraphRun.running
LanggraphRun.completed
LanggraphRun.failed

# Start a new graph run
run = LanggraphrbRails.start!(
  graph: "ProposalDraftGraph",
  context: { "user_id" => current_user.id },
  state: {}
)

# Process the run in the background
Langgraph::RunJob.perform_later(run.thread_id)

module Langgraph
  class RunJob < ApplicationJob
    queue_as { LanggraphrbRails.configuration.job_queue || :default }

    retry_on StandardError, wait: :exponentially_longer, attempts: -> { LanggraphrbRails.configuration.max_retries || 3 }

    def perform(thread_id)
      run = LanggraphRun.find_by(thread_id: thread_id)
      return unless run

      # Process the run
      LanggraphrbRails.resume!(thread_id: thread_id)

      # Re-queue the job if the run is not in a terminal state
      unless run.reload.terminal?
        self.class.set(wait: 1.second).perform_later(thread_id)
      end
    end
  end
end

namespace :langgraph_proposal do
  desc "Process pending Proposal graph runs"
  task process: :environment do
    puts "Processing pending Proposal graph runs..."
    count = 0
    
    LanggraphRun.where(graph: "ProposalGraph", status: :queued).find_each do |run|
      Langgraph::RunJob.perform_later(run.thread_id)
      count += 1
    end
    
    puts "Queued #{count} Proposal graph runs for processing."
  end
  
  desc "Clean up expired Proposal graph runs"
  task cleanup: :environment do
    puts "Cleaning up expired Proposal graph runs..."
    count = LanggraphRun.where(graph: "ProposalGraph").expired.delete_all
    puts "Deleted #{count} expired Proposal graph runs."
  end
end

class Nodes::ParseRfp < LangGraphRB::Node
  include LangsmithTraced
  
  def call(context:, state:)
    # Wrap your node logic in a trace block
    trace(name: "ParseRfp", meta: { user_id: context["user_id"] }) do |run|
      # Your node logic here
      # Access the run object for additional tracing
      run.add_metadata(document_size: state[:document].size)
      
      # Return your node result
      { state: { parsed_content: "..." } }
    end
  end
end

# config/application.rb
config.middleware.use LanggraphrbRails::Middleware::Streaming

# config/initializers/langgraph_rb.rb

LanggraphrbRails.configure_store do |store_config|
  store_config.adapter = :redis
  store_config.options = { 
    url: ENV['REDIS_URL'],
    namespace: 'langgraph_rb'
  }
end

# config/initializers/langgraph_rb.rb

LanggraphrbRails.configure_observers do |observers|
  observers << LangGraphRB::Observers::Logger.new
  observers << LangGraphRB::Observers::Structured.new
  observers << MyCustomObserver.new
end

require 'rails_helper'

RSpec.describe ProposalDraftGraph do
  # Use a memory store for testing
  before do
    allow(LanggraphrbRails).to receive(:create_store).and_return(LangGraphRB::Storage::Memory.new)
  end
  
  describe "#invoke" do
    it "processes an RFP document" do
      # Create test data
      rfp_text = "Request for Proposal: AI-powered analytics platform"
      
      # Invoke the graph
      result = described_class.invoke(rfp_text: rfp_text)
      
      # Verify the result
      expect(result[:state]).to include(:proposal)
      expect(result[:state][:proposal]).to be_a(String)
      expect(result[:state][:proposal]).to include("Analytics")
    end
  end
  
  describe "persistence" do
    it "can be resumed from a saved state" do
      # Start a graph run
      run = LanggraphrbRails.start!(
        graph: "ProposalDraftGraph",
        context: { rfp_text: "Sample RFP" },
        state: {}
      )
      
      # Resume the run
      result = LanggraphrbRails.resume!(run.thread_id)
      
      # Verify the result
      expect(result).to be_a(LanggraphRun)
      expect(result.state).to include("proposal")
    end
  end
end

require 'rails_helper'

RSpec.describe Nodes::ParseRfp do
  describe "#call" do
    it "extracts key information from an RFP" do
      # Create a node instance
      node = described_class.new
      
      # Call the node with test data
      result = node.call(
        context: { "user_id" => 1 },
        state: { rfp_text: "Request for Proposal: AI-powered analytics platform" }
      )
      
      # Verify the result
      expect(result[:state]).to include(:rfp_details)
      expect(result[:state][:rfp_details]).to include(:title)
      expect(result[:state][:rfp_details][:title]).to include("analytics")
    end
  end
end

RSpec.describe Nodes::GenerateProposal do
  describe "#call" do
    it "generates a proposal based on RFP details" do
      # Mock any external services
      allow_any_instance_of(OpenAI::Client).to receive(:chat).and_return(
        { "choices" => [{ "message" => { "content" => "Mock proposal content" } }] }
      )
      
      # Create a node instance
      node = described_class.new
      
      # Call the node with test data
      result = node.call(
        context: {},
        state: { rfp_details: { title: "AI Analytics", requirements: ["Real-time data"] } }
      )
      
      # Verify the result
      expect(result[:state]).to include(:proposal)
      expect(result[:state][:proposal]).to eq("Mock proposal content")
    end
  end
end

require 'spec_helper'

RSpec.describe YourGenerator, type: :generator do
  include RailsMockHelper
  
  before(:each) do
    setup_rails_mocks
    # Your test setup
  end
  
  # Your tests
end

RSpec.describe YourGenerator, type: :generator do
  include RailsMockHelper
  include DummyAppHelper
  
  before(:each) do
    setup_rails_mocks
    setup_dummy_directories
    
    # Stub generator methods
    allow_any_instance_of(described_class).to receive(:template) do |_, source, dest|
      rel_path = dest.to_s.sub("#{Rails.root}/", '')
      create_dummy_file(rel_path, "# Generated from #{source}")
    end
  end
  
  after(:each) do
    cleanup_dummy_directories
  end
  
  # Your tests
end

it "creates the expected files" do
  run_generator(["MyGraph", "--nodes=node1,node2"])
  
  expect(File.exist?(File.join(Rails.root, 'app/langgraphs/my_graph.rb'))).to be true
  expect(File.exist?(File.join(Rails.root, 'app/langgraph_nodes/nodes/node1.rb'))).to be true
  expect(File.exist?(File.join(Rails.root, 'app/langgraph_nodes/nodes/node2.rb'))).to be true
end

RSpec.describe LanggraphrbRails::Persistence::ActiveRecordStore do
  before(:each) do
    @langgraph_run = double("LanggraphRun")
    allow(LanggraphRun).to receive(:find_by).and_return(@langgraph_run)
    
    @store = described_class.new
  end
  
  it "retrieves state from the database" do
    allow(@langgraph_run).to receive(:state).and_return({"key" => "value"})
    
    result = @store.get("thread-123")
    expect(result).to eq({"key" => "value"})
  end
end

# app/langgraphs/proposal_draft_graph.rb
class ProposalDraftGraph < LanggraphrbRails::Graph
  def build
    # Define nodes
    add_node :parse_rfp, Nodes::ParseRfp.new
    add_node :generate_proposal, Nodes::GenerateProposal.new
    add_node :review_and_finalize, Nodes::ReviewAndFinalize.new
    
    # Define edges
    add_edge :parse_rfp, :generate_proposal
    add_edge :generate_proposal, :review_and_finalize
    
    # Set terminal node
    set_entry_point :parse_rfp
    set_terminal_nodes :review_and_finalize
  end
end

# app/langgraph_nodes/nodes/parse_rfp.rb
module Nodes
  class ParseRfp < LanggraphrbRails::Node
    def call(context:, state:)
      # Extract RFP details from text
      rfp_details = { 
        title: extract_title(state[:rfp_text]),
        requirements: extract_requirements(state[:rfp_text])
      }
      
      # Return updated state
      { state: state.merge(rfp_details: rfp_details) }
    end
    
    private
    
    def extract_title(text)
      # Implementation
    end
    
    def extract_requirements(text)
      # Implementation
    end
  end
end

class RfpsController < ApplicationController
  def create
    # Start a graph run with the uploaded RFP
    run = LanggraphrbRails.start!(
      graph: "ProposalDraftGraph",
      context: { user_id: current_user.id },
      state: { rfp_text: params[:rfp][:content] }
    )
    
    # Process in background
    Langgraph::RunJob.perform_later(run.thread_id)
    
    redirect_to rfp_path(run.thread_id)
  end
  
  def show
    @run = LanggraphRun.find_by(thread_id: params[:id])
  end
end