llm_hub 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8dd3ffff8762625d2ab27200f05b3e6e2d1c4b79aa458a1497d208eda656db38
+  data.tar.gz: 9e98d2e9bf3a1afb8d071e7740a4aef5c10bfb719f03ac51745609c3dd382a55
+SHA512:
+  metadata.gz: 5a353fcd5c607bd96c30dbdb41103d92cf042c04c04d7b2a1f3982961f52f2e3d60241cf02237f1ac93bfab76e80c6e724ea50e830633e22f5f5bd2d426bf184
+  data.tar.gz: '08262623da034f3091866f2c0e3e983731145091016533f902af1d7e8140de0e24f1c3480dd9e5d35752f4ed6eeb497694329823b914bfb5056a3461e7852bf4'

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 3.1
+
+Style/StringLiterals:
+  EnforcedStyle: single_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'
+    - '*.gemspec'

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-05-30
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 upft-akiranumakura
+
+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,50 @@
+# LlmHub
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/llm_hub`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add llm_hub
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install llm_hub
+```
+
+## Usage
+
+```ruby
+client = LlmHub::Completion::Client.new(
+  api_key: ENV['OPENAI_API_KEY'],
+  provider: :openai
+)
+
+response = client.ask_single_question(
+  system_prompt: 'You are a helpful assistant.',
+  content: 'What is the capital of Japan?',
+  model_name: 'gpt-4o-mini'
+)
+
+puts response
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/akiraNuma/llm_hub.
+
+## 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/examples/basic_usage.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'llm_hub'
+
+# Completion example using OpenAI's GPT-4o-mini model
+client = LlmHub::Completion::Client.new(
+  api_key: ENV['OPENAI_API_KEY'],
+  provider: :openai
+)
+
+response = client.ask_single_question(
+  system_prompt: 'You are a helpful assistant.',
+  content: 'What is the capital of Japan?',
+  model_name: 'gpt-4o-mini'
+)
+
+# Check for errors and display if any
+if response[:error]
+  puts "Error occurred: #{response[:error]}"
+else
+  puts "Answer: #{response[:answer]}"
+  puts "Tokens used: #{response[:tokens]}"
+end
+
+# Or, use it simply (returns nil on error)
+puts response[:answer] if response[:answer]
+
+# Embedding example using OpenAI's text-embedding-3-small model
+embedding_client = LlmHub::Embedding::Client.new(
+  api_key: ENV['OPENAI_API_KEY'],
+  provider: :openai
+)
+
+embedding_response = embedding_client.post_embedding(
+  text: 'This is a sample text to generate an embedding.',
+  model_name: 'text-embedding-3-small'
+)
+
+# Check for errors and display if any
+if embedding_response[:error]
+  puts "Error occurred: #{embedding_response[:error]}"
+else
+  puts "Embedding: #{embedding_response[:embedding]&.length} dimensions"
+  puts "Tokens used: #{embedding_response[:tokens]}"
+end
+
+# Or, use it simply (returns nil on error)
+puts embedding_response[:embedding]&.length if embedding_response[:embedding]

data/lib/llm_hub/common/abstract_methods.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module LlmHub
+  module Common
+    # Module to define abstract methods for base classes
+    module AbstractMethods
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Provides class-level methods for defining abstract methods
+      module ClassMethods
+        # Define abstract methods that must be implemented by subclasses
+        def abstract_methods(*methods)
+          methods.each do |method_name|
+            define_method(method_name) do |*_args|
+              raise NotImplementedError, "#{self.class}##{method_name} must be implemented"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llm_hub/common/client_base.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module LlmHub
+  module Common
+    # Base client class for LLM providers
+    # Provides common functionality for API clients including HTTP requests,
+    # retry logic, and provider initialization
+    class ClientBase
+      include LlmHub::Common::HttpHelper
+
+      attr_reader :api_key, :provider, :retry_count
+
+      # Initialize a new client
+      # @param api_key [String] API key for the provider (required)
+      # @param provider [Symbol, String] Provider name (required)
+      def initialize(api_key:, provider:)
+        @api_key = api_key
+        @provider = provider
+        @retry_count = LlmHub::Config::RETRY_COUNT
+      end
+
+      protected
+
+      def create_provider_client
+        # Use PROVIDER_CLASSES defined in subclasses
+        provider_classes = self.class::PROVIDER_CLASSES
+        # Convert to symbol to support both string and symbol
+        provider_key = @provider.to_sym
+        provider_class = provider_classes[provider_key]
+
+        raise ArgumentError, "Unknown provider: #{@provider}." unless provider_class
+
+        provider_class.new(@api_key)
+      end
+
+      def with_retry(&_block)
+        retries = 0
+        begin
+          yield
+        rescue StandardError => e
+          retries += 1
+          retry if retries < @retry_count
+          # Raise the exception if the last retry fails
+          raise "Request failed after #{@retry_count} retries: [#{e.class}] #{e.message}"
+        end
+      end
+
+      def make_request(url, request_body, headers)
+        res = http_post(url, request_body, headers)
+
+        unless res.is_a?(Net::HTTPSuccess)
+          error_message = begin
+            JSON.parse(res.body).to_s
+          rescue JSON::ParserError
+            res.body.to_s
+          end
+          raise "HTTP #{res.code} Error: #{error_message}"
+        end
+
+        JSON.parse(res.body)
+      end
+    end
+  end
+end

data/lib/llm_hub/common/http_helper.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module LlmHub
+  module Common
+    # Module to provide HTTP helper methods
+    module HttpHelper
+      # Call API endpoint for Post
+      #
+      # @param url [String] URL
+      # @param request_body [String] Request body
+      # @param headers [Hash] Headers
+      # @return [Hash] Response
+      def http_post(url, request_body, headers = {})
+        # generate uri http
+        uri = URI.parse(url)
+        http = http_client(uri)
+        # http request
+        http.post(uri.path, request_body.to_json, headers)
+      end
+
+      # Return HTTP client based on Uri
+      #
+      # @param uri [URI::HTTP] Uri
+      # @return [Net::HTTP] HTTP
+      def http_client(uri)
+        http_client = Net::HTTP.new(
+          uri.host,
+          uri.port
+        )
+        http_client.use_ssl = uri.scheme == 'https'
+        http_client.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        http_client.open_timeout = LlmHub::Config::OPEN_TIME_OUT
+        http_client.read_timeout = LlmHub::Config::READ_TIME_OUT
+        http_client
+      end
+    end
+  end
+end

data/lib/llm_hub/completion/client.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module LlmHub
+  module Completion
+    # Client for LLM providers (OpenAI, Anthropic, etc.)
+    class Client < LlmHub::Common::ClientBase
+      # Available provider mappings
+      # @return [Hash<Symbol, Class>] mapping of provider names to their classes
+      PROVIDER_CLASSES = {
+        openai: Providers::OpenAI,
+        anthropic: Providers::Anthropic
+      }.freeze
+
+      # Initialize a new completion client
+      # @param api_key [String] API key for the provider (required)
+      # @param provider [Symbol, String] Provider name (:openai, :anthropic) (required)
+      # @see LlmHub::Common::ClientBase#initialize
+      def initialize(api_key:, provider:)
+        super
+        @provider_client = create_provider_client
+      end
+
+      # Execute a single question prompt and return the response
+      # @param system_prompt [String] System prompt for the LLM
+      # @param content [String] User content/question
+      # @param model_name [String] Model name to use
+      # @param option_params [Hash] Additional parameters for the provider
+      # @return [Hash{Symbol => String, Integer}] Response with :answer and :tokens keys on success
+      #                                            or :error key on failure
+      def ask_single_question(
+        system_prompt:,
+        content:,
+        model_name:,
+        option_params: {}
+      )
+        with_retry do
+          url = @provider_client.url
+          request_body = @provider_client.request_body(system_prompt, content, model_name, option_params)
+          headers = @provider_client.headers
+
+          response_body = make_request(url, request_body, headers)
+          formatted_response(response_body)
+        end
+      rescue StandardError => e
+        { error: e.message }.deep_symbolize_keys
+      end
+
+      private
+
+      # Format the response from provider
+      # @param response_body [Hash] Raw response from provider
+      # @return [Hash{Symbol => String, Integer}] Formatted response
+      def formatted_response(response_body)
+        {
+          answer: @provider_client.extract_answer(response_body),
+          tokens: @provider_client.extract_tokens(response_body)
+        }
+      end
+    end
+  end
+end

data/lib/llm_hub/completion/providers/anthropic.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module LlmHub
+  module Completion
+    module Providers
+      # Anthropic completion provider
+      class Anthropic < Base
+        COMPLETIONS_URI = 'https://api.anthropic.com/v1/messages'
+
+        def url
+          COMPLETIONS_URI
+        end
+
+        def headers
+          {
+            'Content-Type' => 'application/json',
+            'x-api-key' => @api_key,
+            'anthropic-version' => '2023-06-01'
+          }
+        end
+
+        def request_body(system_prompt, content, model_name, option_params)
+          base_params = {
+            model: model_name,
+            max_tokens: 1024,
+            temperature: 0.2,
+            system: system_prompt,
+            messages: [
+              { role: 'user', content: content }
+            ]
+          }
+          base_params.merge(option_params)
+        end
+
+        def extract_answer(response_body)
+          response_body&.dig('content')&.first&.dig('text')
+        end
+
+        def extract_tokens(response_body)
+          usage = response_body&.dig('usage')
+          {
+            total_tokens: (usage&.dig('input_tokens') || 0) + (usage&.dig('output_tokens') || 0),
+            prompt_tokens: usage&.dig('input_tokens'),
+            completion_tokens: usage&.dig('output_tokens')
+          }
+        end
+      end
+    end
+  end
+end

data/lib/llm_hub/completion/providers/base.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module LlmHub
+  module Completion
+    module Providers
+      # Base class for LLM completion providers
+      # @abstract Subclass and override required methods to implement a provider
+      class Base
+        include LlmHub::Common::AbstractMethods
+
+        attr_reader :api_key
+
+        def initialize(api_key)
+          @api_key = api_key
+        end
+
+        # Required methods - must be implemented by subclasses
+        abstract_methods :url, :headers, :request_body, :extract_answer, :extract_tokens
+      end
+    end
+  end
+end

data/lib/llm_hub/completion/providers/openai.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module LlmHub
+  module Completion
+    module Providers
+      # OpenAI completion provider
+      class OpenAI < Base
+        COMPLETIONS_URI = 'https://api.openai.com/v1/chat/completions'
+
+        def url
+          COMPLETIONS_URI
+        end
+
+        def headers
+          {
+            'Content-Type' => 'application/json',
+            'Authorization' => "Bearer #{@api_key}"
+          }
+        end
+
+        def request_body(system_prompt, content, model_name, option_params)
+          base_params = {
+            model: model_name,
+            n: 1,
+            temperature: 0.2,
+            messages: build_messages(system_prompt, content)
+          }
+          base_params.merge(option_params)
+        end
+
+        def extract_answer(response_body)
+          choices = response_body&.dig('choices')
+          return nil if choices.nil? || choices.empty?
+
+          choices[0]&.dig('message')&.dig('content')
+        end
+
+        def extract_tokens(response_body)
+          usage = response_body&.dig('usage')
+          {
+            total_tokens: usage&.dig('total_tokens'),
+            prompt_tokens: usage&.dig('prompt_tokens'),
+            completion_tokens: usage&.dig('completion_tokens')
+          }
+        end
+
+        private
+
+        def build_messages(system_prompt, content)
+          [
+            { role: 'system', content: system_prompt },
+            { role: 'user', content: content }
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/llm_hub/config.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module LlmHub
+  module Config
+    OPEN_TIME_OUT = 5
+    READ_TIME_OUT = 20
+    RETRY_COUNT = 1
+  end
+end

data/lib/llm_hub/embedding/client.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module LlmHub
+  module Embedding
+    # Client for LLM providers (OpenAI, Anthropic, etc.)
+    class Client < LlmHub::Common::ClientBase
+      # Available provider mappings
+      # @return [Hash<Symbol, Class>] mapping of provider names to their classes
+      PROVIDER_CLASSES = {
+        openai: Providers::OpenAI
+      }.freeze
+
+      # Initialize a new embedding client
+      # @param api_key [String] API key for the provider (required)
+      # @param provider [Symbol, String] Provider name (:openai) (required)
+      # @see LlmHub::Common::ClientBase#initialize
+      def initialize(api_key:, provider:)
+        super
+        @provider_client = create_provider_client
+      end
+
+      # Generate embeddings for the given text
+      # @param text [String] The text to generate embeddings for
+      # @param model_name [String] The model to use for embedding generation
+      # @param option_params [Hash] Additional parameters to pass to the provider
+      # @return [Hash{Symbol => Array<Float>, Hash}] Response with :embedding and :tokens keys on success
+      #                                            or :error key on failure
+      def post_embedding(
+        text:,
+        model_name:,
+        option_params: {}
+      )
+        with_retry do
+          url = @provider_client.url
+          request_body = @provider_client.request_body(text, model_name, option_params)
+          headers = @provider_client.headers
+
+          response_body = make_request(url, request_body, headers)
+          formatted_response(response_body)
+        end
+      rescue StandardError => e
+        { error: e.message }.deep_symbolize_keys
+      end
+
+      private
+
+      # Format the API response into a standardized structure
+      # @param response_body [Hash] The raw response from the API
+      # @return [Hash{Symbol => Object}] Formatted response with embedding and token information
+      # @api private
+      def formatted_response(response_body)
+        {
+          embedding: @provider_client.extract_embedding(response_body),
+          tokens: @provider_client.extract_tokens(response_body)
+        }
+      end
+    end
+  end
+end

data/lib/llm_hub/embedding/providers/base.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module LlmHub
+  module Embedding
+    module Providers
+      # Base class for LLM embedding providers
+      # @abstract Subclass and override required methods to implement a provider
+      class Base
+        include LlmHub::Common::AbstractMethods
+
+        attr_reader :api_key
+
+        def initialize(api_key)
+          @api_key = api_key
+        end
+
+        # Required methods - must be implemented by subclasses
+        abstract_methods :url, :headers, :request_body, :extract_embedding, :extract_tokens
+      end
+    end
+  end
+end

data/lib/llm_hub/embedding/providers/openai.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module LlmHub
+  module Embedding
+    module Providers
+      # OpenAI embedding provider
+      class OpenAI < Base
+        EMBEDDINGS_URI = 'https://api.openai.com/v1/embeddings'
+
+        def url
+          EMBEDDINGS_URI
+        end
+
+        def headers
+          {
+            'Content-Type' => 'application/json',
+            'Authorization' => "Bearer #{@api_key}"
+          }
+        end
+
+        def request_body(text, model_name, option_params)
+          base_params = {
+            model: model_name,
+            input: text
+          }
+          base_params.merge(option_params)
+        end
+
+        def extract_embedding(response_body)
+          data_array = response_body&.dig('data')
+          return nil if data_array.nil? || data_array.empty?
+
+          data_array[0]&.dig('embedding')
+        end
+
+        def extract_tokens(response_body)
+          usage = response_body&.dig('usage')
+          {
+            total_tokens: usage&.dig('total_tokens'),
+            prompt_tokens: usage&.dig('prompt_tokens')
+          }
+        end
+      end
+    end
+  end
+end

data/lib/llm_hub/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LlmHub
+  VERSION = '0.1.0'
+end

data/lib/llm_hub.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Standard libraries
+require 'net/http'
+require 'json'
+require 'openssl'
+require 'active_support/core_ext/hash/keys'
+
+require_relative 'llm_hub/version'
+require_relative 'llm_hub/config'
+
+# Common modules
+require_relative 'llm_hub/common/abstract_methods'
+require_relative 'llm_hub/common/http_helper'
+require_relative 'llm_hub/common/client_base'
+
+# Completion providers
+require_relative 'llm_hub/completion/providers/base'
+require_relative 'llm_hub/completion/providers/openai'
+require_relative 'llm_hub/completion/providers/anthropic'
+require_relative 'llm_hub/completion/client'
+
+# Embedding providers
+require_relative 'llm_hub/embedding/providers/base'
+require_relative 'llm_hub/embedding/providers/openai'
+require_relative 'llm_hub/embedding/client'
+
+module LlmHub
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: llm_hub
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- akiraNuma
+bindir: exe
+cert_chain: []
+date: 2025-05-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+description: A Ruby interface for multiple LLM providers like OpenAI and Anthropic.
+  Provides easy access to Completion and Embedding functionalities.
+email:
+- akiran@akiranumakura.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/basic_usage.rb
+- lib/llm_hub.rb
+- lib/llm_hub/common/abstract_methods.rb
+- lib/llm_hub/common/client_base.rb
+- lib/llm_hub/common/http_helper.rb
+- lib/llm_hub/completion/client.rb
+- lib/llm_hub/completion/providers/anthropic.rb
+- lib/llm_hub/completion/providers/base.rb
+- lib/llm_hub/completion/providers/openai.rb
+- lib/llm_hub/config.rb
+- lib/llm_hub/embedding/client.rb
+- lib/llm_hub/embedding/providers/base.rb
+- lib/llm_hub/embedding/providers/openai.rb
+- lib/llm_hub/version.rb
+homepage: https://github.com/akiraNuma/llm_hub
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/akiraNuma/llm_hub
+  source_code_uri: https://github.com/akiraNuma/llm_hub
+  changelog_uri: https://github.com/akiraNuma/llm_hub/blob/main/CHANGELOG.md
+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.6.3
+specification_version: 4
+summary: A Ruby interface for multiple LLM providers like OpenAI and Anthropic.
+test_files: []