ai_client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b12bef21b23a46a47cc409042afd5eaae36d6cf1cdd2fae47f12fd0b958ed961
+  data.tar.gz: 0c70c7f7e562da50876ee65c1f1de81f6ee7d37e97a2a7c114bb692ce5d6155d
+SHA512:
+  metadata.gz: 56d14adae8ab29719083dc7bb63edf33fa625237274edef043b3738f39757fa0c15983232c9aab0a2afbf8db33cbcafc89ed0cb39d0180d045e3c2f6f467a5fe
+  data.tar.gz: 5c3d314a10a6aa6f10a51b6f8eaf574dea6d108feb5b5ec64f47fb0e494cc1ebe865a7b2fbc9401aada23c692cae2346a48dbcf062e84a202e080f25f0790d9d

data/.envrc

@@ -0,0 +1,3 @@
+# ai_client/,envrc
+
+export RR=`pwd`

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-10-02
+
+- Initial working release

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Dewayne VanHoozer
+
+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,76 @@
+# AiClient
+
+First and foremost a big **THANK YOU** to [Kevin Sylvestre](https://ksylvest.com/) for his gem [OmniAI](https://github.com/ksylvest/omniai) upon which this effort depends.
+
+**This is a work in progress**  Its implemented as a class rather than the typical module for most gems.  The `AiClient::Configuration` class is a little first draft-ish.  I'm looking to bulk it up a lot.  At this point I think some of the current tests are failing; but, over all `AiClien` is working.  I've used early versions of it in several projects.
+
+## Summary
+
+`ai_client` is a versatile Ruby gem that serves as a generic client for interacting with various AI service providers through a unified API provided by Kevin's gem `OmniAI`. The `AiClient` class is designed to simplify the integration of large language models (LLMs) into applications. `AiClient` allows developers to create instances using just the model name, greatly reducing configuration overhead.
+
+With built-in support for popular AI providers—including OpenAI, Anthropic, Google, Mistral, LocalAI and Ollama—the gem abstracts the complexities of API interactions, offering methods for tasks such as chatting, transcription, speech synthesis, and embedding.
+
+The middleware architecture enables customizable processing of requests and responses, making it easy to implement features like logging and retry logic. Seamlessly integrated with the `OmniAI` framework, `ai_client` empowers developers to leverage cutting-edge AI capabilities without vendor lock-in, making it an essential tool for modern AI-driven applications.
+
+## Installation
+
+If you are using a Gemfile and bundler in your project just install the gem by executing:
+
+```bash
+bundle add ai_client
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install ai_client
+```
+
+## Usage
+
+Basic usage:
+
+```ruby
+AI = AiClient.new('gpt-4o')
+```
+
+That's it.  Just provide the model name that you want to use.  If you application is using more than one model, no worries, just create multiple AiClient instances.
+
+```ruby
+c1 = AiClient.new('nomic-embeddings-text')
+c2 = AiClient.new('gpt-4o-mini')
+```
+
+### What Now?
+
+TODO: Document the methods and their options.
+
+```ruby
+AI.chat(...)
+AI.transcribe(...)
+AI.speak(...)
+AI.embed(...)
+AI.batch_embed(...)
+```
+
+TODO: see the [examples] directory.
+
+### System Environment Variables
+
+The API keys used with each LLM provider have the pattern `XXX_API_KEY` where XXX is the name of the provided.  For example `OPENAI_API_KEY1` and `ANTROPIC_API_KEY` etc.
+
+TODO: list all providers supported and their envar
+
+### Options
+
+TODO: document the options like `provider: :ollama`
+
+## Contributing
+
+I can sure use your help.  This industry is moving faster than I can keep up with.  If you have a bug fix or new feature idea then have at it.  Send me a pull request so we all can benefit from your efforts.
+
+If you only have time to report a bug, that's fine.  Just create an issue in this repo.
+
+## 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,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+task default: :test

data/examples/common.rb

@@ -0,0 +1,24 @@
+# examples/common.rb
+#
+# Stuff common to all the examples
+
+require_relative '../lib/ai_client'
+
+require 'amazing_print'
+
+require 'debug_me'
+include DebugMe
+
+def title(a_string='Something Different', chr='=')
+  puts
+  puts a_string
+  puts chr*a_string.size
+end
+
+
+def box(a_string='Something Different', chr='=')
+  a_string = "#{chr*2} #{a_string} #{chr*2}"  
+  a_line = "\n" + (chr*a_string.size) + "\n"
+  puts "#{a_line}#{a_string}#{a_line}"
+  puts
+end

data/examples/embed.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+# examples/embed.rb
+
+require_relative 'common'
+require 'matrix'
+require 'kmeans-clusterer'
+
+# We'll use only one model for this example
+model = 'nomic-embed-text'
+client = AiClient.new(model, provider: :ollama)
+
+# More meaningful text samples
+texts = [
+  "The quick brown fox jumps over the lazy dog.",
+  "Machine learning is a subset of artificial intelligence.",
+  "Natural language processing is crucial for chatbots.",
+  "Deep learning models require large amounts of data.",
+  "Quantum computing may revolutionize cryptography.",
+  "Renewable energy sources include solar and wind power.",
+  "Climate change is affecting global weather patterns.",
+  "Sustainable agriculture practices can help protect the environment.",
+  "The human genome project mapped our DNA sequence.",
+  "CRISPR technology allows for precise gene editing.",
+  "Artificial neural networks are inspired by biological brains.",
+  "The Internet of Things connects everyday devices to the web.",
+]
+
+title "Generating Embeddings"
+
+embeddings = client.batch_embed(texts, batch_size: 1)
+
+debug_me{[
+  :embeddings,
+  'embeddings.methods.sort'
+]}
+
+# Helper function to compute cosine similarity
+def cosine_similarity(a, b)
+  dot_product = a.zip(b).map { |x, y| x * y }.sum
+  magnitude_a = Math.sqrt(a.map { |x| x**2 }.sum)
+  magnitude_b = Math.sqrt(b.map { |x| x**2 }.sum)
+  dot_product / (magnitude_a * magnitude_b)
+end
+
+title "Clustering Embeddings"
+
+# Convert embeddings to a format suitable for KMeans
+data = embeddings.map(&:embedding)
+
+debug_me{[
+  'data.class',
+  'data.size',
+  'data.first.size'
+]}
+
+# Perform K-means clustering
+k = 3  # Number of clusters
+kmeans = KMeansClusterer.run(k, data, labels: texts, runs: 5)
+
+puts "Clusters:"
+kmeans.clusters.each_with_index do |cluster, i|
+  puts "Cluster #{i + 1}:"
+  cluster.points.each { |p| puts "  - #{p.label}" }
+  puts
+end
+
+title "Finding Similar Texts"
+sleep 1 # Rate Limit gets exceeded without this
+
+query_text = "Artificial intelligence and machine learning"
+query_embedding = client.embed(query_text)
+
+debug_me{[
+  :query_embedding,
+  'query_embedding.methods.sort'
+]}
+
+similarities = texts.zip(embeddings).map do |text, embedding|
+  similarity = cosine_similarity(query_embedding.embedding, embedding.embedding)
+  [text, similarity]
+end
+
+puts "Top 3 texts similar to '#{query_text}':"
+similarities.sort_by { |_, sim| -sim }.first(3).each do |text, sim|
+  puts "#{text} (Similarity: #{sim.round(4)})"
+end
+
+title "Simple Classification"
+
+# Define some categories and their representative texts
+categories = {
+  "Technology" => "Computers, software, and digital innovations",
+  "Science" => "Scientific research, experiments, and discoveries",
+  "Environment" => "Nature, ecology, and environmental issues"
+}
+
+# Generate embeddings for category descriptions
+category_embeddings = client.batch_embed(categories.values, batch_size: 1)
+
+# Classify each text
+puts "Classification results:"
+texts.each do |text|
+  sleep 1 # DEBUG: Rate Limited
+  text_embedding = client.embed(text)
+
+  # Find the category with the highest similarity
+  best_category = categories.keys.max_by do |category|
+    category_index = categories.keys.index(category)
+    cosine_similarity(text_embedding.embedding, category_embeddings[category_index].embedding)
+  end
+
+  puts "#{text} => #{best_category}"
+end

data/examples/speak.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# examples/speak.rb
+
+$player = "afplay" # For MacOS
+
+require_relative 'common'
+
+def play(audio_file)
+  `#{$player} #{audio_file}`
+end
+
+
+models = [
+  'tts-1',               # OpenAI
+  # 'google-tts-1',        # Google (placeholder, adjust as needed)
+  # 'elevenlabs-v1'        # ElevenLabs (if supported)
+]
+clients = []
+
+models.each do |model|
+  clients << AiClient.new(model)
+end
+
+title "Default Configuration Text-to-Speech"
+
+clients.each do |c|
+  puts "\nModel: #{c.model} (#{c.model_type})  Provider: #{c.provider}"
+  text = "Text to speach example using the #{c.model} by provider #{c.provider} with the default voice."
+  result = c.speak(text)
+  puts "Audio generated. Tempfile: #{result.path}"
+  play result.path
+end

data/examples/text.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+# examples/text.rb
+
+require_relative 'common'
+
+
+###################################
+## Working with Ollama
+
+# This is the default configuration which returns
+# text content from the client.
+#
+AiClient.configure do |o|
+  o.return_raw = false
+end
+
+title "Using Mistral model with Ollama locally"
+
+ollama_client = AiClient.new('mistral', provider: :ollama)
+
+puts "\nModel: mistral  Provider: Ollama (local)"
+result = ollama_client.chat('Hello, how are you?')
+puts result
+
+puts "\nRaw response:"
+puts ollama_client.response.pretty_inspect
+puts
+
+
+
+###############################################################
+## Lets look an generic configurations based upon model name ##
+###############################################################
+
+models  = [
+  'gpt-3.5-turbo',        # OpenAI
+  'claude-2.1',           # Anthropic
+  'gemini-1.5-flash',     # Google
+  'mistral-large-latest', # Mistral - La Platform
+]
+clients = []
+
+models.each do |model|
+  clients << AiClient.new(model)
+end
+
+
+title "Default Configuration Response to 'hello'"
+
+clients.each do |c|
+  puts "\nModel: #{c.model} (#{c.model_type})  Provider: #{c.provider}"
+  begin
+    response = c.chat('hello')
+    puts response
+  rescue => e
+    puts e
+  end
+end
+
+###################################
+
+AiClient.configure do |o|
+  o.return_raw = true
+end
+
+raw_clients = []
+
+models.each do |model|
+  raw_clients << AiClient.new(model)
+end
+
+puts
+title "Raw Configuration Response to 'hello'"
+
+raw_clients.each do |c|
+  puts "\nModel: #{c.model} (#{c.model_type})  Provider: #{c.provider}"
+  begin
+    result = c.chat('hello')
+    puts result.pretty_inspect
+  rescue => e
+    puts e
+  end
+end
+
+puts

data/examples/transcribe.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# examples/transcribe.rb
+
+require_relative 'common'
+
+box "Bethany Hamilton on Facing Fear"
+
+audio_file = 'Bethany Hamilton.m4a'  # Poor volume level
+
+models = [
+  'whisper-1',           # OpenAI
+  # 'deepgram-nova-2'      # Deepgram (if supported)
+]
+clients = []
+
+models.each do |model|
+  clients << AiClient.new(model)
+end
+
+title "Default Configuration Speech-to-Text"
+
+
+clients.each do |c|
+  puts "\nModel: #{c.model} (#{c.model_type})  Provider: #{c.provider}"
+  result = c.transcribe(audio_file)
+  puts "Transcription: #{result.pretty_inspect}"
+end
+
+__END__
+
+Tucker Carlson: How do you deal with fear? 
+
+Bethany Hamilton: Okay, so I deal with fear maybe more naturally and
+better than your average human, but I would say It's not like a really
+thoughtful process for me. It's truly just facing my fears and not letting my
+fears like over take me so much that I get paralyzed. So I think maybe since
+I, you know, when I lost my arm when I was 13 years old. I had such a deep
+passion for surfing that my decision to get back in the ocean was based off
+of like getting back to my passion and my love for riding waves and not just
+facing my fears, you know, I had like a deeper reason like I just love doing
+what I did. And so I wanted to see if it was possible with one arm. So I
+truly just faced my fears and over time, I think facing them over and over
+and over again. I eventually became less fearful of sharks, so to say. And
+it's funny, I've heard that sharks and motivational speaking are like
+people's two greatest fears. That's like the two things that I do I surf with
+sharks in the ocean, or like, you know, overcome my like incident with the
+shark and then I do motivational speaking, which I would say I didn't like
+that at first. But eventually I overcame that like that dislike or that fear
+or that uncomfortability and I think so often in life where we naturally want
+to like run from discomfort, you know, we want to make things as easy and
+comfortable as possible. And so if you can learn to recognize that sometimes
+you can't do that and sometimes you have to like walk into uncomfortable, you
+know, I find them like relationships, for example, sometimes you have to have
+the uncomfortable conversations to make that relationship more beautiful. But
+a lot of us just want to like avoid that instead. And in the long run, that
+just makes the relationship less beautiful and less meaningful and less
+filled with depth, and then eventually that relationship may dissipate.
+
+Tucker Carlson: Absolutely right.

data/lib/ai_client/configuration.rb

@@ -0,0 +1,84 @@
+# ai_client/configuration.rb
+
+require 'logger'
+
+class AiClient
+  # TODO: Need a centralized service where
+  #       metadata about LLMs are available
+  #       via and API call.  Would hope that
+  #       the providers would add a "list"
+  #       endpoint to their API which would
+  #       return the metadata for all of their
+  #       models.
+
+  PROVIDER_PATTERNS = {
+    anthropic:  /^claude/i,
+    openai:     /^(gpt|davinci|curie|babbage|ada|whisper|tts|dall-e)/i,
+    google:     /^(gemini|palm)/i,
+    mistral:    /^(mistral|codestral)/i,
+    localai:    /^local-/i,
+    ollama:     /(llama-|nomic)/i
+  }
+
+  MODEL_TYPES = {
+    text_to_text:   /^(nomic|gpt|davinci|curie|babbage|ada|claude|gemini|palm|command|generate|j2-|mistral|codestral)/i,
+    speech_to_text: /^whisper/i,
+    text_to_speech: /^tts/i,
+    text_to_image:  /^dall-e/i
+  }
+
+  class << self
+
+    def configure
+      yield(configuration)
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+  end
+
+
+
+
+  # Usage example:
+  # Configure general settings
+  #   AiClient.configure do |config|
+  #     config.logger = Logger.new('ai_client.log')
+  #     config.return_raw = true
+  #   end
+  #
+  # Configure provider-specific settings
+  #   AiClient.configure do |config|
+  #     config.configure_provider(:openai) do
+  #       {
+  #         organization: 'org-123',
+  #         api_version: 'v1'
+  #       }
+  #     end
+  #   end
+  #
+
+  class Configuration
+    attr_accessor :logger, :timeout, :return_raw
+    attr_reader :providers, :provider_patterns, :model_types
+
+    def initialize
+      @logger             = Logger.new(STDOUT)
+      @timeout            = nil
+      @return_raw         = false
+      @providers          = {}
+      @provider_patterns  = AiClient::PROVIDER_PATTERNS.dup
+      @model_types        = AiClient::MODEL_TYPES.dup
+    end
+
+    def provider(name, &block)
+      if block_given?
+        @providers[name] = block
+      else
+        @providers[name]&.call || {}
+      end
+    end
+  end
+end

data/lib/ai_client/logger_middleware.rb

@@ -0,0 +1,37 @@
+# ai_client/logger_middleware.rb
+
+class AiClient
+
+  # logger = Logger.new(STDOUT)
+  #
+  # AiClient.use(
+  #   AiClient::LoggingMiddleware.new(logger)
+  # )
+  #
+  # Or, if you want to use the same logger as the AiClient:
+  # AiClient.use(
+  #   AiClient::LoggingMiddleware.new(
+  #     AiClient.configuration.logger
+  #   )
+  # )
+
+  class LoggingMiddleware
+    def initialize(logger)
+      @logger = logger
+    end
+
+    def call(client, next_middleware, *args)
+      method_name = args.first.is_a?(Symbol) ? args.first : 'unknown method'
+      @logger.info("Starting #{method_name} call")
+      start_time = Time.now
+
+      result = next_middleware.call(*args)
+
+      end_time = Time.now
+      duration = end_time - start_time
+      @logger.info("Finished #{method_name} call (took #{duration.round(3)} seconds)")
+
+      result
+    end
+  end
+end

data/lib/ai_client/retry_middleware.rb

@@ -0,0 +1,37 @@
+# ai_client/retry_middleware.rb
+
+class AiClient
+
+  # AiClient.use(
+  #   AiClient::RetryMiddleware.new(
+  #     max_retries:  5,
+  #     base_delay:   2,
+  #     max_delay:    30
+  #   )
+  # )
+  #
+  class RetryMiddleware
+    def initialize(max_retries: 3, base_delay: 2, max_delay: 16)
+      @max_retries  = max_retries
+      @base_delay   = base_delay
+      @max_delay    = max_delay
+    end
+
+    def call(client, next_middleware, *args)
+      retries = 0
+      begin
+        next_middleware.call
+      rescue OmniAI::RateLimitError, OmniAI::NetworkError => e
+        if retries < @max_retries
+          retries += 1
+          delay = [@base_delay * (2 ** (retries - 1)), @max_delay].min
+          client.logger.warn("Retrying in #{delay} seconds due to error: #{e.message}")
+          sleep(delay)
+          retry
+        else
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/ai_client/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class AiClient
+  VERSION = "0.1.0"
+end

data/lib/ai_client.rb

@@ -0,0 +1,244 @@
+# ai_client.rb
+# WIP:  a generic client to access LLM providers
+#       kinda like the SaaS "open router"
+#
+
+unless defined?(DebugMe)
+  require 'debug_me'
+  include DebugMe
+end
+
+require 'omniai'
+require 'omniai/anthropic'
+require 'omniai/google'
+require 'omniai/mistral'
+require 'omniai/openai'
+require_relative 'extensions/omniai-ollama'
+require_relative 'extensions/omniai-localai'
+
+require_relative 'ai_client/configuration'
+require_relative 'ai_client/version'
+
+# Create a generic client instance using only model name
+#   client = AiClient.new('gpt-3.5-turbo')
+#
+# Add middlewares
+#   AiClient.use(RetryMiddleware.new(max_retries: 5, base_delay: 2, max_delay: 30))
+#   AiClient.use(LoggingMiddleware.new(AiClient.configuration.logger))
+#
+# TODO: As concurrently designed the middleware must
+#       be set before an instance of AiClient is created.
+#       Any `use` commands for middleware made after
+#       the instance is created will not be available
+#       to that instance.
+#       Change this so that middleware can be added
+#       and removed from an existing client.
+
+class AiClient
+
+  attr_reader :client, :provider, :model, :model_type, :logger, :last_response, :config
+
+  def initialize(model, config: Configuration.new, **options)
+    @model      = model
+    @config     = config
+    @provider   = validate_provider(options[:provider]) || determine_provider(model)
+    @model_type = determine_model_type(model)
+
+    provider_config = @config.provider(@provider)
+
+    @logger   = options[:logger]    || @config.logger
+    @timeout  = options[:timeout]   || @config.timeout
+    @base_url = options[:base_url]  || provider_config[:base_url]
+    @options  = options.merge(provider_config)
+
+    # @client is an instance of an OmniAI::* class
+    @client         = create_client
+
+    @last_response  = nil
+  end
+
+
+  def response  = last_response
+  def raw?      = config.return_raw
+  
+  def raw=(value)
+    config.return_raw = value
+  end
+
+
+
+  ######################################
+  def chat(messages, **params)
+    result = call_with_middlewares(:chat_without_middlewares, messages, **params)
+    @last_response = result
+    # debug_me print " (raw: #{raw?}) "
+    raw? ? result : content
+  end
+
+
+  def chat_without_middlewares(messages, **params)
+    @client.chat(messages, model: @model, **params)
+  end
+
+  ######################################
+  def transcribe(audio, format: nil, **params)
+    call_with_middlewares(:transcribe_without_middlewares, audio, format: format, **params)
+  end
+
+  def transcribe_without_middlewares(audio, format: nil, **params)
+    @client.transcribe(audio, model: @model, format: format, **params)
+  end
+
+  ######################################
+  def speak(text, **params)
+    call_with_middlewares(:speak_without_middlewares, text, **params)
+  end
+
+  def speak_without_middlewares(text, **params)
+    @client.speak(text, model: @model, **params)
+  end
+
+
+  ######################################
+  def embed(input, **params)
+    @client.embed(input, model: @model, **params)
+  end
+
+  def batch_embed(inputs, batch_size: 100, **params)
+    inputs.each_slice(batch_size).flat_map do |batch|
+      sleep 1 # DEBUG rate limits being exceeded
+      embed(batch, **params)
+    end
+  end
+
+  ######################################
+  ## Utilities
+  
+  def call_with_middlewares(method, *args, **kwargs, &block)
+    stack = self.class.middlewares.reverse.reduce(-> { send(method, *args, **kwargs, &block) }) do |next_middleware, middleware|
+      -> { middleware.call(self, next_middleware, *args, **kwargs) }
+    end
+    stack.call
+  end
+
+
+  def content
+    case @provider
+    when :openai, :localai, :ollama
+      last_response.data.dig('choices', 0, 'message', 'content')
+    when :anthropic
+      last_response.data.dig('content',0,'text')
+    when :google
+      last_response.data.dig('candidates', 0, 'content', 'parts', 0, 'text')
+    when :mistral
+      last_response.data.dig('choices', 0, 'message', 'content')
+    else
+      raise NotImplementedError, "Content extraction not implemented for provider: #{@provider}"
+    end
+  end
+  alias_method :text, :content
+
+  ##############################################
+  ## Public Class Methods
+
+  class << self
+
+    def middlewares
+      @middlewares ||= []
+    end
+
+    def use(middleware)
+      middlewares << middleware
+    end
+
+    def clear_middlewares
+      @middlewares = []
+    end
+  end
+
+  def method_missing(method_name, *args, &block)
+    if @client.respond_to?(method_name)
+      result = @client.send(method_name, *args, &block)
+      @last_response = result if result.is_a?(OmniAI::Response)
+      result
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    @client.respond_to?(method_name) || super
+  end
+
+
+  ##############################################
+  private
+
+  def validate_provider(provider)
+    return nil if provider.nil?
+
+    valid_providers = config.provider_patterns.keys
+    unless valid_providers.include?(provider)
+      raise ArgumentError, "Unsupported provider: #{provider}"
+    end
+
+    provider
+  end
+
+
+  def create_client
+    api_key = fetch_api_key  # Fetching the API key should only happen for valid providers
+    client_options = {
+      api_key:  api_key,
+      logger:   @logger,
+      timeout:  @timeout
+    }
+    client_options[:base_url] = @base_url if @base_url
+    client_options.merge!(@options).delete(:provider)
+
+    case provider
+    when :openai
+      OmniAI::OpenAI::Client.new(**client_options)
+    when :anthropic
+      OmniAI::Anthropic::Client.new(**client_options)
+    when :google
+      OmniAI::Google::Client.new(**client_options)
+    when :mistral
+      OmniAI::Mistral::Client.new(**client_options)
+    when :ollama
+      OmniAI::Ollama::Client.new(**client_options)
+    when :localai
+      OmniAI::LocalAI::Client.new(**client_options)
+    else
+      raise ArgumentError, "Unsupported provider: #{@provider}"
+    end
+  end
+
+
+  def fetch_api_key
+    env_var_name = "#{@provider.upcase}_API_KEY"
+    api_key = ENV[env_var_name]
+
+    if api_key.nil? || api_key.empty?
+      unless [:localai, :ollama].include? provider
+        raise ArgumentError, "API key not found in environment variable #{env_var_name}"
+      end
+    end
+
+    api_key
+  end
+
+
+  def determine_provider(model)
+    config.provider_patterns.find { |provider, pattern| model.match?(pattern) }&.first ||
+      raise(ArgumentError, "Unsupported model: #{model}")
+  end
+
+
+  def determine_model_type(model)
+    config.model_types.find { |type, pattern| model.match?(pattern) }&.first ||
+      raise(ArgumentError, "Unable to determine model type for: #{model}")
+  end
+end
+
+

data/lib/extensions/omniai-localai.rb

@@ -0,0 +1,31 @@
+# extensions/omniai-localai.rb
+# frozen_string_literal: true
+
+require 'omniai'
+require 'omniai/openai'
+
+module OmniAI
+
+  # Create an alias for OmniAI::OpenAI module
+  module LocalAI
+    extend OmniAI::OpenAI
+
+    # Alias classes from OmniAI::OpenAI
+    class Client < OmniAI::OpenAI::Client
+      def initialize(**options)
+        options[:host] = 'http://localhost:8080' unless options.has_key?(:host)
+        super(**options)
+      end
+    end
+
+
+    Config = OmniAI::OpenAI::Config
+
+    # Alias the Thread class and its nested classes
+    Thread      = OmniAI::OpenAI::Thread
+    Annotation  = OmniAI::OpenAI::Thread::Annotation
+    Attachment  = OmniAI::OpenAI::Thread::Attachment
+    Message     = OmniAI::OpenAI::Thread::Message
+    Run         = OmniAI::OpenAI::Thread::Run
+  end
+end

data/lib/extensions/omniai-ollama.rb

@@ -0,0 +1,30 @@
+# extensions/omniai-ollama.rb
+# frozen_string_literal: true
+
+require 'omniai'
+require 'omniai/openai'
+
+module OmniAI
+
+  # Create an alias for OmniAI::OpenAI module
+  module Ollama
+    extend OmniAI::OpenAI
+
+    # Alias classes from OmniAI::OpenAI
+    class Client < OmniAI::OpenAI::Client
+      def initialize(**options)
+        options[:host] = 'http://localhost:11434' unless options.has_key?(:host)
+        super(**options)
+      end
+    end    
+
+    Config = OmniAI::OpenAI::Config
+
+    # Alias the Thread class and its nested classes
+    Thread      = OmniAI::OpenAI::Thread
+    Annotation  = OmniAI::OpenAI::Thread::Annotation
+    Attachment  = OmniAI::OpenAI::Thread::Attachment
+    Message     = OmniAI::OpenAI::Thread::Message
+    Run         = OmniAI::OpenAI::Thread::Run
+  end
+end

data/sig/ai_client.rbs

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

data/the_ollama_model_problem.md

@@ -0,0 +1,5 @@
+## The Ollama Model Problem
+
+The ability ot a model-centric configuration where the provider is derived from the model break with those models that can be run locally as well as be accessed through an off-platform provider API.  Take for example the `mistral` model family which can be access to the `La Platform` API or downloaded locally and used with `Ollama`.
+
+If I specify `mistral-large` I should also in the constructor method also provide a `provider:` parameter to specify where that model is going to be accessed.

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification
+name: ai_client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dewayne VanHoozer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-10-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: omniai
+  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: omniai-anthropic
+  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: omniai-google
+  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: omniai-mistral
+  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: omniai-openai
+  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: amazing_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: debug_me
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "`ai_client` is a versatile Ruby gem that serves as a generic client
+  \nfor interacting with various AI service providers through a unified \nAPI. Designed
+  to simplify the integration of large language models \n(LLMs) into applications,
+  `ai_client` allows developers to create \ninstances using just the model name, greatly
+  reducing configuration \noverhead. With built-in support for popular AI providers—including
+  \nOpenAI, Anthropic, Google, Mistral, LocalAI and Ollama—the gem abstracts the \ncomplexities
+  of API interactions, offering methods for tasks such \nas chatting, transcription,
+  speech synthesis, and embedding. The \nmiddleware architecture enables customizable
+  processing of requests \nand responses, making it easy to implement features like
+  logging and \nretry logic. Seamlessly integrated with the `OmniAI` framework, \n`ai_client`
+  empowers developers to leverage cutting-edge AI capabilities \nwithout vendor lock-in,
+  making it an essential tool for modern AI-driven \napplications.\n"
+email:
+- dvanhoozer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".envrc"
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- examples/Bethany Hamilton.m4a
+- examples/common.rb
+- examples/embed.rb
+- examples/speak.rb
+- examples/text.rb
+- examples/transcribe.rb
+- lib/ai_client.rb
+- lib/ai_client/configuration.rb
+- lib/ai_client/logger_middleware.rb
+- lib/ai_client/retry_middleware.rb
+- lib/ai_client/version.rb
+- lib/extensions/omniai-localai.rb
+- lib/extensions/omniai-ollama.rb
+- sig/ai_client.rbs
+- the_ollama_model_problem.md
+homepage: https://github.com/MadBomber/ai_client
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/MadBomber/ai_client
+  source_code_uri: https://github.com/MadBomber/ai_client
+  changelog_uri: https://github.com/MadBomber/ai_client/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.20
+signing_key:
+specification_version: 4
+summary: A generic AI Client for many providers
+test_files: []