llm_chain 0.5.3 → 0.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c94520a98ace3d2bb61ca2b470af041e0f95d6818120ce01dfc5a9cfe76316b
-  data.tar.gz: 5155099cdf777ecaed3a30c9da1e7e200476258369ef3b976967888daf001876
+  metadata.gz: 1963821b40f17c255520b55422bbc7cf6603be88555a99403a8ce24b1c4914f4
+  data.tar.gz: f27902811ba56ee4b1d9da09b22bd99204f01573b848c16e6a9e368f68eb40a4
 SHA512:
-  metadata.gz: b37c6ed16c6b6a66d1f9c6e2a62717e576c5211aba605b98b97e5ba54b436d9a38602aabcedf34a23963ee034d6332dadefe03fa6c6a5d4d3f4941b2df9efd88
-  data.tar.gz: 4e5c3b6921e4f0656ea8266ca67a00dbcbc8c11736573df9172b8cb2d8821d3799f87085f31e7975d916d56c29f10a4637c6df5f102520fc2da3f5284143ef79
+  metadata.gz: 4a3611448d4e85e2f3bcec56f0c8d1c599bcf9da467a963b23fcffe6466e28e1d99dcae34449bffde4bb4672b1be5a6fe4dc35146c97dba8d968ab1fd6b77af1
+  data.tar.gz: e918646ffa824e762d7cefa92da2effcb5a23b412202c6d967e99e6d719035fc89834c0c6f65aea68fe131a92e41474bcf20d93d6ec1cdc2900943f0d51faf39

data/CHANGELOG.md

@@ -7,6 +7,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.5] - 2025-07-17
+
+### Changed
+* **Major refactor:**
+  * Core classes have been extensively refactored for improved modularity, clarity, and maintainability:
+    * Adopted SOLID principles throughout the codebase.
+    * Extracted interfaces for memory, tool management, and all builder components, now located in a dedicated `interfaces` namespace.
+    * Introduced a `builders` folder and builder pattern for prompt, memory context, tool responses, RAG documents, and retriever context.
+    * Improved dependency injection and separation of concerns, making the codebase easier to extend and test.
+    * Centralized error handling and configuration validation.
+    * Enhanced documentation and type signatures for all major classes.
+    * The public API remains minimal and idiomatic, with extensibility via interfaces and factories.
+  * `Chain#ask` method rewritten following Ruby best practices: now declarative, each pipeline stage is a private method, code is cleaner and easier to extend.
+  * All ToolManager creation and configuration is now done via a dedicated factory: `ToolManagerFactory`. Old calls (`ToolManager.create_default_toolset`, `ToolManager.from_config`) have been replaced with factory methods.
+
+## [0.5.4] - 2025-07-08
+
+### 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,8 +110,9 @@ 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
-[0.5.0]: https://github.com/FuryCow/llm_chain/releases/tag/v0.5.0 
+[0.5.0]: https://github.com/FuryCow/llm_chain/releases/tag/v0.5.0 

data/README.md

@@ -159,7 +159,7 @@ chain = LLMChain.quick_chain(
 # Manual validation
 LLMChain::ConfigurationValidator.validate_chain_config!(
   model: "qwen3:1.7b",
-  tools: LLMChain::Tools::ToolManager.create_default_toolset
+  tools: LLMChain::Tools::ToolManagerFactory.create_default_toolset
 )
 ```
 
@@ -182,7 +182,7 @@ chain.ask("Execute code: puts (1..10).sum")
 # 💻 Result: 55
 
 # Traditional setup
-tool_manager = LLMChain::Tools::ToolManager.create_default_toolset
+tool_manager = LLMChain::Tools::ToolManagerFactory.create_default_toolset
 chain = LLMChain::Chain.new(
   model: "qwen3:1.7b",
   tools: tool_manager
@@ -342,6 +342,7 @@ end
 
 # Usage
 weather = WeatherTool.new(api_key: "your-key")
+tool_manager = LLMChain::Tools::ToolManagerFactory.create_default_toolset
 tool_manager.register_tool(weather)
 ```
 
@@ -353,6 +354,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 +377,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
@@ -480,7 +489,7 @@ chain.ask("Tell me about Ruby history", stream: true) do |chunk|
 end
 
 # Streaming with tools
-tool_manager = LLMChain::Tools::ToolManager.create_default_toolset
+tool_manager = LLMChain::Tools::ToolManagerFactory.create_default_toolset
 chain = LLMChain::Chain.new(
   model: "qwen3:1.7b", 
   tools: tool_manager
@@ -535,7 +544,7 @@ tools_config = [
   }
 ]
 
-tool_manager = LLMChain::Tools::ToolManager.from_config(tools_config)
+tool_manager = LLMChain::Tools::ToolManagerFactory.from_config(tools_config)
 ```
 
 ### Client Settings
@@ -625,7 +634,7 @@ require 'llm_chain'
 
 class ChatBot
   def initialize
-    @tool_manager = LLMChain::Tools::ToolManager.create_default_toolset
+    @tool_manager = LLMChain::Tools::ToolManagerFactory.create_default_toolset
     @memory = LLMChain::Memory::Array.new(max_size: 20)
     @chain = LLMChain::Chain.new(
       model: "qwen3:1.7b",
@@ -660,7 +669,7 @@ bot.chat_loop
 ```ruby
 data_chain = LLMChain::Chain.new(
   model: "qwen3:7b",
-  tools: LLMChain::Tools::ToolManager.create_default_toolset
+  tools: LLMChain::Tools::ToolManagerFactory.create_default_toolset
 )
 
 # Analyze CSV data

data/examples/quick_demo.rb

@@ -71,7 +71,7 @@ end
 # 5. Chain with tools
 puts "\n5. 🛠️ Chain with automatic tools"
 begin
-  tool_manager = LLMChain::Tools::ToolManager.create_default_toolset
+  tool_manager = LLMChain::Tools::ToolManagerFactory.create_default_toolset
   smart_chain = LLMChain::Chain.new(
     model: "qwen3:1.7b",
     tools: tool_manager,

data/examples/tools_example.rb

@@ -101,7 +101,7 @@ end
 
 # 4. Tool Manager Usage
 puts "\n4. 🎯 Tool Manager"
-tool_manager = LLMChain::Tools::ToolManager.create_default_toolset
+tool_manager = LLMChain::Tools::ToolManagerFactory.create_default_toolset
 
 puts "Registered tools: #{tool_manager.list_tools.map(&:name).join(', ')}"
 
@@ -243,7 +243,7 @@ tools_config = [
   }
 ]
 
-config_tool_manager = LLMChain::Tools::ToolManager.from_config(tools_config)
+config_tool_manager = LLMChain::Tools::ToolManagerFactory.from_config(tools_config)
 puts "Tools from config: #{config_tool_manager.list_tools.map(&:name).join(', ')}"
 
 # Test configuration-based setup

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"
 
@@ -109,7 +112,7 @@ when "tools"
   sub = ARGV.shift
   case sub
   when "list"
-    tm = LLMChain::Tools::ToolManager.create_default_toolset
+    tm = LLMChain::Tools::ToolManagerFactory.create_default_toolset
     puts tm.tools_description
   else
     warn "Unknown tools subcommand"; warn USAGE

data/lib/llm_chain/builders/memory_context.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/builders/memory_context_builder'
+
+module LLMChain
+  module Builders
+    # Production implementation of memory context builder for LLMChain.
+    # Formats conversation history for inclusion in the prompt.
+    class MemoryContext < Interfaces::Builders::MemoryContext
+      # Build the memory context string for the prompt.
+      # @param memory_history [Array<Hash>] conversation history
+      # @return [String] formatted memory context
+      def build(memory_history)
+        return "" if memory_history.nil? || memory_history.empty?
+        parts = ["Dialogue history:"]
+        memory_history.each do |item|
+          parts << "User: #{item[:prompt]}"
+          parts << "Assistant: #{item[:response]}"
+        end
+        parts.join("\n")
+      end
+    end
+  end
+end 

data/lib/llm_chain/builders/prompt.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/builders/prompt_builder'
+
+module LLMChain
+  module Builders
+    # Production implementation of prompt builder for LLMChain.
+    # Assembles the final prompt from memory, tools, RAG, and user prompt.
+    class Prompt < Interfaces::Builders::Prompt
+      # Build the final prompt for the LLM.
+      # @param memory_context [String]
+      # @param tool_responses [String]
+      # @param rag_documents [String]
+      # @param prompt [String]
+      # @return [String] final prompt for LLM
+      def build(memory_context:, tool_responses:, rag_documents:, prompt:)
+        parts = []
+        parts << memory_context if memory_context && !memory_context.empty?
+        parts << rag_documents if rag_documents && !rag_documents.empty?
+        parts << tool_responses if tool_responses && !tool_responses.empty?
+        parts << "Current question: #{prompt}"
+        parts.join("\n\n")
+      end
+    end
+  end
+end 

data/lib/llm_chain/builders/rag_documents.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/builders/rag_documents_builder'
+
+module LLMChain
+  module Builders
+    # Production implementation of RAG documents builder for LLMChain.
+    # Formats retrieved documents for inclusion in the prompt.
+    class RagDocuments < Interfaces::Builders::RagDocuments
+      # Build the RAG documents string for the prompt.
+      # @param rag_documents [Array<Hash>] list of retrieved documents
+      # @return [String] formatted RAG context
+      def build(rag_documents)
+        return "" if rag_documents.nil? || rag_documents.empty?
+        parts = ["Relevant documents:"]
+        rag_documents.each_with_index do |doc, i|
+          parts << "Document #{i + 1}: #{doc['content'] || doc[:content]}"
+          meta = doc['metadata'] || doc[:metadata]
+          parts << "Metadata: #{meta.to_json}" if meta
+        end
+        parts.join("\n")
+      end
+    end
+  end
+end 

data/lib/llm_chain/builders/retriever_context.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/builders/retriever_context_builder'
+
+module LLMChain
+  module Builders
+    # Production implementation of retriever context builder for LLMChain.
+    # Retrieves and formats RAG context documents.
+    class RetrieverContext < Interfaces::Builders::RetrieverContext
+      # Retrieve and format RAG context documents.
+      # @param retriever [Object] retriever instance (must respond to #search)
+      # @param query [String] user query
+      # @param options [Hash]
+      # @return [Array<Hash>] list of retrieved documents
+      def retrieve(retriever, query, options = {})
+        return [] unless retriever && retriever.respond_to?(:search)
+        limit = options[:limit] || 3
+        retriever.search(query, limit: limit)
+      rescue => e
+        warn "[RetrieverContext] Error retrieving context: #{e.message}"
+        []
+      end
+    end
+  end
+end 

data/lib/llm_chain/builders/tool_responses.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/builders/tool_responses_builder'
+
+module LLMChain
+  module Builders
+    # Production implementation of tool responses builder for LLMChain.
+    # Formats tool results for inclusion in the prompt.
+    class ToolResponses < Interfaces::Builders::ToolResponses
+      # Build the tool responses string for the prompt.
+      # @param tool_results [Hash] tool name => result
+      # @return [String] formatted tool responses
+      def build(tool_results)
+        return "" if tool_results.nil? || tool_results.empty?
+        parts = ["Tool results:"]
+        tool_results.each do |name, response|
+          if response.is_a?(Hash) && response[:formatted]
+            parts << "#{name}: #{response[:formatted]}"
+          else
+            parts << "#{name}: #{response}"
+          end
+        end
+        parts.join("\n")
+      end
+    end
+  end
+end 

data/lib/llm_chain/chain.rb

@@ -1,21 +1,49 @@
 require 'json'
+require_relative 'memory/array'
+require_relative 'tools/tool_manager_factory'
+require_relative 'builders/prompt'
+require_relative 'builders/memory_context'
+require_relative 'builders/tool_responses'
+require_relative 'builders/rag_documents'
+require_relative 'builders/retriever_context'
 
 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)
-      # Валидация конфигурации (можно отключить через validate_config: false)
+    # Create a new chain.
+    #
+    # @param model [String] model name, e.g. "gpt-4" or "qwen3:1.7b"
+    # @param memory [LLMChain::Interfaces::Memory] conversation memory backend
+    # @param tools [LLMChain::Interfaces::ToolManager, Array, true, false, nil]
+    # @param retriever [#search, false, nil] document retriever for RAG
+    # @param prompt_builder [LLMChain::Interfaces::Builders::Prompt]
+    # @param memory_context_builder [LLMChain::Interfaces::Builders::MemoryContext]
+    # @param tool_responses_builder [LLMChain::Interfaces::Builders::ToolResponses]
+    # @param rag_documents_builder [LLMChain::Interfaces::Builders::RagDocuments]
+    # @param retriever_context_builder [LLMChain::Interfaces::Builders::RetrieverContext]
+    # @param validate_config [Boolean] run {ConfigurationValidator}
+    # @param client_options [Hash] extra LLM-client options (api_key etc.)
+    def initialize(
+      model: nil,
+      memory: nil,
+      tools: true,
+      retriever: false,
+      validate_config: true,
+      **client_options
+    )
       if validate_config
         begin
           ConfigurationValidator.validate_chain_config!(
-            model: model, 
-            tools: tools, 
+            model: model,
+            tools: tools,
             memory: memory,
             retriever: retriever,
             **client_options
@@ -27,7 +55,18 @@ module LLMChain
 
       @model = model
       @memory = memory || Memory::Array.new
-      @tools = tools
+      @tools =
+        if tools == true
+          Tools::ToolManagerFactory.create_default_toolset
+        elsif tools.is_a?(Array)
+          Tools::ToolManager.new(tools: tools)
+        elsif tools.is_a?(Tools::ToolManager)
+          tools
+        elsif tools.is_a?(Hash) && tools[:config]
+          Tools::ToolManagerFactory.from_config(tools[:config])
+        else
+          nil
+        end
       @retriever = if retriever.nil?
                     Embeddings::Clients::Local::WeaviateRetriever.new
                   elsif retriever == false
@@ -36,101 +75,63 @@ module LLMChain
                     retriever
                   end
       @client = ClientRegistry.client_for(model, **client_options)
+
+      # Always use default builders
+      @prompt_builder = Builders::Prompt.new
+      @memory_context_builder = Builders::MemoryContext.new
+      @tool_responses_builder = Builders::ToolResponses.new
+      @rag_documents_builder = Builders::RagDocuments.new
+      @retriever_context_builder = Builders::RetrieverContext.new
     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)
+      memory_context = build_memory_context(prompt)
+      tool_responses = build_tool_responses(prompt)
+      rag_documents  = build_rag_documents(prompt, rag_context, rag_options)
+      full_prompt    = build_full_prompt(prompt, memory_context, tool_responses, rag_documents)
+
       response = generate_response(full_prompt, stream: stream, &block)
-      memory.store(prompt, response)
+      store_memory(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 = {})
-      return [] unless @retriever
-
-      limit = options[:limit] || 3
-      @retriever.search(query, limit: limit)
-    rescue => e
-      raise Error, "Cannot retrieve rag context"
+    def build_memory_context(prompt)
+      history = @memory&.recall(prompt)
+      @memory_context_builder.build(history)
     end
 
-    def process_tools(prompt)
-      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")
+    def build_tool_responses(prompt)
+      results = @tools&.execute_tools(prompt) || {}
+      @tool_responses_builder.build(results)
     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")
+    def build_rag_documents(prompt, rag_context, rag_options)
+      return "" unless rag_context && @retriever
+      docs = @retriever_context_builder.retrieve(@retriever, prompt, rag_options)
+      @rag_documents_builder.build(docs)
     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")
+    def build_full_prompt(prompt, memory_context, tool_responses, rag_documents)
+      @prompt_builder.build(
+        memory_context: memory_context,
+        tool_responses: tool_responses,
+        rag_documents: rag_documents,
+        prompt: prompt
+      )
     end
 
-    def build_tool_responses(tool_responses)
-      parts = ["Tool results:"]
-      tool_responses.each do |name, response|
-        if response.is_a?(Hash) && response[:formatted]
-          # Особая обработка для поиска без результатов
-          if name == "web_search" && response[:results] && response[:results].empty?
-            parts << "#{name}: No search results found. Please answer based on your knowledge, but indicate that search was unavailable."
-          else
-            parts << "#{name}: #{response[:formatted]}"
-          end
-        else
-          parts << "#{name}: #{response}"
-        end
-      end
-      parts.join("\n")
+    def store_memory(prompt, response)
+      @memory&.store(prompt, response)
     end
 
     def generate_response(prompt, stream: false, &block)

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.")