llm_chain 0.4.0 → 0.5.0

data/lib/llm_chain/tools/code_interpreter.rb

@@ -0,0 +1,233 @@
+require 'tempfile'
+require 'timeout'
+
+module LLMChain
+  module Tools
+    class CodeInterpreter < BaseTool
+      KEYWORDS = %w[
+        code run execute script program
+        ruby python javascript
+        calculate compute
+        def class function
+      ].freeze
+
+      SUPPORTED_LANGUAGES = %w[ruby python javascript].freeze
+      
+      DANGEROUS_PATTERNS = [
+        /system\s*\(/i,
+        /exec\s*\(/i, 
+        /`[^`]*`/,
+        /File\.(delete|rm|unlink)/i,
+        /Dir\.(delete|rmdir)/i,
+        /require\s+['"]net\/http['"]/i,
+        /require\s+['"]open-uri['"]/i,
+        /eval\s*\(/i,
+        /instance_eval/i,
+        /class_eval/i
+      ].freeze
+
+      def initialize(timeout: 30, allowed_languages: SUPPORTED_LANGUAGES)
+        @timeout = timeout
+        @allowed_languages = allowed_languages
+        
+        super(
+          name: "code_interpreter",
+          description: "Executes code safely in an isolated environment",
+          parameters: {
+            code: {
+              type: "string",
+              description: "Code to execute"
+            },
+            language: {
+              type: "string", 
+              description: "Programming language (ruby, python, javascript)",
+              enum: @allowed_languages
+            }
+          }
+        )
+      end
+
+      def match?(prompt)
+        contains_keywords?(prompt, KEYWORDS) ||
+        contains_code_blocks?(prompt) ||
+        contains_function_definitions?(prompt)
+      end
+
+      def call(prompt, context: {})
+        code = extract_code(prompt)
+        language = detect_language(code, prompt)
+        
+        return "No code found to execute" if code.empty?
+        return "Unsupported language: #{language}" unless @allowed_languages.include?(language)
+        
+        begin
+          if safe_to_execute?(code)
+            result = execute_code(code, language)
+            {
+              code: code,
+              language: language,
+              result: result,
+              formatted: format_execution_result(code, language, result)
+            }
+          else
+            {
+              code: code,
+              language: language,
+              error: "Code contains potentially dangerous operations",
+              formatted: "Cannot execute: Code contains potentially dangerous operations"
+            }
+          end
+        rescue => e
+          {
+            code: code,
+            language: language,
+            error: e.message,
+            formatted: "Execution error: #{e.message}"
+          }
+        end
+      end
+
+      def extract_parameters(prompt)
+        code = extract_code(prompt)
+        {
+          code: code,
+          language: detect_language(code, prompt)
+        }
+      end
+
+      private
+
+      def contains_code_blocks?(prompt)
+        prompt.include?('```') || 
+        prompt.match?(/^\s*def\s+\w+/m) ||
+        prompt.match?(/^\s*class\s+\w+/m)
+      end
+
+      def contains_function_definitions?(prompt)
+        prompt.match?(/\b(def|function|class)\s+\w+/i)
+      end
+
+      def extract_code(prompt)
+        # Ищем код в блоках ```
+        code_block = prompt.match(/```(?:ruby|python|javascript|js)?\s*\n(.*?)\n```/m)
+        return code_block[1].strip if code_block
+
+        # Ищем код после ключевых слов
+        KEYWORDS.each do |keyword|
+          if prompt.downcase.include?(keyword)
+            lines = prompt.split("\n")
+            keyword_line = lines.find_index { |line| line.downcase.include?(keyword) }
+            if keyword_line
+              # Берем строки после ключевого слова
+              code_lines = lines[(keyword_line + 1)..-1]
+              code = code_lines&.join("\n")&.strip
+              return code if code && !code.empty?
+            end
+          end
+        end
+
+        # Ищем строки, которые выглядят как код
+        code_lines = prompt.split("\n").select do |line|
+          line.strip.match?(/^(def|class|function|var|let|const|print|puts|console\.log)/i) ||
+          line.strip.match?(/^\w+\s*[=+\-*\/]\s*/) ||
+          line.strip.match?(/^\s*(if|for|while|return)[\s(]/i)
+        end
+
+        code_lines.join("\n")
+      end
+
+      def detect_language(code, prompt)
+        # Явное указание языка
+        return 'ruby' if prompt.match?(/```ruby/i) || prompt.include?('Ruby')
+        return 'python' if prompt.match?(/```python/i) || prompt.include?('Python')
+        return 'javascript' if prompt.match?(/```(javascript|js)/i) || prompt.include?('JavaScript')
+
+        # Определение по синтаксису
+        return 'ruby' if code.include?('puts') || code.include?('def ') || code.match?(/\bend\b/)
+        return 'python' if code.include?('print(') || code.match?(/def \w+\(.*\):/) || code.include?('import ')
+        return 'javascript' if code.include?('console.log') || code.include?('function ') || code.include?('var ') || code.include?('let ')
+
+        'ruby' # default
+      end
+
+      def safe_to_execute?(code)
+        DANGEROUS_PATTERNS.none? { |pattern| code.match?(pattern) }
+      end
+
+      def execute_code(code, language)
+        case language
+        when 'ruby'
+          execute_ruby(code)
+        when 'python'
+          execute_python(code)
+        when 'javascript'
+          execute_javascript(code)
+        else
+          raise "Unsupported language: #{language}"
+        end
+      end
+
+      def execute_ruby(code)
+        Timeout.timeout(@timeout) do
+          # Создаем временный файл
+          Tempfile.create(['code', '.rb']) do |file|
+            file.write(code)
+            file.flush
+            
+            # Выполняем код в отдельном процессе
+            result = `ruby #{file.path} 2>&1`
+            
+            if $?.success?
+              result.strip
+            else
+              raise "Ruby execution failed: #{result}"
+            end
+          end
+        end
+      end
+
+      def execute_python(code)
+        Timeout.timeout(@timeout) do
+          Tempfile.create(['code', '.py']) do |file|
+            file.write(code)
+            file.flush
+            
+            result = `python3 #{file.path} 2>&1`
+            
+            if $?.success?
+              result.strip
+            else
+              raise "Python execution failed: #{result}"
+            end
+          end
+        end
+      end
+
+      def execute_javascript(code)
+        Timeout.timeout(@timeout) do
+          Tempfile.create(['code', '.js']) do |file|
+            file.write(code)
+            file.flush
+            
+            # Пробуем node.js
+            result = `node #{file.path} 2>&1`
+            
+            if $?.success?
+              result.strip
+            else
+              raise "JavaScript execution failed: #{result}"
+            end
+          end
+        end
+      end
+
+      def format_execution_result(code, language, result)
+        "Code execution (#{language}):\n\n```#{language}\n#{code}\n```\n\nOutput:\n```\n#{result}\n```"
+      end
+
+      def required_parameters
+        ['code']
+      end
+    end
+  end
+end 

data/lib/llm_chain/tools/tool_manager.rb

@@ -0,0 +1,204 @@
+module LLMChain
+  module Tools
+    class ToolManager
+      attr_reader :tools
+
+      def initialize(tools: [])
+        @tools = {}
+        tools.each { |tool| register_tool(tool) }
+      end
+
+      # Регистрирует новый инструмент
+      def register_tool(tool)
+        unless tool.is_a?(BaseTool)
+          raise ArgumentError, "Tool must inherit from BaseTool"
+        end
+        @tools[tool.name] = tool
+      end
+
+      # Удаляет инструмент
+      def unregister_tool(name)
+        @tools.delete(name.to_s)
+      end
+
+      # Получает инструмент по имени
+      def get_tool(name)
+        @tools[name.to_s]
+      end
+
+      # Возвращает список всех инструментов
+      def list_tools
+        @tools.values
+      end
+
+      # Получает схемы всех инструментов для LLM
+      def get_tools_schema
+        @tools.values.map(&:to_schema)
+      end
+
+      # Находит подходящие инструменты для промпта
+      def find_matching_tools(prompt)
+        @tools.values.select { |tool| tool.match?(prompt) }
+      end
+
+      # Выполняет все подходящие инструменты
+      def execute_tools(prompt, context: {})
+        matching_tools = find_matching_tools(prompt)
+        
+        results = {}
+        matching_tools.each do |tool|
+          begin
+            result = tool.call(prompt, context: context)
+            results[tool.name] = {
+              success: true,
+              result: result,
+              formatted: tool.format_result(result)
+            }
+          rescue => e
+            results[tool.name] = {
+              success: false,
+              error: e.message,
+              formatted: "Error in #{tool.name}: #{e.message}"
+            }
+          end
+        end
+
+        results
+      end
+
+      # Выполняет конкретный инструмент по имени
+      def execute_tool(name, prompt, context: {})
+        tool = get_tool(name)
+        raise ArgumentError, "Tool '#{name}' not found" unless tool
+
+        begin
+          result = tool.call(prompt, context: context)
+          {
+            success: true,
+            result: result,
+            formatted: tool.format_result(result)
+          }
+        rescue => e
+          {
+            success: false,
+            error: e.message,
+            formatted: "Error in #{name}: #{e.message}"
+          }
+        end
+      end
+
+      # Создает стандартный набор инструментов
+      def self.create_default_toolset
+        tools = [
+          Calculator.new,
+          WebSearch.new,
+          CodeInterpreter.new
+        ]
+        
+        new(tools: tools)
+      end
+
+      # Создает набор инструментов из конфигурации
+      def self.from_config(config)
+        tools = []
+        
+        config.each do |tool_config|
+          tool_class = tool_config[:class] || tool_config['class']
+          tool_options = tool_config[:options] || tool_config['options'] || {}
+          
+          case tool_class.to_s.downcase
+          when 'calculator'
+            tools << Calculator.new
+          when 'web_search', 'websearch'
+            tools << WebSearch.new(**tool_options)
+          when 'code_interpreter', 'codeinterpreter'
+            tools << CodeInterpreter.new(**tool_options)
+          else
+            raise ArgumentError, "Unknown tool class: #{tool_class}"
+          end
+        end
+        
+        new(tools: tools)
+      end
+
+      # Форматирует результаты выполнения для включения в промпт
+      def format_tool_results(results)
+        return "" if results.empty?
+
+        formatted_results = results.map do |tool_name, result|
+          "#{tool_name}: #{result[:formatted]}"
+        end
+
+        "Tool Results:\n#{formatted_results.join("\n\n")}"
+      end
+
+      # Получает краткое описание доступных инструментов
+      def tools_description
+        descriptions = @tools.values.map do |tool|
+          "- #{tool.name}: #{tool.description}"
+        end
+
+        "Available tools:\n#{descriptions.join("\n")}"
+      end
+
+      # Проверяет, содержит ли промпт запрос на использование инструментов
+      def needs_tools?(prompt)
+        # Проверяем явные запросы на использование инструментов
+        return true if prompt.match?(/\b(use tool|call tool|execute|calculate|search|run code)\b/i)
+        
+        # Проверяем, есть ли подходящие инструменты
+        find_matching_tools(prompt).any?
+      end
+
+      # Автоматически решает, какие инструменты использовать
+      def auto_execute(prompt, context: {})
+        return {} unless needs_tools?(prompt)
+        
+        # Ограничиваем количество одновременно выполняемых инструментов
+        matching_tools = find_matching_tools(prompt)
+        selected_tools = select_best_tools(matching_tools, prompt)
+        
+        results = {}
+        selected_tools.each do |tool|
+          begin
+            result = tool.call(prompt, context: context)
+            results[tool.name] = {
+              success: true,
+              result: result,
+              formatted: tool.format_result(result)
+            }
+          rescue => e
+            results[tool.name] = {
+              success: false,
+              error: e.message,
+              formatted: "Error in #{tool.name}: #{e.message}"
+            }
+          end
+        end
+
+        results
+      end
+
+      private
+
+      # Выбирает лучшие инструменты для выполнения (ограничение по количеству)
+      def select_best_tools(tools, prompt, limit: 3)
+        # Простая логика приоритизации
+        prioritized = tools.sort_by do |tool|
+          case tool.name
+          when 'calculator'
+            prompt.include?('calculate') || prompt.match?(/\d+\s*[+\-*\/]\s*\d+/) ? 0 : 2
+          when 'web_search'
+            prompt.include?('search') || prompt.match?(/\b(what|who|where|when)\b/i) ? 0 : 2
+          when 'code_interpreter'
+            prompt.include?('```') || prompt.include?('code') ? 0 : 2
+          else
+            1
+          end
+        end
+
+        prioritized.first(limit)
+      end
+    end
+  end
+end 

data/lib/llm_chain/tools/web_search.rb

@@ -0,0 +1,255 @@
+require 'net/http'
+require 'json'
+require 'uri'
+
+module LLMChain
+  module Tools
+    class WebSearch < BaseTool
+      KEYWORDS = %w[
+        search find lookup google bing
+        what is who is where is when is
+        latest news current information
+        weather forecast stock price
+        definition meaning wikipedia
+      ].freeze
+
+      def initialize(api_key: nil, search_engine: :duckduckgo)
+        @api_key = api_key || ENV['SEARCH_API_KEY']
+        @search_engine = search_engine
+        
+        super(
+          name: "web_search",
+          description: "Searches the internet for current information",
+          parameters: {
+            query: {
+              type: "string", 
+              description: "Search query to find information about"
+            },
+            num_results: {
+              type: "integer",
+              description: "Number of results to return (default: 5)"
+            }
+          }
+        )
+      end
+
+      def match?(prompt)
+        contains_keywords?(prompt, KEYWORDS) ||
+        contains_question_pattern?(prompt) ||
+        contains_current_info_request?(prompt)
+      end
+
+      def call(prompt, context: {})
+        query = extract_query(prompt)
+        return "No search query found" if query.empty?
+
+        num_results = extract_num_results(prompt)
+        
+        begin
+          results = perform_search(query, num_results)
+          format_search_results(query, results)
+        rescue => e
+          {
+            query: query,
+            error: e.message,
+            formatted: "Error searching for '#{query}': #{e.message}"
+          }
+        end
+      end
+
+      def extract_parameters(prompt)
+        {
+          query: extract_query(prompt),
+          num_results: extract_num_results(prompt)
+        }
+      end
+
+      private
+
+      def contains_question_pattern?(prompt)
+        prompt.match?(/\b(what|who|where|when|how|why|which)\b/i)
+      end
+
+      def contains_current_info_request?(prompt)
+        prompt.match?(/\b(latest|current|recent|today|now|2024|2023)\b/i)
+      end
+
+      def extract_query(prompt)
+        # Удаляем команды поиска и оставляем суть запроса
+        query = prompt.gsub(/\b(search for|find|lookup|google|what is|who is|where is|when is)\b/i, '')
+                     .gsub(/\b(please|can you|could you|would you)\b/i, '')
+                     .strip
+        
+        # Если запрос слишком длинный, берем первые слова
+        words = query.split
+        if words.length > 10
+          words.first(10).join(' ')
+        else
+          query
+        end
+      end
+
+      def extract_num_results(prompt)
+        # Ищем числа в контексте результатов
+        match = prompt.match(/(\d+)\s*(results?|items?|links?)/i)
+        return match[1].to_i if match && match[1].to_i.between?(1, 20)
+        
+        5 # default
+      end
+
+      def perform_search(query, num_results)
+        case @search_engine
+        when :duckduckgo
+          search_duckduckgo(query, num_results)
+        when :google
+          search_google(query, num_results)
+        when :bing
+          search_bing(query, num_results)
+        else
+          raise "Unsupported search engine: #{@search_engine}"
+        end
+      end
+
+      def search_duckduckgo(query, num_results)
+        # DuckDuckGo Instant Answer API (бесплатный)
+        uri = URI("https://api.duckduckgo.com/")
+        params = {
+          q: query,
+          format: 'json',
+          no_html: '1',
+          skip_disambig: '1'
+        }
+        uri.query = URI.encode_www_form(params)
+
+        response = Net::HTTP.get_response(uri)
+        raise "DuckDuckGo API error: #{response.code}" unless response.code == '200'
+
+        data = JSON.parse(response.body)
+        
+        results = []
+        
+        # Основной ответ
+        if data['AbstractText'] && !data['AbstractText'].empty?
+          results << {
+            title: data['AbstractSource'] || 'DuckDuckGo',
+            url: data['AbstractURL'] || '',
+            snippet: data['AbstractText']
+          }
+        end
+
+        # Связанные темы
+        if data['RelatedTopics']
+          data['RelatedTopics'].first(num_results - results.length).each do |topic|
+            next unless topic['Text']
+            results << {
+              title: topic['Text'].split(' - ').first || 'Related',
+              url: topic['FirstURL'] || '',
+              snippet: topic['Text']
+            }
+          end
+        end
+
+        # Если результатов мало, добавляем информацию из Infobox
+        if results.length < num_results / 2 && data['Infobox']
+          infobox_text = data['Infobox']['content']&.map { |item| 
+            "#{item['label']}: #{item['value']}" 
+          }&.join('; ')
+          
+          if infobox_text
+            results << {
+              title: 'Information',
+              url: data['AbstractURL'] || '',
+              snippet: infobox_text
+            }
+          end
+        end
+
+        results.first(num_results)
+      end
+
+      def search_google(query, num_results)
+        # Google Custom Search API (требует API ключ)
+        raise "Google API key required" unless @api_key
+
+        uri = URI("https://www.googleapis.com/customsearch/v1")
+        params = {
+          key: @api_key,
+          cx: ENV['GOOGLE_SEARCH_ENGINE_ID'] || raise("GOOGLE_SEARCH_ENGINE_ID required"),
+          q: query,
+          num: [num_results, 10].min
+        }
+        uri.query = URI.encode_www_form(params)
+
+        response = Net::HTTP.get_response(uri)
+        raise "Google API error: #{response.code}" unless response.code == '200'
+
+        data = JSON.parse(response.body)
+        
+        (data['items'] || []).map do |item|
+          {
+            title: item['title'],
+            url: item['link'],
+            snippet: item['snippet']
+          }
+        end
+      end
+
+      def search_bing(query, num_results)
+        # Bing Web Search API (требует API ключ)
+        raise "Bing API key required" unless @api_key
+
+        uri = URI("https://api.bing.microsoft.com/v7.0/search")
+        params = {
+          q: query,
+          count: [num_results, 20].min,
+          responseFilter: 'Webpages'
+        }
+        uri.query = URI.encode_www_form(params)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        
+        request = Net::HTTP::Get.new(uri)
+        request['Ocp-Apim-Subscription-Key'] = @api_key
+        
+        response = http.request(request)
+        raise "Bing API error: #{response.code}" unless response.code == '200'
+
+        data = JSON.parse(response.body)
+        
+        (data.dig('webPages', 'value') || []).map do |item|
+          {
+            title: item['name'],
+            url: item['url'],
+            snippet: item['snippet']
+          }
+        end
+      end
+
+      def format_search_results(query, results)
+        if results.empty?
+          return {
+            query: query,
+            results: [],
+            formatted: "No results found for '#{query}'"
+          }
+        end
+
+        formatted_results = results.map.with_index(1) do |result, index|
+          "#{index}. #{result[:title]}\n   #{result[:snippet]}\n   #{result[:url]}"
+        end.join("\n\n")
+
+        {
+          query: query,
+          results: results,
+          count: results.length,
+          formatted: "Search results for '#{query}':\n\n#{formatted_results}"
+        }
+      end
+
+      def required_parameters
+        ['query']
+      end
+    end
+  end
+end 

data/lib/llm_chain/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LlmChain
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/llm_chain.rb

@@ -24,4 +24,9 @@ require "llm_chain/memory/redis"
 require "llm_chain/embeddings/clients/local/ollama_client"
 require "llm_chain/embeddings/clients/local/weaviate_vector_store"
 require "llm_chain/embeddings/clients/local/weaviate_retriever"
+require "llm_chain/tools/base_tool"
+require "llm_chain/tools/calculator"
+require "llm_chain/tools/web_search"
+require "llm_chain/tools/code_interpreter"
+require "llm_chain/tools/tool_manager"
 require "llm_chain/chain"