lammy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8a3c37bb78fae05b1c34a205b5a763149077199651acd8f52896f887f8edda45
+  data.tar.gz: c6af72cc5f7c29d2ee6ab211743398b8757f4b3ba9a38fcfa20031de7f625982
+SHA512:
+  metadata.gz: fe0ca83a8d96703ad5d8543ca6b96a854bf69eaac1a909925e7eb99c9a54fd6b02d9eb0faa5ee0cfadf54643b4b9f8ab3506e9a88f5df85541e161370ad6b334
+  data.tar.gz: bd399dcb3f6a1b75a8d5f6b2dd6b3d2657a5db52c736c905a0c72285ab3feb51f545a385c3bd21269243b033568f4f96be6b4aa8d100e498f73098b97b3463a6

data/lib/lammy/chat.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module L
+  module Chat
+    def llm(**kwargs)
+      @next_llm_settings = kwargs
+    end
+
+    def handle_llm(method_name)
+      settings = @next_llm_settings
+      @next_llm_settings = nil
+
+      # Unbind the original method
+      original_method = instance_method(method_name)
+
+      # Redefine the method
+      define_method(method_name) do |*args, &block|
+        # Initialize context
+        @system_message = nil
+
+        # Make `context` method available within the instance
+        define_singleton_method(:context) do |message|
+          @system_message = message
+        end
+
+        # Call the original method to get the user message
+        user_message = original_method.bind(self).call(*args, &block)
+
+        case settings[:model]
+        when *OpenAI::MODELS
+          client = OpenAI.new
+          client.chat(settings, user_message, @system_message)
+        else
+          raise "Unsupported model: #{settings[:model]}"
+        end
+      end
+    end
+  end
+end

data/lib/lammy/embeddings.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module L
+  module Embeddings
+    def v(**kwargs)
+      @next_v_settings = kwargs
+    end
+
+    def handle_v(method_name)
+      settings = @next_v_settings
+      @next_v_settings = nil
+
+      # Unbind the original method
+      original_method = instance_method(method_name)
+
+      # Redefine the method
+      define_method(method_name) do |*args, &block|
+        # Initialize chunking settings
+        @chunk_by_size = nil
+
+        # Make `chunk_by_size` method available within the instance
+        define_singleton_method(:chunk_by_size) do |size|
+          @chunk_by_size = size
+        end
+
+        # Call the original method to get the input
+        input = original_method.bind(self).call(*args, &block)
+
+        # # Tokenize the input
+        # if @chunk_by_size.blank?
+        #   input = [ input ]
+        # else
+        #   tokenizer = Tokenizers.from_pretrained("bert-base-cased")
+        #   input = tokenizer.encode(input).tokens
+        # end
+        input = [input]
+
+        case settings[:model]
+        when *OpenAI::EMBEDDINGS
+          client = OpenAI.new
+          client.embeddings(settings, input)
+        else
+          raise "Unsupported model: #{settings[:model]}"
+        end
+      end
+    end
+  end
+end

data/lib/lammy/openai.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'openai'
+
+module L
+  # Use the OpenAI API's official Ruby library
+  class OpenAI
+    MODELS = %w[
+      gpt-4o-mini gpt-4o gpt-4-turbo gpt-4 gpt-3.5-turbo gpt-4o-mini-2024-07-18 gpt-4o-2024-08-06
+      gpt-4o-2024-05-13 gpt-4-turbo-preview gpt-4-turbo-2024-04-09
+    ].freeze
+
+    EMBEDDINGS = %w[
+      text-embedding-3-small text-embedding-3-large text-embedding-ada-002
+    ].freeze
+
+    # Generate a response with support for structured output
+    def chat(settings, user_message, system_message = nil)
+      response = client.chat(
+        parameters: {
+          model: settings[:model], response_format: schema(settings), messages: [
+            system_message ? { role: :system, content: system_message } : nil,
+            { role: :user, content: user_message }
+          ].compact
+        }.compact
+      )
+
+      content = response.dig('choices', 0, 'message', 'content')
+      settings[:schema] ? Hashie::Mash.new(JSON.parse(content)) : content
+    end
+
+    # OpenAI’s text embeddings measure the relatedness of text strings. An embedding is a vector of floating point
+    # numbers. The distance between two vectors measures their relatedness. Small distances suggest high relatedness
+    # and large distances suggest low relatedness.
+    def embeddings(settings, chunks)
+      responses = chunks.map do |chunk|
+        response = client.embeddings(
+          parameters: { model: settings[:model], dimensions: settings[:dimensions], input: chunk }
+        )
+
+        response.dig('data', 0, 'embedding')
+      end
+
+      responses.one? ? responses.first : responses
+    end
+
+    private
+
+    def schema(settings)
+      return unless settings[:schema]
+
+      {
+        type: :json_schema,
+        json_schema: {
+          name: :schema,
+          schema: settings[:schema]
+        }
+      }
+    end
+
+    def client
+      @client ||= ::OpenAI::Client.new(
+        access_token: ENV.fetch('OPENAI_ACCESS_TOKEN')
+      )
+    end
+  end
+end

data/lib/lammy/schema.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module L
+  # Structured Outputs is a feature that ensures the model will always generate responses
+  # that adhere to your supplied JSON Schema, so you don't need to worry about the model
+  # omitting a required key, or hallucinating an invalid enum value. This is a set of
+  # helper methods to help you define your JSON Schema easily.
+  module Schema
+    def to_a(object)
+      {
+        'type' => 'object',
+        'properties' => {
+          'items' => {
+            'type' => 'array', 'items' => to_h(object)
+          }
+        },
+        'required' => ['items'],
+        'additionalProperties' => false
+      }
+    end
+
+    def to_h(object)
+      {
+        'type' => 'object',
+        "properties": object.inject({}) { |h, (k, v)| h.merge(k => { 'type' => v }) },
+        "required": object.keys,
+        "additionalProperties": false
+      }
+    end
+  end
+end

data/lib/lammy.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'lammy/embeddings'
+require 'lammy/openai'
+require 'lammy/schema'
+require 'lammy/chat'
+
+# Example:
+#
+# ```ruby
+# class User < ApplicationRecord
+#   include L
+#
+#   llm(model: 'gpt-4o')
+#   def welcome
+#     context "You are a helpful assistant that writes in lower case."
+#     "Say hello to #{name.reverse} with a poem."
+#   end
+#
+#   v(model: 'text-embedding-3-large')
+#   def embeddings
+#     chunk_by_size 256
+#     welcome
+#   end
+# end
+#
+# user = User.new(name: 'John Doe')
+# user.welcome
+#
+# # => "hello eoD nhoJ, let's make a cheer,\n
+# # with a whimsical poem to bring you near.\n
+# # though your name's in reverse, it’s clear and bright,\n
+# # let's dance in verse on this delightful night.\n\n
+# #
+# # to a friend unique, in every single way,\n
+# # we flip the letters but the bond will stay.\n
+# # the sun may set and rise again,\n
+# # with you, the fun will never wane.\n\n
+# #
+# # through twists and turns, in backwards flow,\n
+# # we celebrate you in this poetic show.\n
+# # eoD nhoJ, here's a cheer to you,\n
+# # in every form, our friendship's true!"
+# ```
+module L
+  extend Schema
+
+  def self.included(base)
+    base.extend Chat
+    base.extend Embeddings
+    base.extend ClassMethods
+  end
+
+  # Wrap generative methods with handlers
+  module ClassMethods
+    def method_added(method_name)
+      handle_llm(method_name) if @next_llm_settings
+      handle_v(method_name) if @next_v_settings
+      super
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: lammy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kamil Nicieja
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-09-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: ruby-openai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+description: An LLM library for Ruby
+email: kamil@nicieja.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/lammy.rb
+- lib/lammy/chat.rb
+- lib/lammy/embeddings.rb
+- lib/lammy/openai.rb
+- lib/lammy/schema.rb
+homepage: https://github.com/nicieja/lammy
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: Lammy
+test_files: []