llm_chain 0.5.3 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c94520a98ace3d2bb61ca2b470af041e0f95d6818120ce01dfc5a9cfe76316b
-  data.tar.gz: 5155099cdf777ecaed3a30c9da1e7e200476258369ef3b976967888daf001876
+  metadata.gz: f7c55f5d0965bd544f4f3eb647e85127207f41d257803023d4a5df854faa3b7b
+  data.tar.gz: 988b46a9300325e3ab6c4bf94ea07c016c79d308b7c8c0b6bde7a12ec8fcbdca
 SHA512:
-  metadata.gz: b37c6ed16c6b6a66d1f9c6e2a62717e576c5211aba605b98b97e5ba54b436d9a38602aabcedf34a23963ee034d6332dadefe03fa6c6a5d4d3f4941b2df9efd88
-  data.tar.gz: 4e5c3b6921e4f0656ea8266ca67a00dbcbc8c11736573df9172b8cb2d8821d3799f87085f31e7975d916d56c29f10a4637c6df5f102520fc2da3f5284143ef79
+  metadata.gz: 1f59c7598a9a84d10bde4100aba65c7d55d5a986e0d7bfe2af71a08d83ae5ea689acc4ed22349377b023a7e23ba85facb151b6f70da3d9bd6549ddb8d7552f40
+  data.tar.gz: dc672ea465a8d0f91591b00b3f75ff0c95319e2eee54cad0709976b254f9173bd701c607e2fbe7025fb01e044fbe20d6f9f0998c61c80da7128b1c0daeea6ed8

data/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.4] - 2025-01-17
+
+### Added
+* **Deepseek-Coder-V2 Client** - Support for Deepseek-Coder-V2 models via Ollama
+  * Available variants: `deepseek-coder-v2:latest`, `deepseek-coder-v2:16b`, `deepseek-coder-v2:236b`
+  * Optimized settings for code generation tasks (low temperature, large context)
+  * Integrated with existing tool ecosystem (CodeInterpreter, WebSearch, Calculator)
+  * Full compatibility with Chain, ClientRegistry, and CLI
+
+### Changed
+* Updated model support table in README with Deepseek-Coder-V2 information
+
 ## [0.5.3] - 2025-07-05
 
 ### Added
@@ -83,7 +95,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 - Initial stable release with core functionality
 
-[Unreleased]: https://github.com/FuryCow/llm_chain/compare/v0.5.3...HEAD
+[Unreleased]: https://github.com/FuryCow/llm_chain/compare/v0.5.4...HEAD
+[0.5.4]: https://github.com/FuryCow/llm_chain/compare/v0.5.3...v0.5.4
 [0.5.3]: https://github.com/FuryCow/llm_chain/compare/v0.5.2...v0.5.3
 [0.5.2]: https://github.com/FuryCow/llm_chain/compare/v0.5.1...v0.5.2
 [0.5.1]: https://github.com/FuryCow/llm_chain/compare/v0.5.0...v0.5.1

data/README.md

@@ -353,6 +353,7 @@ tool_manager.register_tool(weather)
 | **Qwen/Qwen2** | Ollama | ✅ Supported | 0.5B - 72B parameters |
 | **LLaMA2/3** | Ollama | ✅ Supported | 7B, 13B, 70B |
 | **Gemma** | Ollama | ✅ Supported | 2B, 7B, 9B, 27B |
+| **Deepseek-Coder-V2** | Ollama | ✅ Supported | 16B, 236B - Code specialist |
 | **Mistral/Mixtral** | Ollama | 🔄 In development | 7B, 8x7B |
 | **Claude** | Anthropic | 🔄 Planned | Haiku, Sonnet, Opus |
 | **Command R+** | Cohere | 🔄 Planned | Optimized for RAG |
@@ -375,6 +376,13 @@ llama_chain = LLMChain::Chain.new(
   temperature: 0.8,
   top_p: 0.95
 )
+
+# Deepseek-Coder-V2 for code tasks
+deepseek_chain = LLMChain::Chain.new(model: "deepseek-coder-v2:16b")
+
+# Direct client usage
+deepseek_client = LLMChain::Clients::DeepseekCoderV2.new(model: "deepseek-coder-v2:16b")
+response = deepseek_client.chat("Create a Ruby method to sort an array")
 ```
 
 ## 💾 Memory System

data/exe/llm-chain

@@ -2,15 +2,18 @@
 # frozen_string_literal: true
 
 # Load Bundler only if running from the development repo (Gemfile present)
-if File.exist?(File.expand_path("../../Gemfile", __dir__))
+if File.exist?(File.expand_path("../Gemfile", __dir__))
+  # In development mode, always load local version
+  require_relative "../lib/llm_chain"
   begin
     require "bundler/setup"
   rescue LoadError
     warn "[llm-chain] Bundler not available; continuing without it"
   end
+else
+  # In production mode, load installed gem
+  require "llm_chain"
 end
-
-require "llm_chain"
 require "optparse"
 require "readline"
 

data/lib/llm_chain/chain.rb

@@ -1,15 +1,25 @@
 require 'json'
 
 module LLMChain
+  # High-level interface that ties together an LLM client, optional memory,
+  # tool system and RAG retriever. Use {LLMChain.quick_chain} for the common
+  # defaults or build manually via this class.
   class Chain
+    # @return [String] selected model identifier
+    # @return [Object] memory backend
+    # @return [Array, Tools::ToolManager, nil] tools collection
+    # @return [Object, nil] RAG retriever
     attr_reader :model, :memory, :tools, :retriever
 
-    # @param model [String] Имя модели (gpt-4, llama3 и т.д.)
-    # @param memory [#recall, #store] Объект памяти
-    # @param tools [Array<Tool>] Массив инструментов
-    # @param retriever [#search] RAG-ретривер (Weaviate, Pinecone и т.д.)
-    # @param client_options [Hash] Опции для клиента LLM
-    def initialize(model: nil, memory: nil, tools: [], retriever: nil, validate_config: true, **client_options)
+    # Create a new chain.
+    #
+    # @param model [String] model name, e.g. "gpt-4" or "qwen3:1.7b"
+    # @param memory [#recall, #store, nil] conversation memory backend
+    # @param tools [Array<Tools::Base>, Tools::ToolManager, nil]
+    # @param retriever [#search, false, nil] document retriever for RAG
+    # @param validate_config [Boolean] run {ConfigurationValidator}
+    # @param client_options [Hash] extra LLM-client options (api_key etc.)
+    def initialize(model: nil, memory: nil, tools: [], retriever: false, validate_config: true, **client_options)
       # Валидация конфигурации (можно отключить через validate_config: false)
       if validate_config
         begin
@@ -38,12 +48,14 @@ module LLMChain
       @client = ClientRegistry.client_for(model, **client_options)
     end
 
-    # Основной метод для взаимодействия с цепочкой
-    # @param prompt [String] Входной промпт
-    # @param stream [Boolean] Использовать ли потоковый вывод
-    # @param rag_context [Boolean] Использовать ли RAG-контекст
-    # @param rag_options [Hash] Опции для RAG-поиска
-    # @yield [String] Передает чанки ответа если stream=true
+    # Main inference entrypoint.
+    #
+    # @param prompt [String] user prompt
+    # @param stream [Boolean] if `true` yields chunks and returns full string
+    # @param rag_context [Boolean] whether to include retriever context
+    # @param rag_options [Hash] options passed to retriever (eg. :limit)
+    # @yield [String] chunk — called when `stream` is true
+    # @return [String] assistant response
     def ask(prompt, stream: false, rag_context: false, rag_options: {}, &block)
       context = collect_context(prompt, rag_context, rag_options)
       full_prompt = build_prompt(prompt: prompt, **context)
@@ -52,10 +64,12 @@ module LLMChain
       response
     end
 
+    # Collect memory, tool results and RAG docs for current request.
+    # @api private
     def collect_context(prompt, rag_context, rag_options)
-      context = memory.recall(prompt)
+      context        = memory.recall(prompt)
       tool_responses = process_tools(prompt)
-      rag_documents = retrieve_rag_context(prompt, rag_options) if rag_context
+      rag_documents  = retrieve_rag_context(prompt, rag_options) if rag_context
       { memory_context: context, tool_responses: tool_responses, rag_documents: rag_documents }
     end
 

data/lib/llm_chain/client_registry.rb

@@ -16,6 +16,8 @@ module LLMChain
         Clients::Llama2
       when /gemma3/
         Clients::Gemma3
+      when /deepseek-coder-v2/
+        Clients::DeepseekCoderV2
       else
         raise UnknownModelError, "Unknown model: #{model}"
       end

data/lib/llm_chain/clients/base.rb

@@ -1,15 +1,37 @@
 module LLMChain
   module Clients
+    # Abstract base class for an LLM client adapter.
+    #
+    # Concrete clients **must** implement two methods:
+    #   * `#chat(prompt, **options)` – single-shot request
+    #   * `#stream_chat(prompt, **options)` – streaming request yielding chunks
+    #
+    # Constructor should accept `model:` plus any client-specific options
+    # (`api_key`, `base_url`, …).
+    #
+    # @abstract
     class Base
+      # @param model [String]
       def initialize(model)
         @model = model
       end
 
-      def chat(_prompt)
+      # Send a non-streaming chat request.
+      #
+      # @param prompt [String]
+      # @param options [Hash]
+      # @return [String] assistant response
+      def chat(prompt, **options)
         raise NotImplementedError
       end
 
-      def stream_chat(_prompt)
+      # Send a streaming chat request.
+      #
+      # @param prompt [String]
+      # @param options [Hash]
+      # @yieldparam chunk [String] partial response chunk
+      # @return [String] full concatenated response
+      def stream_chat(prompt, **options, &block)
         raise NotImplementedError
       end
     end

data/lib/llm_chain/clients/deepseek_coder_v2.rb

@@ -0,0 +1,32 @@
+module LLMChain
+  module Clients
+    # Deepseek-Coder-V2 client for Ollama
+    # 
+    # An open-source Mixture-of-Experts (MoE) code language model that achieves 
+    # performance comparable to GPT4-Turbo in code-specific tasks.
+    #
+    # @example Using default model
+    #   client = LLMChain::Clients::DeepseekCoderV2.new
+    #   response = client.chat("Write a Python function to sort a list")
+    #
+    # @example Using specific model variant
+    #   client = LLMChain::Clients::DeepseekCoderV2.new(model: "deepseek-coder-v2:16b")
+    #   response = client.chat("Explain this algorithm")
+    #
+    class DeepseekCoderV2 < OllamaBase
+      DEFAULT_MODEL = "deepseek-coder-v2:latest".freeze
+      
+      # Optimized settings for code generation tasks
+      DEFAULT_OPTIONS = {
+        temperature: 0.1,     # Lower temperature for more precise code
+        top_p: 0.95,         # High top_p for diverse but relevant responses
+        num_ctx: 8192,       # Large context for complex code analysis
+        stop: ["User:", "Assistant:"]  # Stop tokens for chat format
+      }.freeze
+
+      def initialize(model: DEFAULT_MODEL, base_url: nil, **options)
+        super(model: model, base_url: base_url, default_options: DEFAULT_OPTIONS.merge(options))
+      end
+    end
+  end
+end 

data/lib/llm_chain/configuration_validator.rb

@@ -57,7 +57,7 @@ module LLMChain
       case model.to_s
       when /^gpt/
         validate_openai_requirements!(model)
-      when /qwen|llama|gemma/
+      when /qwen|llama|gemma|deepseek-coder-v2/
         validate_ollama_requirements!(model)
       else
         add_warning("Unknown model type: #{model}. Proceeding with default settings.")

data/lib/llm_chain/tools/base.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+module LLMChain
+  module Tools
+    # Base class for all LLMChain tools.
+    #
+    # Subclasses must implement:
+    #   * {#match?} – decide whether the tool should run for a given prompt.
+    #   * {#call}   – perform the work and return result (`String` or `Hash`).
+    #
+    # Optional overrides: {#extract_parameters}, {#format_result}.
+    #
+    # @abstract
+    class Base
+      attr_reader :name, :description, :parameters
+
+      # @param name [String]
+      # @param description [String]
+      # @param parameters [Hash]
+      def initialize(name:, description:, parameters: {})
+        @name = name
+        @description = description
+        @parameters = parameters
+      end
+
+      # Check whether this tool matches the given prompt.
+      # @param prompt [String]
+      # @return [Boolean]
+      def match?(prompt)
+        raise NotImplementedError, "Subclasses must implement #match?"
+      end
+
+      # Perform the tool action.
+      # @param prompt [String]
+      # @param context [Hash]
+      # @return [String, Hash]
+      def call(prompt, context: {})
+        raise NotImplementedError, "Subclasses must implement #call"
+      end
+
+      # Build a JSON schema describing the tool interface for LLMs.
+      # @return [Hash]
+      def to_schema
+        {
+          name: @name,
+          description: @description,
+          parameters: {
+            type: "object",
+            properties: @parameters,
+            required: required_parameters
+          }
+        }
+      end
+
+      # Extract parameters from prompt if needed.
+      # @param prompt [String]
+      # @return [Hash]
+      def extract_parameters(prompt)
+        {}
+      end
+
+      # Format result for inclusion into LLM prompt.
+      # @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
+
+      # List of required parameter names
+      # @return [Array<String>]
+      def required_parameters
+        []
+      end
+
+      # Helper: checks if prompt contains any keyword
+      # @param prompt [String]
+      # @param keywords [Array<String>]
+      # @return [Boolean]
+      def contains_keywords?(prompt, keywords)
+        keywords.any? { |keyword| prompt.downcase.include?(keyword.downcase) }
+      end
+
+      # Helper: extract numeric values from text
+      # @param text [String]
+      # @return [Array<Float>]
+      def extract_numbers(text)
+        text.scan(/-?\d+\.?\d*/).map(&:to_f)
+      end
+
+      # Helper: extract URLs from text
+      # @param text [String]
+      # @return [Array<String>]
+      def extract_urls(text)
+        text.scan(%r{https?://[^\s]+})
+      end
+    end
+  end
+end 

data/lib/llm_chain/tools/base_tool.rb

@@ -1,81 +1,11 @@
+# frozen_string_literal: true
+require_relative 'base'
+
 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
+    # @deprecated Use {LLMChain::Tools::Base}. Will be removed in 0.7.0.
+    class BaseTool < Base
+      # Empty shim for backward compatibility
     end
   end
 end 

data/lib/llm_chain/tools/calculator.rb

@@ -2,7 +2,7 @@ require 'bigdecimal'
 
 module LLMChain
   module Tools
-    class Calculator < BaseTool
+    class Calculator < Base
       KEYWORDS = %w[
         calculate compute math equation formula
         add subtract multiply divide

data/lib/llm_chain/tools/code_interpreter.rb

@@ -3,7 +3,7 @@ require 'timeout'
 
 module LLMChain
   module Tools
-    class CodeInterpreter < BaseTool
+    class CodeInterpreter < Base
       KEYWORDS = %w[
         code run execute script program
         ruby python javascript
@@ -108,26 +108,26 @@ module LLMChain
       end
 
       def extract_code(prompt)
-        # Нормализуем line endings
+        # Normalize line endings (CRLF -> LF)
         normalized_prompt = normalize_line_endings(prompt)
         
-        # 1. Пробуем различные паттерны markdown блоков
+        # 1. Try various markdown block patterns
         code = extract_markdown_code_blocks(normalized_prompt)
         return clean_code(code) if code && !code.empty?
 
-        # 2. Ищем код после ключевых команд в одной строке
+        # 2. Attempt inline "run code:" patterns
         code = extract_inline_code_commands(normalized_prompt)
         return clean_code(code) if code && !code.empty?
 
-        # 3. Ищем код после ключевых слов в разных строках
+        # 3. Look for code after keywords across multiple lines
         code = extract_multiline_code_blocks(normalized_prompt)
         return clean_code(code) if code && !code.empty?
 
-        # 4. Ищем строки, которые выглядят как код
+        # 4. Fallback: detect code-like lines
         code = extract_code_like_lines(normalized_prompt)
         return clean_code(code) if code && !code.empty?
 
-        # 5. Последняя попытка - весь текст после первого кода
+        # 5. Last resort – everything after first code-looking line
         code = extract_fallback_code(normalized_prompt)
         clean_code(code)
       end
@@ -139,19 +139,19 @@ module LLMChain
       end
 
       def extract_markdown_code_blocks(prompt)
-        # Различные паттерны для markdown блоков
+        # Pattern list for markdown code blocks
         patterns = [
-          # Стандартный markdown с указанием языка
+          # Standard fenced block with language tag
           /```(?:ruby|python|javascript|js)\s*\n(.*?)\n```/mi,
-          # Markdown без указания языка
+          # Fenced block without language tag
           /```\s*\n(.*?)\n```/mi,
-          # Markdown с любым языком
+          # Fenced block any language
           /```\w*\s*\n(.*?)\n```/mi,
-          # Тильды вместо backticks
+          # Using ~~~ instead of ```
           /~~~(?:ruby|python|javascript|js)?\s*\n(.*?)\n~~~/mi,
-          # Без переносов строк
+          # Single-line fenced block
           /```(?:ruby|python|javascript|js)?(.*?)```/mi,
-          # Четыре пробела (indented code blocks)
+          # Indented code block (4 spaces)
           /^    (.+)$/m
         ]
         
@@ -164,7 +164,7 @@ module LLMChain
       end
 
       def extract_inline_code_commands(prompt)
-        # Команды в одной строке
+        # Inline "run code" commands
         inline_patterns = [
           /execute\s+code:\s*(.+)/i,
           /run\s+code:\s*(.+)/i,
@@ -189,30 +189,30 @@ module LLMChain
           keyword_line_index = lines.find_index { |line| line.downcase.include?(keyword.downcase) }
           next unless keyword_line_index
           
-          # Берем строки после ключевого слова
+          # Take lines after the keyword
           code_lines = lines[(keyword_line_index + 1)..-1]
           next unless code_lines
           
-          # Найдем первую непустую строку
+          # Find the first non-empty line
           first_code_line = code_lines.find_index { |line| !line.strip.empty? }
           next unless first_code_line
           
-          # Берем все строки начиная с первой непустой
+          # Take all lines starting from the first non-empty line
           relevant_lines = code_lines[first_code_line..-1]
           
-          # Определяем отступ первой строки кода
+          # Determine indentation of the first code line
           first_line = relevant_lines.first
           indent = first_line.match(/^(\s*)/)[1].length
           
-          # Собираем все строки с таким же или большим отступом
+          # Collect all lines with the same or greater indentation
           code_block = []
           relevant_lines.each do |line|
             if line.strip.empty?
-              code_block << "" # Сохраняем пустые строки
+              code_block << "" # Preserve empty lines
             elsif line.match(/^(\s*)/)[1].length >= indent
               code_block << line
             else
-              break # Прекращаем при уменьшении отступа
+              break # Stop when indentation decreases
             end
           end
           
@@ -229,26 +229,26 @@ module LLMChain
           stripped = line.strip
           next false if stripped.empty?
           
-          # Проверяем различные паттерны кода
+          # Check various code patterns
           stripped.match?(/^(def|class|function|var|let|const|print|puts|console\.log)/i) ||
           stripped.match?(/^\w+\s*[=+\-*\/]\s*/) ||
           stripped.match?(/^\s*(if|for|while|return|import|require)[\s(]/i) ||
           stripped.match?(/puts\s+/) ||
           stripped.match?(/print\s*\(/) ||
           stripped.match?(/^\w+\(.*\)/) ||
-          stripped.match?(/^\s*#.*/) ||  # Комментарии
-          stripped.match?(/^\s*\/\/.*/) || # JS комментарии
-          stripped.match?(/^\s*\/\*.*\*\//) # Блочные комментарии
+          stripped.match?(/^\s*#.*/) ||  # Comments
+          stripped.match?(/^\s*\/\/.*/) || # JS comments
+          stripped.match?(/^\s*\/\*.*\*\//) # Block comments
         end
         
         code_lines.join("\n") if code_lines.any?
       end
 
       def extract_fallback_code(prompt)
-        # Последняя попытка - ищем что-то похожее на код
+        # Final attempt – look for anything resembling code
         lines = prompt.split("\n")
         
-        # Найдем первую строку, которая выглядит как код
+        # Find first line that looks like code
         start_index = lines.find_index do |line|
           stripped = line.strip
           stripped.match?(/^(def|class|function|puts|print|console\.log|var|let|const)/i) ||
@@ -258,14 +258,14 @@ module LLMChain
         
         return nil unless start_index
         
-        # Берем все строки после найденной
+        # Take all subsequent lines
         code_lines = lines[start_index..-1]
         
-        # Останавливаемся на первой строке, которая явно не код
+        # Stop when line clearly not code
         end_index = code_lines.find_index do |line|
           stripped = line.strip
-          stripped.match?(/^(что|как|где|когда|зачем|почему|what|how|where|when|why)/i) ||
-          stripped.length > 100 # Слишком длинная строка
+          stripped.match?(/^(что|как|где|когда|зачем|почему|what|how|where|when|why)/i) || # Russian/English question words
+          stripped.length > 100 # Too long -> unlikely code
         end
         
         relevant_lines = end_index ? code_lines[0...end_index] : code_lines
@@ -277,16 +277,16 @@ module LLMChain
         
         lines = code.strip.lines
         
-        # Удаляем только комментарии, которые не являются частью кода
+        # Remove pure comment lines, keep inline comments
         cleaned_lines = lines.reject do |line|
           stripped = line.strip
-          # Удаляем только строки, которые содержат ТОЛЬКО комментарии
-          stripped.match?(/^\s*#[^{]*$/) || # Ruby комментарии (но не интерполяция)
-          stripped.match?(/^\s*\/\/.*$/) || # JS комментарии
-          stripped.match?(/^\s*\/\*.*\*\/\s*$/) # Блочные комментарии
+          # Remove only lines that contain ONLY comments
+          stripped.match?(/^\s*#[^{]*$/) || # Ruby comments (excluding interpolation)
+          stripped.match?(/^\s*\/\/.*$/) || # JS comments
+          stripped.match?(/^\s*\/\*.*\*\/\s*$/) # Block comments
         end
         
-        # Убираем пустые строки в начале и конце, но сохраняем внутри
+        # Remove blank lines at the beginning and end, but keep them inside
         start_index = cleaned_lines.find_index { |line| !line.strip.empty? }
         return "" unless start_index
         
@@ -297,12 +297,12 @@ module LLMChain
       end
 
       def detect_language(code, prompt)
-        # Явное указание языка
+        # Explicit language specification
         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')
 
-        # Определение по синтаксису
+        # Determine by syntax
         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 ')
@@ -329,12 +329,12 @@ module LLMChain
 
       def execute_ruby(code)
         Timeout.timeout(@timeout) do
-          # Создаем временный файл
+          # Create a temporary file
           Tempfile.create(['code', '.rb']) do |file|
             file.write(code)
             file.flush
             
-            # Выполняем код в отдельном процессе
+            # Execute code in a separate process
             result = `ruby #{file.path} 2>&1`
             
             if $?.success?
@@ -369,7 +369,7 @@ module LLMChain
             file.write(code)
             file.flush
             
-            # Пробуем node.js
+            # Try node.js
             result = `node #{file.path} 2>&1`
             
             if $?.success?

data/lib/llm_chain/tools/date_time.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require 'time'
+
+module LLMChain
+  module Tools
+    # Simple tool that returns current date and time.
+    class DateTime < Base
+      KEYWORDS = %w[time date today now current].freeze
+
+      def initialize
+        super(
+          name: "date_time",
+          description: "Returns current date and time (optionally for given timezone)",
+          parameters: {
+            timezone: {
+              type: "string",
+              description: "IANA timezone name, e.g. 'Europe/Moscow'. Defaults to system TZ"
+            }
+          }
+        )
+      end
+
+      # @param prompt [String]
+      # @return [Boolean]
+      def match?(prompt)
+        contains_keywords?(prompt, KEYWORDS)
+      end
+
+      # @param prompt [String]
+      # @param context [Hash]
+      def call(prompt, context: {})
+        params = extract_parameters(prompt)
+        tz = params[:timezone]
+        time = tz ? Time.now.getlocal(timezone_offset(tz)) : Time.now
+        {
+          timezone: tz || Time.now.zone,
+          iso: time.iso8601,
+          formatted: time.strftime("%Y-%m-%d %H:%M:%S %Z")
+        }
+      end
+
+      def extract_parameters(prompt)
+        tz_match = prompt.match(/in\s+([A-Za-z_\/]+)/)
+        { timezone: tz_match && tz_match[1] }
+      end
+
+      private
+
+      def timezone_offset(tz)
+        # Fallback: use TZInfo if available, else default to system
+        require 'tzinfo'
+        TZInfo::Timezone.get(tz).current_period.offset
+      rescue LoadError, TZInfo::InvalidTimezoneIdentifier
+        0
+      end
+    end
+  end
+end 

data/lib/llm_chain/tools/tool_manager.rb

@@ -8,40 +8,47 @@ module LLMChain
         tools.each { |tool| register_tool(tool) }
       end
 
-      # Регистрирует новый инструмент
+      # Register a new tool instance.
+      #
+      # @param tool [LLMChain::Tools::Base]
+      # @raise [ArgumentError] if object does not inherit from Tools::Base
       def register_tool(tool)
-        unless tool.is_a?(BaseTool)
-          raise ArgumentError, "Tool must inherit from BaseTool"
+        unless tool.is_a?(Base)
+          raise ArgumentError, "Tool must inherit from LLMChain::Tools::Base"
         end
         @tools[tool.name] = tool
       end
 
-      # Удаляет инструмент
+      # Unregister a tool by name.
       def unregister_tool(name)
         @tools.delete(name.to_s)
       end
 
-      # Получает инструмент по имени
+      # Fetch a tool by its name.
       def get_tool(name)
         @tools[name.to_s]
       end
 
-      # Возвращает список всех инструментов
+      # @return [Array<LLMChain::Tools::Base>] list of registered tools
       def list_tools
         @tools.values
       end
 
-      # Получает схемы всех инструментов для LLM
+      # Build JSON schemas for all registered tools.
       def get_tools_schema
         @tools.values.map(&:to_schema)
       end
 
-      # Находит подходящие инструменты для промпта
+      # Find tools whose {Tools::Base#match?} returns `true` for the prompt.
       def find_matching_tools(prompt)
         @tools.values.select { |tool| tool.match?(prompt) }
       end
 
-      # Выполняет все подходящие инструменты
+      # Execute every matching tool and collect results.
+      #
+      # @param prompt [String]
+      # @param context [Hash]
+      # @return [Hash] mapping tool name → result hash
       def execute_tools(prompt, context: {})
         matching_tools = find_matching_tools(prompt)
         
@@ -66,7 +73,12 @@ module LLMChain
         results
       end
 
-      # Выполняет конкретный инструмент по имени
+      # Execute a single tool by name.
+      #
+      # @param name [String]
+      # @param prompt [String]
+      # @param context [Hash]
+      # @return [Hash] result wrapper
       def execute_tool(name, prompt, context: {})
         tool = get_tool(name)
         raise ArgumentError, "Tool '#{name}' not found" unless tool
@@ -87,18 +99,19 @@ module LLMChain
         end
       end
 
-      # Создает стандартный набор инструментов
+      # Create default toolset (Calculator, WebSearch, CodeInterpreter, DateTime).
       def self.create_default_toolset
         tools = [
           Calculator.new,
           WebSearch.new,
-          CodeInterpreter.new
+          CodeInterpreter.new,
+          DateTime.new
         ]
         
         new(tools: tools)
       end
 
-      # Создает набор инструментов из конфигурации
+      # Build toolset from a config array.
       def self.from_config(config)
         tools = []
         
@@ -121,7 +134,7 @@ module LLMChain
         new(tools: tools)
       end
 
-      # Форматирует результаты выполнения для включения в промпт
+      # Format tool execution results for inclusion into an LLM prompt.
       def format_tool_results(results)
         return "" if results.empty?
 
@@ -132,7 +145,7 @@ module LLMChain
         "Tool Results:\n#{formatted_results.join("\n\n")}"
       end
 
-      # Получает краткое описание доступных инструментов
+      # Human-readable list of available tools.
       def tools_description
         descriptions = @tools.values.map do |tool|
           "- #{tool.name}: #{tool.description}"
@@ -141,20 +154,20 @@ module LLMChain
         "Available tools:\n#{descriptions.join("\n")}"
       end
 
-      # Проверяет, содержит ли промпт запрос на использование инструментов
+      # Determine if prompt likely needs tool usage.
       def needs_tools?(prompt)
-        # Проверяем явные запросы на использование инструментов
+        # Check for explicit tool usage requests
         return true if prompt.match?(/\b(use tool|call tool|execute|calculate|search|run code)\b/i)
         
-        # Проверяем, есть ли подходящие инструменты
+        # Check if there are any matching tools
         find_matching_tools(prompt).any?
       end
 
-      # Автоматически решает, какие инструменты использовать
+      # Auto-select and execute best tools for prompt.
       def auto_execute(prompt, context: {})
         return {} unless needs_tools?(prompt)
         
-        # Ограничиваем количество одновременно выполняемых инструментов
+        # Limit the number of tools executed at once
         matching_tools = find_matching_tools(prompt)
         selected_tools = select_best_tools(matching_tools, prompt)
         
@@ -181,9 +194,9 @@ module LLMChain
 
       private
 
-      # Выбирает лучшие инструменты для выполнения (ограничение по количеству)
-      def select_best_tools(tools, prompt, limit: 3)
-        # Простая логика приоритизации
+      # Simple heuristic to rank matching tools.
+        def select_best_tools(tools, prompt, limit: 3)
+          # Simple prioritization logic
         prioritized = tools.sort_by do |tool|
           case tool.name
           when 'calculator'

data/lib/llm_chain/tools/web_search.rb

@@ -4,7 +4,7 @@ require 'uri'
 
 module LLMChain
   module Tools
-    class WebSearch < BaseTool
+    class WebSearch < Base
       KEYWORDS = %w[
         search find lookup google bing
         what is who is where is when is

data/lib/llm_chain/version.rb

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

data/lib/llm_chain.rb

@@ -9,13 +9,15 @@ require_relative "llm_chain/clients/ollama_base"
 require_relative "llm_chain/clients/qwen"
 require_relative "llm_chain/clients/llama2"
 require_relative "llm_chain/clients/gemma3"
+require_relative "llm_chain/clients/deepseek_coder_v2"
 require_relative "llm_chain/memory/array"
 require_relative "llm_chain/memory/redis"
-require_relative "llm_chain/tools/base_tool"
+require_relative "llm_chain/tools/base"
 require_relative "llm_chain/tools/calculator"
 require_relative "llm_chain/tools/web_search"
 require_relative "llm_chain/tools/code_interpreter"
 require_relative "llm_chain/tools/tool_manager"
+require_relative "llm_chain/tools/date_time"
 require_relative "llm_chain/embeddings/clients/local/weaviate_vector_store"
 require_relative "llm_chain/embeddings/clients/local/weaviate_retriever"
 require_relative "llm_chain/embeddings/clients/local/ollama_client"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: llm_chain
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors:
 - FuryCow
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-05 00:00:00.000000000 Z
+date: 2025-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -130,6 +130,7 @@ files:
 - lib/llm_chain/chain.rb
 - lib/llm_chain/client_registry.rb
 - lib/llm_chain/clients/base.rb
+- lib/llm_chain/clients/deepseek_coder_v2.rb
 - lib/llm_chain/clients/gemma3.rb
 - lib/llm_chain/clients/llama2.rb
 - lib/llm_chain/clients/ollama_base.rb
@@ -141,9 +142,11 @@ files:
 - lib/llm_chain/embeddings/clients/local/weaviate_vector_store.rb
 - lib/llm_chain/memory/array.rb
 - lib/llm_chain/memory/redis.rb
+- lib/llm_chain/tools/base.rb
 - lib/llm_chain/tools/base_tool.rb
 - lib/llm_chain/tools/calculator.rb
 - lib/llm_chain/tools/code_interpreter.rb
+- lib/llm_chain/tools/date_time.rb
 - lib/llm_chain/tools/tool_manager.rb
 - lib/llm_chain/tools/web_search.rb
 - lib/llm_chain/version.rb