Add Ollama as a supported provider

bin/console

@@ -17,6 +17,7 @@ RubyLLM.configure do |config|
   config.bedrock_secret_key = ENV.fetch('AWS_SECRET_ACCESS_KEY', nil)
   config.bedrock_region = ENV.fetch('AWS_REGION', nil)
   config.bedrock_session_token = ENV.fetch('AWS_SESSION_TOKEN', nil)
+  config.ollama_api_base_url = ENV.fetch('OLLAMA_API_BASE_URL', nil)
 end
 
 IRB.start(__FILE__)

docs/guides/getting-started.md

@@ -132,4 +132,4 @@ You've seen the basics! Now you're ready to explore RubyLLM's features in more d
 *   [Using Tools]({% link guides/tools.md %}) (Letting AI call your code)
 *   [Streaming Responses]({% link guides/streaming.md %})
 *   [Rails Integration]({% link guides/rails.md %})
-*   [Error Handling]({% link guides/error-handling.md %})
+*   [Error Handling]({% link guides/error-handling.md %})

docs/installation.md

@@ -71,7 +71,6 @@ require 'ruby_llm'
 RubyLLM.configure do |config|
   # Set keys for the providers you need. Using environment variables is best practice.
   config.openai_api_key = ENV.fetch('OPENAI_API_KEY', nil)
-  # Add other keys like config.anthropic_api_key if needed
 end
 ```
 
@@ -112,4 +111,4 @@ Now that you've installed RubyLLM:
 
 *   Read the **[Configuration Guide]({% link configuration.md %})** for all setup options.
 *   Check out the **[Getting Started Guide]({% link guides/getting-started.md %})** for basic usage examples.
-*   Explore other **[Guides]({% link guides/index.md %})** for specific features like Chat, Tools, Embeddings, etc.
+*   Explore other **[Guides]({% link guides/index.md %})** for specific features like Chat, Tools, Embeddings, etc.

lib/ruby_llm.rb

@@ -17,7 +17,8 @@
   'api' => 'API',
   'deepseek' => 'DeepSeek',
   'bedrock' => 'Bedrock',
-  'openrouter' => 'OpenRouter'
+  'openrouter' => 'OpenRouter',
+  'ollama' => 'Ollama'
 )
 loader.ignore("#{__dir__}/tasks")
 loader.ignore("#{__dir__}/ruby_llm/railtie")
@@ -79,6 +80,7 @@ def logger
 RubyLLM::Provider.register :anthropic, RubyLLM::Providers::Anthropic
 RubyLLM::Provider.register :gemini, RubyLLM::Providers::Gemini
 RubyLLM::Provider.register :deepseek, RubyLLM::Providers::DeepSeek
+RubyLLM::Provider.register :ollama, RubyLLM::Providers::Ollama
 RubyLLM::Provider.register :bedrock, RubyLLM::Providers::Bedrock
 RubyLLM::Provider.register :openrouter, RubyLLM::Providers::OpenRouter
 

lib/ruby_llm/configuration.rb

@@ -16,6 +16,7 @@ class Configuration
                   :anthropic_api_key,
                   :gemini_api_key,
                   :deepseek_api_key,
+                  :ollama_api_base_url,
                   :bedrock_api_key,
                   :bedrock_secret_key,
                   :bedrock_region,

lib/ruby_llm/providers/ollama.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # Native Ollama API implementation
+    module Ollama
+      extend Provider
+      extend Ollama::Chat
+      extend Ollama::Embeddings
+      extend Ollama::Models
+      extend Ollama::Streaming
+      extend Ollama::Media
+      extend Ollama::Tools
+
+      module_function
+
+      def api_base(config)
+        # no default since this is the only configuration for this provider,
+        # so it must be provided deliberately
+        config.ollama_api_base_url
+      end
+
+      def headers(_config)
+        {}
+      end
+
+      def capabilities
+        Ollama::Capabilities
+      end
+
+      def slug
+        'ollama'
+      end
+
+      def configuration_requirements
+        %i[ollama_api_base_url]
+      end
+
+      def parse_error(response)
+        return if response.body.empty?
+
+        body = try_parse_json(response.body)
+        body['error']
+      end
+    end
+  end
+end

lib/ruby_llm/providers/ollama/capabilities.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Ollama
+      # Determines capabilities for Ollama
+      module Capabilities
+        module_function
+
+        # FIXME: none of these facts are available from the Ollama server,
+        # or from the Ollama library (https://ollama.com/library) in a structured way.
+
+        # Returns the context window size (input token limit) for the given model
+        # @param model_id [String] the model identifier
+        # @return [Integer] the context window size in tokens
+        def context_window_for(_model_id)
+          # FIXME: placeholder
+          4_192 # Sensible (and conservative) default for unknown models
+        end
+
+        # Returns the maximum output tokens for the given model
+        # @param model_id [String] the model identifier
+        # @return [Integer] the maximum output tokens
+        def max_tokens_for(_model_id)
+          # FIXME: placeholder
+          32_768
+        end
+
+        # Determines if the model supports vision (image/video) inputs
+        # @param model_id [String] the model identifier
+        # @return [Boolean] true if the model supports vision inputs
+        def supports_vision?(_model_id)
+          # FIXME: placeholder
+          false
+        end
+
+        # Determines if the model supports function calling
+        # @param model_id [String] the model identifier
+        # @return [Boolean] true if the model supports function calling
+        def supports_functions?(_model_id)
+          # FIXME: placeholder
+          true
+        end
+
+        # Determines if the model supports JSON mode
+        # @param model_id [String] the model identifier
+        # @return [Boolean] true if the model supports JSON mode
+        def supports_json_mode?(_model_id)
+          # FIXME: placeholder
+          false
+        end
+
+        # Returns the type of model (chat, embedding, image)
+        # @param model_id [String] the model identifier
+        # @return [String] the model type
+        def model_type(_model_id)
+          # FIXME: placeholder
+          'chat'
+        end
+      end
+    end
+  end
+end

lib/ruby_llm/providers/ollama/chat.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Ollama
+      # Chat methods for the Ollama API implementation
+      module Chat
+        module_function
+
+        def completion_url
+          'api/chat'
+        end
+
+        def render_payload(messages, tools:, temperature:, model:, stream: false)
+          {
+            model: model,
+            messages: Media.format_messages(messages),
+            options: {
+              temperature: temperature
+            },
+            stream: stream
+          }.tap { |h| h.merge!(tools: tools.map { |_, t| tool_for(t) }) if tools.any? }
+        end
+
+        def parse_completion_response(response)
+          data = Tools.preprocess_tool_calls(response.body)
+
+          Message.new(
+            role: :assistant,
+            content: data.dig('message', 'content'),
+            model_id: data['model'],
+            input_tokens: data['prompt_eval_count'].to_i,
+            output_tokens: data['eval_count'].to_i,
+            tool_calls: parse_tool_calls(data.dig('message', 'tool_calls'))
+          )
+        end
+      end
+    end
+  end
+end

lib/ruby_llm/providers/ollama/embeddings.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Ollama
+      # Embeddings methods for the Ollama API integration
+      module Embeddings
+        module_function
+
+        def embedding_url
+          'api/embed'
+        end
+
+        def render_embedding_payload(text, model:)
+          {
+            model: model,
+            input: format_text_for_embedding(text)
+          }
+        end
+
+        def parse_embedding_response(response)
+          vectors = response.body['embeddings']
+          model_id = response.body['model']
+          input_tokens = response.body['prompt_eval_count'] || 0
+          vectors = vectors.first if vectors.size == 1
+
+          Embedding.new(
+            vectors: vectors,
+            model: model_id,
+            # only available when passing a single string input
+            input_tokens: input_tokens
+          )
+        end
+
+        private
+
+        def format_text_for_embedding(text)
+          # Ollama supports either a string or a string array here
+          unless text.is_a?(Array) || text.is_a?(String)
+            raise NotImplementedException, "unsupported argument for Ollama embedding: #{text.class}"
+          end
+
+          text
+        end
+      end
+    end
+  end
+end

lib/ruby_llm/providers/ollama/media.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Ollama
+      # Handles formatting of text or media content for Ollama
+      module Media
+        module_function
+
+        def format_messages(messages)
+          messages.map do |msg|
+            text, images = separate_by_type(msg)
+
+            {
+              role: msg.role.to_s,
+              content: text
+            }.tap { |h| h.merge!(images: images) if images.any? }
+          end
+        end
+
+        def separate_by_type(msg) # rubocop:disable Metrics/MethodLength
+          text = nil
+          images = []
+
+          if msg.content.is_a?(Array)
+            msg.content.each do |part|
+              case part[:type]
+              when 'text'
+                text = part[:text]
+              when 'image'
+                images << part[:source][:data]
+              end
+            end
+          else
+            text = msg.content
+          end
+
+          [text, images]
+        end
+      end
+    end
+  end
+end

lib/ruby_llm/providers/ollama/models.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Ollama
+      # Models methods for the Ollama API integration
+      module Models
+        # Methods needed by Provider - must be public
+        def models_url
+          'api/tags'
+        end
+
+        # FIXME: include aliases for tags with the format \d+m or \d+b
+        # ie. given these models in the server,
+        # - gemma3:27b
+        # - gemma3:9b
+        #
+        # create an alias gemma3 for gemma3:27b
+
+        # NOTE: Unlike other providers for well known APIs with stable model
+        # offerings, the Ollama provider deals with local servers which
+        # might have arbitrarily named models or even zero models installed.
+        #
+        # Thus, this provider can't ship hardcoded assumptions in models.json
+        # and thus no Ollama models will be known at runtime, so you'll need a
+        # `RubyLLM.models.refresh!` to populate your instance's models.
+
+        def list_models(connection:)
+          config = connection.config
+          response = connection.get('api/tags') do |req|
+            req.headers.merge!(headers(config))
+          end
+
+          parse_list_models_response(response, slug, capabilities)
+        end
+
+        private
+
+        def parse_list_models_response(response, slug, capabilities) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+          (response.body['models'] || []).map do |model|
+            model_id = model['name']
+
+            ModelInfo.new(
+              id: model_id,
+              # NOTE: this is date pulled into the Ollama server, not date of introduction of a model
+              created_at: model['modified_at'],
+              display_name: model_id,
+              provider: slug,
+              type: capabilities.model_type(model_id),
+              family: model['family'],
+              context_window: capabilities.context_window_for(model_id),
+              max_tokens: capabilities.max_tokens_for(model_id),
+              supports_vision: capabilities.supports_vision?(model_id),
+              supports_functions: capabilities.supports_functions?(model_id),
+              supports_json_mode: capabilities.supports_json_mode?(model_id),
+              input_price_per_million: 0.0,
+              output_price_per_million: 0.0,
+              metadata: {
+                byte_size: model['size']&.to_i,
+                parameter_size: model.dig('details', 'parameter_size'),
+                quantization_level: model.dig('details', 'quantization_level'),
+                format: model.dig('details', 'format'),
+                parent_model: model.dig('details', 'parent_model')
+              }
+            )
+          end
+        end
+      end
+    end
+  end
+end