llm_chain 0.3.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

@@ -13,7 +13,13 @@ module LLMChain
       @model = model
       @memory = memory || Memory::Array.new
       @tools = tools
-      @retriever = retriever || Embeddings::Clients::Local::WeaviateRetriever.new
+      @retriever = if retriever.nil?
+                    Embeddings::Clients::Local::WeaviateRetriever.new
+                  elsif retriever == false
+                    nil
+                  else
+                    retriever
+                  end
       @client = ClientRegistry.client_for(model, **client_options)
     end
 
@@ -24,27 +30,20 @@ module LLMChain
     # @param rag_options [Hash] Опции для RAG-поиска
     # @yield [String] Передает чанки ответа если stream=true
     def ask(prompt, stream: false, rag_context: false, rag_options: {}, &block)
-      # 1. Сбор контекста
-      context = memory.recall(prompt)
-      tool_responses = process_tools(prompt)
-      rag_documents = retrieve_rag_context(prompt, rag_options) if rag_context
-
-      # 2. Построение промпта
-      full_prompt = build_prompt(
-        prompt: prompt,
-        memory_context: context,
-        tool_responses: tool_responses,
-        rag_documents: rag_documents
-      )
-
-      # 3. Генерация ответа
+      context = collect_context(prompt, rag_context, rag_options)
+      full_prompt = build_prompt(prompt: prompt, **context)
       response = generate_response(full_prompt, stream: stream, &block)
-
-      # 4. Сохранение в память
       memory.store(prompt, response)
       response
     end
 
+    def collect_context(prompt, rag_context, rag_options)
+      context = memory.recall(prompt)
+      tool_responses = process_tools(prompt)
+      rag_documents = retrieve_rag_context(prompt, rag_options) if rag_context
+      { memory_context: context, tool_responses: tool_responses, rag_documents: rag_documents }
+    end
+
     private
 
     def retrieve_rag_context(query, options = {})
@@ -53,48 +52,65 @@ module LLMChain
       limit = options[:limit] || 3
       @retriever.search(query, limit: limit)
     rescue => e
-      puts "[RAG Error] #{e.message}"
-      []
+      raise Error, "Cannot retrieve rag context"
     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
 
     def build_prompt(prompt:, memory_context: nil, tool_responses: {}, rag_documents: nil)
       parts = []
+      parts << build_memory_context(memory_context) if memory_context&.any?
+      parts << build_rag_documents(rag_documents) if rag_documents&.any?
+      parts << build_tool_responses(tool_responses) unless tool_responses.empty?
+      parts << "Сurrent question: #{prompt}"
+      parts.join("\n\n")
+    end
 
-      if memory_context&.any?
-        parts << "Dialogue history:"
-        memory_context.each do |item|
-          parts << "User: #{item[:prompt]}"
-          parts << "Assistant: #{item[:response]}"
-        end
+    def build_memory_context(memory_context)
+      parts = ["Dialogue history:"]
+      memory_context.each do |item|
+        parts << "User: #{item[:prompt]}"
+        parts << "Assistant: #{item[:response]}"
       end
+      parts.join("\n")
+    end
 
-      if rag_documents&.any?
-        parts << "Relevant documents:"
-        rag_documents.each_with_index do |doc, i|
-          parts << "Document #{i + 1}: #{doc['content']}"
-          parts << "Metadata: #{doc['metadata'].to_json}" if doc['metadata']
-        end
+    def build_rag_documents(rag_documents)
+      parts = ["Relevant documents:"]
+      rag_documents.each_with_index do |doc, i|
+        parts << "Document #{i + 1}: #{doc['content']}"
+        parts << "Metadata: #{doc['metadata'].to_json}" if doc['metadata']
       end
+      parts.join("\n")
+    end
 
-      unless tool_responses.empty?
-        parts << "Tool results:"
-        tool_responses.each do |name, response|
+    def build_tool_responses(tool_responses)
+      parts = ["Tool results:"]
+      tool_responses.each do |name, response|
+        if response.is_a?(Hash) && response[:formatted]
+          parts << "#{name}: #{response[:formatted]}"
+        else
           parts << "#{name}: #{response}"
         end
       end
-
-      parts << "Qurrent question: #{prompt}"
-
-      parts.join("\n\n")
+      parts.join("\n")
     end
 
     def generate_response(prompt, stream: false, &block)

data/lib/llm_chain/client_registry.rb

@@ -15,6 +15,8 @@ module LLMChain
         Clients::Qwen
       when /llama2/
         Clients::Llama2
+      when /gemma3/
+        Clients::Gemma3
       else
         raise UnknownModelError, "Unknown model: #{model}"
       end

data/lib/llm_chain/clients/gemma3.rb

@@ -0,0 +1,144 @@
+require 'faraday'
+require 'json'
+
+module LLMChain
+  module Clients
+    class Gemma3 < OllamaBase
+      # Доступные версии моделей Gemma3
+      MODEL_VERSIONS = {
+        gemma3: {
+          default: "gemma3:2b",
+          versions: [
+            "gemma3:2b", "gemma3:8b", "gemma3:27b",
+            "gemma3:2b-instruct", "gemma3:8b-instruct", "gemma3:27b-instruct", "gemma3:4b"
+          ]
+        }
+      }.freeze
+
+      # Общие настройки по умолчанию для Gemma3
+      COMMON_DEFAULT_OPTIONS = {
+        temperature: 0.7,
+        top_p: 0.9,
+        top_k: 40,
+        repeat_penalty: 1.1,
+        num_ctx: 8192
+      }.freeze
+
+      # Специфичные настройки для разных версий
+      VERSION_SPECIFIC_OPTIONS = {
+        gemma3: {
+          stop: ["<|im_end|>", "<|endoftext|>", "<|user|>", "<|assistant|>"]
+        }
+      }.freeze
+
+      # Внутренние теги для очистки ответов
+      INTERNAL_TAGS = {
+        common: {
+          think: /<think>.*?<\/think>\s*/mi,
+          reasoning: /<reasoning>.*?<\/reasoning>\s*/mi
+        },
+        gemma3: {
+          system: /<\|system\|>.*?<\|im_end\|>\s*/mi,
+          user: /<\|user\|>.*?<\|im_end\|>\s*/mi,
+          assistant: /<\|assistant\|>.*?<\|im_end\|>\s*/mi
+        }
+      }.freeze
+
+      def initialize(model: nil, base_url: nil, **options)
+        model ||= detect_default_model
+
+        @model = model
+        validate_model_version(@model)
+
+        super(
+          model: @model,
+          base_url: base_url,
+          default_options: default_options_for(@model).merge(options)
+        )
+      end
+
+      def chat(prompt, show_internal: false, stream: false, **options, &block)
+        if stream
+          stream_chat(prompt, show_internal: show_internal, **options, &block)
+        else
+          response = super(prompt, **options)
+          process_response(response, show_internal: show_internal)
+        end
+      end
+
+      def stream_chat(prompt, show_internal: false, **options, &block)
+        buffer = ""
+        connection.post(API_ENDPOINT) do |req|
+          req.headers['Content-Type'] = 'application/json'
+          req.body = build_request_body(prompt, options.merge(stream: true))
+          
+          req.options.on_data = Proc.new do |chunk, _bytes, _env|
+            processed = process_stream_chunk(chunk)
+            next unless processed
+
+            buffer << processed
+            block.call(processed) if block_given?
+          end
+        end
+
+        process_response(buffer, show_internal: show_internal)
+      end
+
+      protected
+
+      def build_request_body(prompt, options)
+        body = super
+        version_specific_options = VERSION_SPECIFIC_OPTIONS[model_version]
+        body[:options].merge!(version_specific_options) if version_specific_options
+        body
+      end
+
+      private
+
+      def model_version
+        :gemma3
+      end
+
+      def detect_default_model
+        MODEL_VERSIONS[model_version][:default]
+      end
+
+      def validate_model_version(model)
+        valid_models = MODEL_VERSIONS.values.flat_map { |v| v[:versions] }
+        unless valid_models.include?(model)
+          raise InvalidModelVersion, "Invalid Gemma3 model version. Available: #{valid_models.join(', ')}"
+        end
+      end
+
+      def default_options_for(model)
+        COMMON_DEFAULT_OPTIONS.merge(
+          VERSION_SPECIFIC_OPTIONS[model_version] || {}
+        )
+      end
+
+      def process_stream_chunk(chunk)
+        parsed = JSON.parse(chunk)
+        parsed["response"] if parsed.is_a?(Hash) && parsed["response"]
+      rescue JSON::ParserError
+        nil
+      end
+
+      def process_response(response, show_internal: false)
+        return response unless response.is_a?(String)
+        
+        if show_internal
+          response
+        else
+          clean_response(response)
+        end
+      end
+
+      def clean_response(text)
+        tags = INTERNAL_TAGS[:common].merge(INTERNAL_TAGS[model_version] || {})
+        tags.values.reduce(text) do |processed, regex|
+          processed.gsub(regex, '')
+        end.gsub(/\n{3,}/, "\n\n").strip
+      end
+    end
+  end
+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: [
@@ -92,16 +98,21 @@ module LLMChain
 
       def build_request_body(prompt, options)
         body = super
-        version_specific_options = VERSION_SPECIFIC_OPTIONS[model_version]
+        version_specific_options = VERSION_SPECIFIC_OPTIONS[model_version]  
         body[:options].merge!(version_specific_options) if version_specific_options
-        puts body
         body
       end
 
       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