llm.rb 0.1.0

data/lib/llm.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module LLM
+  require_relative "llm/version"
+  require_relative "llm/error"
+  require_relative "llm/message"
+  require_relative "llm/response"
+  require_relative "llm/file"
+  require_relative "llm/provider"
+  require_relative "llm/conversation"
+  require_relative "llm/lazy_conversation"
+  require_relative "llm/core_ext/ostruct"
+
+  module_function
+
+  ##
+  # @param secret (see LLM::Anthropic#initialize)
+  # @return (see LLM::Anthropic#initialize)
+  def anthropic(secret, **)
+    require_relative "llm/providers/anthropic" unless defined?(LLM::Anthropic)
+    LLM::Anthropic.new(secret, **)
+  end
+
+  ##
+  # @param secret (see LLM::Gemini#initialize)
+  # @return (see LLM::Gemini#initialize)
+  def gemini(secret, **)
+    require_relative "llm/providers/gemini" unless defined?(LLM::Gemini)
+    LLM::Gemini.new(secret, **)
+  end
+
+  ##
+  # @param host (see LLM::Ollama#initialize)
+  # @return (see LLM::Ollama#initialize)
+  def ollama(secret)
+    require_relative "llm/providers/ollama" unless defined?(LLM::Ollama)
+    LLM::Ollama.new(secret)
+  end
+
+  ##
+  # @param secret (see LLM::OpenAI#initialize)
+  # @return (see LLM::OpenAI#initialize)
+  def openai(secret, **)
+    require_relative "llm/providers/openai" unless defined?(LLM::OpenAI)
+    LLM::OpenAI.new(secret, **)
+  end
+end

data/llm.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "lib/llm/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "llm.rb"
+  spec.version = LLM::VERSION
+  spec.authors = ["Antar Azri", "0x1eef"]
+  spec.email = ["azantar@proton.me", "0x1eef@proton.me"]
+
+  spec.summary = "llm.rb is a lightweight Ruby library that provides a " \
+                 "common interface and set of functionality for multple " \
+                 "Large Language Models (LLMs). It is designed to be simple, " \
+                 "flexible, and easy to use."
+  spec.description = spec.summary
+  spec.homepage = "https://github.com/llmrb/llm"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/llmrb/llm"
+  spec.metadata["changelog_uri"] = "https://github.com/llmrb/llm/blob/main/CHANGELOG.md"
+
+  spec.files = Dir[
+    "README.md", "LICENSE.txt",
+    "lib/*.rb", "lib/**/*.rb",
+    "spec/*.rb", "spec/**/*.rb",
+    "llm.gemspec"
+  ]
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "net-http", "~> 0.6.0"
+  spec.add_runtime_dependency "json"
+
+  spec.add_development_dependency "webmock", "~> 3.24.0"
+  spec.add_development_dependency "yard", "~> 0.9.37"
+  spec.add_development_dependency "kramdown", "~> 2.4"
+  spec.add_development_dependency "webrick", "~> 1.8"
+  spec.add_development_dependency "test-cmd.rb", "~> 0.12.0"
+end

data/spec/anthropic/completion_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "setup"
+
+RSpec.describe "LLM::Anthropic: completions" do
+  subject(:anthropic) { LLM.anthropic("") }
+
+  before(:each, :success) do
+    stub_request(:post, "https://api.anthropic.com/v1/messages")
+      .with(headers: {"Content-Type" => "application/json"})
+      .to_return(
+        status: 200,
+        body: fixture("anthropic/completions/ok_completion.json"),
+        headers: {"Content-Type" => "application/json"}
+      )
+  end
+
+  before(:each, :unauthorized) do
+    stub_request(:post, "https://api.anthropic.com/v1/messages")
+      .with(headers: {"Content-Type" => "application/json"})
+      .to_return(
+        status: 403,
+        body: fixture("anthropic/completions/unauthorized_completion.json"),
+        headers: {"Content-Type" => "application/json"}
+      )
+  end
+
+  context "when given a successful response", :success do
+    subject(:response) { anthropic.complete("Hello, world", :user) }
+
+    it "returns a completion" do
+      expect(response).to be_a(LLM::Response::Completion)
+    end
+
+    it "returns a model" do
+      expect(response.model).to eq("claude-3-5-sonnet-20240620")
+    end
+
+    it "includes token usage" do
+      expect(response).to have_attributes(
+        prompt_tokens: 2095,
+        completion_tokens: 503,
+        total_tokens: 2598
+      )
+    end
+
+    context "with a choice" do
+      subject(:choice) { response.choices[0] }
+
+      it "has choices" do
+        expect(choice).to have_attributes(
+          role: "assistant",
+          content: "Hi! My name is Claude."
+        )
+      end
+
+      it "includes the response" do
+        expect(choice.extra[:completion]).to eq(response)
+      end
+    end
+  end
+
+  context "when given an unauthorized response", :unauthorized do
+    subject(:response) { anthropic.complete("Hello", :user) }
+
+    it "raises an error" do
+      expect { response }.to raise_error(LLM::Error::Unauthorized)
+    end
+
+    it "includes the response" do
+      response
+    rescue LLM::Error::Unauthorized => ex
+      expect(ex.response).to be_kind_of(Net::HTTPResponse)
+    end
+  end
+end

data/spec/gemini/completion_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "setup"
+
+RSpec.describe "LLM::Gemini: completions" do
+  subject(:gemini) { LLM.gemini("") }
+
+  before(:each, :success) do
+    stub_request(:post, "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=")
+      .with(headers: {"Content-Type" => "application/json"})
+      .to_return(
+        status: 200,
+        body: fixture("gemini/completions/ok_completion.json"),
+        headers: {"Content-Type" => "application/json"}
+      )
+  end
+
+  before(:each, :unauthorized) do
+    stub_request(:post, "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=")
+      .with(headers: {"Content-Type" => "application/json"})
+      .to_return(
+        status: 400,
+        body: fixture("gemini/completions/unauthorized_completion.json"),
+        headers: {"Content-Type" => "application/json"}
+      )
+  end
+
+  context "when given a successful response", :success do
+    subject(:response) { gemini.complete(LLM::Message.new("user", "Hello!")) }
+
+    it "returns a completion" do
+      expect(response).to be_a(LLM::Response::Completion)
+    end
+
+    it "returns a model" do
+      expect(response.model).to eq("gemini-1.5-flash-001")
+    end
+
+    it "includes token usage" do
+      expect(response).to have_attributes(
+        prompt_tokens: 2,
+        completion_tokens: 10,
+        total_tokens: 12
+      )
+    end
+
+    context "with a choice" do
+      subject(:choice) { response.choices[0] }
+
+      it "has choices" do
+        expect(response).to be_a(LLM::Response::Completion).and have_attributes(
+          choices: [
+            have_attributes(
+              role: "model",
+              content: "Hello! How can I help you today? \n"
+            )
+          ]
+        )
+      end
+
+      it "includes the response" do
+        expect(choice.extra[:completion]).to eq(response)
+      end
+    end
+  end
+
+  context "when given an unauthorized response", :unauthorized do
+    subject(:response) { gemini.complete(LLM::Message.new("user", "Hello!")) }
+
+    it "raises an error" do
+      expect { response }.to raise_error(LLM::Error::Unauthorized)
+    end
+
+    it "includes a response" do
+      response
+    rescue LLM::Error::Unauthorized => ex
+      expect(ex.response).to be_kind_of(Net::HTTPResponse)
+    end
+  end
+end

data/spec/gemini/embedding_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "setup"
+
+RSpec.describe "LLM::OpenAI: embeddings" do
+  let(:gemini) { LLM.gemini("") }
+
+  before(:each, :success) do
+    stub_request(:post, "https://generativelanguage.googleapis.com/v1beta/models/text-embedding-004:embedContent?key=")
+      .with(headers: {"Content-Type" => "application/json"})
+      .to_return(
+        status: 200,
+        body: fixture("gemini/embeddings/hello_world_embedding.json"),
+        headers: {"Content-Type" => "application/json"}
+      )
+  end
+
+  context "when given a successful response", :success do
+    subject(:response) { gemini.embed("Hello, world") }
+
+    it "returns an embedding" do
+      expect(response).to be_instance_of(LLM::Response::Embedding)
+    end
+
+    it "returns a model" do
+      expect(response.model).to eq("text-embedding-004")
+    end
+
+    it "has embeddings" do
+      expect(response.embeddings).to be_instance_of(Array)
+    end
+  end
+end

data/spec/llm/conversation_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+RSpec.describe LLM::Conversation do
+  shared_examples "a multi-turn conversation" do
+    context "when given a thread of messages" do
+      let(:inputs) do
+        [
+          LLM::Message.new(:system, "Provide concise, short answers about The Netherlands"),
+          LLM::Message.new(:user, "What is the capital of The Netherlands?"),
+          LLM::Message.new(:user, "How many people live in the capital?")
+        ]
+      end
+
+      let(:outputs) do
+        [
+          LLM::Message.new(:assistant, "Ok, got it"),
+          LLM::Message.new(:assistant, "The capital of The Netherlands is Amsterdam"),
+          LLM::Message.new(:assistant, "The population of Amsterdam is about 900,000")
+        ]
+      end
+
+      let(:messages) { [] }
+
+      it "maintains a conversation" do
+        bot = nil
+        inputs.zip(outputs).each_with_index do |(input, output), index|
+          expect(provider).to receive(:complete)
+                                .with(input.content, instance_of(Symbol), messages:)
+                                .and_return(OpenStruct.new(choices: [output]))
+          bot = index.zero? ? provider.chat!(input.content, :system) : bot.chat(input.content)
+          messages.concat([input, output])
+        end
+      end
+    end
+  end
+
+  context "with openai" do
+    subject(:provider) { LLM.openai("") }
+    include_examples "a multi-turn conversation"
+  end
+
+  context "with gemini" do
+    subject(:provider) { LLM.gemini("") }
+    include_examples "a multi-turn conversation"
+  end
+
+  context "with anthropic" do
+    subject(:provider) { LLM.anthropic("") }
+    include_examples "a multi-turn conversation"
+  end
+
+  context "with ollama" do
+    subject(:provider) { LLM.ollama("") }
+    include_examples "a multi-turn conversation"
+  end
+end

data/spec/llm/lazy_conversation_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "setup"
+
+RSpec.describe LLM::LazyConversation do
+  context "with gemini" do
+    let(:provider) { LLM.gemini("") }
+    let(:conversation) { described_class.new(provider) }
+
+    context "when given a thread of messages" do
+      subject(:message) { conversation.messages.to_a[-1] }
+
+      before do
+        stub_request(:post, "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=")
+          .with(
+            headers: {"Content-Type" => "application/json"},
+            body: request_fixture("gemini/completions/ok_completion.json")
+          )
+          .to_return(
+            status: 200,
+            body: response_fixture("gemini/completions/ok_completion.json"),
+            headers: {"Content-Type" => "application/json"}
+          )
+      end
+
+      before do
+        conversation.chat "Hello"
+        conversation.chat "I have a question"
+        conversation.chat "How are you?"
+      end
+
+      it "maintains a conversation" do
+        expect(message).to have_attributes(
+          role: "model",
+          content: "Hello! How can I help you today? \n"
+        )
+      end
+    end
+  end
+
+  context "with openai" do
+    let(:provider) { LLM.openai("") }
+    let(:conversation) { described_class.new(provider) }
+
+    context "when given a thread of messages" do
+      subject(:message) { conversation.messages.to_a[-1] }
+
+      before do
+        stub_request(:post, "https://api.openai.com/v1/chat/completions")
+          .with(
+            headers: {"Content-Type" => "application/json"},
+            body: request_fixture("openai/completions/ok_completion.json")
+          )
+          .to_return(
+            status: 200,
+            body: response_fixture("openai/completions/ok_completion.json"),
+            headers: {"Content-Type" => "application/json"}
+          )
+      end
+
+      before do
+        conversation.chat "Hello"
+        conversation.chat "I have a question"
+        conversation.chat "How are you?"
+      end
+
+      it "maintains a conversation" do
+        expect(message).to have_attributes(
+          role: "assistant",
+          content: "Hello! How can I assist you today?"
+        )
+      end
+    end
+  end
+
+  context "with ollama" do
+    let(:provider) { LLM.ollama("") }
+    let(:conversation) { described_class.new(provider) }
+
+    context "when given a thread of messages" do
+      subject(:message) { conversation.messages.to_a[-1] }
+
+      before do
+        stub_request(:post, "http://localhost:11434/api/chat")
+          .with(
+            headers: {"Content-Type" => "application/json"},
+            body: request_fixture("ollama/completions/ok_completion.json")
+          )
+          .to_return(
+            status: 200,
+            body: response_fixture("ollama/completions/ok_completion.json"),
+            headers: {"Content-Type" => "application/json"}
+          )
+      end
+
+      before do
+        conversation.chat "Hello"
+        conversation.chat "I have a question"
+        conversation.chat "How are you?"
+      end
+
+      it "maintains a conversation" do
+        expect(message).to have_attributes(
+          role: "assistant",
+          content: "Hello! How are you today?"
+        )
+      end
+    end
+  end
+end

data/spec/ollama/completion_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "setup"
+
+RSpec.describe "LLM::Ollama: completions" do
+  subject(:ollama) { LLM.ollama("") }
+
+  before(:each, :success) do
+    stub_request(:post, "localhost:11434/api/chat")
+      .with(headers: {"Content-Type" => "application/json"})
+      .to_return(
+        status: 200,
+        body: fixture("ollama/completions/ok_completion.json"),
+        headers: {"Content-Type" => "application/json"}
+      )
+  end
+
+  context "when given a successful response", :success do
+    subject(:response) { ollama.complete("Hello!", :user) }
+
+    it "returns a completion" do
+      expect(response).to be_a(LLM::Response::Completion)
+    end
+
+    it "returns a model" do
+      expect(response.model).to eq("llama3.2")
+    end
+
+    it "includes token usage" do
+      expect(response).to have_attributes(
+        prompt_tokens: 26,
+        completion_tokens: 298,
+        total_tokens: 324
+      )
+    end
+
+    context "with a choice" do
+      subject(:choice) { response.choices[0] }
+
+      it "has choices" do
+        expect(choice).to have_attributes(
+          role: "assistant",
+          content: "Hello! How are you today?"
+        )
+      end
+
+      it "includes the response" do
+        expect(choice.extra[:completion]).to eq(response)
+      end
+    end
+  end
+end

data/spec/ollama/embedding_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "setup"
+
+RSpec.describe "LLM::Ollama: embeddings" do
+  let(:ollama) { LLM.ollama("") }
+
+  context "when given a successful response", :success do
+    subject(:response) { ollama.embed("Hello, world") }
+
+    it "raises NotImplementedError" do
+      expect { response }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/openai/completion_spec.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "setup"
+
+RSpec.describe "LLM::OpenAI: completions" do
+  subject(:openai) { LLM.openai("") }
+
+  before(:each, :success) do
+    stub_request(:post, "https://api.openai.com/v1/chat/completions")
+      .with(headers: {"Content-Type" => "application/json"})
+      .to_return(
+        status: 200,
+        body: fixture("openai/completions/ok_completion.json"),
+        headers: {"Content-Type" => "application/json"}
+      )
+  end
+
+  before(:each, :unauthorized) do
+    stub_request(:post, "https://api.openai.com/v1/chat/completions")
+      .with(headers: {"Content-Type" => "application/json"})
+      .to_return(
+        status: 401,
+        body: fixture("openai/completions/unauthorized_completion.json"),
+        headers: {"Content-Type" => "application/json"}
+      )
+  end
+
+  before(:each, :bad_request) do
+    stub_request(:post, "https://api.openai.com/v1/chat/completions")
+      .with(headers: {"Content-Type" => "application/json"})
+      .to_return(
+        status: 400,
+        body: fixture("openai/completions/badrequest_completion.json")
+      )
+  end
+
+  context "when given a successful response", :success do
+    subject(:response) { openai.complete("Hello!", :user) }
+
+    it "returns a completion" do
+      expect(response).to be_a(LLM::Response::Completion)
+    end
+
+    it "returns a model" do
+      expect(response.model).to eq("gpt-4o-mini-2024-07-18")
+    end
+
+    it "includes token usage" do
+      expect(response).to have_attributes(
+        prompt_tokens: 9,
+        completion_tokens: 9,
+        total_tokens: 18
+      )
+    end
+
+    context "with a choice" do
+      subject(:choice) { response.choices[0] }
+
+      it "has choices" do
+        expect(choice).to have_attributes(
+          role: "assistant",
+          content: "Hello! How can I assist you today?"
+        )
+      end
+
+      it "includes the response" do
+        expect(choice.extra[:completion]).to eq(response)
+      end
+    end
+  end
+
+  context "when given an unauthorized response", :unauthorized do
+    subject(:response) { openai.complete(LLM::Message.new("Hello!", :user)) }
+
+    it "raises an error" do
+      expect { response }.to raise_error(LLM::Error::Unauthorized)
+    end
+
+    it "includes the response" do
+      response
+    rescue LLM::Error::Unauthorized => ex
+      expect(ex.response).to be_kind_of(Net::HTTPResponse)
+    end
+  end
+
+  context "when given a 'bad request' response", :bad_request do
+    subject(:response) { openai.complete(URI("/foobar.exe"), :user) }
+
+    it "raises an error" do
+      expect { response }.to raise_error(LLM::Error::BadResponse)
+    end
+
+    it "includes the response" do
+      response
+    rescue LLM::Error => ex
+      expect(ex.response).to be_instance_of(Net::HTTPBadRequest)
+    end
+  end
+end

data/spec/openai/embedding_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "setup"
+
+RSpec.describe "LLM::OpenAI: embeddings" do
+  let(:openai) { LLM.openai("") }
+
+  before(:each, :success) do
+    stub_request(:post, "https://api.openai.com/v1/embeddings")
+      .with(headers: {"Content-Type" => "application/json"})
+      .to_return(
+        status: 200,
+        body: fixture("openai/embeddings/hello_world_embedding.json"),
+        headers: {"Content-Type" => "application/json"}
+      )
+  end
+
+  context "when given a successful response", :success do
+    subject(:response) { openai.embed("Hello, world") }
+
+    it "returns an embedding" do
+      expect(response).to be_instance_of(LLM::Response::Embedding)
+    end
+
+    it "returns a model" do
+      expect(response.model).to eq("text-embedding-3-small")
+    end
+
+    it "has embeddings" do
+      expect(response.embeddings).to be_instance_of(Array)
+    end
+  end
+end