desiru 0.1.0 → 0.1.1

data/examples/graphql_performance_benchmark.rb

@@ -0,0 +1,247 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'desiru'
+require 'desiru/graphql/schema_generator'
+require 'desiru/graphql/executor'
+require 'desiru/graphql/data_loader'
+require 'benchmark'
+
+# Example: GraphQL Performance Benchmark with Request Deduplication
+# This demonstrates the performance improvement from request deduplication
+
+# Mock model for benchmarking
+class MockModel < Desiru::Models::Base
+  def initialize(config = {})
+    super
+  end
+
+  def call(_prompt, **_options)
+    # Return a simple response without actually calling an LLM
+    { content: "Mock response", usage: { total_tokens: 0 } }
+  end
+
+  def validate_config!
+    # No validation needed for mock
+  end
+end
+
+# Configure Desiru with mock model
+Desiru.configure do |config|
+  config.default_model = MockModel.new
+end
+
+# Create a module that tracks call counts
+class BenchmarkModule < Desiru::Modules::Predict
+  @call_count = 0
+  @batch_count = 0
+
+  class << self
+    attr_reader :call_count, :batch_count
+
+    def reset_counts!
+      @call_count = 0
+      @batch_count = 0
+    end
+
+    def increment_call_count
+      @call_count += 1
+    end
+
+    def increment_batch_count
+      @batch_count += 1
+    end
+  end
+
+  def call(inputs)
+    self.class.increment_call_count
+    # Simulate some processing time
+    sleep(0.001)
+    { result: "Processed: #{inputs[:id]}", timestamp: Time.now.to_f }
+  end
+
+  def batch_forward(inputs_array)
+    self.class.increment_batch_count
+    # Simulate batch processing time (more efficient than individual calls)
+    sleep(0.001 * Math.log(inputs_array.size + 1))
+    inputs_array.map do |inputs|
+      { result: "Batch processed: #{inputs[:id]}", timestamp: Time.now.to_f }
+    end
+  end
+end
+
+# Create schema generator and register the module
+generator = Desiru::GraphQL::SchemaGenerator.new
+signature = Desiru::Signature.new('id: string -> result: string, timestamp: float')
+module_instance = BenchmarkModule.new(signature)
+
+generator.register_signature('fetchData', signature)
+generator.register_module('fetchData', module_instance)
+
+# Generate schema
+schema = generator.generate_schema
+
+# Create executors with and without DataLoader
+data_loader = Desiru::GraphQL::DataLoader.new
+executor_with_loader = Desiru::GraphQL::Executor.new(schema, data_loader: data_loader)
+executor_without_loader = Desiru::GraphQL::Executor.new(schema)
+
+puts "=== GraphQL Performance Benchmark with Request Deduplication ==="
+puts
+
+# Test 1: Query with duplicate fields (common in GraphQL)
+duplicate_query = <<~GRAPHQL
+  {
+    user1: fetchData(id: "123") { result timestamp }
+    user2: fetchData(id: "456") { result timestamp }
+    user3: fetchData(id: "123") { result timestamp }
+    user4: fetchData(id: "789") { result timestamp }
+    user5: fetchData(id: "456") { result timestamp }
+    user6: fetchData(id: "123") { result timestamp }
+  }
+GRAPHQL
+
+puts "Test 1: Query with duplicate requests (3x id:123, 2x id:456, 1x id:789)"
+puts
+
+# Without deduplication
+BenchmarkModule.reset_counts!
+time_without = Benchmark.realtime do
+  executor_without_loader.execute(duplicate_query)
+end
+without_calls = BenchmarkModule.call_count
+without_batches = BenchmarkModule.batch_count
+
+# With deduplication
+BenchmarkModule.reset_counts!
+time_with = Benchmark.realtime do
+  executor_with_loader.execute(duplicate_query)
+end
+with_calls = BenchmarkModule.call_count
+with_batches = BenchmarkModule.batch_count
+
+puts "Without deduplication:"
+puts "  Time: #{(time_without * 1000).round(2)}ms"
+puts "  Individual calls: #{without_calls}"
+puts "  Batch calls: #{without_batches}"
+puts
+
+puts "With deduplication:"
+puts "  Time: #{(time_with * 1000).round(2)}ms"
+puts "  Individual calls: #{with_calls}"
+puts "  Batch calls: #{with_batches}"
+puts "  Unique requests processed: 3 (deduplication working!)"
+puts
+
+improvement = ((time_without - time_with) / time_without * 100).round(1)
+puts "Performance improvement: #{improvement}%"
+puts
+
+# Test 2: Nested query simulation (common with relationships)
+puts "\nTest 2: Simulating nested queries (N+1 problem)"
+puts
+
+nested_query = <<~GRAPHQL
+  {
+    posts1: fetchData(id: "post1") { result }
+    posts2: fetchData(id: "post2") { result }
+    posts3: fetchData(id: "post3") { result }
+    author1: fetchData(id: "author1") { result }
+    author2: fetchData(id: "author2") { result }
+    author3: fetchData(id: "author1") { result }
+    author4: fetchData(id: "author2") { result }
+    author5: fetchData(id: "author1") { result }
+    comments1: fetchData(id: "comment1") { result }
+    comments2: fetchData(id: "comment2") { result }
+    comments3: fetchData(id: "comment1") { result }
+  }
+GRAPHQL
+
+# Without deduplication
+BenchmarkModule.reset_counts!
+time_without = Benchmark.realtime do
+  executor_without_loader.execute(nested_query)
+end
+without_calls = BenchmarkModule.call_count
+without_batches = BenchmarkModule.batch_count
+
+# With deduplication
+BenchmarkModule.reset_counts!
+time_with = Benchmark.realtime do
+  executor_with_loader.execute(nested_query)
+end
+with_calls = BenchmarkModule.call_count
+with_batches = BenchmarkModule.batch_count
+
+puts "Without deduplication:"
+puts "  Time: #{(time_without * 1000).round(2)}ms"
+puts "  Total module calls: #{without_calls + without_batches}"
+puts
+
+puts "With deduplication + batching:"
+puts "  Time: #{(time_with * 1000).round(2)}ms"
+puts "  Total module calls: #{with_calls + with_batches}"
+puts "  Unique requests: 7 (3 posts, 2 authors, 2 comments)"
+puts
+
+improvement = ((time_without - time_with) / time_without * 100).round(1)
+puts "Performance improvement: #{improvement}%"
+puts
+
+# Test 3: Large batch with many duplicates
+puts "\nTest 3: Large batch with high duplication rate"
+puts
+
+# Generate a query with many duplicates
+field_count = 50
+unique_ids = 10
+fields = []
+field_count.times do |i|
+  id = rand(unique_ids)
+  fields << "field#{i}: fetchData(id: \"id_#{id}\") { result }"
+end
+large_query = "{ #{fields.join(' ')} }"
+
+# Without deduplication
+BenchmarkModule.reset_counts!
+time_without = Benchmark.realtime do
+  executor_without_loader.execute(large_query)
+end
+without_calls = BenchmarkModule.call_count
+without_batches = BenchmarkModule.batch_count
+
+# With deduplication
+BenchmarkModule.reset_counts!
+time_with = Benchmark.realtime do
+  executor_with_loader.execute(large_query)
+end
+BenchmarkModule.call_count
+with_batches = BenchmarkModule.batch_count
+
+puts "Query with #{field_count} fields, ~#{unique_ids} unique IDs"
+puts
+
+puts "Without deduplication:"
+puts "  Time: #{(time_without * 1000).round(2)}ms"
+puts "  Total requests processed: #{without_calls + without_batches}"
+puts
+
+puts "With deduplication + batching:"
+puts "  Time: #{(time_with * 1000).round(2)}ms"
+puts "  Unique requests processed: #{unique_ids}"
+puts "  Batch calls: #{with_batches}"
+puts
+
+improvement = ((time_without - time_with) / time_without * 100).round(1)
+puts "Performance improvement: #{improvement}%"
+puts
+puts "Deduplication ratio: #{(field_count.to_f / unique_ids).round(1)}:1"
+
+puts "\n=== Summary ==="
+puts "Request deduplication in GraphQL DataLoader prevents duplicate operations,"
+puts "significantly improving performance when the same data is requested multiple"
+puts "times within a single query. This is especially beneficial for:"
+puts "- Complex queries with repeated fields"
+puts "- Nested relationships that cause N+1 problems"
+puts "- High-traffic APIs where efficiency matters"

data/examples/persistence_example.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'desiru'
+require 'desiru/persistence'
+
+# Configure persistence
+Desiru::Persistence.database_url = 'sqlite://desiru_example.db'
+
+# Connect and migrate
+puts "Setting up database..."
+Desiru::Persistence.connect!
+Desiru::Persistence.migrate!
+
+# Access repositories
+module_executions = Desiru::Persistence[:module_executions]
+api_requests = Desiru::Persistence[:api_requests]
+optimization_results = Desiru::Persistence[:optimization_results]
+training_examples = Desiru::Persistence[:training_examples]
+
+# Example 1: Track module executions
+puts "\n1. Tracking module executions:"
+execution = module_executions.create_for_module('TextSummarizer', { text: 'Long article...' })
+puts "Created execution: #{execution.id}"
+
+# Simulate processing
+sleep 0.5
+result = { summary: 'Article summary', word_count: 50 }
+module_executions.complete(execution.id, result, { model: 'gpt-3.5-turbo' })
+puts "Completed execution with result"
+
+# Example 2: Store API requests
+puts "\n2. Storing API requests:"
+api_request = api_requests.create(
+  method: 'POST',
+  path: '/api/v1/summarize',
+  remote_ip: '127.0.0.1',
+  headers: { 'Content-Type' => 'application/json' },
+  params: { text: 'Long article...' },
+  status_code: 200,
+  response_body: { summary: 'Article summary' },
+  response_time: 0.234
+)
+puts "Stored API request: #{api_request.path} (#{api_request.duration_ms}ms)"
+
+# Example 3: Track optimization results
+puts "\n3. Recording optimization results:"
+opt_result = optimization_results.create_result(
+  module_name: 'TextSummarizer',
+  optimizer_type: 'BootstrapFewShot',
+  score: 0.89,
+  baseline_score: 0.75,
+  training_size: 50,
+  parameters: { temperature: 0.7, max_tokens: 150 },
+  metrics: { accuracy: 0.89, f1_score: 0.87 }
+)
+puts "Optimization improved performance by #{opt_result.improvement_percentage}%"
+
+# Example 4: Store training examples
+puts "\n4. Managing training examples:"
+examples = [
+  { inputs: { text: 'Example 1' }, outputs: { summary: 'Summary 1' } },
+  { inputs: { text: 'Example 2' }, outputs: { summary: 'Summary 2' } },
+  { inputs: { text: 'Example 3' }, outputs: { summary: 'Summary 3' } }
+]
+
+training_examples.bulk_create('TextSummarizer', examples)
+puts "Created #{examples.length} training examples"
+
+# Example 5: Query data
+puts "\n5. Querying stored data:"
+puts "- Module execution success rate: #{module_executions.success_rate}%"
+puts "- Recent API requests: #{api_requests.recent(5).map(&:path).join(', ')}"
+puts "- Best optimization score: #{optimization_results.find_best_for_module('TextSummarizer')&.score}"
+puts "- Training examples available: #{training_examples.count}"
+
+# Example 6: Analytics
+puts "\n6. Analytics:"
+puts "- Average response time: #{api_requests.average_response_time}s"
+puts "- Requests per minute: #{api_requests.requests_per_minute(60)}"
+puts "- Top API paths:"
+api_requests.top_paths(3).each do |path_info|
+  puts "  #{path_info[:path]}: #{path_info[:count]} requests"
+end
+
+# Example 7: Dataset splitting
+puts "\n7. Dataset management:"
+splits = training_examples.split_dataset('TextSummarizer')
+puts "- Training set: #{splits[:training].length} examples"
+puts "- Validation set: #{splits[:validation].length} examples"
+puts "- Test set: #{splits[:test].length} examples"
+
+# Export for training
+puts "\n8. Export training data:"
+export_data = training_examples.export_for_training('TextSummarizer', format: :dspy)
+puts "Exported #{export_data.length} examples in DSPy format"
+
+# Cleanup
+puts "\nCleaning up..."
+Desiru::Persistence.disconnect!
+puts "Done!"

data/examples/react_agent.rb

@@ -0,0 +1,203 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/desiru'
+require_relative '../lib/desiru/modules/react'
+require 'json'
+require 'net/http'
+
+# Example of using ReAct module to build a tool-using agent
+
+# Define some useful tools
+class WeatherTool
+  def self.name
+    "get_weather"
+  end
+
+  def self.description
+    "Get current weather for a city. Args: city (string)"
+  end
+
+  def self.call(city:)
+    # In a real implementation, this would call a weather API
+    # For demo purposes, we'll return mock data
+    temps = {
+      "Tokyo" => 72,
+      "New York" => 68,
+      "London" => 59,
+      "Sydney" => 77
+    }
+
+    temp = temps[city] || rand(50..85)
+    conditions = ["sunny", "partly cloudy", "cloudy", "rainy"].sample
+
+    "Current weather in #{city}: #{conditions}, #{temp}°F"
+  end
+end
+
+class CalculatorTool
+  def self.name
+    "calculator"
+  end
+
+  def self.description
+    "Perform calculations. Args: expression (string) - a mathematical expression to evaluate"
+  end
+
+  def self.call(expression:)
+    # Safety note: In production, use a proper expression parser
+    # This is just for demonstration
+
+    # Only allow basic math operations
+    if expression =~ %r{^[\d\s\+\-\*/\(\)\.]+$}
+      result = eval(expression) # rubocop:disable Security/Eval
+      "Result: #{result}"
+    else
+      "Error: Invalid expression. Only numbers and basic operators allowed."
+    end
+  rescue StandardError => e
+    "Error: #{e.message}"
+  end
+end
+
+class TimeTool
+  def self.name
+    "get_time"
+  end
+
+  def self.description
+    "Get current time for a timezone. Args: timezone (string) - e.g., 'EST', 'PST', 'GMT'"
+  end
+
+  def self.call(timezone: "GMT")
+    # Simple timezone offset mapping
+    offsets = {
+      "GMT" => 0,
+      "EST" => -5,
+      "PST" => -8,
+      "JST" => 9,
+      "AEST" => 10
+    }
+
+    offset = offsets[timezone.upcase] || 0
+    time = Time.now.utc + (offset * 3600)
+
+    "Current time in #{timezone}: #{time.strftime('%Y-%m-%d %H:%M:%S')}"
+  end
+end
+
+# Configure Desiru
+Desiru.configure do |config|
+  config.default_model = Desiru::Models::Anthropic.new(
+    model: ENV['LLM_MODEL'] || 'claude-3-haiku-20240307',
+    api_key: ENV['ANTHROPIC_API_KEY'] || raise('Please set ANTHROPIC_API_KEY environment variable')
+  )
+end
+
+# Create tools array
+tools = [WeatherTool, CalculatorTool, TimeTool]
+
+# Example 1: Weather Query
+puts "=== Example 1: Weather Query ==="
+weather_agent = Desiru::Modules::ReAct.new(
+  'question: string -> answer: string',
+  tools: tools,
+  max_iterations: 5
+)
+
+result = weather_agent.call(
+  question: "What's the weather like in Tokyo and New York? Also, what time is it in JST?"
+)
+puts "Question: What's the weather like in Tokyo and New York? Also, what time is it in JST?"
+puts "Answer: #{result[:answer]}"
+puts
+
+# Example 2: Multi-step Calculation
+puts "=== Example 2: Multi-step Calculation ==="
+calc_agent = Desiru::Modules::ReAct.new(
+  'problem: string -> solution: string, result: float',
+  tools: tools,
+  max_iterations: 5
+)
+
+result = calc_agent.call(
+  problem: "If the temperature in Tokyo is 72°F, what is it in Celsius? (Use formula: C = (F - 32) * 5/9)"
+)
+puts "Problem: If the temperature in Tokyo is 72°F, what is it in Celsius?"
+puts "Solution: #{result[:solution]}"
+puts "Result: #{result[:result]}"
+puts
+
+# Example 3: Complex Query Requiring Multiple Tools
+puts "=== Example 3: Complex Multi-tool Query ==="
+complex_agent = Desiru::Modules::ReAct.new(
+  'query: string -> summary: string, data: list[string]',
+  tools: tools,
+  max_iterations: 8
+)
+
+result = complex_agent.call(
+  query: "I'm planning a trip. Get the weather for London and Sydney, " \
+         "calculate the time difference between GMT and AEST, and tell me what time it is in both cities."
+)
+puts "Query: Planning a trip - need weather and time info for London and Sydney"
+puts "Summary: #{result[:summary]}"
+puts "Data points:"
+result[:data].each { |point| puts "  - #{point}" }
+puts
+
+# Example 4: Tool with Error Handling
+puts "=== Example 4: Error Handling ==="
+error_agent = Desiru::Modules::ReAct.new(
+  'task: string -> result: string, status: string',
+  tools: tools,
+  max_iterations: 3
+)
+
+result = error_agent.call(
+  task: "Calculate the result of this expression: 10 / 0"
+)
+puts "Task: Calculate 10 / 0"
+puts "Result: #{result[:result]}"
+puts "Status: #{result[:status]}"
+puts
+
+# Example 5: Custom Tool Integration
+puts "=== Example 5: Custom Tool Integration ==="
+
+# Define a custom database lookup tool
+database = {
+  "user123" => { name: "Alice", balance: 1500.50 },
+  "user456" => { name: "Bob", balance: 2300.75 }
+}
+
+lookup_tool = lambda do |user_id:|
+  if database.key?(user_id)
+    user = database[user_id]
+    "User #{user[:name]} has balance: $#{user[:balance]}"
+  else
+    "User not found"
+  end
+end
+
+# Create agent with custom tool
+custom_agent = Desiru::Modules::ReAct.new(
+  'request: string -> response: string, amount: float',
+  tools: [
+    { name: "lookup_user", function: lookup_tool },
+    CalculatorTool
+  ],
+  max_iterations: 5
+)
+
+result = custom_agent.call(
+  request: "Look up user123 and calculate 10% of their balance"
+)
+puts "Request: Look up user123 and calculate 10% of their balance"
+puts "Response: #{result[:response]}"
+puts "Amount: #{result[:amount]}"
+
+# Demonstrate trajectory truncation for long conversations
+puts "\n=== Trajectory Management ==="
+puts "The ReAct module automatically manages long trajectories to fit within context limits."
+puts "This ensures the agent can handle extended conversations without exceeding token limits."