rach 0.1.0 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f427f0e11f94e869ea14d6d7ed35bd5d73311212fd958daa52b1d8964886fc3
-  data.tar.gz: b0fbf4e2dfcc18c9aa39c6e23b8ebc5edafa62deb125a4b0d25bb0c0eeb5ba4c
+  metadata.gz: 9e0ae465e2ccd6c5f2c56690cd7ee0a7c7fd7dd892df5e08091f678a9c2a9f32
+  data.tar.gz: d9f5054384e3b7d510f7046ff306a99b5a84b1831ca9dbafe1189c750d268b4d
 SHA512:
-  metadata.gz: 0abf7aa58e283fa66cf18b322c9711f250365760b6f77b25d1276e77daf28a0f0640f98050b0bc2ccee38b181735398572e21c95d3f0872a770e6f545ce40cd5
-  data.tar.gz: 2a2553158981ff4f425ada8381c3e61635f302faf5b88c9d952247a60ea126dda4ddc91440dd32324194a94a80d86aad283d0a74bc2a1b3c48066348447f96ae
+  metadata.gz: f34a357311318ab7086b8cdf42e75ad070897bb1b9bfdad8b07394d85e5894a908e58a96ac51774cfe9334e26c29b2d3b7a7b7c7954004b7fedd188a5cb54ace
+  data.tar.gz: 87ae8011f8c9efcfb025d4019e6343764175915b162b68c281be9b528ef05898cbf1c88384dc865ab79be1ec1b88597b81faec288a6196c214d2da9a058317fa

data/README.md

@@ -2,11 +2,191 @@
 
 A lightweight Ruby framework for OpenAI interactions, focusing on simplicity and clean design.
 
+## Installation
 
-## Configuration
+Add this line to your application's Gemfile:
 
-1. Copy the example environment file:
+```ruby
+gem 'rach'
 ```
-cp .env.example .env
+
+And then execute:
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+```bash
+$ gem install rach
+```
+
+## Usage
+
+### Basic Chat
+
+```ruby
+require 'rach'
+client = Rach::Client.new(access_token: YOUR_OPENAI_API_KEY, model: "gpt-4o")
+response = client.chat("Hello, how are you?")
+puts response.content
+# => "Hello! I'm just a computer program, so I don't have feelings, but I'm here and ready to help you. How can I assist you today?"
 ```
-2. Set your OpenAI API key in the `.env` file.
+
+### Conversations
+
+Rach supports stateful conversations with memory:
+
+```ruby
+require 'rach'
+
+client = Rach::Client.new(access_token: YOUR_OPENAI_API_KEY, model: "gpt-4o")
+convo = Rach::Conversation.new
+convo.system "You teach the German language."
+convo.user "Translate: There are two birds singing outside my window."
+
+response = client.chat(convo)
+response.content
+# => "Es gibt zwei Vögel, die draußen vor meinem Fenster singen."
+
+# Continue the conversation...
+convo.add_response(response)
+convo.user "What are the verbs in your translation?"
+response = client.chat(convo)
+response.content
+# => "The verbs in the translation \"Es gibt zwei Vögel, die vor meinem Fenster singen\" are \"gibt\" and \"singen.\""
+
+# Remove the last message from the conversation history and continue
+convo.pop
+convo.user "Explain the structure of your translation."
+response = client.chat(convo)
+response.content
+# => "Your last message to me was: \"Translate: There are two birds singing outside my window.\""
+```
+
+### Response Formatting
+
+Define structured response schemas for type-safe AI responses:
+
+```ruby
+class GermanTranslatorSchema
+  include Rach::ResponseFormat
+
+  def explain_structure
+    object do
+      array :structure_explanation do
+        items type: :string
+        description "A step by step explanation of the structure of the translation."
+      end
+      string :final_translation
+    end
+  end
+end
+
+response = client.chat(convo, response_format: GermanTranslatorSchema.render(:explain_structure))
+JSON.load(response.content)
+# => {"structure_explanation"=> ["The phrase starts with 'Es gibt' which translates to 'There are'. 'Es' is a pronoun that means 'it', and 'gibt' is the third person singular form of the verb 'geben' (to give), meaning 'there are' in this context.", "'zwei Vögel' means 'two birds'. 'zwei' is the number 'two' and 'Vögel' is the plural form of 'Vogel' (bird).", "The relative clause 'die draußen vor meinem Fenster singen' describes the birds. 'die' is a relative pronoun meaning 'that' or 'which',' 'draußen' means 'outside', and 'vor meinem Fenster' means 'in front of my window'.", "'singen' is the infinitive form of the verb 'sing' (to sing). It tells us what the birds are doing."], "final_translation"=>"Es gibt zwei Vögel, die draußen vor meinem Fenster singen."}
+```
+
+### Function Calling / Tools
+
+Rach supports OpenAI's function calling feature:
+
+```ruby
+class GetWeather
+  include Rach::Function
+
+  def function_name
+    "get_current_weather"
+  end
+
+  def function_description
+    "Get the current weather in a given location"
+  end
+
+  def schema
+    object do
+      string :location, description: "The city and state, e.g. San Francisco, CA"
+      string :unit, enum: %w[celsius fahrenheit]
+    end
+  end
+
+  def execute(location:, unit: "fahrenheit")
+    # Implementation of weather fetching logic
+    "The weather in #{location} is nice 🌞 #{unit}"
+  end
+end
+
+response = client.chat("What is the weather in San Francisco?", tools: [GetWeather.function_schema])
+response.tool_calls
+# => [{"id"=>"call_8v3MuUICwn0AjPRy1wZMCXtf",
+#   "type"=>"function",
+#   "function"=>{"name"=>"get_current_weather", "arguments"=>"{\"location\":\"San Francisco, CA\",\"unit\":\"celsius\"}"}}]
+```
+
+### Multiple Providers
+
+Rach supports using multiple providers in your application. You can configure different providers and their parameters when creating a client:
+
+```ruby
+client = Rach::Client.new(
+  providers: {
+    openai: {
+      access_token: YOUR_OPENAI_API_KEY
+    },
+    anthropic: {
+      access_token: YOUR_ANTHROPIC_API_KEY
+    }
+  }
+)
+
+# Use specific provider
+response = client.chat("Hello!", model: "gpt-4o")
+puts response.content
+
+# Switch to another provider
+response = client.chat("Hi there!", model: "claude-3-5-sonnet-20241022")
+puts response.content
+```
+
+### Logging
+
+Rach supports logging of API calls and their parameters. You can provide any logger that responds to the `info` method:
+
+```ruby
+require 'logger'
+
+# Create a logger that writes to STDOUT
+logger = Logger.new(STDOUT)
+
+# Pass the logger when creating the client
+client = Rach::Client.new(
+  access_token: YOUR_OPENAI_API_KEY,
+  model: "gpt-4",
+  logger: logger
+)
+
+# Now when you make API calls, parameters will be logged
+client.chat("Hello!")
+# [2024-01-20T10:30:00.000Z] INFO: Making API call to openai
+# [2024-01-20T10:30:00.000Z] INFO: Request parameters: {:model=>"gpt-4", :messages=>[{:role=>"user", :content=>"Hello!"}], :temperature=>1.0}
+```
+
+You can also use your own custom logger as long as it responds to the `info` method:
+
+```ruby
+class CustomLogger
+  def info(message)
+    puts "[RACH] #{message}"
+  end
+end
+
+client = Rach::Client.new(
+  access_token: YOUR_OPENAI_API_KEY,
+  model: "gpt-4",
+  logger: CustomLogger.new
+)
+```
+
+## License
+
+Rach is available as open source under the terms of the MIT License.

data/lib/rach/client.rb

@@ -1,43 +1,57 @@
 module Rach
   class Client
-    attr_reader :tracker, :client, :model
+    attr_reader :tracker, :client, :model, :providers
+    attr_accessor :logger
 
-    def initialize(access_token:, model: "gpt-4o-mini")
-      @client = OpenAI::Client.new(log_errors: true, access_token: access_token)
-      @model = model
+    def initialize(providers: nil, access_token: nil, model: nil, logger: nil, **kwargs)
       @tracker = UsageTracker.new
+      @providers = {}
+      @logger = logger
+      @default_model = model
+
+      if providers
+        setup_providers(providers)
+      elsif access_token && model
+        provider = Provider.for(model)
+        setup_providers({ provider.key => { access_token: access_token } })
+      else
+        raise ArgumentError, "Either (providers) or (access_token AND model) must be provided"
+      end
     end
 
-    def chat(prompt, response_format: nil, tools: nil)
-      messages = format_messages(prompt)
-      
-      response = Response.new(
-        @client.chat(
-          parameters: {
-            model: @model,
-            messages:,
-            response_format:,
-            tools:,
-          }.compact
-        )
-      )
-      
-      @tracker.track(response)
+    def chat(input, **options)
+      prompt = input.is_a?(Prompt) ? input : Prompt.new(input, **options)
+      model = prompt.model || @default_model
+
+      raise ArgumentError, "No model specified" unless model
+
+      provider_key = Provider.for(model).key
+      client = @providers[provider_key]
+
+      # Filter out options that are already handled by Prompt
+      filtered_options = options.reject { |k, _| [:model, :temperature, :response_format, :tools].include?(k) }
+
+      request_params = {
+        model:,
+        messages: prompt.to_messages,
+        response_format: prompt.response_format,
+        temperature: prompt.temperature,
+        tools: prompt.tools&.map(&:function_schema),
+        **filtered_options  # Pass through remaining options to the underlying client
+      }.compact
+
+
+      response = client.chat(parameters: request_params)
+      tracker.track(response)
       response
     end
 
     private
 
-    def format_messages(prompt)
-      case prompt
-      when String
-        [{ role: "user", content: prompt }]
-      when Message
-        [prompt.to_h]
-      when Conversation
-        prompt.to_a
-      else
-        raise ArgumentError, "prompt must be a String, Message, or Conversation"
+    def setup_providers(provider_configs)
+      provider_configs.each do |provider_key, config|
+        provider_class = Provider.get_provider_class(provider_key)
+        @providers[provider_class.key] = provider_class.new(logger: @logger, **config)
       end
     end
   end

data/lib/rach/conversation.rb

@@ -39,11 +39,14 @@ module Rach
 
     def clear
       @messages.clear
-      self
     end
 
     def empty?
       @messages.empty?
     end
+
+    def pop
+      @messages.pop
+    end
   end
 end

data/lib/rach/function.rb

@@ -80,5 +80,11 @@ module Rach
     def function_description
       raise NotImplementedError, "#{self.class} must implement #function_description"
     end
+
+    def validate_arguments!(arguments)
+      unless schema.validate(arguments)
+        raise ArgumentError, "Invalid arguments for function #{function_name}"
+      end
+    end
   end
 end

data/lib/rach/prompt.rb

@@ -0,0 +1,26 @@
+module Rach
+  class Prompt
+    attr_reader :content, :model, :temperature, :response_format, :tools
+
+    def initialize(content, model: nil, temperature: 0, response_format: nil, tools: nil)
+      @content = content
+      @model = model
+      @temperature = temperature
+      @response_format = response_format
+      @tools = tools
+    end
+
+    def to_messages
+      case content
+      when String
+        [{ role: "user", content: content }]
+      when Message
+        [content.to_h]
+      when Conversation
+        content.to_a
+      else
+        raise ArgumentError, "content must be a String, Message, or Conversation"
+      end
+    end
+  end
+end

data/lib/rach/provider/anthropic.rb

@@ -0,0 +1,140 @@
+require 'securerandom'
+require 'json'
+
+module Rach
+  module Provider
+    class Anthropic < Base
+
+      def initialize(access_token: nil, logger: nil, **kwargs)
+        @client = create_client(access_token, **kwargs)
+        @logger = logger
+      end
+
+      def chat(**parameters)
+        # Extract system message if present
+        messages = parameters.dig(:parameters, :messages) || []
+        system_message = messages.find { |msg| msg[:role] == "system" }
+
+        # Remove system message from messages array if present
+        messages = messages.reject { |msg| msg[:role] == "system" } if system_message
+
+        # Convert messages to Anthropic format
+        messages = messages.map do |msg|
+          {
+            role: msg[:role] == "assistant" ? "assistant" : "user",
+            content: msg[:content]
+          }
+        end
+
+        temperature = (parameters.dig(:parameters, :temperature) || 1).clamp(0, 1)
+        max_tokens = parameters.dig(:parameters, :max_tokens) || 1024
+        tools = convert_tools(parameters.dig(:parameters, :tools))
+
+        anthropic_params = {
+          model: parameters.dig(:parameters, :model),
+          messages:,
+          temperature:,
+          max_tokens:,
+          tools:,
+          tool_choice: convert_tool_choice(tools),
+          system: system_message&.[](:content)
+        }.compact
+
+        if @logger
+          @logger.info("Making API call to Anthropic")
+          @logger.info("Request parameters: #{anthropic_params.inspect}")
+        end
+
+        raw_response = @client.messages(
+          parameters: anthropic_params.compact
+          # parameters: {
+          #   model: anthropic_params[:model],
+          #   messages: anthropic_params[:messages],
+          #   system: anthropic_params[:system],
+          #   temperature: anthropic_params[:temperature],
+          #   max_tokens: anthropic_params[:max_tokens],
+          #   tools: anthropic_params[:tools],
+          #   tool_choice: anthropic_params[:tool_choice],
+          # }.compact
+        )
+
+        if @logger
+          @logger.info("Request to Anthropic: #{JSON.pretty_generate(anthropic_params)}")
+          @logger.info("Response: #{JSON.pretty_generate(raw_response)}")
+        end
+
+        Response.new(
+          id: raw_response["id"],
+          model: raw_response["model"],
+          content: raw_response.dig("content", 0, "text"),
+          tool_calls: convert_tool_calls(raw_response["content"]),
+          usage: {
+            "prompt_tokens" => raw_response["usage"]["input_tokens"],
+            "completion_tokens" => raw_response["usage"]["output_tokens"],
+            "total_tokens" => raw_response["usage"]["input_tokens"] + raw_response["usage"]["output_tokens"]
+          },
+          raw_response: raw_response
+        )
+      end
+
+      def self.supports?(model)
+        model.start_with?("claude")
+      end
+
+      private
+
+      def create_client(access_token, **kwargs)
+        ::Anthropic::Client.new(
+          access_token: access_token,
+          **kwargs
+        )
+      end
+
+      def convert_tools(functions)
+        return nil if functions.nil?
+
+        functions.map do |fn|
+          {
+            name: fn[:function][:name],
+            description: fn[:function][:description],
+            input_schema: {
+              type: "object",
+              properties: fn[:function][:parameters][:properties],
+              required: fn[:function][:parameters][:required]
+            }
+          }
+        end
+      end
+
+      def convert_tool_calls(content)
+        return nil if content.nil?
+
+        tool_calls = content.select { |c| c["type"] == "tool_use" }
+        return nil if tool_calls.empty?
+
+        tool_calls.map do |call|
+          {
+            "id" => call["id"],
+            "type" => "function",
+            "function" => {
+              "name" => call["name"],
+              "arguments" => call["input"].to_json
+            }
+          }
+        end
+      end
+
+      def convert_tool_choice(tools)
+        if tools
+          if tools.size == 1
+            { type: "tool", name: tools.first[:name] }
+          else
+            { type: "any" }
+          end
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rach/provider/base.rb

@@ -0,0 +1,27 @@
+module Rach
+  module Provider
+    class Base
+      def initialize(access_token, **kwargs)
+        @client = create_client(access_token, **kwargs)
+      end
+
+      def self.key
+        name.split("::").last.downcase.to_sym
+      end
+
+      def self.supports?(model)
+        raise NotImplementedError
+      end
+
+      def chat(**parameters)
+        raise NotImplementedError
+      end
+
+      private
+
+      def create_client(access_token, **kwargs)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/rach/provider/openai.rb

@@ -0,0 +1,54 @@
+module Rach
+  module Provider
+    class OpenAI < Base
+
+      def initialize(access_token: nil, logger: nil, **kwargs)
+        @client = create_client(access_token, **kwargs)
+        @logger = logger
+      end
+
+      def chat(**parameters)
+        raw_response = @client.chat(**parameters)
+
+        if @logger
+          @logger.info("Request to OpenAI: #{JSON.pretty_generate(parameters)}")
+          @logger.info("Response: #{JSON.pretty_generate(raw_response)}")
+        end
+
+        Response.new(
+          id: raw_response["id"],
+          model: raw_response["model"],
+          created_at: Time.at(raw_response["created"]),
+          content: raw_response.dig("choices", 0, "message", "content"),
+          tool_calls: raw_response.dig("choices", 0, "message", "tool_calls"),
+          usage: raw_response["usage"],
+          system_fingerprint: raw_response["system_fingerprint"],
+          raw_response: raw_response
+        )
+      end
+
+      def self.supports?(model)
+        model.start_with?("gpt", "o1")
+      end
+
+      private
+
+      def create_client(access_token, **kwargs)
+        ::OpenAI::Client.new(
+          access_token: access_token,
+          log_errors: true,
+          **kwargs
+        )
+      end
+
+      def convert_params(parameters)
+        {
+          parameters: {
+            **parameters[:parameters],
+            tool_choice: parameters.dig(:parameters, :tools) ? "required" : nil
+          }.compact
+        }
+      end
+    end
+  end
+end

data/lib/rach/provider.rb

@@ -0,0 +1,27 @@
+module Rach
+  module Provider
+
+    AVAILABLE_PROVIDERS = [
+      Provider::OpenAI,
+      Provider::Anthropic
+    ].to_h { |p| [p.key, p] }.freeze
+
+    def self.for(model)
+      _key, provider_class = AVAILABLE_PROVIDERS.find { |_, p| p.supports?(model) }
+      raise ArgumentError, "Unsupported model: #{model}" unless provider_class
+
+      provider_class
+    end
+
+    def self.create_client(provider_key, access_token)
+      provider_class = get_provider_class(provider_key)
+      provider_class.new(access_token:)
+    end
+
+    def self.get_provider_class(key)
+      provider_class = AVAILABLE_PROVIDERS[key.to_sym]
+      raise ArgumentError, "Unknown provider: #{key}" unless provider_class
+      provider_class
+    end
+  end
+end

data/lib/rach/response.rb

@@ -1,17 +1,18 @@
 module Rach
   class Response
-    attr_reader :raw_response
+    attr_reader :id, :model, :created_at, :content, :tool_calls, :usage, 
+                :system_fingerprint, :raw_response, :request_params
 
-    def initialize(response)
-      @raw_response = response
-    end
-
-    def content
-      message&.dig("content")
-    end
-
-    def tool_calls
-      message&.dig("tool_calls")
+    def initialize(**options)
+      @id = options[:id]
+      @model = options[:model]
+      @created_at = options[:created_at]
+      @content = options[:content]
+      @tool_calls = options[:tool_calls]
+      @usage = options[:usage]
+      @system_fingerprint = options[:system_fingerprint]
+      @raw_response = options[:raw_response]
+      @request_params = options[:request_params]
     end
 
     def function_call?
@@ -30,10 +31,6 @@ module Rach
       raise ParseError, "Function arguments are not valid JSON"
     end
 
-    def usage
-      @raw_response["usage"]
-    end
-
     def prompt_tokens
       usage&.fetch("prompt_tokens", 0)
     end
@@ -46,12 +43,25 @@ module Rach
       usage&.fetch("total_tokens", 0)
     end
 
-    private
+    def on_function(function_class = nil, &block)
+      return self unless function_call?
+
+      function = function_class.new
+      return self unless function.function_name == function_name
+
+      args = function_arguments.transform_keys(&:to_sym)
+      function.validate_arguments!(args)
+      block.call(function, args)
+      self
+    end
 
-    def message
-      @raw_response.dig("choices", 0, "message")
+    def on_content(&block)
+      block.call(content) if content
+      self
     end
 
+    private
+
     def to_json
       JSON.parse(content)
     rescue JSON::ParserError

data/lib/rach/version.rb

@@ -1,3 +1,4 @@
 module Rach
-  VERSION = "0.1.0"
+  VERSION = "0.2.6"
 end
+

data/lib/rach.rb

@@ -1,4 +1,5 @@
 require 'openai'
+require 'anthropic'
 
 require_relative "rach/version"
 require_relative "rach/client"
@@ -10,6 +11,11 @@ require_relative "rach/response_format"
 require_relative "rach/conversation"
 require_relative "rach/usage_tracker"
 require_relative "rach/function"
+require_relative "rach/provider/base"
+require_relative "rach/provider/openai"
+require_relative "rach/provider/anthropic"
+require_relative "rach/provider"
+require_relative "rach/prompt"
 
 module Rach
   # Your code goes here...

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rach
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.6
 platform: ruby
 authors:
 - Roger Garcia
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-30 00:00:00.000000000 Z
+date: 2025-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -58,6 +58,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: anthropic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: json-schema_builder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: ruby-openai
   requirement: !ruby/object:Gem::Requirement
@@ -87,6 +115,11 @@ files:
 - lib/rach/function.rb
 - lib/rach/message.rb
 - lib/rach/message_template.rb
+- lib/rach/prompt.rb
+- lib/rach/provider.rb
+- lib/rach/provider/anthropic.rb
+- lib/rach/provider/base.rb
+- lib/rach/provider/openai.rb
 - lib/rach/response.rb
 - lib/rach/response_format.rb
 - lib/rach/usage_tracker.rb
@@ -103,14 +136,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: Orchestrate AI agents like a virtuoso