rubycanusellm 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb98a91b1d857f47d5ed3905d0fc520175297366268125d382fe928a91a993a3
-  data.tar.gz: '0284438324a2fc028176c0405a3af011a0457617ca930abc7cbcc4012f204fa1'
+  metadata.gz: 95279ea6440be4ca1db0588578072aeec9ceb7ed60b3491a9a8a7e2e9f1cd354
+  data.tar.gz: d584565619149e8e23a50997345da518c65d1646daee38b5dafecabd76b467cd
 SHA512:
-  metadata.gz: 9b7d8455fca4b21d60597e8d49a765a5a210d6c314b855cceb9ca21c46924555ea2841a7bda802fb55cdfd7ad49721d9a49d2a67edafd37f8427da98ba1fe522
-  data.tar.gz: d7c5818f91bc9a7973b20df9a465deaa4c4878e59e48c0859ef18bc4f0a5c6e4e261ac96458d9a05af90a901cf2b6614fb2fe4588339e1598c6a9e9b403aad11
+  metadata.gz: f390e611e876ebbe93e4f9a80a2f48126156d620477489fb4de1786db739bfddbc029bbcd3ddfcfc3f06947956ffbec2d942a3dc10430ada08c6a8c754f92673
+  data.tar.gz: 95b04a2d9c73571ed57c97ad8f2b752866329ff9f8914eb8324e0b1eeb3000ca963a56b4e31206f7fbec17b5f5ba56874380e98ecc658f4ab43efd3b1f215c0d

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [0.4.0] - 2026-04-03
+
+### Added
+
+- Mistral provider (chat + embeddings)
+- Ollama provider (chat + embeddings, local, no API key required)
+- `config.base_url` for pointing to custom Ollama instances
+- Mistral and Ollama added to `EMBEDDING_PROVIDERS`
+
 ## [0.3.1] - 2026-04-03
 
 ### Added

data/README.md

@@ -67,6 +67,8 @@ That's it. Same code, different provider.
 |----------|--------|--------|-------|
 | OpenAI | gpt-4o-mini, gpt-4o, etc. | ✅ | Chat + Embeddings |
 | Anthropic | claude-sonnet-4-20250514, etc. | ✅ | Chat only |
+| Mistral | mistral-small-latest, mistral-large-latest, etc. | ✅ | Chat + Embeddings |
+| Ollama | llama3.2, mistral, etc. | ✅ | Chat + Embeddings (local) |
 | Voyage AI | voyage-3.5, voyage-4, etc. | ✅ | Embeddings only |
 
 ## API Reference
@@ -74,15 +76,24 @@ That's it. Same code, different provider.
 ### Configuration
 ```ruby
 RubyCanUseLLM.configure do |config|
-  config.provider = :openai          # :openai or :anthropic
-  config.api_key = "your-key"        # required
+  config.provider = :openai          # :openai, :anthropic, :mistral, or :ollama
+  config.api_key = "your-key"        # required (not needed for Ollama)
   config.model = "gpt-4o-mini"       # optional, has sensible defaults
   config.timeout = 30                # optional, default 30s
+  config.base_url = "http://localhost:11434"  # optional, for Ollama (default shown)
   config.embedding_provider = :voyage  # optional, for separate embedding provider
   config.embedding_api_key = "key"     # required when embedding_provider is set
 end
 ```
 
+**Ollama (local, no API key needed):**
+```ruby
+RubyCanUseLLM.configure do |config|
+  config.provider = :ollama
+  # config.base_url = "http://localhost:11434"  # default, change if needed
+end
+```
+
 ### Chat
 ```ruby
 response = RubyCanUseLLM.chat(messages, **options)
@@ -109,7 +120,7 @@ RubyCanUseLLM.chat(messages, stream: true) do |chunk|
 end
 ```
 
-Each `chunk` is a `RubyCanUseLLM::Chunk` with `content` (the token text) and `role` (`"assistant"`). Works with both OpenAI and Anthropic.
+Each `chunk` is a `RubyCanUseLLM::Chunk` with `content` (the token text) and `role` (`"assistant"`). Works with OpenAI, Anthropic, Mistral, and Ollama.
 
 ### Response
 ```ruby
@@ -205,8 +216,9 @@ end
 - [x] Streaming support
 - [x] Embeddings + configurable embedding provider
 - [x] Voyage AI provider (embeddings)
+- [x] Mistral provider (chat + embeddings)
+- [x] Ollama provider (chat + embeddings, local)
 - [ ] `generate:embedding` command
-- [ ] Mistral and Ollama providers
 - [ ] Tool calling
 
 ## Development

data/lib/rubycanusellm/configuration.rb

@@ -2,10 +2,10 @@
 
 module RubyCanUseLLM
   class Configuration
-    SUPPORTED_PROVIDERS = %i[openai anthropic voyage].freeze
-    EMBEDDING_PROVIDERS = %i[openai voyage].freeze
+    SUPPORTED_PROVIDERS = %i[openai anthropic voyage mistral ollama].freeze
+    EMBEDDING_PROVIDERS = %i[openai voyage mistral ollama].freeze
 
-    attr_accessor :provider, :api_key, :model, :timeout, :embedding_provider, :embedding_api_key
+    attr_accessor :provider, :api_key, :model, :timeout, :embedding_provider, :embedding_api_key, :base_url
 
     def initialize
       @provider = nil
@@ -14,11 +14,14 @@ module RubyCanUseLLM
       @timeout = 30
       @embedding_provider = nil
       @embedding_api_key = nil
+      @base_url = nil
     end
 
     def validate!
-      raise Error, "provider is required. Use :openai or :anthropic" if provider.nil?
-      raise Error, "api_key is required" if api_key.nil? || api_key.empty?
+      raise Error, "provider is required. Use :openai, :anthropic, :mistral, or :ollama" if provider.nil?
+      unless provider == :ollama
+        raise Error, "api_key is required" if api_key.nil? || api_key.empty?
+      end
       raise Error, "Unknown provider: #{provider}. Supported: #{SUPPORTED_PROVIDERS.join(", ")}" unless SUPPORTED_PROVIDERS.include?(provider)
     end
 

data/lib/rubycanusellm/providers/mistral.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module RubyCanUseLLM
+  module Providers
+    class Mistral < Base
+      CHAT_URL = "https://api.mistral.ai/v1/chat/completions"
+      EMBED_URL = "https://api.mistral.ai/v1/embeddings"
+
+      def chat(messages, **options, &block)
+        if options[:stream] && block
+          body = build_body(messages, options.except(:stream)).merge(stream: true)
+          stream_request(body, &block)
+        else
+          body = build_body(messages, options)
+          response = request(body)
+          parse_response(response)
+        end
+      end
+
+      def embed(text, **options)
+        body = {
+          model: options[:model] || "mistral-embed",
+          input: text
+        }
+        response = embedding_request(body)
+        parse_embedding(response)
+      end
+
+      private
+
+      def build_body(messages, options)
+        {
+          model: options[:model] || config.model || "mistral-small-latest",
+          messages: format_messages(messages),
+          temperature: options[:temperature] || 0.7
+        }
+      end
+
+      def format_messages(messages)
+        messages.map do |msg|
+          { role: msg[:role].to_s, content: msg[:content] }
+        end
+      end
+
+      def request(body)
+        uri = URI(CHAT_URL)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.read_timeout = config.timeout
+
+        req = Net::HTTP::Post.new(uri)
+        req["Authorization"] = "Bearer #{config.api_key}"
+        req["Content-Type"] = "application/json"
+        req.body = body.to_json
+
+        handle_response(http.request(req))
+      rescue Net::ReadTimeout, Net::OpenTimeout
+        raise TimeoutError, "Request to Mistral timed out after #{config.timeout}s"
+      end
+
+      def stream_request(body, &block)
+        uri = URI(CHAT_URL)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.read_timeout = config.timeout
+
+        req = Net::HTTP::Post.new(uri)
+        req["Authorization"] = "Bearer #{config.api_key}"
+        req["Content-Type"] = "application/json"
+        req["Accept-Encoding"] = "identity"
+        req.body = body.to_json
+
+        http.request(req) do |response|
+          case response.code.to_i
+          when 401 then raise AuthenticationError, "Invalid Mistral API key"
+          when 429 then raise RateLimitError, "Mistral rate limit exceeded"
+          end
+          raise ProviderError, "Mistral error (#{response.code})" unless response.code.to_i == 200
+
+          buffer = ""
+          response.read_body do |raw_chunk|
+            buffer += raw_chunk
+            lines = buffer.split("\n", -1)
+            buffer = lines.pop || ""
+            lines.each do |line|
+              line.chomp!
+              next unless line.start_with?("data: ")
+
+              data = line[6..]
+              next if data == "[DONE]"
+
+              parsed = JSON.parse(data)
+              content = parsed.dig("choices", 0, "delta", "content")
+              block.call(Chunk.new(content: content)) if content && !content.empty?
+            end
+          end
+        end
+      rescue Net::ReadTimeout, Net::OpenTimeout
+        raise TimeoutError, "Request to Mistral timed out after #{config.timeout}s"
+      end
+
+      def handle_response(response)
+        case response.code.to_i
+        when 200
+          JSON.parse(response.body)
+        when 401
+          raise AuthenticationError, "Invalid Mistral API key"
+        when 429
+          raise RateLimitError, "Mistral rate limit exceeded"
+        else
+          raise ProviderError, "Mistral error (#{response.code}): #{response.body}"
+        end
+      end
+
+      def parse_response(data)
+        choice = data.dig("choices", 0, "message")
+        usage = data["usage"]
+
+        Response.new(
+          content: choice["content"],
+          model: data["model"],
+          input_tokens: usage["prompt_tokens"],
+          output_tokens: usage["completion_tokens"],
+          raw: data
+        )
+      end
+
+      def embedding_request(body)
+        uri = URI(EMBED_URL)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.read_timeout = config.timeout
+
+        req = Net::HTTP::Post.new(uri)
+        req["Authorization"] = "Bearer #{config.api_key}"
+        req["Content-Type"] = "application/json"
+        req.body = body.to_json
+
+        handle_response(http.request(req))
+      rescue Net::ReadTimeout, Net::OpenTimeout
+        raise TimeoutError, "Request to Mistral timed out after #{config.timeout}s"
+      end
+
+      def parse_embedding(data)
+        embedding = data.dig("data", 0, "embedding")
+        usage = data["usage"]
+
+        EmbeddingResponse.new(
+          embedding: embedding,
+          model: data["model"],
+          tokens: usage["total_tokens"],
+          raw: data
+        )
+      end
+    end
+  end
+end

data/lib/rubycanusellm/providers/ollama.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module RubyCanUseLLM
+  module Providers
+    class Ollama < Base
+      DEFAULT_BASE_URL = "http://localhost:11434"
+
+      def chat(messages, **options, &block)
+        if options[:stream] && block
+          body = build_body(messages, options.except(:stream)).merge(stream: true)
+          stream_request(body, &block)
+        else
+          body = build_body(messages, options).merge(stream: false)
+          response = request(body)
+          parse_response(response)
+        end
+      end
+
+      def embed(text, **options)
+        body = {
+          model: options[:model] || "nomic-embed-text",
+          input: text
+        }
+        response = embedding_request(body)
+        parse_embedding(response)
+      end
+
+      private
+
+      def base_url
+        config.base_url || DEFAULT_BASE_URL
+      end
+
+      def build_body(messages, options)
+        {
+          model: options[:model] || config.model || "llama3.2",
+          messages: format_messages(messages),
+          temperature: options[:temperature] || 0.7
+        }
+      end
+
+      def format_messages(messages)
+        messages.map do |msg|
+          { role: msg[:role].to_s, content: msg[:content] }
+        end
+      end
+
+      def request(body)
+        uri = URI("#{base_url}/api/chat")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.read_timeout = config.timeout
+
+        req = Net::HTTP::Post.new(uri)
+        req["Content-Type"] = "application/json"
+        req.body = body.to_json
+
+        handle_response(http.request(req))
+      rescue Net::ReadTimeout, Net::OpenTimeout
+        raise TimeoutError, "Request to Ollama timed out after #{config.timeout}s"
+      end
+
+      def stream_request(body, &block)
+        uri = URI("#{base_url}/api/chat")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.read_timeout = config.timeout
+
+        req = Net::HTTP::Post.new(uri)
+        req["Content-Type"] = "application/json"
+        req["Accept-Encoding"] = "identity"
+        req.body = body.to_json
+
+        http.request(req) do |response|
+          raise ProviderError, "Ollama error (#{response.code})" unless response.code.to_i == 200
+
+          response.read_body do |raw_chunk|
+            raw_chunk.split("\n").each do |line|
+              line.strip!
+              next if line.empty?
+
+              parsed = JSON.parse(line)
+              content = parsed.dig("message", "content")
+              block.call(Chunk.new(content: content)) if content && !content.empty? && !parsed["done"]
+            end
+          end
+        end
+      rescue Net::ReadTimeout, Net::OpenTimeout
+        raise TimeoutError, "Request to Ollama timed out after #{config.timeout}s"
+      end
+
+      def handle_response(response)
+        case response.code.to_i
+        when 200
+          JSON.parse(response.body)
+        else
+          raise ProviderError, "Ollama error (#{response.code}): #{response.body}"
+        end
+      end
+
+      def parse_response(data)
+        message = data["message"]
+        Response.new(
+          content: message["content"],
+          model: data["model"],
+          input_tokens: data["prompt_eval_count"] || 0,
+          output_tokens: data["eval_count"] || 0,
+          raw: data
+        )
+      end
+
+      def embedding_request(body)
+        uri = URI("#{base_url}/api/embed")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.read_timeout = config.timeout
+
+        req = Net::HTTP::Post.new(uri)
+        req["Content-Type"] = "application/json"
+        req.body = body.to_json
+
+        handle_response(http.request(req))
+      rescue Net::ReadTimeout, Net::OpenTimeout
+        raise TimeoutError, "Request to Ollama timed out after #{config.timeout}s"
+      end
+
+      def parse_embedding(data)
+        embedding = data.dig("embeddings", 0)
+        EmbeddingResponse.new(
+          embedding: embedding,
+          model: data["model"],
+          tokens: data["prompt_eval_count"] || 0,
+          raw: data
+        )
+      end
+    end
+  end
+end

data/lib/rubycanusellm/templates/config.rb.tt

@@ -1,22 +1,27 @@
 # frozen_string_literal: true
 
 RubyCanUseLLM.configure do |config|
-  # Choose your provider: :openai or :anthropic
+  # Choose your provider: :openai, :anthropic, :mistral, or :ollama
   config.provider = :openai
 
   # Your API key (use environment variables in production)
+  # Not required for Ollama (runs locally)
   config.api_key = ENV["LLM_API_KEY"]
 
   # Default model (optional, each provider has a sensible default)
   # OpenAI: "gpt-4o-mini", Anthropic: "claude-sonnet-4-20250514"
+  # Mistral: "mistral-small-latest", Ollama: "llama3.2"
   # config.model = "gpt-4o-mini"
 
   # Request timeout in seconds (default: 30)
   # config.timeout = 30
 
+  # Ollama base URL (optional, default: http://localhost:11434)
+  # config.base_url = "http://localhost:11434"
+
   # Embedding provider (optional, defaults to main provider)
   # Anthropic doesn't support embeddings natively.
-  # Use :voyage (recommended by Anthropic) or :openai for embeddings.
+  # Use :voyage (recommended by Anthropic), :openai, :mistral, or :ollama for embeddings.
   # config.embedding_provider = :voyage
   # config.embedding_api_key = ENV["VOYAGE_API_KEY"]
 end

data/lib/rubycanusellm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubycanusellm
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/lib/rubycanusellm.rb

@@ -9,13 +9,17 @@ require_relative "rubycanusellm/providers/base"
 require_relative "rubycanusellm/providers/openai"
 require_relative "rubycanusellm/providers/anthropic"
 require_relative "rubycanusellm/providers/voyage"
+require_relative "rubycanusellm/providers/mistral"
+require_relative "rubycanusellm/providers/ollama"
 require_relative "rubycanusellm/embedding_response"
 
 module RubyCanUseLLM
   PROVIDERS = {
     openai: Providers::OpenAI,
     anthropic: Providers::Anthropic,
-    voyage: Providers::Voyage
+    voyage: Providers::Voyage,
+    mistral: Providers::Mistral,
+    ollama: Providers::Ollama
   }.freeze
 
   class << self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubycanusellm
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Juan Manuel Guzman Nava
@@ -35,6 +35,8 @@ files:
 - lib/rubycanusellm/errors.rb
 - lib/rubycanusellm/providers/anthropic.rb
 - lib/rubycanusellm/providers/base.rb
+- lib/rubycanusellm/providers/mistral.rb
+- lib/rubycanusellm/providers/ollama.rb
 - lib/rubycanusellm/providers/openai.rb
 - lib/rubycanusellm/providers/voyage.rb
 - lib/rubycanusellm/response.rb