durable-llm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3ce04ccf2ee305fcba4a22e53473f9428f32dd869577d85af7923d15cfbd63b5
+  data.tar.gz: bcd7a736b0ad7d199f9ab836e84b6ff7f077da0d172385ded64b24dde82da984
+SHA512:
+  metadata.gz: d1786c13db8285c512d5fa0f83541f349f13d54e0bdc968c7aa1e94caf2c9226c9ba1c83f9525d8718cf2a3315674e9ef45322c969ccee1efc984086440a6d05
+  data.tar.gz: 97d7ecccb4c6ae9b4bc6e2ed321af0c22899703044f8e8c75684b306ce8e88b241b0447ffdca2afa3dcb44a8f36f8a67c780de016c0594d92eb9f8898a4ad538

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-10-09
+
+- Initial release

data/Gemfile

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in durable-llm.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.0"
+
+gem "rubocop", "~> 1.21"
+
+gem "ruby-openai", "~> 7.1"
+
+gem "thor", "~> 1.3"
+
+
+
+gem "webmock", "~> 3.24"

data/Gemfile.lock

@@ -0,0 +1,102 @@
+PATH
+  remote: .
+  specs:
+    durable-llm (0.1.0)
+      faraday (~> 2.0)
+      highline (~> 3.1)
+      json (~> 2.6)
+      thor (~> 1.3)
+      zeitwerk (~> 2.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.7)
+      public_suffix (>= 2.0.2, < 7.0)
+    ast (2.4.2)
+    base64 (0.2.0)
+    bigdecimal (3.1.8)
+    crack (1.0.0)
+      bigdecimal
+      rexml
+    dotenv (2.8.1)
+    event_stream_parser (1.0.0)
+    faraday (2.12.0)
+      faraday-net_http (>= 2.0, < 3.4)
+      json
+      logger
+    faraday-multipart (1.0.4)
+      multipart-post (~> 2)
+    faraday-net_http (3.3.0)
+      net-http
+    hashdiff (1.1.1)
+    highline (3.1.1)
+      reline
+    io-console (0.7.2)
+    json (2.7.2)
+    language_server-protocol (3.17.0.3)
+    logger (1.6.1)
+    minitest (5.25.1)
+    mocha (2.4.5)
+      ruby2_keywords (>= 0.0.5)
+    multipart-post (2.4.1)
+    net-http (0.4.1)
+      uri
+    parallel (1.26.3)
+    parser (3.3.5.0)
+      ast (~> 2.4.1)
+      racc
+    public_suffix (6.0.1)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    rake (13.2.1)
+    regexp_parser (2.9.2)
+    reline (0.5.10)
+      io-console (~> 0.5)
+    rexml (3.3.8)
+    rubocop (1.66.1)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.4, < 3.0)
+      rubocop-ast (>= 1.32.2, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.32.3)
+      parser (>= 3.3.1.0)
+    ruby-openai (7.1.0)
+      event_stream_parser (>= 0.3.0, < 2.0.0)
+      faraday (>= 1)
+      faraday-multipart (>= 1)
+    ruby-progressbar (1.13.0)
+    ruby2_keywords (0.0.5)
+    thor (1.3.2)
+    unicode-display_width (2.6.0)
+    uri (0.13.1)
+    vcr (6.3.1)
+      base64
+    webmock (3.24.0)
+      addressable (>= 2.8.0)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+    zeitwerk (2.6.18)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  dotenv (~> 2.8)
+  durable-llm!
+  minitest (~> 5.0)
+  mocha (~> 2.1)
+  rake (~> 13.0)
+  rubocop (~> 1.21)
+  ruby-openai (~> 7.1)
+  thor (~> 1.3)
+  vcr (~> 6.0)
+  webmock (~> 3.24)
+
+BUNDLED WITH
+   2.4.10

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Durable Programming Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,96 @@
+# Durable-LLM
+
+Durable-LLM is a Ruby gem providing a unified interface for interacting with multiple Large Language Model APIs. It simplifies the integration of AI capabilities into Ruby applications by offering a consistent way to access various LLM providers.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'durable-llm'
+```
+
+And then execute:
+
+```
+$ bundle install
+```
+
+Or install it yourself as:
+
+```
+$ gem install durable-llm
+```
+
+## Usage
+
+Here's a basic example of how to use Durable-LLM:
+
+```ruby
+require 'durable-llm'
+
+client = Durable::Llm::Client.new(:openai, api_key: 'your-api-key')
+
+response = client.completion(
+  model: 'gpt-3.5-turbo',
+  messages: [{ role: 'user', content: 'Hello, how are you?' }]
+)
+
+puts response.choices.first.message.content
+
+```
+
+## Features
+
+- Unified interface for multiple LLM providers
+- Consistent input/output format across different models
+- Error handling and retries
+- Streaming support
+- Customizable timeout and request options
+
+## Supported Providers
+
+- OpenAI
+- Anthropic
+- Cohere
+- AI21
+- (More providers to be added)
+
+## Configuration
+
+You can configure Durable-LLM globally or on a per-request basis:
+
+```ruby
+Durable::Llm.configure do |config|
+  config.default_provider   = :openai
+  config.openai.api_key     = 'your-openai-api-key'
+  config.anthropic.api_key  = 'your-anthropic-api-key'
+  # Add other provider configurations as needed
+end
+```
+
+## Error Handling
+
+Durable-LLM provides a unified error handling system:
+
+```ruby
+begin
+  response = client.completion(model: 'gpt-3.5-turbo', messages: [...])
+rescue Durable::Llm::APIError => e
+  puts "API Error: #{e.message}"
+rescue Durable::Llm::RateLimitError => e
+  puts "Rate Limit Exceeded: #{e.message}"
+end
+```
+
+## Acknowledgements
+
+Thank you to the lite-llm and llm.datasette.io projects for their hard work, which was invaluable to this project. The dllm command line tool is patterned after the llm tool, though not as full-featured (yet).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/durableprogramming/durable-llm.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/enterprise/GET_ENTERPRISE.md

@@ -0,0 +1,40 @@
+# Enterprise Features for Durable-LLM
+
+Durable-LLM offers customized enterprise-grade options designed to meet the needs of large-scale organizations and mission-critical applications. Custom-fit Durable-LLM solutions enhance security, scalability, and reliability for enterprise users.
+
+## Advanced Security
+
+- **End-to-End Encryption**: All communications with LLM providers are encrypted using industry-standard protocols.
+- **Role-Based Access Control (RBAC)**: Granular control over user permissions and access to different LLM providers and models.
+- **Audit Logging**: Comprehensive logging of all API calls and user actions for compliance and security purposes.
+
+## High Availability and Scalability
+
+- **Load Balancing**: Automatically distribute requests across multiple LLM providers to ensure optimal performance and reliability.
+- **Failover Mechanisms**: Seamlessly switch between providers in case of outages or performance issues.
+- **Horizontal Scaling**: Easily scale your Durable-LLM deployment across multiple servers to handle increased load.
+
+## Advanced Monitoring and Analytics
+
+- **Real-time Metrics**: Monitor usage, latency, and error rates across all integrated LLM providers.
+- **Custom Dashboards**: Create tailored dashboards to visualize key performance indicators and usage patterns.
+- **Alerting System**: Set up custom alerts for various thresholds and events to proactively manage your LLM infrastructure.
+
+## Customization and Integration
+
+- **Custom Model Integration**: Easily integrate your own fine-tuned models or proprietary LLMs.
+- **API Customization**: Tailor the Durable-LLM API to fit your specific enterprise needs.
+- **Advanced Webhooks**: Set up complex event-driven workflows with our advanced webhook system.
+
+## Compliance and Governance
+
+- **Data Residency Options**: Choose where your data is processed and stored to comply with regional regulations.
+- **Policy Management**: Implement and enforce organization-wide policies for LLM usage and data handling.
+
+## Cost Management and Optimization
+
+- **Usage Analytics**: Detailed breakdowns of API usage and costs across different providers and models.
+- **Smart Routing**: Automatically route requests to the most cost-effective provider based on your defined rules.
+- **Budget Controls**: Set spending limits and receive alerts to prevent unexpected costs.
+
+To learn more about our customized enterprise offerings or to schedule a demo, please contact our sales team at enterprise@durableprogramming.com.

data/lib/durable/llm/cli.rb

@@ -0,0 +1,122 @@
+require 'thor'
+require 'durable/llm'
+require 'durable/llm/client'
+require 'highline'
+
+module Durable
+  module Llm
+    class CLI < Thor
+      def self.exit_on_failure?
+        true
+      end
+
+      desc "prompt PROMPT", "Run a prompt"
+      option :model, aliases: "-m", desc: "Specify the model to use"
+      option :system, aliases: "-s", desc: "Set a system prompt"
+      option :continue, aliases: "-c", type: :boolean, desc: "Continue the previous conversation"
+      option :conversation, aliases: "--cid", desc: "Continue a specific conversation by ID"
+      option :no_stream, type: :boolean, desc: "Disable streaming of tokens"
+      option :option, aliases: "-o", type: :hash, desc: "Set model-specific options"
+
+      def prompt(prompt)
+        config = Durable::Llm.configuration
+        model = options[:model] || "gpt-3.5-turbo"
+        provider_class = Durable::Llm::Providers.model_id_to_provider(model)
+
+        if provider_class.nil? 
+          raise "no provider found for model '#{model}'"
+        end
+
+        provider_name = provider_class.name.split('::').last.downcase.to_sym
+        client = Durable::Llm::Client.new(provider_name)
+        
+        messages = []
+        messages << { role: "system", content: options[:system] } if options[:system]
+        messages << { role: "user", content: prompt }
+
+        params = {
+          model: model,
+          messages: messages
+        }
+        params.merge!(options[:option]) if options[:option]
+
+        if options[:no_stream] 
+          response = client.completion(params)
+          puts response.choices.first.to_s
+        else
+          client.stream(params) do |chunk|
+            print chunk.to_s
+            $stdout.flush
+          end
+        end
+      end
+
+      desc "chat", "Start an interactive chat"
+      option :model, aliases: "-m", desc: "Specify the model to use"
+      option :system, aliases: "-s", desc: "Set a system prompt"
+      option :continue, aliases: "-c", type: :boolean, desc: "Continue the previous conversation"
+      option :conversation, aliases: "--cid", desc: "Continue a specific conversation by ID"
+      option :option, aliases: "-o", type: :hash, desc: "Set model-specific options"
+      def chat
+        config = Durable::Llm.configuration
+        model = options[:model] || "gpt-3.5-turbo"
+        provider_class = Durable::Llm::Providers.model_id_to_provider(model)
+
+        if provider_class.nil? || provider_class.name.nil?
+          raise "no provider found for model '#{model}'"
+        end
+
+        provider_name = provider_class.name.split('::').last.downcase.to_sym
+        client = Durable::Llm::Client.new(provider_name)
+        
+        messages = []
+        messages << { role: "system", content: options[:system] } if options[:system]
+
+        cli = HighLine.new
+
+        cli.say("Chatting with #{model}")
+        cli.say("Type 'exit' or 'quit' to exit")
+        cli.say("Type '!multi' to enter multiple lines, then '!end' to finish")
+
+        loop do
+          input = cli.ask("> ")
+          break if ['exit', 'quit'].include?(input.downcase)
+
+          if input == "!multi"
+            input = cli.ask("Enter multiple lines. Type '!end' to finish:") do |q|
+              q.gather = "!end"
+            end
+          end
+
+          messages << { role: "user", content: input }
+          params = {
+            model: model,
+            messages: messages
+          }
+          params.merge!(options[:option]) if options[:option]
+
+          response = client.completion(params)
+          cli.say(response.choices.first.to_s)
+          messages << { role: "assistant", content: response.choices.first.to_s }
+        end
+      end
+
+      desc "models", "List available models"
+      option :options, type: :boolean, desc: "Show model options"
+      def models
+        cli = HighLine.new
+        cli.say("Available models:")
+        
+        Durable::Llm::Providers.providers.each do |provider_name|
+          provider_class = Durable::Llm::Providers.const_get(provider_name.to_s.capitalize)
+          provider_models = provider_class.new.models
+          
+          cli.say("#{provider_name.to_s.capitalize}:")
+          provider_models.each do |model|
+            cli.say("  #{model}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/durable/llm/client.rb

@@ -0,0 +1,32 @@
+require 'zeitwerk'
+require 'durable/llm/providers'
+
+module Durable
+  module Llm
+    class Client
+      attr_reader :provider
+
+      def initialize(provider_name, options = {})
+        provider_class = Durable::Llm::Providers.const_get(provider_name.to_s.capitalize)
+
+        @provider = provider_class.new(**options)
+      end
+
+      def completion(params = {})
+        @provider.completion(params)
+      end
+
+      def chat(params = {})
+        @provider.chat(params)
+      end
+
+      def embed(params = {})
+        @provider.embed(params)
+      end
+
+      def stream(params = {}, &block)
+        @provider.stream(params, &block)
+      end
+    end
+  end
+end

data/lib/durable/llm/configuration.rb

@@ -0,0 +1,63 @@
+require 'ostruct'
+
+module Durable
+  module Llm
+    class Configuration
+      attr_accessor :default_provider
+      attr_reader :providers
+
+      def initialize
+        @providers = {}
+        load_from_env
+
+      end
+
+      def load_from_datasette
+
+        config_file = File.expand_path('~/.config/io.datasette.llm/keys.json')
+
+        if File.exist?(config_file)
+          config_data = JSON.parse(File.read(config_file))
+
+          Durable::Llm::Providers.providers.each do |provider|
+
+            @providers[provider.to_sym] ||= OpenStruct.new
+
+            if config_data[provider.to_s]
+              @providers[provider.to_sym][:api_key] = config_data[provider.to_s]
+            end
+
+          end
+        end
+
+      rescue JSON::ParserError => e
+        puts "Error parsing JSON file: #{e.message}"
+      end
+
+      def load_from_env
+        ENV.each do |key, value|
+          if key.start_with?('DLLM__')
+            parts = key.split('__')
+            provider = parts[1].downcase.to_sym
+            setting = parts[2].downcase.to_sym
+            @providers[provider] ||= OpenStruct.new
+            @providers[provider][setting] = value
+          end
+        end
+      end
+
+      def method_missing(method_name, *args, &block)
+        if method_name.to_s.end_with?('=')
+          provider = method_name.to_s.chomp('=').to_sym
+          @providers[provider] = args.first
+        else
+          @providers[method_name]
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        method_name.to_s.end_with?('=') || @providers.key?(method_name) || super
+      end
+    end
+  end
+end

data/lib/durable/llm/errors.rb

@@ -0,0 +1,33 @@
+module Durable
+  module Llm
+    class Error < StandardError; end
+
+    class APIError < Error; end
+
+    class RateLimitError < Error; end
+
+    class AuthenticationError < Error; end
+
+    class InvalidRequestError < Error; end
+
+    class ResourceNotFoundError < Error; end
+
+    class TimeoutError < Error; end
+
+    class ServerError < Error; end
+
+    class UnsupportedProviderError < Error; end
+
+    class ConfigurationError < Error; end
+
+    class ModelNotFoundError < Error; end
+
+    class InsufficientQuotaError < Error; end
+
+    class InvalidResponseError < Error; end
+
+    class NetworkError < Error; end
+
+    class StreamingError < Error; end
+  end
+end