spectre_ai 1.1.3 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6cce97e6ac3ab3cde8536f7d422609ff35756847c562769f21305a68421cb89
-  data.tar.gz: cd092c3a8eef87550999630dc77c66eb8900ff24ed4129eff32f8050cb90a5dd
+  metadata.gz: 68106b39f46d2b4069e560eb8e51dcc64ed005a05d9f062919db94e628c2c5f4
+  data.tar.gz: c35b62f8f973763c2029620a0b4608e0dd15591c991e9a13b91d427e2b5dddd7
 SHA512:
-  metadata.gz: e4b701d7447eabb48a5c82e0d1bcbf5585c68497a49c513a81a0091e409aa84fd44d3c45e39b2b88ff53ef4643c63e047f24e88a705c3358b08be408cd0f9ed1
-  data.tar.gz: 639a433617ffc983cc078d26a22b516d415086c66e5091e42e1c85219f6885efe64daf924431182e1589db073a19bb8ab330c8a71793a0d5f7a95a2a2e722237
+  metadata.gz: 7c4632584286d800799a66a1b5ac2f2c5dbb6a9c35597f6c1256dffa94a9f228c2c0ff5aa1a30170a1aae93d9d26cbad42df55297468b853471a3559aa72c69a
+  data.tar.gz: 998ab9f6d356b9f3f9cc404260ea931c35a4e80abb2b6b5f9da1757fbdbc39365bfc0041c9a9ae934f97c954d66fa9ffc8c75a8d66b4228cf5db3f26972bd2e0

data/CHANGELOG.md

@@ -95,6 +95,7 @@ This version enhances the flexibility and robustness of the Completions class, e
   *	**Example**: If you're using `spectre` inside a gem, the `detect_prompts_path` method will now correctly resolve the prompts path within the gem project root.
   *	If no markers are found, the system falls back to the current working directory (`Dir.pwd`).
 
+
 # Changelog for Version 1.1.3
 
 **Release Date:** [2nd Dec 2024]
@@ -102,4 +103,98 @@ This version enhances the flexibility and robustness of the Completions class, e
 **Fixes:**
 
 * **Removed unnecessary validations in `Completions` class**
-  * Removed redundant validations in the `Completions` class that were causing unnecessary errors in specific edge cases. LLM providers returns a proper errors messages now.
+  * Removed redundant validations in the `Completions` class that were causing unnecessary errors in specific edge cases. LLM providers returns a proper errors messages now.
+
+
+# Changelog for Version 1.1.4
+
+**Release Date:** [5th Dec 2024]
+
+**New Features:**
+
+* Customizable Timeout for API Requests
+* Introduced DEFAULT_TIMEOUT constant (set to 60 seconds) for managing request timeouts across the Completions and Embeddings classes.
+* Added optional arguments (args) to create methods, allowing users to override read_timeout and open_timeout dynamically.
+* This change ensures greater flexibility when dealing with varying network conditions or API response times.
+
+**Example Usage:**
+
+```ruby
+Spectre::Openai::Completions.create(
+  messages: messages,
+  read_timeout: 30,
+  open_timeout: 20
+)
+```
+
+**Key Changes:**
+
+* **Updated Completions class:**
+  * http.read_timeout = args.fetch(:read_timeout, DEFAULT_TIMEOUT)
+  * http.open_timeout = args.fetch(:open_timeout, DEFAULT_TIMEOUT)
+  * Updated Embeddings class with the same timeout handling logic.
+
+**Fixes:**
+
+* 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.
+
+
+# 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

@@ -1,17 +1,19 @@
-# Spectre [![Gem Version](https://badge.fury.io/rb/spectre_ai.svg)](https://badge.fury.io/rb/spectre_ai)
+# <img src='logo.svg' height='120' alt='Spectre Logo' />
+
+[![Gem Version](https://badge.fury.io/rb/spectre_ai.svg)](https://badge.fury.io/rb/spectre_ai)
 
 **Spectre** is a Ruby gem that makes it easy to AI-enable your Ruby on Rails application. Currently, Spectre focuses on helping developers create embeddings, perform vector-based searches, create chat completions, and manage dynamic prompts — ideal for applications that are featuring RAG (Retrieval-Augmented Generation), chatbots and dynamic prompts.
 
 ## 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
 
@@ -35,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
 
@@ -144,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:
@@ -166,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.
 
@@ -180,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 = [
@@ -202,7 +211,7 @@ messages = [
 Spectre.provider_module::Completions.create(
         messages: messages,
         model: "gpt-4",
-        max_tokens: 50
+        openai: { max_tokens: 50 }
 )
 
 ```
@@ -239,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:
 
@@ -319,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).
 
@@ -422,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!
 
@@ -432,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

@@ -9,19 +9,20 @@ module Spectre
     class Completions
       API_URL = 'https://api.openai.com/v1/chat/completions'
       DEFAULT_MODEL = 'gpt-4o-mini'
+      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 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, 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)
-        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)
@@ -29,14 +30,15 @@ module Spectre
         uri = URI(API_URL)
         http = Net::HTTP.new(uri.host, uri.port)
         http.use_ssl = true
-        http.read_timeout = 10 # seconds
-        http.open_timeout = 10 # seconds
+        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}"
         })
 
+        max_tokens = args.dig(:openai, :max_tokens)
         request.body = generate_body(messages, model, json_schema, max_tokens, tools).to_json
         response = http.request(request)
 
@@ -49,8 +51,6 @@ module Spectre
         handle_response(parsed_response)
       rescue JSON::ParserError => e
         raise "JSON Parse Error: #{e.message}"
-      rescue Net::OpenTimeout, Net::ReadTimeout => e
-        raise "Request Timeout: #{e.message}"
       end
 
       private

data/lib/spectre/openai/embeddings.rb

@@ -9,23 +9,25 @@ module Spectre
     class Embeddings
       API_URL = 'https://api.openai.com/v1/embeddings'
       DEFAULT_MODEL = 'text-embedding-3-small'
+      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] 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)
-        api_key = Spectre.api_key
+      def self.create(text, model: DEFAULT_MODEL, **args)
+        api_key = Spectre.openai_configuration.api_key
         raise APIKeyNotConfiguredError, "API key is not configured" unless api_key
 
         uri = URI(API_URL)
         http = Net::HTTP.new(uri.host, uri.port)
         http.use_ssl = true
-        http.read_timeout = 10 # seconds
-        http.open_timeout = 10 # seconds
+        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',
@@ -42,8 +44,6 @@ module Spectre
         JSON.parse(response.body).dig('data', 0, 'embedding')
       rescue JSON::ParserError => e
         raise "JSON Parse Error: #{e.message}"
-      rescue Net::OpenTimeout, Net::ReadTimeout => e
-        raise "Request Timeout: #{e.message}"
       end
     end
   end

data/lib/spectre/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Spectre # :nodoc:all
-  VERSION = "1.1.3"
+  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.3
+  version: 1.2.0
 platform: ruby
 authors:
 - Ilya Klapatok
 - Matthew Black
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-02 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: []