llm_chain 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: efda7d777bfd7333f75b65ccc74d46abaff6c70e2a30a31709988811ed54cfff
+  data.tar.gz: 4ea72695094eff0ee6d1a1acc029f66ea34be3a0052d39d33d70a9c6f5a1e1d7
+SHA512:
+  metadata.gz: 94423d0dc1cc4d6305aeb94dfc06fe50882726df1d1f72d03596317db4c37cb517fc9ad272236717439878fac7ca46d23354911e64bd1801b9e250d61d237a4b
+  data.tar.gz: a1ca64366d7343ae2ad8622372d19c97291a0046cf7056af0e9f79902c31e113d8dac8008e687ee53c9bd32f5f24243ded5b74d7dd256f6c23ba9aedb319862d

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 3.1
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 FuryCow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,190 @@
+# LLMChain
+
+A Ruby gem for interacting with Large Language Models (LLMs) through a unified interface, with native Ollama and local model support.
+
+[![Gem Version](https://badge.fury.io/rb/llm_chain.svg)](https://badge.fury.io/rb/llm_chain)
+[![Tests](https://github.com/your_username/llm_chain/actions/workflows/tests.yml/badge.svg)](https://github.com/your_username/llm_chain/actions)
+[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE.txt)
+
+## Features
+
+- Unified interface for multiple LLMs (Qwen, Llama2, Mistral, etc.)
+- Native [Ollama](https://ollama.ai/) integration for local models
+- Prompt templating system
+- Streaming response support
+- RAG-ready with vector database integration
+- Automatic model verification
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'llm_chain'
+```
+Or install directly:
+
+```
+gem install llm_chain
+```
+
+## Prerequisites
+Install [Ollama](https://ollama.ai/)
+
+Pull desired models:
+
+```bash
+ollama pull qwen:7b
+ollama pull llama2:13b
+```
+
+## Usage
+
+basic example:
+
+```ruby
+require 'llm_chain'
+
+memory = LLMChain::Memory::Array.new(max_size: 1)
+chain = LLMChain::Chain.new(model: "qwen3:1.7b", memory: memory)
+puts chain.ask("What is 2+2?")
+```
+
+Using redis as redistributed memory store:
+
+```ruby
+# redis_url: 'redis://localhost:6379' is default or either set REDIS_URL env var
+# max_size: 10 is default
+# namespace: 'llm_chain' is default
+memory = LLMChain::Memory::Redis.new(redis_url: 'redis://localhost:6379', max_size: 10, namespace: 'my_app')
+
+chain = LLMChain::Chain.new(model: "qwen3:1.7b", memory: memory)
+puts chain.ask("What is 2+2?")
+```
+
+Model-specific Clients:
+
+```ruby
+# Qwen with custom options (Without RAG support)
+qwen = LLMChain::Clients::Qwen.new(
+  model: "qwen3:1.7b",
+  temperature: 0.8,
+  top_p: 0.95
+)
+puts qwen.chat("Write Ruby code for Fibonacci sequence")
+```
+
+Streaming Responses:
+
+```ruby
+LLMChain::Chain.new(model: "qwen3:1.7b").ask('How are you?', stream: true) do |chunk|
+  print chunk
+end
+```
+
+Chain pattern:
+
+```ruby
+chain = LLMChain::Chain.new(
+  model: "qwen3:1.7b",
+  memory: LLMChain::Memory::Array.new
+)
+
+# Conversation with context
+chain.ask("What's 2^10?")
+chain.ask("Now multiply that by 5")
+```
+
+## Supported Models
+
+| Model Family | Backend/Service | Notes |
+|-------------|----------------|-------|
+| OpenAI (GPT-3.5, GPT-4) | Web API | Supports all OpenAI API models (Not tested) |
+| LLaMA2 (7B, 13B, 70B) | Ollama | Local inference via Ollama |
+| Qwen/Qwen3 (0.5B-72B) | Ollama | Supports all Qwen model sizes |
+| Mistral/Mixtral | Ollama | Including Mistral 7B and Mixtral 8x7B (In progress) |
+| Gemma (2B, 7B) | Ollama | Google's lightweight models (In progress) |
+| Claude (Haiku, Sonnet, Opus) | Anthropic API | Web API access (In progress) |
+| Command R+ | Cohere API | Optimized for RAG (In progress) |
+
+## Retrieval-Augmented Generation (RAG) 
+
+```ruby
+# Initialize components
+embedder = LLMChain::Embeddings::Clients::Local::OllamaClient.new(model: "nomic-embed-text")
+rag_store = LLMChain::Embeddings::Clients::Local::WeaviateVectorStore.new(embedder: embedder, weaviate_url: 'http://localhost:8080') # Replace with your Weaviate URL if needed
+retriever = LLMChain::Embeddings::Clients::Local::WeaviateRetriever.new(embedder: embedder)
+memory = LLMChain::Memory::Array.new
+tools = []
+
+# Create chain
+chain = LLMChain::Chain.new(
+  model: "qwen3:1.7b",
+  memory: memory, # LLMChain::Memory::Array.new is default
+  tools: tools, # There is no tools supported yet
+  retriever: retriever # LLMChain::Embeddings::Clients::Local::WeaviateRetriever.new is default
+)
+
+# simple Chain definition, with default settings
+
+simple_chain = LLMChain::Chain.new(model: "qwen3:1.7b")
+
+# Example of adding documents to vector database
+documents = [
+  {
+    text: "Ruby supports four OOP principles: encapsulation, inheritance, polymorphism and abstraction",
+    metadata: { source: "ruby-docs", page: 42 }
+  },
+  {
+    text: "Modules in Ruby are used for namespaces and mixins",
+    metadata: { source: "ruby-guides", author: "John Doe" }
+  },
+  {
+    text: "2 + 2 is equals to 4",
+    matadata: { source: 'mad_brain', author: 'John Doe' }
+  }
+]
+
+# Ingest documents into Weaviate
+documents.each do |doc|
+  rag_store.add_document(
+    text: doc[:text],
+    metadata: doc[:metadata]
+  )
+end
+
+# Simple query without RAG
+response = chain.ask("What is 2+2?", rag_context: false) # rag_context: false is default
+puts response
+
+# Query with RAG context
+response = chain.ask(
+  "What OOP principles does Ruby support?",
+  rag_context: true,
+  rag_options: { limit: 3 }
+)
+puts response
+
+# Streamed response with RAG
+chain.ask("Explain Ruby modules", stream: true, rag_context: true) do |chunk|
+  print chunk
+end
+```
+
+## Error handling
+
+```ruby
+begin
+  chain.ask("Explain DNS")
+rescue LLMChain::Error => e
+  puts "Error: #{e.message}"
+  # Auto-fallback logic can be implemented here
+end
+```
+
+## Contributing
+Bug reports and pull requests are welcome on GitHub at:
+https://github.com/FuryCow/llm_chain
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/llm_chain/chain.rb

@@ -0,0 +1,117 @@
+require 'json'
+
+module LLMChain
+  class Chain
+    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, **client_options)
+      @model = model
+      @memory = memory || Memory::Array.new
+      @tools = tools
+      @retriever = retriever || Embeddings::Clients::Local::WeaviateRetriever.new
+      @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
+    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. Генерация ответа
+      response = generate_response(full_prompt, stream: stream, &block)
+
+      # 4. Сохранение в память
+      memory.store(prompt, response)
+      response
+    end
+
+    private
+
+    def retrieve_rag_context(query, options = {})
+      return [] unless @retriever
+
+      limit = options[:limit] || 3
+      @retriever.search(query, limit: limit)
+    rescue => e
+      puts "[RAG Error] #{e.message}"
+      []
+    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?
+        end
+      end
+    end
+
+    def build_prompt(prompt:, memory_context: nil, tool_responses: {}, rag_documents: nil)
+      parts = []
+
+      if memory_context&.any?
+        parts << "Dialogue history:"
+        memory_context.each do |item|
+          parts << "User: #{item[:prompt]}"
+          parts << "Assistant: #{item[:response]}"
+        end
+      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
+      end
+
+      unless tool_responses.empty?
+        parts << "Tool results:"
+        tool_responses.each do |name, response|
+          parts << "#{name}: #{response}"
+        end
+      end
+
+      parts << "Qurrent question: #{prompt}"
+
+      parts.join("\n\n")
+    end
+
+    def generate_response(prompt, stream: false, &block)
+      if stream
+        stream_response(prompt, &block)
+      else
+        @client.chat(prompt)
+      end
+    end
+
+    def stream_response(prompt)
+      buffer = ""
+      @client.stream_chat(prompt) do |chunk|
+        buffer << chunk
+        yield chunk if block_given?
+      end
+      buffer
+    end
+  end
+end

data/lib/llm_chain/client_registry.rb

@@ -0,0 +1,25 @@
+module LLMChain
+  module ClientRegistry
+    @clients = {}
+
+    def self.register_client(name, klass)
+      @clients[name.to_s] = klass
+    end
+
+    def self.client_for(model, **options)
+      puts model
+      instance = case model
+      when /gpt|openai/
+        Clients::OpenAI
+      when /qwen/
+        Clients::Qwen
+      when /llama2/
+        Clients::Llama2
+      else
+        raise UnknownModelError, "Unknown model: #{model}"
+      end
+
+      instance.new(**options.merge(model: model))
+    end
+  end
+end

data/lib/llm_chain/clients/base.rb

@@ -0,0 +1,17 @@
+module LLMChain
+  module Clients
+    class Base
+      def initialize(model)
+        @model = model
+      end
+
+      def chat(_prompt)
+        raise NotImplementedError
+      end
+
+      def stream_chat(_prompt)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/llm_chain/clients/llama2.rb

@@ -0,0 +1,16 @@
+module LLMChain
+  module Clients
+    class Llama2 < OllamaBase
+      DEFAULT_MODEL = "llama2:13b".freeze
+      DEFAULT_OPTIONS = {
+        temperature: 0.7,
+        top_k: 40,
+        num_ctx: 4096
+      }.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/clients/ollama_base.rb

@@ -0,0 +1,84 @@
+require 'faraday'
+require 'json'
+
+module LLMChain
+  module Clients
+    class OllamaBase < Base
+      DEFAULT_BASE_URL = "http://localhost:11434".freeze
+      API_ENDPOINT = "/api/generate".freeze
+
+      def initialize(model:, base_url: nil, default_options: {})
+        @base_url = base_url || DEFAULT_BASE_URL
+        @model = model
+        @default_options = {
+          temperature: 0.7,
+          top_p: 0.9,
+          num_ctx: 2048
+        }.merge(default_options)
+      end
+
+      def chat(prompt, **options)
+        response = connection.post(API_ENDPOINT) do |req|
+          req.headers['Content-Type'] = 'application/json'
+          req.body = build_request_body(prompt, options)
+        end
+
+        handle_response(response)
+      rescue Faraday::Error => e
+        handle_error(e)
+      end
+
+      protected
+
+      def build_request_body(prompt, options)
+        {
+          model: @model,
+          prompt: prompt,
+          stream: options[:stream] || false,
+          options: @default_options.merge(options)
+        }
+      end
+
+      private
+
+      def connection
+        @connection ||= Faraday.new(url: @base_url) do |f|
+          f.request :json
+          f.response :json
+          f.adapter Faraday.default_adapter
+          f.options.timeout = 300 # 5 минут для больших моделей
+        end
+      end
+
+      def handle_response(response)
+        if response.success?
+          response.body["response"] || raise(LLMChain::Error, "Empty response from Ollama")
+        else
+          raise LLMChain::Error, "Ollama API error: #{response.body['error'] || response.body}"
+        end
+      end
+
+      def handle_error(error)
+        case error
+        when Faraday::ResourceNotFound
+          raise LLMChain::Error, <<~ERROR
+            Ollama API error (404). Possible reasons:
+            1. Model '#{@model}' not found
+            2. API endpoint not available
+            
+            Solutions:
+            1. Check available models: `ollama list`
+            2. Pull the model: `ollama pull #{@model}`
+            3. Verify server: `curl #{@base_url}/api/tags`
+          ERROR
+        when Faraday::ConnectionFailed
+          raise LLMChain::Error, "Cannot connect to Ollama at #{@base_url}"
+        when Faraday::TimeoutError
+          raise LLMChain::Error, "Ollama request timed out. Try smaller prompt or faster model."
+        else
+          raise LLMChain::Error, "Ollama communication error: #{error.message}"
+        end
+      end
+    end
+  end
+end

data/lib/llm_chain/clients/openai.rb

@@ -0,0 +1,109 @@
+require 'faraday'
+require 'json'
+
+module LLMChain
+  module Clients
+    class OpenAI < Base
+      BASE_URL = "https://api.openai.com/v1".freeze
+      DEFAULT_MODEL = "gpt-3.5-turbo".freeze
+      DEFAULT_OPTIONS = {
+        temperature: 0.7,
+        max_tokens: 1000,
+        top_p: 1.0,
+        frequency_penalty: 0,
+        presence_penalty: 0
+      }.freeze
+
+      def initialize(api_key: nil, model: nil, organization_id: nil, **options)
+        @api_key = api_key || ENV.fetch('OPENAI_API_KEY') { raise LLMChain::Error, "OPENAI_API_KEY is required" }
+        @model = model || DEFAULT_MODEL
+        @organization_id = organization_id || ENV['OPENAI_ORGANIZATION_ID']
+        @default_options = DEFAULT_OPTIONS.merge(options)
+      end
+
+      def chat(messages, stream: false, **options)
+        params = build_request_params(messages, stream: stream, **options)
+
+        if stream
+          stream_chat(params, &block)
+        else
+          response = connection.post("chat/completions") do |req|
+            req.headers = headers
+            req.body = params.to_json
+          end
+          handle_response(response)
+        end
+      rescue Faraday::Error => e
+        raise LLMChain::Error, "OpenAI API request failed: #{e.message}"
+      end
+
+      def stream_chat(params, &block)
+        buffer = ""
+        connection.post("chat/completions") do |req|
+          req.headers = headers
+          req.body = params.to_json
+          
+          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
+        buffer
+      end
+
+      private
+
+      def build_request_params(messages, stream: false, **options)
+        {
+          model: @model,
+          messages: prepare_messages(messages),
+          stream: stream,
+          **@default_options.merge(options)
+        }.compact
+      end
+
+      def prepare_messages(input)
+        case input
+        when String then [{ role: "user", content: input }]
+        when Array then input
+        else raise ArgumentError, "Messages should be String or Array"
+        end
+      end
+
+      def process_stream_chunk(chunk)
+        return if chunk.strip.empty?
+        
+        data = JSON.parse(chunk.gsub(/^data: /, ''))
+        data.dig("choices", 0, "delta", "content").to_s
+      rescue JSON::ParserError
+        nil
+      end
+
+      def headers
+        {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Bearer #{@api_key}",
+          'OpenAI-Organization' => @organization_id.to_s
+        }.compact
+      end
+
+      def connection
+        @connection ||= Faraday.new(url: BASE_URL) do |f|
+          f.request :json
+          f.response :raise_error
+          f.adapter :net_http
+        end
+      end
+
+      def handle_response(response)
+        data = JSON.parse(response.body)
+        content = data.dig("choices", 0, "message", "content")
+        
+        content || raise(LLMChain::Error, "Unexpected API response: #{data.to_json}")
+      end
+    end
+  end
+end

data/lib/llm_chain/clients/qwen.rb

@@ -0,0 +1,149 @@
+require 'faraday'
+require 'json'
+
+module LLMChain
+  module Clients
+    class Qwen < OllamaBase
+      # Доступные версии моделей
+      MODEL_VERSIONS = {
+        qwen: {
+          default: "qwen:7b",
+          versions: ["qwen:7b", "qwen:14b", "qwen:72b", "qwen:0.5b"]
+        },
+        qwen3: {
+          default: "qwen3:latest",
+          versions: [
+            "qwen3:latest", "qwen3:0.6b", "qwen3:1.7b", "qwen3:4b",
+            "qwen3:8b", "qwen3:14b", "qwen3:30b", "qwen3:32b", "qwen3:235b"
+          ]
+        }
+      }.freeze
+
+      COMMON_DEFAULT_OPTIONS = {
+        temperature: 0.7,
+        top_p: 0.9,
+        repeat_penalty: 1.1
+      }.freeze
+
+      VERSION_SPECIFIC_OPTIONS = {
+        qwen: {
+          num_gqa: 8,
+          stop: ["<|im_end|>", "<|endoftext|>"]
+        },
+        qwen3: {
+          num_ctx: 4096
+        }
+      }.freeze
+
+      INTERNAL_TAGS = {
+        common: {
+          think: /<think>.*?<\/think>\s*/mi,
+          reasoning: /<reasoning>.*?<\/reasoning>\s*/mi
+        },
+        qwen: {
+          system: /<\|system\|>.*?<\|im_end\|>\s*/mi
+        },
+        qwen3: {
+          qwen_meta: /<qwen_meta>.*?<\/qwen_meta>\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
+        puts body
+        body
+      end
+
+      private
+
+      def model_version
+        @model.start_with?('qwen3:') ? :qwen3 : :qwen
+      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 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/embeddings/clients/local/ollama_client.rb

@@ -0,0 +1,65 @@
+require 'net/http'
+require 'json'
+
+module LLMChain
+  module Embeddings
+    module Clients
+      module Local
+        class OllamaClient
+          DEFAULT_MODEL = "nomic-embed-text"
+          OLLAMA_API_URL = "http://localhost:11434"
+
+          def initialize(model: DEFAULT_MODEL, ollama_url: nil)
+            @model = model
+            @ollama_url = (ollama_url || OLLAMA_API_URL) + "/api/embeddings"
+          end
+
+          # Генерация эмбеддинга для текста
+          def embed(text)
+            response = send_ollama_request(text)
+            validate_response(response)
+            parse_response(response)
+          rescue => e
+            raise EmbeddingError, "Failed to generate embedding: #{e.message}"
+          end
+
+          # Пакетная обработка
+          def embed_batch(texts, batch_size: 5)
+            texts.each_slice(batch_size).flat_map do |batch|
+              batch.map { |text| embed(text) }
+            end
+          end
+
+          private
+
+          def send_ollama_request(text)
+            uri = URI(@ollama_url)
+            http = Net::HTTP.new(uri.host, uri.port)
+            request = Net::HTTP::Post.new(uri)
+            request['Content-Type'] = 'application/json'
+            request.body = {
+              model: @model,
+              prompt: text
+            }.to_json
+
+            http.request(request)
+          end
+
+          def validate_response(response)
+            unless response.is_a?(Net::HTTPSuccess)
+              error = JSON.parse(response.body) rescue {}
+              raise EmbeddingError, "API error: #{response.code} - #{error['error'] || response.message}"
+            end
+          end
+
+          def parse_response(response)
+            data = JSON.parse(response.body)
+            data['embedding'] or raise EmbeddingError, "No embedding in response"
+          end
+
+          class EmbeddingError < StandardError; end
+        end
+      end
+    end
+  end
+end

data/lib/llm_chain/embeddings/clients/local/weaviate_retriever.rb

@@ -0,0 +1,19 @@
+module LLMChain
+  module Embeddings
+    module Clients
+      module Local
+        class WeaviateRetriever
+          def initialize(embedder: nil)
+            @vector_store = WeaviateVectorStore.new(
+              embedder: embedder
+            )
+          end
+
+          def search(query, limit: 3)
+            @vector_store.semantic_search(query, limit: limit)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llm_chain/embeddings/clients/local/weaviate_vector_store.rb

@@ -0,0 +1,68 @@
+require 'weaviate'
+
+module LLMChain
+  module Embeddings
+    module Clients
+      module Local
+        class WeaviateVectorStore
+          def initialize(
+            weaviate_url: ENV['WEAVIATE_URL'] || 'http://localhost:8080',
+            class_name: 'Document',
+            embedder: nil
+          )
+            @client = Weaviate::Client.new(
+              url: weaviate_url,
+              model_service: :ollama
+            )
+            @embedder = embedder || OllamaClient.new
+            @class_name = class_name
+            create_schema_if_not_exists
+          end
+
+          def add_document(text:, metadata: {})
+            embedding = @embedder.embed(text)
+            
+            @client.objects.create(
+              class_name: @class_name,
+              properties: {
+                content: text,
+                metadata: metadata.to_json,
+                text: text
+              },
+              vector: embedding
+            )
+          end
+
+          # Поиск по семантическому сходству
+          def semantic_search(query, limit: 3, certainty: 0.7)
+            near_vector = "{ vector: #{@embedder.embed(query)}, certainty: 0.7 }"
+
+            @client.query.get(
+                class_name: @class_name,
+                fields: "content metadata text",
+                limit: "1",
+                offset: "1",
+                near_vector: near_vector,
+            )
+          end
+
+          private
+
+          def create_schema_if_not_exists
+            begin
+              @client.schema.get(class_name: @class_name)
+            rescue Faraday::ResourceNotFound
+              @client.schema.create(
+                class_name: @class_name,
+                properties: [
+                  { name: 'content', dataType: ['text'] },
+                  { name: 'metadata', dataType: ['text'] }
+                ]
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llm_chain/memory/array.rb

@@ -0,0 +1,27 @@
+module LLMChain
+  module Memory
+    class Array
+      def initialize(max_size: 10)
+        @storage = []
+        @max_size = max_size
+      end
+
+      def store(prompt, response)
+        @storage << { prompt: prompt, response: response }
+        @storage.shift if @storage.size > @max_size
+      end
+
+      def recall(_ = nil)
+        @storage.dup
+      end
+
+      def clear
+        @storage.clear
+      end
+
+      def size
+        @storage.size
+      end
+    end
+  end
+end

data/lib/llm_chain/memory/redis.rb

@@ -0,0 +1,48 @@
+require 'redis'
+require 'json'
+
+module LLMChain
+  module Memory
+    class Redis
+      class Error < StandardError; end
+
+      def initialize(max_size: 10, redis_url: nil, namespace: 'llm_chain')
+        @max_size = max_size
+        @redis = ::Redis.new(url: redis_url || ENV['REDIS_URL'] || 'redis://localhost:6379')
+        @namespace = namespace
+        @session_key = "#{namespace}:session"
+      end
+
+      def store(prompt, response)
+        entry = { prompt: prompt, response: response, timestamp: Time.now.to_i }.to_json
+        @redis.multi do
+          @redis.rpush(@session_key, entry)
+          @redis.ltrim(@session_key, -@max_size, -1) # Сохраняем только последние max_size записей
+        end
+      end
+
+      def recall(_ = nil)
+        entries = @redis.lrange(@session_key, 0, -1)
+        entries.map { |e| symbolize_keys(JSON.parse(e)) }
+      rescue JSON::ParserError
+        []
+      rescue ::Redis::CannotConnectError
+        raise MemoryError, "Cannot connect to Redis server"
+      end
+
+      def clear
+        @redis.del(@session_key)
+      end
+
+      def size
+        @redis.llen(@session_key)
+      end
+
+      private
+
+      def symbolize_keys(hash)
+        hash.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+      end
+    end
+  end
+end

data/lib/llm_chain/version.rb

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

data/lib/llm_chain.rb

@@ -0,0 +1,26 @@
+require "llm_chain/version"
+require "faraday"
+require "json"
+
+module LLMChain
+  class Error < StandardError; end
+  class UnknownModelError < Error; end
+  class InvalidModelVersion < Error; end
+  class ClientError < Error; end
+  class ServerError < Error; end
+  class TimeoutError < Error; end
+  class MemoryError < Error; end
+end
+
+require "llm_chain/clients/base"
+require "llm_chain/clients/ollama_base"
+require "llm_chain/clients/openai"
+require "llm_chain/clients/qwen"
+require "llm_chain/clients/llama2"
+require "llm_chain/client_registry"
+require "llm_chain/memory/array"
+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/chain"

data/sig/llm_chain.rbs

@@ -0,0 +1,4 @@
+module LlmChain
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: llm_chain
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- FuryCow
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-06-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: faraday-net_http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: weaviate-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description:
+email:
+- dreamweaver0408@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/llm_chain.rb
+- lib/llm_chain/chain.rb
+- lib/llm_chain/client_registry.rb
+- lib/llm_chain/clients/base.rb
+- lib/llm_chain/clients/llama2.rb
+- lib/llm_chain/clients/ollama_base.rb
+- lib/llm_chain/clients/openai.rb
+- lib/llm_chain/clients/qwen.rb
+- lib/llm_chain/embeddings/clients/local/ollama_client.rb
+- lib/llm_chain/embeddings/clients/local/weaviate_retriever.rb
+- 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/version.rb
+- sig/llm_chain.rbs
+homepage: https://github.com/FuryCow/llm_chain
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/FuryCow/llm_chain
+  source_code_uri: https://github.com/FuryCow/llm_chain
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Ruby-аналог LangChain для работы с LLM
+test_files: []