ruby_llm 0.1.0.pre4 → 0.1.0.pre6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33195e0b579713ebc168acdf2d1b6e67e1ee4a0d5db68cacaf1648cd4d1e744e
-  data.tar.gz: ee20d7adaa4f8ef22853894885dc6dfab2e19aab1526fd5022cd7413653e4736
+  metadata.gz: a3f047af8fc43eadb0f4b678f175ec2484c92f954f45bff44373b577e03c1a74
+  data.tar.gz: 6be674b01d98fb2c18c48f51f874de29bb9d21a739b3c2275f873bf133758e47
 SHA512:
-  metadata.gz: bef854e5f925aa246b40ef1f12e4a9cde1c085c97a996ecd4c266810b97f9ac324f6cd19dede1526215e92249cbb9aee7017a512fd309baf834aee06570be6c0
-  data.tar.gz: 3dc20b4b9093cca54bb1d5e033e2270a8e33146c3b3c8dcc85997ca6b01eb9e2b07e95d833938df5ceca561d4a2da75a45473dbc878ce744c93d7816fde82009
+  metadata.gz: 2026bf3da2c7170a98dd5a0ee1d859a468bfa1907a709966195b65316277b2135520b3d51fc0e1e4228e986f5c98aa1ae218c32ec176f8867138cff1da4f755a
+  data.tar.gz: ec25bc364c2bca512facb709481be1d17d9a84cf91625beaed8389e6b9637d2546a075330e2934c47fe569864406ea9bf167330e915bf93ca0b120dc91952538

data/.github/workflows/test.yml

@@ -1,10 +1,13 @@
 name: Test
 
+
+
 on:
   push:
     branches: [ "main" ]
   pull_request:
     branches: [ "main" ]
+  workflow_call:
 
 jobs:
   test:
@@ -28,5 +31,5 @@ jobs:
     # - name: Check code format
     #   run: bundle exec rubocop
 
-    - name: Run tests
-      run: bundle exec rspec
+    # - name: Run tests
+    #   run: bundle exec rspec

data/.overcommit.yml

@@ -8,7 +8,7 @@ PreCommit:
     enabled: true
 
   RSpec:
-    enabled: true
+    enabled: false
     command: ['bundle', 'exec', 'rspec']
     on_warn: fail
 

data/README.md

@@ -1,237 +1,112 @@
 # RubyLLM
 
-The Ruby library for working with Large Language Models (LLMs).
+A delightful Ruby interface to the latest large language models. Stop wrestling with multiple APIs and inconsistent interfaces. RubyLLM gives you a clean, unified way to work with models from OpenAI, Anthropic, and more.
 
 [![Gem Version](https://badge.fury.io/rb/ruby_llm.svg)](https://badge.fury.io/rb/ruby_llm)
 [![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
 
-RubyLLM provides a unified interface for interacting with various LLM providers including OpenAI, Anthropic, and more. It offers both standalone usage and seamless Rails integration.
-
-## Features
-
-- 🤝 Unified interface for multiple LLM providers (OpenAI, Anthropic, etc.)
-- 📋 Comprehensive model listing and capabilities detection
-- 🛠️ Simple and flexible tool/function calling
-- 📊 Automatic token counting and tracking
-- 🔄 Streaming support
-- 🚂 Seamless Rails integration
-
 ## Installation
 
-Add this line to your application's Gemfile:
+Add it to your Gemfile:
 
 ```ruby
 gem 'ruby_llm'
 ```
 
-And then execute:
-```bash
-$ bundle install
-```
-
-Or install it directly:
+Or install it yourself:
 
 ```bash
-$ gem install ruby_llm
+gem install ruby_llm
 ```
 
-## Usage
+## Quick Start
 
-### Basic Setup
+RubyLLM makes it dead simple to start chatting with AI models:
 
 ```ruby
 require 'ruby_llm'
 
+# Configure your API keys
 RubyLLM.configure do |config|
   config.openai_api_key = ENV['OPENAI_API_KEY']
   config.anthropic_api_key = ENV['ANTHROPIC_API_KEY']
-  config.default_model = 'gpt-4o-mini'
+  config.default_model = 'gpt-4o-mini' # OpenAI's efficient model
 end
-```
-
-### Listing Available Models
-
-```ruby
-client = RubyLLM.client
-
-# List models from all providers
-all_models = client.list_models
-
-# List models from a specific provider
-openai_models = client.list_models(:openai)
-anthropic_models = client.list_models(:anthropic)
-
-# Access model information
-model = openai_models.first
-puts model.display_name
-puts "Context window: #{model.context_window}"
-puts "Maximum tokens: #{model.max_tokens}"
-puts "Input price per million tokens: $#{model.input_price_per_million}"
-puts "Output price per million tokens: $#{model.output_price_per_million}"
-puts "Supports vision: #{model.supports_vision}"
-puts "Supports function calling: #{model.supports_functions}"
-puts "Supports JSON mode: #{model.supports_json_mode}"
-```
-
-### Simple Chat
-
-```ruby
-client = RubyLLM.client
-
-response = client.chat([
-  { role: :user, content: "Hello!" }
-])
 
+# Start a conversation
+chat = RubyLLM.chat
+response = chat.ask "What's the best way to learn Ruby?"
 puts response.content
 ```
 
-### Tools (Function Calling)
+## Available Models
 
-RubyLLM supports tools/functions with a simple, flexible interface. You can create tools using blocks or wrap existing methods:
+RubyLLM gives you access to the latest models from multiple providers. Check what's available:
 
 ```ruby
-# Using a block
-calculator = RubyLLM::Tool.new(
-  name: "calculator",
-  description: "Performs mathematical calculations",
-  parameters: {
-    expression: {
-      type: "string",
-      description: "The mathematical expression to evaluate",
-      required: true
-    }
-  }
-) do |args|
-  eval(args[:expression]).to_s
+# List all available models
+RubyLLM.models.all.each do |model|
+  puts "#{model.display_name} (#{model.provider})"
+  puts "  Context window: #{model.context_window}"
+  puts "  Price: $#{model.input_price_per_million}/M tokens (input)"
+  puts "        $#{model.output_price_per_million}/M tokens (output)"
 end
 
-# Using an existing method
-class MathUtils
-  def arithmetic(x, y, operation)
-    case operation
-    when 'add' then x + y
-    when 'subtract' then x - y
-    when 'multiply' then x * y
-    when 'divide' then x.to_f / y
-    else
-      raise ArgumentError, "Unknown operation: #{operation}"
-    end
-  end
-end
-
-math_tool = RubyLLM::Tool.from_method(
-  MathUtils.instance_method(:arithmetic),
-  description: "Performs basic arithmetic operations",
-  parameter_descriptions: {
-    x: "First number in the operation",
-    y: "Second number in the operation",
-    operation: "Operation to perform (add, subtract, multiply, divide)"
-  }
-)
-
-# Use tools in conversations
-response = client.chat([
-  { role: :user, content: "What is 123 * 456?" }
-], tools: [calculator])
-
-puts response.content
+# Get models by type
+chat_models = RubyLLM.models.chat_models
+embedding_models = RubyLLM.models.embedding_models
+audio_models = RubyLLM.models.audio_models
+image_models = RubyLLM.models.image_models
 ```
 
-### Streaming
+## Having a Conversation
 
-```ruby
-client.chat([
-  { role: :user, content: "Count to 10 slowly" }
-], stream: true) do |chunk|
-  print chunk.content
-end
-```
+Conversations are simple and natural, with automatic token counting built right in:
 
-## Rails Integration
-
-RubyLLM provides seamless Rails integration with Active Record models.
+```ruby
+chat = RubyLLM.chat model: 'claude-3-opus-20240229'
 
-### Configuration
+# Single messages with token tracking
+response = chat.ask "What's your favorite Ruby feature?"
+puts "Response used #{response.input_tokens} input tokens and #{response.output_tokens} output tokens"
 
-Create an initializer `config/initializers/ruby_llm.rb`:
+# Multi-turn conversations just work
+chat.ask "Can you elaborate on that?"
+chat.ask "How does that compare to Python?"
 
-```ruby
-RubyLLM.configure do |config|
-  config.openai_api_key = Rails.application.credentials.openai[:api_key]
-  config.anthropic_api_key = Rails.application.credentials.anthropic[:api_key]
-  config.default_model = Rails.env.production? ? 'gpt-4' : 'gpt-3.5-turbo'
+# Stream responses as they come
+chat.ask "Tell me a story about a Ruby programmer" do |chunk|
+  print chunk.content
 end
+
+# Get token usage for the whole conversation from the last message
+last_message = chat.messages.last
+puts "Conversation used #{last_message.input_tokens} input tokens and #{last_message.output_tokens} output tokens"
 ```
 
-### Models
+## Choosing the Right Model
 
-```ruby
-# app/models/llm_model.rb
-class LLMModel < ApplicationRecord
-  acts_as_llm_model
-
-  # Schema:
-  #  t.string :provider
-  #  t.string :name
-  #  t.jsonb :capabilities
-  #  t.integer :context_length
-  #  t.timestamps
-end
-
-# app/models/conversation.rb
-class Conversation < ApplicationRecord
-  acts_as_llm_conversation
-  belongs_to :user
+RubyLLM gives you easy access to model capabilities:
 
-  # Schema:
-  #  t.references :user
-  #  t.string :title
-  #  t.string :current_model
-  #  t.timestamps
-end
+```ruby
+model = RubyLLM.models.find 'claude-3-opus-20240229'
 
-# app/models/message.rb
-class Message < ApplicationRecord
-  acts_as_llm_message
-
-  # Schema:
-  #  t.references :conversation
-  #  t.string :role
-  #  t.text :content
-  #  t.jsonb :tool_calls
-  #  t.jsonb :tool_results
-  #  t.integer :token_count
-  #  t.timestamps
-end
+model.context_window     # => 200000
+model.max_tokens        # => 4096
+model.supports_vision?  # => true
+model.supports_json_mode? # => true
 ```
 
-### Controller Usage
+## Coming Soon
 
-```ruby
-class ConversationsController < ApplicationController
-  def create
-    @conversation = current_user.conversations.create!
-    redirect_to @conversation
-  end
-
-  def send_message
-    @conversation = current_user.conversations.find(params[:id])
-
-    message = @conversation.send_message(
-      params[:content],
-      model: params[:model]
-    )
-
-    render json: message
-  end
-end
-```
+- Rails integration for seamless database and Active Record support
+- Function calling / tool use capabilities
+- Automatic retries and error handling
+- Much more!
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt.
 
 ## Contributing
 
@@ -239,4 +114,4 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/crmne/
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+Released under the MIT License. See LICENSE.txt for details.

data/bin/console

@@ -6,4 +6,10 @@ require 'ruby_llm'
 require 'dotenv/load'
 
 require 'irb'
+
+RubyLLM.configure do |config|
+  config.openai_api_key = ENV['OPENAI_API_KEY']
+  config.anthropic_api_key = ENV['ANTHROPIC_API_KEY']
+end
+
 IRB.start(__FILE__)

data/lib/ruby_llm/chat.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  class Chat
+    include Enumerable
+
+    attr_reader :model, :messages, :tools
+
+    def initialize(model: nil)
+      model_id = model || RubyLLM.config.default_model
+      @model = Models.find(model_id)
+      @provider = Models.provider_for(model_id)
+      @messages = []
+      @tools = []
+    end
+
+    def ask(message, &block)
+      add_message role: :user, content: message
+      complete(&block)
+    end
+
+    def tool(tool)
+      raise Error, "Model #{@model.id} doesn't support function calling" unless @model.supports_functions
+
+      @tools << tool
+      self
+    end
+
+    alias with_tool tool
+
+    def tools(*tools)
+      tools.each { |tool| self.tool(tool) }
+      self
+    end
+
+    alias with_tools tools
+
+    def each(&block)
+      messages.each(&block)
+    end
+
+    private
+
+    def complete(&block)
+      response = @provider.complete(messages, tools: @tools, model: @model.id, &block)
+
+      if response.tool_call?
+        handle_tool_calls(response)
+      else
+        add_message(response)
+      end
+
+      response
+    end
+
+    def handle_tool_calls(response)
+      add_message(response)
+
+      response.tool_calls.each do |tool_call|
+        result = execute_tool(tool_call)
+        add_tool_result(tool_call[:id], result) if result
+      end
+
+      # Get final response after tool calls
+      final_response = complete
+      add_message(final_response)
+      final_response
+    end
+
+    def execute_tool(tool_call)
+      tool = @tools.find { |t| t.name == tool_call[:name] }
+      return unless tool
+
+      args = JSON.parse(tool_call[:arguments], symbolize_names: true)
+      tool.call(args)
+    end
+
+    def add_message(message_or_attributes)
+      message = message_or_attributes.is_a?(Message) ? message_or_attributes : Message.new(message_or_attributes)
+      messages << message
+      message
+    end
+
+    def add_tool_result(tool_use_id, result)
+      add_message(
+        role: :user,
+        tool_results: {
+          tool_use_id: tool_use_id,
+          content: result.is_a?(Hash) && result[:error] ? result[:error] : result.to_s,
+          is_error: result.is_a?(Hash) && result[:error]
+        }
+      )
+    end
+  end
+end

data/lib/ruby_llm/chunk.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  class Chunk < Message
+  end
+end

data/lib/ruby_llm/configuration.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
 module RubyLLM
-  # Configuration class for RubyLLM settings
   class Configuration
-    attr_accessor :openai_api_key, :anthropic_api_key, :default_provider, :default_model, :request_timeout
+    attr_accessor :openai_api_key, :anthropic_api_key, :default_model, :request_timeout
 
     def initialize
       @request_timeout = 30
-      @default_provider = :openai
-      @default_model = 'gpt-3.5-turbo'
+      @default_model = 'gpt-4o-mini'
     end
 
     def provider_settings

data/lib/ruby_llm/message.rb

@@ -2,18 +2,28 @@
 
 module RubyLLM
   class Message
-    VALID_ROLES = %i[system user assistant tool].freeze
-
-    attr_reader :role, :content, :tool_calls, :tool_results, :token_usage, :model_id
-
-    def initialize(role:, content: nil, tool_calls: nil, tool_results: nil, token_usage: nil, model_id: nil)
-      @role = role.to_sym
-      @content = content
-      @tool_calls = tool_calls
-      @tool_results = tool_results
-      @token_usage = token_usage
-      @model_id = model_id
-      validate!
+    ROLES = %i[system user assistant tool].freeze
+
+    attr_reader :role, :content, :tool_calls, :tool_results, :input_tokens, :output_tokens, :model_id
+
+    def initialize(options = {})
+      @role = options[:role].to_sym
+      @content = options[:content]
+      @tool_calls = options[:tool_calls]
+      @tool_results = options[:tool_results]
+      @input_tokens = options[:input_tokens]
+      @output_tokens = options[:output_tokens]
+      @model_id = options[:model_id]
+
+      ensure_valid_role
+    end
+
+    def tool_call?
+      !tool_calls.nil? && !tool_calls.empty?
+    end
+
+    def tool_result?
+      !tool_results.nil? && !tool_results.empty?
     end
 
     def to_h
@@ -22,18 +32,16 @@ module RubyLLM
         content: content,
         tool_calls: tool_calls,
         tool_results: tool_results,
-        token_usage: token_usage,
+        input_tokens: input_tokens,
+        output_tokens: output_tokens,
         model_id: model_id
       }.compact
     end
 
     private
 
-    def validate!
-      return if VALID_ROLES.include?(role)
-
-      raise ArgumentError,
-            "Invalid role: #{role}. Must be one of: #{VALID_ROLES.join(', ')}"
+    def ensure_valid_role
+      raise Error, "Expected role to be one of: #{ROLES.join(', ')}" unless ROLES.include?(role)
     end
   end
 end

data/lib/ruby_llm/model_capabilities/anthropic.rb

@@ -2,71 +2,36 @@
 
 module RubyLLM
   module ModelCapabilities
-    class Anthropic < Base
+    module Anthropic
+      extend self
+
       def determine_context_window(model_id)
         case model_id
-        when /claude-3-5-sonnet/, /claude-3-5-haiku/,
-             /claude-3-opus/, /claude-3-sonnet/, /claude-3-haiku/
-          200_000
-        else
-          100_000
+        when /claude-3/ then 200_000
+        else 100_000
         end
       end
 
       def determine_max_tokens(model_id)
         case model_id
-        when /claude-3-5-sonnet/, /claude-3-5-haiku/
-          8_192
-        when /claude-3-opus/, /claude-3-sonnet/, /claude-3-haiku/
-          4_096
-        else
-          4_096
+        when /claude-3-5/ then 8_192
+        else 4_096
         end
       end
 
       def get_input_price(model_id)
-        case model_id
-        when /claude-3-5-sonnet/
-          3.0     # $3.00 per million tokens
-        when /claude-3-5-haiku/
-          0.80    # $0.80 per million tokens
-        when /claude-3-opus/
-          15.0    # $15.00 per million tokens
-        when /claude-3-sonnet/
-          3.0     # $3.00 per million tokens
-        when /claude-3-haiku/
-          0.25    # $0.25 per million tokens
-        else
-          3.0
-        end
+        PRICES.dig(model_family(model_id), :input) || default_input_price
       end
 
       def get_output_price(model_id)
-        case model_id
-        when /claude-3-5-sonnet/
-          15.0    # $15.00 per million tokens
-        when /claude-3-5-haiku/
-          4.0     # $4.00 per million tokens
-        when /claude-3-opus/
-          75.0    # $75.00 per million tokens
-        when /claude-3-sonnet/
-          15.0    # $15.00 per million tokens
-        when /claude-3-haiku/
-          1.25    # $1.25 per million tokens
-        else
-          15.0
-        end
+        PRICES.dig(model_family(model_id), :output) || default_output_price
       end
 
       def supports_vision?(model_id)
-        case model_id
-        when /claude-3-5-haiku/
-          false
-        when /claude-2/, /claude-1/
-          false
-        else
-          true
-        end
+        return false if model_id.match?(/claude-3-5-haiku/)
+        return false if model_id.match?(/claude-[12]/)
+
+        true
       end
 
       def supports_functions?(model_id)
@@ -76,6 +41,36 @@ module RubyLLM
       def supports_json_mode?(model_id)
         model_id.include?('claude-3')
       end
+
+      private
+
+      def model_family(model_id)
+        case model_id
+        when /claude-3-5-sonnet/  then :claude35_sonnet
+        when /claude-3-5-haiku/   then :claude35_haiku
+        when /claude-3-opus/      then :claude3_opus
+        when /claude-3-sonnet/    then :claude3_sonnet
+        when /claude-3-haiku/     then :claude3_haiku
+        else :claude2
+        end
+      end
+
+      PRICES = {
+        claude35_sonnet: { input: 3.0, output: 15.0 }, # $3.00/$15.00 per million tokens
+        claude35_haiku: { input: 0.80, output: 4.0 }, # $0.80/$4.00 per million tokens
+        claude3_opus: { input: 15.0, output: 75.0 }, # $15.00/$75.00 per million tokens
+        claude3_sonnet: { input: 3.0, output: 15.0 }, # $3.00/$15.00 per million tokens
+        claude3_haiku: { input: 0.25, output: 1.25 }, # $0.25/$1.25 per million tokens
+        claude2: { input: 3.0,  output: 15.0 } # Default pricing for Claude 2.x models
+      }.freeze
+
+      def default_input_price
+        3.0
+      end
+
+      def default_output_price
+        15.0
+      end
     end
   end
 end