ollama-client 0.2.5 → 0.2.7

data/examples/advanced_multi_step_agent.rb

@@ -1,341 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Advanced Example: Multi-Step Agent with Complex Decision Making
-# Demonstrates: Nested schemas, state management, error recovery, confidence thresholds
-
-require "json"
-require_relative "../lib/ollama_client"
-
-class MultiStepAgent
-  def initialize(client:)
-    @client = client
-    @state = {
-      steps_completed: [],
-      data_collected: {},
-      errors: []
-    }
-
-    # Complex nested schema for decision making
-    @decision_schema = {
-      "type" => "object",
-      "required" => ["step", "action", "reasoning", "confidence", "next_steps"],
-      "properties" => {
-        "step" => {
-          "type" => "integer",
-          "description" => "Current step number in the workflow"
-        },
-        "action" => {
-          "type" => "object",
-          "required" => ["type", "parameters"],
-          "properties" => {
-            "type" => {
-              "type" => "string",
-              "enum" => ["collect", "analyze", "transform", "validate", "complete"]
-            },
-            "parameters" => {
-              "type" => "object",
-              "additionalProperties" => true
-            }
-          }
-        },
-        "reasoning" => {
-          "type" => "string",
-          "description" => "Why this action was chosen"
-        },
-        "confidence" => {
-          "type" => "number",
-          "minimum" => 0,
-          "maximum" => 1,
-          "description" => "Confidence level (0.0 to 1.0, where 1.0 is 100% confident)"
-        },
-        "next_steps" => {
-          "type" => "array",
-          "items" => {
-            "type" => "string"
-          },
-          "minItems" => 0,
-          "maxItems" => 5
-        },
-        "risk_assessment" => {
-          "type" => "object",
-          "properties" => {
-            "level" => {
-              "type" => "string",
-              "enum" => ["low", "medium", "high"]
-            },
-            "factors" => {
-              "type" => "array",
-              "items" => { "type" => "string" }
-            }
-          }
-        }
-      }
-    }
-  end
-
-  def execute_workflow(goal:)
-    puts "🚀 Starting multi-step workflow"
-    puts "Goal: #{goal}\n\n"
-
-    max_steps = 10
-    step_count = 0
-
-    loop do
-      step_count += 1
-      break if step_count > max_steps
-
-      puts "─" * 60
-      puts "Step #{step_count}/#{max_steps}"
-      puts "─" * 60
-
-      context = build_context(goal: goal)
-
-      begin
-        decision = @client.generate(
-          prompt: build_prompt(goal: goal, context: context),
-          schema: @decision_schema
-        )
-
-        # Validate confidence threshold
-        if decision["confidence"] < 0.5
-          puts "⚠️  Low confidence (#{(decision["confidence"] * 100).round}%) - requesting manual review"
-          break
-        end
-
-        display_decision(decision)
-        result = execute_action(decision)
-
-        # Update state
-        @state[:steps_completed] << {
-          step: decision["step"],
-          action: decision["action"]["type"],
-          result: result
-        }
-
-        # Check if workflow is complete
-        if decision["action"]["type"] == "complete"
-          puts "\n✅ Workflow completed successfully!"
-          break
-        end
-
-        # Prevent infinite loops - if we've done the same action 3+ times, force progression
-        recent_actions = @state[:steps_completed].last(3).map { |s| s[:action] }
-        if recent_actions.length == 3 && recent_actions.uniq.length == 1
-          puts "⚠️  Detected repetitive actions - forcing workflow progression"
-          # Force next phase
-          case recent_actions.first
-          when "collect"
-            puts "   → Moving to analysis phase"
-            decision["action"]["type"] = "analyze"
-            decision["action"]["parameters"] = { "target" => "collected_data" }
-            result = execute_action(decision)
-            @state[:steps_completed] << {
-              step: decision["step"],
-              action: "analyze",
-              result: result
-            }
-          when "analyze"
-            puts "   → Moving to validation phase"
-            decision["action"]["type"] = "validate"
-            decision["action"]["parameters"] = { "type" => "results" }
-            result = execute_action(decision)
-            @state[:steps_completed] << {
-              step: decision["step"],
-              action: "validate",
-              result: result
-            }
-          when "validate"
-            puts "   → Completing workflow"
-            decision["action"]["type"] = "complete"
-            result = execute_action(decision)
-            @state[:steps_completed] << {
-              step: decision["step"],
-              action: "complete",
-              result: result
-            }
-            puts "\n✅ Workflow completed successfully!"
-            break
-          end
-        end
-
-        # Handle risk
-        if decision["risk_assessment"] && decision["risk_assessment"]["level"] == "high"
-          puts "⚠️  High risk detected - proceeding with caution"
-        end
-      rescue Ollama::SchemaViolationError => e
-        puts "❌ Schema violation: #{e.message}"
-        @state[:errors] << { step: step_count, error: "schema_violation", message: e.message }
-        break
-      rescue Ollama::RetryExhaustedError => e
-        puts "❌ Retries exhausted: #{e.message}"
-        @state[:errors] << { step: step_count, error: "retry_exhausted", message: e.message }
-        break
-      rescue Ollama::Error => e
-        puts "❌ Error: #{e.message}"
-        @state[:errors] << { step: step_count, error: "general", message: e.message }
-        # Try to recover or break
-        break if step_count > 3 # Don't loop forever
-      end
-
-      puts
-      sleep 0.5 # Small delay for readability
-    end
-
-    display_summary
-    @state
-  end
-
-  private
-
-  def build_context(goal:) # rubocop:disable Lint/UnusedMethodArgument
-    {
-      steps_completed: @state[:steps_completed].map { |s| s[:action] },
-      data_collected: @state[:data_collected].keys,
-      error_count: @state[:errors].length,
-      step_count: @state[:steps_completed].length
-    }
-  end
-
-  def build_prompt(goal:, context:)
-    step_count = context[:step_count]
-    completed_actions = context[:steps_completed]
-    collected_data = context[:data_collected]
-
-    # Determine current phase based on what's been done
-    phase = if completed_actions.empty?
-              "collection"
-            elsif completed_actions.include?("collect") && !completed_actions.include?("analyze")
-              "analysis"
-            elsif completed_actions.include?("analyze") && !completed_actions.include?("validate")
-              "validation"
-            else
-              "completion"
-            end
-
-    <<~PROMPT
-      Goal: #{goal}
-
-      Current Phase: #{phase}
-      Steps completed: #{step_count}
-      Actions taken: #{completed_actions.join(", ") || "none"}
-      Data collected: #{collected_data.join(", ") || "none"}
-      Errors encountered: #{context[:error_count]}
-
-      Workflow Phases (in order):
-      1. COLLECTION: Collect initial data (user data, patterns, etc.)
-      2. ANALYSIS: Analyze collected data for patterns and insights
-      3. VALIDATION: Validate the analysis results
-      4. COMPLETION: Finish the workflow
-
-      Current State Analysis:
-      - You are in the #{phase} phase
-      - You have completed #{step_count} steps
-      - You have collected: #{collected_data.any? ? collected_data.join(", ") : "nothing yet"}
-
-      Decision Guidelines:
-      - If in COLLECTION phase and no data collected: use action "collect" with specific data_type (e.g., "user_data", "patterns")
-      - If data collected but not analyzed: use action "analyze" with target
-      - If analyzed but not validated: use action "validate"
-      - If all phases done: use action "complete"
-      - AVOID repeating the same action multiple times unless necessary
-      - Progress through phases: collect → analyze → validate → complete
-
-      Provide a structured decision with high confidence (>0.7) if possible.
-      Set step number to #{step_count + 1}.
-    PROMPT
-  end
-
-  def display_decision(decision)
-    puts "\n📋 Decision:"
-    puts "   Step: #{decision['step']}"
-    puts "   Action: #{decision['action']['type']}"
-    puts "   Reasoning: #{decision['reasoning']}"
-    puts "   Confidence: #{(decision['confidence'] * 100).round}%"
-    if decision["risk_assessment"]
-      puts "   Risk Level: #{decision['risk_assessment']['level']}"
-      if decision["risk_assessment"]["factors"]
-        puts "   Risk Factors: #{decision['risk_assessment']['factors'].join(', ')}"
-      end
-    end
-    return unless decision["next_steps"] && !decision["next_steps"].empty?
-
-    puts "   Next Steps: #{decision['next_steps'].join(' → ')}"
-  end
-
-  def execute_action(decision)
-    action_type = decision["action"]["type"]
-    params = decision["action"]["parameters"] || {}
-
-    case action_type
-    when "collect"
-      data_key = params["data_type"] || params["key"] || "user_data"
-      # Prevent collecting the same generic data repeatedly
-      data_key = "user_data" if should_collect_user_data?(data_key)
-      puts "   📥 Collecting: #{data_key}"
-      @state[:data_collected][data_key] = "collected_at_#{Time.now.to_i}"
-      { status: "collected", key: data_key }
-
-    when "analyze"
-      target = params["target"] || "collected_data"
-      puts "   🔍 Analyzing: #{target}"
-      # Mark that analysis has been done
-      @state[:data_collected]["analysis_complete"] = true
-      { status: "analyzed", target: target, insights: "Patterns identified in collected data" }
-
-    when "transform"
-      transformation = params["type"] || "default"
-      puts "   🔄 Transforming: #{transformation}"
-      { status: "transformed", type: transformation }
-
-    when "validate"
-      validation_type = params["type"] || "results"
-      puts "   ✓ Validating: #{validation_type}"
-      # Mark that validation has been done
-      @state[:data_collected]["validation_complete"] = true
-      { status: "validated", type: validation_type, result: "All checks passed" }
-
-    when "complete"
-      puts "   ✅ Completing workflow"
-      { status: "complete" }
-
-    else
-      { status: "unknown_action" }
-    end
-  end
-
-  def should_collect_user_data?(data_key)
-    @state[:data_collected].key?(data_key) &&
-      data_key.match?(/^(missing|unknown|data)$/i) &&
-      !@state[:data_collected].key?("user_data")
-  end
-
-  def display_summary
-    puts "\n" + "=" * 60
-    puts "Workflow Summary"
-    puts "=" * 60
-    puts "Steps completed: #{@state[:steps_completed].length}"
-    puts "Data collected: #{@state[:data_collected].keys.join(', ') || 'none'}"
-    puts "Errors: #{@state[:errors].length}"
-    return unless @state[:errors].any?
-
-    puts "\nErrors:"
-    @state[:errors].each do |error|
-      puts "  Step #{error[:step]}: #{error[:error]} - #{error[:message]}"
-    end
-  end
-end
-
-# Run example
-if __FILE__ == $PROGRAM_NAME
-  # Use longer timeout for multi-step workflows
-  config = Ollama::Config.new
-  config.timeout = 60 # 60 seconds for complex operations
-  client = Ollama::Client.new(config: config)
-
-  agent = MultiStepAgent.new(client: client)
-  agent.execute_workflow(
-    goal: "Collect user data, analyze patterns, validate results, and generate report"
-  )
-end
-

data/examples/advanced_performance_testing.rb

@@ -1,186 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Advanced Example: Performance Testing and Observability
-# Demonstrates: Latency measurement, throughput testing, error rate tracking, concurrent requests
-
-require "json"
-require "benchmark"
-require "time"
-require_relative "../lib/ollama_client"
-
-class PerformanceMonitor
-  def initialize(client:)
-    @client = client
-    @metrics = {
-      calls: [],
-      errors: [],
-      latencies: []
-    }
-  end
-
-  def measure_call(prompt:, schema:)
-    start_time = Time.now
-
-    begin
-      result = @client.generate(prompt: prompt, schema: schema)
-      latency = (Time.now - start_time) * 1000 # Convert to milliseconds
-
-      @metrics[:calls] << {
-        success: true,
-        latency_ms: latency,
-        timestamp: Time.now.iso8601
-      }
-      @metrics[:latencies] << latency
-
-      { success: true, result: result, latency_ms: latency }
-    rescue Ollama::Error => e
-      latency = (Time.now - start_time) * 1000
-      @metrics[:calls] << {
-        success: false,
-        latency_ms: latency,
-        error: e.class.name,
-        timestamp: Time.now.iso8601
-      }
-      @metrics[:errors] << { error: e.class.name, message: e.message, latency_ms: latency }
-
-      { success: false, error: e, latency_ms: latency }
-    end
-  end
-
-  def run_throughput_test(prompt:, schema:, iterations: 10)
-    puts "🚀 Running throughput test (#{iterations} iterations)..."
-    results = []
-
-    total_time = Benchmark.realtime do
-      iterations.times do |i|
-        print "  #{i + 1}/#{iterations}... "
-        result = measure_call(prompt: prompt, schema: schema)
-        results << result
-        puts result[:success] ? "✓" : "✗"
-      end
-    end
-
-    {
-      total_time: total_time,
-      iterations: iterations,
-      throughput: iterations / total_time,
-      results: results
-    }
-  end
-
-  def run_latency_test(prompt:, schema:, iterations: 10)
-    puts "⏱️  Running latency test (#{iterations} iterations)..."
-    latencies = []
-
-    iterations.times do |i|
-      print "  #{i + 1}/#{iterations}... "
-      result = measure_call(prompt: prompt, schema: schema)
-      if result[:success]
-        latencies << result[:latency_ms]
-        puts "#{result[:latency_ms].round(2)}ms"
-      else
-        puts "ERROR"
-      end
-    end
-
-    {
-      latencies: latencies,
-      min: latencies.min,
-      max: latencies.max,
-      avg: latencies.sum / latencies.length,
-      median: latencies.sort[latencies.length / 2],
-      p95: latencies.sort[(latencies.length * 0.95).to_i],
-      p99: latencies.sort[(latencies.length * 0.99).to_i]
-    }
-  end
-
-  def display_metrics
-    puts "\n" + "=" * 60
-    puts "Performance Metrics"
-    puts "=" * 60
-
-    total_calls = @metrics[:calls].length
-    successful = @metrics[:calls].count { |c| c[:success] }
-    failed = total_calls - successful
-
-    puts "Total calls: #{total_calls}"
-    puts "Successful: #{successful} (#{(successful.to_f / total_calls * 100).round(2)}%)"
-    puts "Failed: #{failed} (#{(failed.to_f / total_calls * 100).round(2)}%)"
-
-    if @metrics[:latencies].any?
-      latencies = @metrics[:latencies]
-      puts "\nLatency Statistics (ms):"
-      puts "  Min: #{latencies.min.round(2)}"
-      puts "  Max: #{latencies.max.round(2)}"
-      puts "  Avg: #{(latencies.sum / latencies.length).round(2)}"
-      puts "  Median: #{latencies.sort[latencies.length / 2].round(2)}"
-      puts "  P95: #{latencies.sort[(latencies.length * 0.95).to_i].round(2)}"
-      puts "  P99: #{latencies.sort[(latencies.length * 0.99).to_i].round(2)}"
-    end
-
-    return unless @metrics[:errors].any?
-
-    puts "\nErrors by type:"
-    error_counts = @metrics[:errors].group_by { |e| e[:error] }
-    error_counts.each do |error_type, errors|
-      puts "  #{error_type}: #{errors.length}"
-    end
-  end
-
-  def export_metrics(filename: "metrics.json")
-    File.write(filename, JSON.pretty_generate(@metrics))
-    puts "\n📊 Metrics exported to #{filename}"
-  end
-end
-
-# Run performance tests
-if __FILE__ == $PROGRAM_NAME
-  # Use longer timeout for performance testing
-  config = Ollama::Config.new
-  config.timeout = 60 # 60 seconds for complex operations
-  client = Ollama::Client.new(config: config)
-  monitor = PerformanceMonitor.new(client: client)
-
-  schema = {
-    "type" => "object",
-    "required" => ["response"],
-    "properties" => {
-      "response" => { "type" => "string" }
-    }
-  }
-
-  puts "=" * 60
-  puts "Performance Testing Suite"
-  puts "=" * 60
-
-  # Test 1: Latency
-  latency_results = monitor.run_latency_test(
-    prompt: "Respond with a simple acknowledgment",
-    schema: schema,
-    iterations: 5
-  )
-
-  puts "\nLatency Results:"
-  puts "  Average: #{latency_results[:avg].round(2)}ms"
-  puts "  P95: #{latency_results[:p95].round(2)}ms"
-  puts "  P99: #{latency_results[:p99].round(2)}ms"
-
-  # Test 2: Throughput
-  throughput_results = monitor.run_throughput_test(
-    prompt: "Count to 5",
-    schema: schema,
-    iterations: 5
-  )
-
-  puts "\nThroughput Results:"
-  puts "  Total time: #{throughput_results[:total_time].round(2)}s"
-  puts "  Throughput: #{throughput_results[:throughput].round(2)} calls/sec"
-
-  # Display all metrics
-  monitor.display_metrics
-
-  # Export metrics
-  monitor.export_metrics
-end
-

data/examples/chat_console.rb

@@ -1,143 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require_relative "../lib/ollama_client"
-require "tty-reader"
-require "tty-screen"
-require "tty-cursor"
-
-def build_config
-  config = Ollama::Config.new
-  config.base_url = ENV["OLLAMA_BASE_URL"] if ENV["OLLAMA_BASE_URL"]
-  config.model = ENV["OLLAMA_MODEL"] if ENV["OLLAMA_MODEL"]
-  config.temperature = ENV["OLLAMA_TEMPERATURE"].to_f if ENV["OLLAMA_TEMPERATURE"]
-  config
-end
-
-def exit_command?(text)
-  %w[/exit /quit exit quit].include?(text.downcase)
-end
-
-def add_system_message(messages)
-  system_prompt = ENV.fetch("OLLAMA_SYSTEM", nil)
-  return unless system_prompt && !system_prompt.strip.empty?
-
-  messages << { role: "system", content: system_prompt }
-end
-
-def print_banner(config)
-  puts "Ollama chat console"
-  puts "Model: #{config.model}"
-  puts "Base URL: #{config.base_url}"
-  puts "Type /exit to quit."
-  puts "Screen: #{TTY::Screen.width}x#{TTY::Screen.height}"
-  puts
-end
-
-HISTORY_PATH = ".ollama_chat_history"
-MAX_HISTORY = 200
-COLOR_RESET = "\e[0m"
-COLOR_USER = "\e[32m"
-COLOR_LLM = "\e[36m"
-USER_PROMPT = "#{COLOR_USER}you>#{COLOR_RESET} ".freeze
-LLM_PROMPT = "#{COLOR_LLM}llm>#{COLOR_RESET} ".freeze
-
-def build_reader
-  TTY::Reader.new
-end
-
-def read_input(reader)
-  reader.read_line(USER_PROMPT)
-end
-
-def load_history(reader, path)
-  history = load_history_list(path)
-  history.reverse_each { |line| reader.add_to_history(line) }
-end
-
-def load_history_list(path)
-  return [] unless File.exist?(path)
-
-  unique_history(normalize_history(File.readlines(path, chomp: true)))
-end
-
-def normalize_history(lines)
-  lines.map(&:strip).reject(&:empty?)
-end
-
-def unique_history(lines)
-  seen = {}
-  lines.each_with_object([]) do |line, unique|
-    next if seen[line]
-
-    unique << line
-    seen[line] = true
-  end
-end
-
-def update_history(path, text)
-  history = load_history_list(path)
-  history.delete(text)
-  history.unshift(text)
-  history = history.first(MAX_HISTORY)
-
-  File.write(path, history.join("\n") + (history.empty? ? "" : "\n"))
-end
-
-def chat_response(client, messages, config)
-  content = +""
-  prompt_printed = false
-
-  print "#{COLOR_LLM}...#{COLOR_RESET}"
-  $stdout.flush
-
-  client.chat_raw(
-    messages: messages,
-    allow_chat: true,
-    options: { temperature: config.temperature },
-    stream: true
-  ) do |chunk|
-    token = chunk.dig("message", "content").to_s
-    next if token.empty?
-
-    unless prompt_printed
-      print "\r#{LLM_PROMPT}"
-      prompt_printed = true
-    end
-
-    content << token
-    print token
-    $stdout.flush
-  end
-
-  puts
-  content
-end
-
-def run_console(client, config)
-  messages = []
-  add_system_message(messages)
-  print_banner(config)
-  reader = build_reader
-  load_history(reader, HISTORY_PATH)
-
-  loop do
-    input = read_input(reader)
-    break unless input
-
-    text = input.strip
-    next if text.empty?
-    break if exit_command?(text)
-
-    update_history(HISTORY_PATH, text)
-    messages << { role: "user", content: text }
-    content = chat_response(client, messages, config)
-    messages << { role: "assistant", content: content }
-  end
-rescue Interrupt
-  puts "\nExiting..."
-end
-
-config = build_config
-client = Ollama::Client.new(config: config)
-run_console(client, config)