spectre_ai 1.1.4 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e92299b643fbf7d928b9c45de5ad9a504528cbb246202d56cb24d36a32030030
-  data.tar.gz: 8dc5d19040a9cac2cc929a1a91b55112d0e78fa21ca8de05bb6c3544838af9ed
+  metadata.gz: 68106b39f46d2b4069e560eb8e51dcc64ed005a05d9f062919db94e628c2c5f4
+  data.tar.gz: c35b62f8f973763c2029620a0b4608e0dd15591c991e9a13b91d427e2b5dddd7
 SHA512:
-  metadata.gz: 8ea61b8b0a0e23d7a5c500fd99e147942fd33538e21d38be0030aff60dda20758a87651b9460d4b4de50f986ffe068da4dd29f172dc0a25a993595eadee34fe6
-  data.tar.gz: b4ef2e616f0143f677c635e6d999e155a1205a1ab90ac47fc2a8c322b95ee6f107522dc4c2d8a16e33a856f3387ffdb1e7ac85ca9f83b3a72960e9b8e6d52ca1
+  metadata.gz: 7c4632584286d800799a66a1b5ac2f2c5dbb6a9c35597f6c1256dffa94a9f228c2c0ff5aa1a30170a1aae93d9d26cbad42df55297468b853471a3559aa72c69a
+  data.tar.gz: 998ab9f6d356b9f3f9cc404260ea931c35a4e80abb2b6b5f9da1757fbdbc39365bfc0041c9a9ae934f97c954d66fa9ffc8c75a8d66b4228cf5db3f26972bd2e0

data/CHANGELOG.md

@@ -138,4 +138,63 @@ Spectre::Openai::Completions.create(
 
 * Simplified Exception Handling for Timeouts
 * Removed explicit handling of Net::OpenTimeout and Net::ReadTimeout exceptions in both Completions and Embeddings classes.
-* Letting these exceptions propagate ensures clearer and more consistent error messages for timeout issues.
+* Letting these exceptions propagate ensures clearer and more consistent error messages for timeout issues.
+
+
+# Changelog for Version 1.2.0
+
+**Release Date:** [30th Jan 2025]
+
+### **New Features & Enhancements**
+
+1️⃣ **Unified Configuration for LLM Providers**
+
+🔧 Refactored the configuration system to provide a consistent interface for setting up OpenAI and Ollama within config/initializers/spectre.rb.\
+•	Now, developers can seamlessly switch between OpenAI and Ollama by defining a single provider configuration block.\
+•	Ensures better modularity and simplifies adding support for future providers (Claude, Cohere, etc.).
+
+🔑 **Example Configuration:**
+
+```ruby
+Spectre.setup do |config|
+  config.default_llm_provider = :openai
+
+  config.openai do |openai|
+    openai.api_key = ENV['OPENAI_API_KEY']
+  end
+
+  config.ollama do |ollama|
+    ollama.host = ENV['OLLAMA_HOST']
+    ollama.api_key = ENV['OLLAMA_API_KEY']
+  end
+end
+```
+
+Key Improvements:\
+✅ API key validation added: Now properly checks if api_key is missing and raises APIKeyNotConfiguredError.\
+✅ Host validation added: Now checks if host is missing for Ollama and raises HostNotConfiguredError.
+
+2️⃣ **Added Ollama Provider Support**
+
+🆕 Introduced full support for Ollama, allowing users to use local LLM models efficiently.\
+•	Supports Ollama-based completions for generating text using local models like llama3.\
+•	Supports Ollama-based embeddings for generating embeddings using local models like nomic-embed-text.\
+•	Automatic JSON Schema Conversion: OpenAI’s json_schema format is now automatically translated into Ollama’s format key.
+
+3️⃣ **Differences in OpenAI Interface: max_tokens Moved to `**args`**
+
+💡 Refactored the OpenAI completions request so that max_tokens is now passed as a dynamic argument inside `**args` instead of a separate parameter.\
+•	Why? To ensure a consistent interface across different providers, making it easier to switch between them seamlessly.\
+•	Before:
+```ruby
+Spectre.provider_module::Completions.create(messages: messages, max_tokens: 50)
+```
+•	After:
+```ruby
+Spectre.provider_module::Completions.create(messages: messages, openai: { max_tokens: 50 })
+```
+
+Key Benefits:\
+✅ Keeps the method signature cleaner and future-proof.\
+✅ Ensures optional parameters are handled dynamically without cluttering the main method signature.\
+✅ Improves consistency across OpenAI and Ollama providers.

data/README.md

@@ -6,14 +6,14 @@
 
 ## Compatibility
 
-| Feature                 | Compatibility |
-|-------------------------|---------------|
-| Foundation Models (LLM) | OpenAI        |
-| Embeddings              | OpenAI        |
-| Vector Searching        | MongoDB Atlas |
-| Prompt Templates        | OpenAI        |
+| Feature                 | Compatibility  |
+|-------------------------|----------------|
+| Foundation Models (LLM) | OpenAI, Ollama |
+| Embeddings              | OpenAI, Ollama |
+| Vector Searching        | MongoDB Atlas  |
+| Prompt Templates        | ✅            |
 
-**💡 Note:** We will first prioritize adding support for additional foundation models (Claude, Cohere, LLaMA, etc.), then look to add support for more vector databases (Pgvector, Pinecone, etc.). If you're looking for something a bit more extensible, we highly recommend checking out [langchainrb](https://github.com/patterns-ai-core/langchainrb).
+**💡 Note:** We will first prioritize adding support for additional foundation models (Claude, Cohere, etc.), then look to add support for more vector databases (Pgvector, Pinecone, etc.). If you're looking for something a bit more extensible, we highly recommend checking out [langchainrb](https://github.com/patterns-ai-core/langchainrb).
 
 ## Installation
 
@@ -37,24 +37,32 @@ gem install spectre_ai
 
 ## Usage
 
-### 1. Setup
+### 🔧 Configuration
 
-First, you’ll need to generate the initializer to configure your OpenAI API key. Run the following command to create the initializer:
+First, you’ll need to generate the initializer. Run the following command to create the initializer:
 
 ```bash
 rails generate spectre:install
 ```
 
-This will create a file at `config/initializers/spectre.rb`, where you can set your OpenAI API key:
+This will create a file at `config/initializers/spectre.rb`, where you can set your llm provider and configure the provider-specific settings.
 
 ```ruby
 Spectre.setup do |config|
-  config.api_key = 'your_openai_api_key'
-  config.llm_provider = :openai
+  config.default_llm_provider = :openai
+
+  config.openai do |openai|
+    openai.api_key = ENV['OPENAI_API_KEY']
+  end
+
+  config.ollama do |ollama|
+    ollama.host = ENV['OLLAMA_HOST']
+    ollama.api_key = ENV['OLLAMA_API_KEY']
+  end
 end
 ```
 
-### 2. Enable Your Rails Model(s)
+### 📡 Embeddings & Vector Search
 
 #### For Embedding
 
@@ -146,6 +154,8 @@ This method sends the text to OpenAI’s API and returns the embedding vector. Y
 Spectre.provider_module::Embeddings.create("Your text here", model: "text-embedding-ada-002")
 ```
 
+**NOTE:** Different providers have different available args for the `create` method. Please refer to the provider-specific documentation for more details.
+
 ### 4. Performing Vector-Based Searches
 
 Once your model is configured as searchable, you can perform vector-based searches on the stored embeddings:
@@ -168,7 +178,7 @@ This method will:
 - **custom_result_fields:** Limit the fields returned in the search results.
 - **additional_scopes:** Apply additional MongoDB filters to the search results.
 
-### 5. Creating Completions
+### 💬 Chat Completions
 
 Spectre provides an interface to create chat completions using your configured LLM provider, allowing you to create dynamic responses, messages, or other forms of text.
 
@@ -182,17 +192,14 @@ messages = [
         { role: 'user', content: "Tell me a joke." }
 ]
 
-Spectre.provider_module::Completions.create(
-        messages: messages
-)
-
+Spectre.provider_module::Completions.create(messages: messages)
 ```
 
 This sends the request to the LLM provider’s API and returns the chat completion.
 
 **Customizing the Completion**
 
-You can customize the behavior by specifying additional parameters such as the model, maximum number of tokens, and any tools needed for function calls:
+You can customize the behavior by specifying additional parameters such as the model, any tools needed for function calls:
 
 ```ruby
 messages = [
@@ -204,7 +211,7 @@ messages = [
 Spectre.provider_module::Completions.create(
         messages: messages,
         model: "gpt-4",
-        max_tokens: 50
+        openai: { max_tokens: 50 }
 )
 
 ```
@@ -241,7 +248,10 @@ Spectre.provider_module::Completions.create(
 
 This structured format guarantees that the response adheres to the schema you’ve provided, ensuring more predictable and controlled results.
 
-**Using Tools for Function Calling**
+**NOTE:** The JSON schema is different for each provider. OpenAI uses [JSON Schema](https://json-schema.org/overview/what-is-jsonschema.html), where you can specify the name of schema and schema itself. Ollama uses just plain JSON object. 
+But you can provide OpenAI's schema to Ollama as well. We just convert it to Ollama's format.
+
+⚙️ Function Calling (Tool Use)
 
 You can incorporate tools (function calls) in your completion to handle more complex interactions such as fetching external information via API or performing calculations. Define tools using the function call format and include them in the request:
 
@@ -321,7 +331,9 @@ else
 end
 ```
 
-### 6. Creating Dynamic Prompts
+**NOTE:** Completions class also supports different `**args` for different providers. Please refer to the provider-specific documentation for more details.
+
+### 🎭 Dynamic Prompt Rendering
 
 Spectre provides a system for creating dynamic prompts based on templates. You can define reusable prompt templates and render them with different parameters in your Rails app (think Ruby on Rails view partials).
 
@@ -424,7 +436,7 @@ Spectre.provider_module::Completions.create(
 
 ```
 
-## Contributing
+## 📜 Contributing
 
 Bug reports and pull requests are welcome on GitHub at [https://github.com/hiremav/spectre](https://github.com/hiremav/spectre). This project is intended to be a safe, welcoming space for collaboration, and your contributions are greatly appreciated!
 
@@ -434,6 +446,6 @@ Bug reports and pull requests are welcome on GitHub at [https://github.com/hirem
 4. **Push** the branch (`git push origin my-new-feature`).
 5. **Create** a pull request.
 
-## License
+## 📜 License
 
 This gem is available as open source under the terms of the MIT License.

data/lib/generators/spectre/templates/spectre_initializer.rb

@@ -3,8 +3,15 @@
 require 'spectre'
 
 Spectre.setup do |config|
-  # Chose your LLM (openai, cohere, ollama)
-  config.llm_provider = :openai
-  # Set the API key for your chosen LLM
-  config.api_key = ENV.fetch('CHATGPT_API_TOKEN')
+  # Chose your LLM (openai, ollama)
+  config.default_llm_provider = :openai
+
+  config.openai do |openai|
+    openai.api_key = ENV['OPENAI_API_KEY']
+  end
+
+  config.ollama do |ollama|
+    ollama.host = ENV['OLLAMA_HOST']
+    ollama.api_key = ENV['OLLAMA_API_KEY']
+  end
 end

data/lib/spectre/errors.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Spectre
+  # Define custom error classes here
+  class APIKeyNotConfiguredError < StandardError; end
+  class HostNotConfiguredError < StandardError; end
+end

data/lib/spectre/ollama/completions.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module Spectre
+  module Ollama
+    class Completions
+      API_PATH = 'api/chat'
+      DEFAULT_MODEL = 'llama3.1:8b'
+      DEFAULT_TIMEOUT = 60
+
+      # Class method to generate a completion based on user messages and optional tools
+      #
+      # @param messages [Array<Hash>] The conversation messages, each with a role and content
+      # @param model [String] The model to be used for generating completions, defaults to DEFAULT_MODEL
+      # @param json_schema [Hash, nil] An optional JSON schema to enforce structured output
+      # @param tools [Array<Hash>, nil] An optional array of tool definitions for function calling
+      # @param args [Hash, nil] optional arguments like read_timeout and open_timeout. You can pass in the ollama hash to specify the path and options.
+      # @param args.ollama.path [String, nil] The path to the Ollama API endpoint, defaults to API_PATH
+      # @param args.ollama.options [Hash, nil] Additional model parameters listed in the documentation for the https://github.com/ollama/ollama/blob/main/docs/modelfile.md#valid-parameters-and-values such as temperature
+      # @return [Hash] The parsed response including any function calls or content
+      # @raise [HostNotConfiguredError] If the API host is not set in the provider configuration.
+      # @raise [APIKeyNotConfiguredError] If the API key is not set
+      # @raise [RuntimeError] For general API errors or unexpected issues
+      def self.create(messages:, model: DEFAULT_MODEL, json_schema: nil, tools: nil, **args)
+        api_host = Spectre.ollama_configuration.host
+        api_key = Spectre.ollama_configuration.api_key
+        raise HostNotConfiguredError, "Host is not configured" unless api_host
+        raise APIKeyNotConfiguredError, "API key is not configured" unless api_key
+
+        validate_messages!(messages)
+
+        path = args.dig(:ollama, :path) || API_PATH
+        uri = URI.join(api_host, path)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true if uri.scheme == 'https'
+        http.read_timeout = args.fetch(:read_timeout, DEFAULT_TIMEOUT)
+        http.open_timeout = args.fetch(:open_timeout, DEFAULT_TIMEOUT)
+
+        request = Net::HTTP::Post.new(uri.path, {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Bearer #{api_key}"
+        })
+
+        options = args.dig(:ollama, :options)
+        request.body = generate_body(messages, model, json_schema, tools, options).to_json
+        response = http.request(request)
+
+        unless response.is_a?(Net::HTTPSuccess)
+          raise "Ollama API Error: #{response.code} - #{response.message}: #{response.body}"
+        end
+
+        parsed_response = JSON.parse(response.body)
+
+        handle_response(parsed_response)
+      rescue JSON::ParserError => e
+        raise "JSON Parse Error: #{e.message}"
+      end
+
+      private
+
+      # Validate the structure and content of the messages array.
+      #
+      # @param messages [Array<Hash>] The array of message hashes to validate.
+      #
+      # @raise [ArgumentError] if the messages array is not in the expected format or contains invalid data.
+      def self.validate_messages!(messages)
+        # Check if messages is an array of hashes.
+        # This ensures that the input is in the correct format for message processing.
+        unless messages.is_a?(Array) && messages.all? { |msg| msg.is_a?(Hash) }
+          raise ArgumentError, "Messages must be an array of message hashes."
+        end
+
+        # Check if the array is empty.
+        # This prevents requests with no messages, which would be invalid.
+        if messages.empty?
+          raise ArgumentError, "Messages cannot be empty."
+        end
+      end
+
+      # Helper method to generate the request body
+      #
+      # @param messages [Array<Hash>] The conversation messages, each with a role and content
+      # @param model [String] The model to be used for generating completions
+      # @param json_schema [Hash, nil] An optional JSON schema to enforce structured output
+      # @param tools [Array<Hash>, nil] An optional array of tool definitions for function calling
+      # @param options [Hash, nil] Additional model parameters listed in the documentation for the https://github.com/ollama/ollama/blob/main/docs/modelfile.md#valid-parameters-and-values such as temperature
+      # @return [Hash] The body for the API request
+      def self.generate_body(messages, model, json_schema, tools, options)
+        body = {
+          model: model,
+          stream: false,
+          messages: messages
+        }
+
+        # Extract schema if json_schema follows OpenAI's structure
+        if json_schema.is_a?(Hash) && json_schema.key?(:schema)
+          body[:format] = json_schema[:schema] # Use only the "schema" key
+        elsif json_schema.is_a?(Hash)
+          body[:format] = json_schema # Use the schema as-is if it doesn't follow OpenAI's structure
+        end
+
+        body[:tools] = tools if tools # Add the tools to the request body if provided
+        body[:options] = options if options
+
+        body
+      end
+
+      # Handles the API response, raising errors for specific cases and returning structured content otherwise
+      #
+      # @param response [Hash] The parsed API response
+      # @return [Hash] The relevant data based on the finish reason
+      def self.handle_response(response)
+        message = response.dig('message')
+        finish_reason = response.dig('done_reason')
+        done = response.dig('done')
+
+        # Check if the model made a function call
+        if message['tool_calls'] && !message['tool_calls'].empty?
+          return { tool_calls: message['tool_calls'], content: message['content'] }
+        end
+
+        # If the response finished normally, return the content
+        if done
+          return { content: message['content'] }
+        end
+
+        # Handle unexpected finish reasons
+        raise "Unexpected finish_reason: #{finish_reason}, done: #{done}, message: #{message}"
+      end
+    end
+  end
+end

data/lib/spectre/ollama/embeddings.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module Spectre
+  module Ollama
+    class Embeddings
+      API_PATH = 'api/embeddings'
+      DEFAULT_MODEL = 'nomic-embed-text'
+      PARAM_NAME = 'prompt'
+      DEFAULT_TIMEOUT = 60
+
+      # Class method to generate embeddings for a given text
+      #
+      # @param text [String] the text input for which embeddings are to be generated
+      # @param model [String] the model to be used for generating embeddings, defaults to DEFAULT_MODEL
+      # @param args [Hash, nil] optional arguments like read_timeout and open_timeout
+      # @param args.ollama.path [String, nil] the API path, defaults to API_PATH
+      # @param args.ollama.param_name [String, nil] the parameter key for the text input, defaults to PARAM_NAME
+      # @return [Array<Float>] the generated embedding vector
+      # @raise [HostNotConfiguredError] if the host is not set in the configuration
+      # @raise [APIKeyNotConfiguredError] if the API key is not set in the configuration
+      # @raise [RuntimeError] for API errors or invalid responses
+      # @raise [JSON::ParserError] if the response cannot be parsed as JSON
+      def self.create(text, model: DEFAULT_MODEL, **args)
+        api_host = Spectre.ollama_configuration.host
+        api_key = Spectre.ollama_configuration.api_key
+        raise HostNotConfiguredError, "Host is not configured" unless api_host
+        raise APIKeyNotConfiguredError, "API key is not configured" unless api_key
+
+        path = args.dig(:ollama, :path) || API_PATH
+        uri = URI.join(api_host, path)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true if uri.scheme == 'https'
+        http.read_timeout = args.fetch(:read_timeout, DEFAULT_TIMEOUT)
+        http.open_timeout = args.fetch(:open_timeout, DEFAULT_TIMEOUT)
+
+        request = Net::HTTP::Post.new(uri.path, {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Bearer #{api_key}"
+        })
+
+        param_name = args.dig(:ollama, :param_name) || PARAM_NAME
+        request.body = { model: model, param_name => text }.to_json
+        response = http.request(request)
+
+        unless response.is_a?(Net::HTTPSuccess)
+          raise "Ollama API Error: #{response.code} - #{response.message}: #{response.body}"
+        end
+
+        JSON.parse(response.body).dig('embedding')
+      rescue JSON::ParserError => e
+        raise "JSON Parse Error: #{e.message}"
+      end
+    end
+  end
+end

data/lib/spectre/ollama.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Spectre
+  module Ollama
+    # Require each specific client file here
+    require_relative 'ollama/embeddings'
+    require_relative 'ollama/completions'
+  end
+end

data/lib/spectre/openai/completions.rb

@@ -16,14 +16,13 @@ module Spectre
       # @param messages [Array<Hash>] The conversation messages, each with a role and content
       # @param model [String] The model to be used for generating completions, defaults to DEFAULT_MODEL
       # @param json_schema [Hash, nil] An optional JSON schema to enforce structured output
-      # @param max_tokens [Integer] The maximum number of tokens for the completion (default: 50)
       # @param tools [Array<Hash>, nil] An optional array of tool definitions for function calling
-      # @param args [Hash] Optional arguments like timeouts
+      # @param args [Hash, nil] optional arguments like read_timeout and open_timeout. For OpenAI, max_tokens can be passed in the openai hash.
       # @return [Hash] The parsed response including any function calls or content
       # @raise [APIKeyNotConfiguredError] If the API key is not set
       # @raise [RuntimeError] For general API errors or unexpected issues
-      def self.create(messages:, model: DEFAULT_MODEL, json_schema: nil, max_tokens: nil, tools: nil, **args)
-        api_key = Spectre.api_key
+      def self.create(messages:, model: DEFAULT_MODEL, json_schema: nil, tools: nil, **args)
+        api_key = Spectre.openai_configuration.api_key
         raise APIKeyNotConfiguredError, "API key is not configured" unless api_key
 
         validate_messages!(messages)
@@ -39,6 +38,7 @@ module Spectre
           'Authorization' => "Bearer #{api_key}"
         })
 
+        max_tokens = args.dig(:openai, :max_tokens)
         request.body = generate_body(messages, model, json_schema, max_tokens, tools).to_json
         response = http.request(request)
 

data/lib/spectre/openai/embeddings.rb

@@ -15,12 +15,12 @@ module Spectre
       #
       # @param text [String] the text input for which embeddings are to be generated
       # @param model [String] the model to be used for generating embeddings, defaults to DEFAULT_MODEL
-      # # @param args [Hash] Optional arguments like timeouts
+      # @param args [Hash] optional arguments like read_timeout and open_timeout
       # @return [Array<Float>] the generated embedding vector
       # @raise [APIKeyNotConfiguredError] if the API key is not set
       # @raise [RuntimeError] for general API errors or unexpected issues
       def self.create(text, model: DEFAULT_MODEL, **args)
-        api_key = Spectre.api_key
+        api_key = Spectre.openai_configuration.api_key
         raise APIKeyNotConfiguredError, "API key is not configured" unless api_key
 
         uri = URI(API_URL)

data/lib/spectre/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Spectre # :nodoc:all
-  VERSION = "1.1.4"
+  VERSION = "1.2.0"
 end

data/lib/spectre.rb

@@ -4,16 +4,16 @@ require "spectre/version"
 require "spectre/embeddable"
 require 'spectre/searchable'
 require "spectre/openai"
+require "spectre/ollama"
 require "spectre/logging"
 require 'spectre/prompt'
+require 'spectre/errors'
 
 module Spectre
-  class APIKeyNotConfiguredError < StandardError; end
-
   VALID_LLM_PROVIDERS = {
     openai: Spectre::Openai,
+    ollama: Spectre::Ollama
     # cohere: Spectre::Cohere,
-    # ollama: Spectre::Ollama
   }.freeze
 
   def self.included(base)
@@ -35,25 +35,67 @@ module Spectre
     end
   end
 
+  class Configuration
+    attr_accessor :default_llm_provider, :providers
+
+    def initialize
+      @providers = {}
+    end
+
+    def openai
+      @providers[:openai] ||= OpenaiConfiguration.new
+      yield @providers[:openai] if block_given?
+    end
+
+    def ollama
+      @providers[:ollama] ||= OllamaConfiguration.new
+      yield @providers[:ollama] if block_given?
+    end
+
+    def provider_configuration
+      providers[default_llm_provider] || raise("No configuration found for provider: #{default_llm_provider}")
+    end
+  end
+
+  class OpenaiConfiguration
+    attr_accessor :api_key
+  end
+
+  class OllamaConfiguration
+    attr_accessor :host, :api_key
+  end
+
   class << self
-    attr_accessor :api_key, :llm_provider
+    attr_accessor :config
 
     def setup
-      yield self
+      self.config ||= Configuration.new
+      yield config
       validate_llm_provider!
     end
 
     def provider_module
-      VALID_LLM_PROVIDERS[llm_provider] || raise("LLM provider #{llm_provider} not supported")
+      VALID_LLM_PROVIDERS[config.default_llm_provider] || raise("LLM provider #{config.default_llm_provider} not supported")
+    end
+
+    def provider_configuration
+      config.provider_configuration
+    end
+
+    def openai_configuration
+      config.providers[:openai]
+    end
+
+    def ollama_configuration
+      config.providers[:ollama]
     end
 
     private
 
     def validate_llm_provider!
-      unless VALID_LLM_PROVIDERS.keys.include?(llm_provider)
-        raise ArgumentError, "Invalid llm_provider: #{llm_provider}. Must be one of: #{VALID_LLM_PROVIDERS.keys.join(', ')}"
+      unless VALID_LLM_PROVIDERS.keys.include?(config.default_llm_provider)
+        raise ArgumentError, "Invalid default_llm_provider: #{config.default_llm_provider}. Must be one of: #{VALID_LLM_PROVIDERS.keys.join(', ')}"
       end
     end
-
   end
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: spectre_ai
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 1.2.0
 platform: ruby
 authors:
 - Ilya Klapatok
 - Matthew Black
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-04 00:00:00.000000000 Z
+date: 2025-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-rails
@@ -54,7 +54,11 @@ files:
 - lib/generators/spectre/templates/spectre_initializer.rb
 - lib/spectre.rb
 - lib/spectre/embeddable.rb
+- lib/spectre/errors.rb
 - lib/spectre/logging.rb
+- lib/spectre/ollama.rb
+- lib/spectre/ollama/completions.rb
+- lib/spectre/ollama/embeddings.rb
 - lib/spectre/openai.rb
 - lib/spectre/openai/completions.rb
 - lib/spectre/openai/embeddings.rb
@@ -65,7 +69,7 @@ homepage: https://github.com/hiremav/spectre
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -81,7 +85,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.5.11
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Spectre
 test_files: []