llm_chain 0.4.0 → 0.5.0

data/examples/quick_demo.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/llm_chain'
+
+puts "🦾 LLMChain v#{LlmChain::VERSION} - Quick Demo"
+puts "=" * 50
+
+# 1. Simple chain without tools
+puts "\n1. 💬 Simple conversation"
+begin
+  simple_chain = LLMChain::Chain.new(
+    model: "qwen3:1.7b",
+    retriever: false
+  )
+  
+  response = simple_chain.ask("Hello! Tell me briefly about yourself.")
+  puts "🤖 #{response}"
+rescue => e
+  puts "❌ Error: #{e.message}"
+  puts "💡 Make sure Ollama is running and qwen3:1.7b model is downloaded"
+end
+
+# 2. Calculator
+puts "\n2. 🧮 Built-in calculator"
+calculator = LLMChain::Tools::Calculator.new
+result = calculator.call("Calculate 25 * 8 + 15")
+puts "📊 #{result[:formatted]}"
+
+# 3. Code interpreter
+puts "\n3. 💻 Code interpreter"
+begin
+  interpreter = LLMChain::Tools::CodeInterpreter.new
+  ruby_code = <<~RUBY_CODE
+    ```ruby
+    # Simple program
+    data = [1, 2, 3, 4, 5]
+    total = data.sum
+    puts "Sum of numbers: \#{total}"
+    puts "Average: \#{total / data.size.to_f}"
+    ```
+  RUBY_CODE
+  
+  code_result = interpreter.call(ruby_code)
+
+  if code_result.is_a?(Hash) && code_result[:result]
+    puts "✅ Execution result:"
+    puts code_result[:result]
+  elsif code_result.is_a?(Hash) && code_result[:error]
+    puts "❌ #{code_result[:error]}"
+  else
+    puts "📝 #{code_result}"
+  end
+rescue => e
+  puts "❌ Interpreter error: #{e.message}"
+end
+
+# 4. Web search (may not work without internet)
+puts "\n4. 🔍 Web search"
+search = LLMChain::Tools::WebSearch.new
+search_result = search.call("Ruby programming language")
+
+if search_result.is_a?(Hash) && search_result[:results] && !search_result[:results].empty?
+  puts "🌐 Found #{search_result[:count]} results:"
+  search_result[:results].first(2).each_with_index do |result, i|
+    puts "  #{i+1}. #{result[:title]}"
+  end
+else
+  puts "❌ Search failed or no results found"
+end
+
+# 5. Chain with tools
+puts "\n5. 🛠️ Chain with automatic tools"
+begin
+  tool_manager = LLMChain::Tools::ToolManager.create_default_toolset
+  smart_chain = LLMChain::Chain.new(
+    model: "qwen3:1.7b",
+    tools: tool_manager,
+    retriever: false
+  )
+  
+  puts "\n🧮 Math test:"
+  math_response = smart_chain.ask("How much is 12 * 15?")
+  puts "🤖 #{math_response}"
+  
+rescue => e
+  puts "❌ Tools error: #{e.message}"
+end
+
+puts "\n" + "=" * 50
+puts "✨ Demo completed!"
+puts "\n📖 More examples:"
+puts "   - ruby -I lib examples/tools_example.rb"
+puts "   - See README.md for complete documentation" 

data/examples/tools_example.rb

@@ -0,0 +1,255 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/llm_chain'
+
+puts "🛠️  LLMChain Tools Demo"
+puts "=" * 40
+
+# 1. Individual Tool Usage
+puts "\n1. 🧮 Calculator Tool"
+calculator = LLMChain::Tools::Calculator.new
+
+# Test mathematical expressions
+examples = [
+  "15 * 7 + 3",
+  "sqrt(144)",
+  "2 * 2 * 2"
+]
+
+examples.each do |expr|
+  result = calculator.call("Calculate: #{expr}")
+  puts "📊 #{result[:formatted]}"
+end
+
+# 2. Web Search Tool
+puts "\n2. 🔍 Web Search Tool"
+search = LLMChain::Tools::WebSearch.new
+
+search_queries = [
+  "Ruby programming language",
+  "Machine learning basics"
+]
+
+search_queries.each do |query|
+  puts "\n🔍 Searching: #{query}"
+  result = search.call(query)
+  
+  if result[:results] && result[:results].any?
+    puts "Found #{result[:count]} results:"
+    result[:results].first(2).each_with_index do |item, i|
+      puts "  #{i+1}. #{item[:title]}"
+      puts "     #{item[:url]}" if item[:url]
+    end
+  else
+    puts "No results found"
+  end
+end
+
+# 3. Code Interpreter Tool
+puts "\n3. 💻 Code Interpreter Tool"
+interpreter = LLMChain::Tools::CodeInterpreter.new
+
+# Test Ruby code execution
+ruby_examples = [
+  <<~RUBY,
+    ```ruby
+    # Simple Fibonacci calculation
+    a, b = 0, 1
+    result = [a, b]
+    8.times do
+      c = a + b
+      result << c
+      a, b = b, c
+    end
+    
+    puts "Fibonacci sequence (first 10 numbers):"
+    puts result.join(" ")
+    ```
+  RUBY
+  
+  <<~RUBY
+    ```ruby
+    # Data analysis example
+    numbers = [23, 45, 67, 89, 12, 34, 56, 78]
+    
+    puts "Dataset: \#{numbers}"
+    puts "Sum: \#{numbers.sum}"
+    puts "Average: \#{numbers.sum.to_f / numbers.size}"
+    puts "Max: \#{numbers.max}"
+    puts "Min: \#{numbers.min}"
+    ```
+  RUBY
+]
+
+ruby_examples.each_with_index do |code, i|
+  puts "\n💻 Ruby Example #{i+1}:"
+  begin
+    result = interpreter.call(code)
+    
+    if result.is_a?(Hash) && result[:result]
+      puts "✅ Output:"
+      puts result[:result]
+    elsif result.is_a?(Hash) && result[:error]
+      puts "❌ Error: #{result[:error]}"
+    else
+      puts "📝 #{result}"
+    end
+  rescue => e
+    puts "❌ Execution error: #{e.message}"
+  end
+end
+
+# 4. Tool Manager Usage
+puts "\n4. 🎯 Tool Manager"
+tool_manager = LLMChain::Tools::ToolManager.create_default_toolset
+
+puts "Registered tools: #{tool_manager.list_tools.map(&:name).join(', ')}"
+
+# Test tool matching
+test_prompts = [
+  "What is 25 squared?",
+  "Find information about Ruby gems",
+  "Run this code: puts 'Hello World'"
+]
+
+test_prompts.each do |prompt|
+  puts "\n🎯 Testing: \"#{prompt}\""
+  matched_tools = tool_manager.list_tools.select { |tool| tool.match?(prompt) }
+  
+  if matched_tools.any?
+    puts "   Matched tools: #{matched_tools.map(&:name).join(', ')}"
+    
+    # Execute with first matched tool
+    tool = matched_tools.first
+    result = tool.call(prompt)
+    puts "   Result: #{result[:formatted] || result.inspect}"
+  else
+    puts "   No tools matched"
+  end
+end
+
+# 5. LLM Chain with Tools
+puts "\n5. 🤖 LLM Chain with Tools"
+
+begin
+  # Create chain with tools (but without retriever for local testing)
+  chain = LLMChain::Chain.new(
+    model: "qwen3:1.7b",
+    tools: tool_manager,
+    retriever: false  # Disable RAG for this example
+  )
+  
+  # Test queries that should trigger tools
+  test_queries = [
+    "Calculate the area of a circle with radius 5 (use pi = 3.14159)",
+    "What's the latest news about Ruby programming?",
+    "Execute this Ruby code: puts (1..100).select(&:even?).sum"
+  ]
+  
+  test_queries.each_with_index do |query, i|
+    puts "\n🤖 Query #{i+1}: #{query}"
+    puts "🔄 Processing..."
+    
+    response = chain.ask(query)
+    puts "📝 Response: #{response}"
+    puts "-" * 40
+  end
+  
+rescue => e
+  puts "❌ Error with LLM Chain: #{e.message}"
+  puts "💡 Make sure Ollama is running with qwen3:1.7b model"
+end
+
+# 6. Custom Tool Example
+puts "\n6. 🔧 Custom Tool Example"
+
+# Create a simple DateTime tool
+class DateTimeTool < LLMChain::Tools::BaseTool
+  def initialize
+    super(
+      name: "datetime",
+      description: "Gets current date and time information",
+      parameters: {
+        format: { 
+          type: "string", 
+          description: "Date format (optional)" 
+        }
+      }
+    )
+  end
+
+  def match?(prompt)
+    contains_keywords?(prompt, ['time', 'date', 'now', 'current', 'today'])
+  end
+
+  def call(prompt, context: {})
+    now = Time.now
+    
+    # Try to detect desired format from prompt
+    format = if prompt.match?(/iso|standard/i)
+               now.iso8601
+             elsif prompt.match?(/human|readable/i)
+               now.strftime("%B %d, %Y at %I:%M %p")
+             else
+               now.to_s
+             end
+    
+    {
+      timestamp: now.to_i,
+      formatted_time: format,
+      timezone: now.zone,
+      formatted: "Current time: #{format} (#{now.zone})"
+    }
+  end
+end
+
+# Test custom tool
+datetime_tool = DateTimeTool.new
+time_queries = [
+  "What time is it now?",
+  "Give me current date in human readable format",
+  "Show me the current time in ISO format"
+]
+
+time_queries.each do |query|
+  puts "\n🕐 Query: #{query}"
+  if datetime_tool.match?(query)
+    result = datetime_tool.call(query)
+    puts "   #{result[:formatted]}"
+  else
+    puts "   Query didn't match datetime tool"
+  end
+end
+
+# 7. Configuration-based Tool Setup
+puts "\n7. ⚙️  Configuration-based Tools"
+
+tools_config = [
+  { 
+    class: 'calculator' 
+  },
+  { 
+    class: 'web_search',
+    options: { 
+      search_engine: :duckduckgo 
+    }
+  },
+  { 
+    class: 'code_interpreter',
+    options: { 
+      timeout: 30,
+      allowed_languages: ['ruby', 'python'] 
+    }
+  }
+]
+
+config_tool_manager = LLMChain::Tools::ToolManager.from_config(tools_config)
+puts "Tools from config: #{config_tool_manager.list_tools.map(&:name).join(', ')}"
+
+# Test configuration-based setup
+config_result = config_tool_manager.execute_tool('calculator', 'What is 99 * 99?')
+puts "Config test result: #{config_result[:formatted]}" if config_result
+
+puts "\n" + "=" * 40
+puts "✨ Tools demo completed!"
+puts "\nTry running the chain with: ruby -I lib examples/quick_demo.rb" 

data/lib/llm_chain/chain.rb

@@ -56,11 +56,21 @@ module LLMChain
     end
 
     def process_tools(prompt)
-      @tools.each_with_object({}) do |tool, acc|
-        if tool.match?(prompt)
-          response = tool.call(prompt)
-          acc[tool.name] = response unless response.nil?
+      return {} if @tools.nil? || (@tools.respond_to?(:empty?) && @tools.empty?)
+      
+      # Если @tools - это ToolManager
+      if @tools.respond_to?(:auto_execute)
+        @tools.auto_execute(prompt)
+      elsif @tools.is_a?(Array)
+        # Старая логика для массива инструментов
+        @tools.each_with_object({}) do |tool, acc|
+          if tool.match?(prompt)
+            response = tool.call(prompt)
+            acc[tool.name] = response unless response.nil?
+          end
         end
+      else
+        {}
       end
     end
 
@@ -94,7 +104,11 @@ module LLMChain
     def build_tool_responses(tool_responses)
       parts = ["Tool results:"]
       tool_responses.each do |name, response|
-        parts << "#{name}: #{response}"
+        if response.is_a?(Hash) && response[:formatted]
+          parts << "#{name}: #{response[:formatted]}"
+        else
+          parts << "#{name}: #{response}"
+        end
       end
       parts.join("\n")
     end

data/lib/llm_chain/clients/qwen.rb

@@ -10,6 +10,12 @@ module LLMChain
           default: "qwen:7b",
           versions: ["qwen:7b", "qwen:14b", "qwen:72b", "qwen:0.5b"]
         },
+        qwen2: {
+          default: "qwen2:1.5b",
+          versions: [
+            "qwen2:0.5b", "qwen2:1.5b", "qwen2:7b", "qwen2:72b"
+          ]
+        },
         qwen3: {
           default: "qwen3:latest",
           versions: [
@@ -100,7 +106,13 @@ module LLMChain
       private
 
       def model_version
-        @model.start_with?('qwen3:') ? :qwen3 : :qwen
+        if @model.start_with?('qwen3:')
+          :qwen3
+        elsif @model.start_with?('qwen2:')
+          :qwen2
+        else
+          :qwen
+        end
       end
 
       def detect_default_model

data/lib/llm_chain/tools/base_tool.rb

@@ -0,0 +1,81 @@
+module LLMChain
+  module Tools
+    class BaseTool
+      attr_reader :name, :description, :parameters
+
+      def initialize(name:, description:, parameters: {})
+        @name = name
+        @description = description
+        @parameters = parameters
+      end
+
+      # Проверяет, подходит ли инструмент для данного промпта
+      # @param prompt [String] Входной промпт от пользователя
+      # @return [Boolean] true если инструмент должен быть вызван
+      def match?(prompt)
+        raise NotImplementedError, "Subclasses must implement #match?"
+      end
+
+      # Выполняет инструмент
+      # @param prompt [String] Входной промпт от пользователя
+      # @param context [Hash] Дополнительный контекст
+      # @return [String, Hash] Результат выполнения инструмента
+      def call(prompt, context: {})
+        raise NotImplementedError, "Subclasses must implement #call"
+      end
+
+      # Возвращает JSON-схему для LLM
+      def to_schema
+        {
+          name: @name,
+          description: @description,
+          parameters: {
+            type: "object",
+            properties: @parameters,
+            required: required_parameters
+          }
+        }
+      end
+
+      # Извлекает параметры из промпта (для автоматического парсинга)
+      # @param prompt [String] Входной промпт
+      # @return [Hash] Извлеченные параметры
+      def extract_parameters(prompt)
+        {}
+      end
+
+      # Форматирует результат для включения в промпт
+      # @param result [Object] Результат выполнения инструмента
+      # @return [String] Форматированный результат
+      def format_result(result)
+        case result
+        when String then result
+        when Hash, Array then JSON.pretty_generate(result)
+        else result.to_s
+        end
+      end
+
+      protected
+
+      # Список обязательных параметров
+      def required_parameters
+        []
+      end
+
+      # Помощник для проверки ключевых слов в промпте
+      def contains_keywords?(prompt, keywords)
+        keywords.any? { |keyword| prompt.downcase.include?(keyword.downcase) }
+      end
+
+      # Помощник для извлечения числовых значений
+      def extract_numbers(text)
+        text.scan(/-?\d+\.?\d*/).map(&:to_f)
+      end
+
+      # Помощник для извлечения URL
+      def extract_urls(text)
+        text.scan(%r{https?://[^\s]+})
+      end
+    end
+  end
+end 

data/lib/llm_chain/tools/calculator.rb

@@ -0,0 +1,143 @@
+require 'bigdecimal'
+
+module LLMChain
+  module Tools
+    class Calculator < BaseTool
+      KEYWORDS = %w[
+        calculate compute math equation formula
+        add subtract multiply divide
+        sum difference product quotient
+        plus minus times divided
+        + - * / = equals
+      ].freeze
+
+      def initialize
+        super(
+          name: "calculator",
+          description: "Performs mathematical calculations and evaluates expressions",
+          parameters: {
+            expression: {
+              type: "string",
+              description: "Mathematical expression to evaluate (e.g., '2 + 2', '15 * 3.14', 'sqrt(16)')"
+            }
+          }
+        )
+      end
+
+      def match?(prompt)
+        contains_keywords?(prompt, KEYWORDS) || 
+        contains_math_pattern?(prompt)
+      end
+
+      def call(prompt, context: {})
+        expression = extract_expression(prompt)
+        return "No mathematical expression found" if expression.empty?
+
+        begin
+          result = evaluate_expression(expression)
+          {
+            expression: expression,
+            result: result,
+            formatted: "#{expression} = #{result}"
+          }
+        rescue => e
+          {
+            expression: expression,
+            error: e.message,
+            formatted: "Error calculating '#{expression}': #{e.message}"
+          }
+        end
+      end
+
+      def extract_parameters(prompt)
+        { expression: extract_expression(prompt) }
+      end
+
+      private
+
+      def contains_math_pattern?(prompt)
+        # Проверяем наличие математических операторов и чисел
+        prompt.match?(/\d+\s*[+\-*\/]\s*\d+/) ||
+        prompt.match?(/\b(sqrt|sin|cos|tan|log|ln|exp|abs|round|ceil|floor)\s*\(/i)
+      end
+
+      def extract_expression(prompt)
+        # Пробуем найти выражение в кавычках
+        quoted = prompt.match(/"([^"]+)"/) || prompt.match(/'([^']+)'/)
+        return quoted[1] if quoted
+
+        # Ищем выражение после ключевых слов
+        KEYWORDS.each do |keyword|
+          if prompt.downcase.include?(keyword)
+            escaped_keyword = Regexp.escape(keyword)
+            after_keyword = prompt.split(/#{escaped_keyword}/i, 2)[1]
+            if after_keyword
+              # Извлекаем математическое выражение
+              expr = after_keyword.strip.split(/[.!?]/).first
+              return clean_expression(expr) if expr
+            end
+          end
+        end
+
+        # Пробуем найти простое выражение в тексте
+        math_expr = prompt.match(/(\d+(?:\.\d+)?\s*[+\-*\/]\s*\d+(?:\.\d+)?(?:\s*[+\-*\/]\s*\d+(?:\.\d+)?)*)/)
+        return math_expr[1] if math_expr
+
+        # Ищем функции
+        func_expr = prompt.match(/\b(sqrt|sin|cos|tan|log|ln|exp|abs|round|ceil|floor)\s*\([^)]+\)/i)
+        return func_expr[0] if func_expr
+
+        ""
+      end
+
+      def clean_expression(expr)
+        # Удаляем лишние слова и оставляем только математическое выражение
+        expr.gsub(/\b(is|what|equals?|result|answer)\b/i, '')
+            .gsub(/[^\d+\-*\/().\s]/, '')
+            .strip
+      end
+
+      def evaluate_expression(expression)
+        # Заменяем математические функции на Ruby-методы
+        expr = expression.downcase
+                        .gsub(/sqrt\s*\(([^)]+)\)/) { "Math.sqrt(#{$1})" }
+                        .gsub(/sin\s*\(([^)]+)\)/) { "Math.sin(#{$1})" }
+                        .gsub(/cos\s*\(([^)]+)\)/) { "Math.cos(#{$1})" }
+                        .gsub(/tan\s*\(([^)]+)\)/) { "Math.tan(#{$1})" }
+                        .gsub(/log\s*\(([^)]+)\)/) { "Math.log10(#{$1})" }
+                        .gsub(/ln\s*\(([^)]+)\)/) { "Math.log(#{$1})" }
+                        .gsub(/exp\s*\(([^)]+)\)/) { "Math.exp(#{$1})" }
+                        .gsub(/abs\s*\(([^)]+)\)/) { "(#{$1}).abs" }
+                        .gsub(/round\s*\(([^)]+)\)/) { "(#{$1}).round" }
+                        .gsub(/ceil\s*\(([^)]+)\)/) { "(#{$1}).ceil" }
+                        .gsub(/floor\s*\(([^)]+)\)/) { "(#{$1}).floor" }
+
+        # Безопасная оценка выражения
+        result = safe_eval(expr)
+        
+        # Округляем результат до разумного количества знаков
+        if result.is_a?(Float)
+          result.round(10)
+        else
+          result
+        end
+      end
+
+      def safe_eval(expression)
+        # Проверяем, что выражение содержит только безопасные символы
+        unless expression.match?(/\A[\d+\-*\/().\s]+\z/) || 
+               expression.include?('Math.') || 
+               expression.match?(/\.(abs|round|ceil|floor)\b/)
+          raise "Unsafe expression: #{expression}"
+        end
+
+        # Оцениваем выражение
+        eval(expression)
+      end
+
+      def required_parameters
+        ['expression']
+      end
+    end
+  end
+end