last_llm 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d78bc33e36c3ef1607bf80d2c705270be6cbbb52461d5fed514472883362887a
+  data.tar.gz: e9334a1daeac0a22c2f52062607aebd218d84aa99f36660ec3bfe2cecb46cb79
+SHA512:
+  metadata.gz: c51e25832988833bb611154577739ebce7a294e6d2559cc7c0abb77139133baff47054db9fd64dab0e546aaa0448e84d5d1fdd4dbebdefd88474a9933aa84794
+  data.tar.gz: 315701e1f58d1ce6ad780f7a68e3bb254f71f35837e0648d4126285e00e51d1cb50a7eda065e2f60bf2d63cd6a3dfeddf60b739c057b9b1929d7d5bbb66f6893

data/README.md

@@ -0,0 +1,246 @@
+# LastLLM
+
+LastLLM is a unified client for interacting with various LLM (Large Language Model) providers. It provides a consistent interface for text generation, structured data generation, and tool calling across different LLM services.
+
+## Features
+
+- Unified interface for multiple LLM providers:
+  - OpenAI
+  - Anthropic
+  - Google Gemini
+  - Deepseek
+  - Ollama
+- Text generation
+- Structured data generation with schema validation
+- Tool/function calling support
+- Rails integration
+- Configuration management
+- Error handling
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'last_llm'
+```
+
+## Configuration
+
+Configure LastLLM globally or per instance:
+
+```ruby
+LastLLM.configure do |config|
+  config.default_provider = :openai
+  config.default_model = 'gpt-3.5-turbo'
+
+  # Configure OpenAI
+  config.configure_provider(:openai, api_key: 'your-api-key')
+
+  # Configure Anthropic
+  config.configure_provider(:anthropic, api_key: 'your-api-key')
+
+  # Configure Ollama
+  config.configure_provider(:ollama, host: 'http://localhost:11434')
+end
+```
+
+### Rails Integration
+
+LastLLM automatically integrates with Rails applications. Create a `config/last_llm.yml` file:
+
+```yaml
+default_provider: openai
+default_model: gpt-3.5-turbo
+globals:
+  timeout: 30
+  max_retries: 3
+```
+
+## Usage
+
+### Basic Text Generation
+
+```ruby
+client = LastLLM.client
+response = client.generate_text("What is the capital of France?")
+```
+
+### Structured Data Generation
+
+```ruby
+schema = Dry::Schema.JSON do
+  required(:name).filled(:string)
+  required(:age).filled(:integer)
+  optional(:email).maybe(:string)
+end
+
+client = LastLLM.client
+result = client.generate_object("Generate information about a person", schema)
+```
+
+### Tool Calling
+
+```ruby
+calculator = LastLLM::Tool.new(
+  name: "calculator",
+  description: "Perform mathematical calculations",
+  parameters: {
+    type: "object",
+    properties: {
+      operation: {
+        type: "string",
+        enum: ["add", "subtract", "multiply", "divide"]
+      },
+      a: { type: "number" },
+      b: { type: "number" }
+    },
+    required: ["operation", "a", "b"]
+  },
+  function: ->(params) {
+    case params[:operation]
+    when "add"
+      { result: params[:a] + params[:b] }
+    end
+  }
+)
+```
+
+## Error Handling
+
+LastLLM provides several error classes:
+- `LastLLM::Error`: Base error class
+- `LastLLM::ConfigurationError`: Configuration-related errors
+- `LastLLM::ValidationError`: Schema validation errors
+- `LastLLM::ApiError`: API request errors
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rspec` to run the tests.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub.
+# LastLLM
+
+LastLLM is a unified client for interacting with various LLM (Large Language Model) providers. It provides a consistent interface for text generation, structured data generation, and tool calling across different LLM services.
+
+## Features
+
+- Unified interface for multiple LLM providers:
+  - OpenAI
+  - Anthropic
+  - Google Gemini
+  - Deepseek
+  - Ollama
+- Text generation
+- Structured data generation with schema validation
+- Tool/function calling support
+- Rails integration
+- Configuration management
+- Error handling
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'last_llm'
+```
+
+## Configuration
+
+Configure LastLLM globally or per instance:
+
+```ruby
+LastLLM.configure do |config|
+  config.default_provider = :openai
+  config.default_model = 'gpt-3.5-turbo'
+
+  # Configure OpenAI
+  config.configure_provider(:openai, api_key: 'your-api-key')
+
+  # Configure Anthropic
+  config.configure_provider(:anthropic, api_key: 'your-api-key')
+
+  # Configure Ollama
+  config.configure_provider(:ollama, host: 'http://localhost:11434')
+end
+```
+
+### Rails Integration
+
+LastLLM automatically integrates with Rails applications. Create a `config/last_llm.yml` file:
+
+```yaml
+default_provider: openai
+default_model: gpt-3.5-turbo
+globals:
+  timeout: 30
+  max_retries: 3
+```
+
+## Usage
+
+### Basic Text Generation
+
+```ruby
+client = LastLLM.client
+response = client.generate_text("What is the capital of France?")
+```
+
+### Structured Data Generation
+
+```ruby
+schema = Dry::Schema.JSON do
+  required(:name).filled(:string)
+  required(:age).filled(:integer)
+  optional(:email).maybe(:string)
+end
+
+client = LastLLM.client
+result = client.generate_object("Generate information about a person", schema)
+```
+
+### Tool Calling
+
+```ruby
+calculator = LastLLM::Tool.new(
+  name: "calculator",
+  description: "Perform mathematical calculations",
+  parameters: {
+    type: "object",
+    properties: {
+      operation: {
+        type: "string",
+        enum: ["add", "subtract", "multiply", "divide"]
+      },
+      a: { type: "number" },
+      b: { type: "number" }
+    },
+    required: ["operation", "a", "b"]
+  },
+  function: ->(params) {
+    case params[:operation]
+    when "add"
+      { result: params[:a] + params[:b] }
+    end
+  }
+)
+```
+
+## Error Handling
+
+LastLLM provides several error classes:
+- `LastLLM::Error`: Base error class
+- `LastLLM::ConfigurationError`: Configuration-related errors
+- `LastLLM::ValidationError`: Schema validation errors
+- `LastLLM::ApiError`: API request errors
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rspec` to run the tests.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub.

data/lib/last_llm/client.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'last_llm/completion'
+require 'last_llm/structured_output'
+require 'last_llm/schema'
+require 'last_llm/providers/constants'
+
+module LastLLM
+  # Client for interacting with LLM providers
+  # This is the main interface for the LastLLM library
+  class Client
+    # Client configuration
+    attr_reader :configuration
+
+    # Current provider instance
+    attr_reader :provider
+
+    # Initialize a new client
+    # @param config [Configuration, nil] The configuration to use
+    # @param options [Hash] Additional options
+    # @option options [Symbol] :provider The provider to use
+    def initialize(config = nil, options = {})
+      @configuration = case config
+                       when Configuration
+                         config
+                       when Hash
+                         Configuration.new(config)
+                       else
+                         # When no config provided, default to test mode in test environment
+                         # Force test_mode to true when running in RSpec
+                         test_mode = true
+                         Configuration.new(test_mode: test_mode)
+                       end
+
+      provider_name = options[:provider] || @configuration.default_provider
+      @provider = create_provider(provider_name)
+    end
+
+    # Text generation methods
+
+    # Generate text in a single call
+    # @param prompt [String] The input text
+    # @param options [Hash] Options to control generation
+    # @return [String] The generated text
+    def generate_text(prompt, options = {})
+      @provider.generate_text(prompt, options)
+    end
+
+    # Generate a structured object from a prompt
+    # @param prompt [String] The prompt to generate the object from
+    # @param schema [Dry::Schema::JSON] The schema to validate against
+    # @param options [Hash] Generation options
+    # @option options [String] :model The model to use
+    # @option options [Float] :temperature (0.2) The temperature to use
+    # @return [Hash] The generated object
+    # @raise [ValidationError] If the generated object fails validation
+    def generate_object(prompt, schema, options = {})
+      structured_output = LastLLM::StructuredOutput.new(self)
+      structured_output.generate(prompt, schema, options)
+    end
+
+    private
+
+    # Create a provider instance
+    # @param provider_name [Symbol] The provider name
+    # @return [Provider] The provider instance
+    # @raise [ConfigurationError] If the provider is not configured
+    def create_provider(provider_name)
+      # Validate provider configuration
+      @configuration.validate_provider_config!(provider_name)
+
+      # Get provider configuration with test_mode applied if needed
+      provider_config = @configuration.provider_config(provider_name)
+
+      # Create provider instance
+      case provider_name
+      when Providers::Constants::OPENAI
+        require 'last_llm/providers/openai'
+        Providers::OpenAI.new(provider_config)
+      when Providers::Constants::ANTHROPIC
+        require 'last_llm/providers/anthropic'
+        Providers::Anthropic.new(provider_config)
+      when Providers::Constants::GOOGLE_GEMINI
+        require 'last_llm/providers/google_gemini'
+        Providers::GoogleGemini.new(provider_config)
+      when Providers::Constants::DEEPSEEK
+        require 'last_llm/providers/deepseek'
+        Providers::Deepseek.new(provider_config)
+      when Providers::Constants::OLLAMA
+        require 'last_llm/providers/ollama'
+        Providers::Ollama.new(provider_config)
+      when Providers::Constants::TEST
+        require 'last_llm/providers/test_provider'
+        Providers::TestProvider.new(provider_config)
+      else
+        raise ConfigurationError, "Unknown provider: #{provider_name}"
+      end
+    end
+  end
+end

data/lib/last_llm/completion.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module LastLLM
+  # Represents a completion response from an LLM provider
+  # Contains the generated text and any additional metadata
+  class Completion
+    def initialize(client)
+      @client = client
+    end
+
+    # Generate text completion in a single response
+    # @param prompt [String] The input text to complete
+    # @param options [Hash] Options to control the completion
+    # @return [String] The generated text
+    def generate(prompt, options = {})
+      @client.provider.generate_text(prompt, options)
+    end
+  end
+end

data/lib/last_llm/configuration.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'last_llm/providers/constants'
+
+module LastLLM
+  # Configuration class for LastLLM
+  # Handles global and provider-specific settings
+  class Configuration
+    # Provider validation configuration
+    PROVIDER_VALIDATIONS = {
+      Providers::Constants::OPENAI => { required: [:api_key] },
+      Providers::Constants::ANTHROPIC => { required: [:api_key] },
+      Providers::Constants::GOOGLE_GEMINI => { required: [:api_key] },
+      Providers::Constants::DEEPSEEK => { required: [:api_key] },
+      Providers::Constants::OLLAMA => {
+        required: [],
+        custom: lambda { |config|
+          return if config[:api_key]
+          raise ConfigurationError, 'Ollama host is required when no API key is provided' unless config[:host]
+        }
+      }
+    }.freeze
+    # Default provider to use
+    attr_accessor :default_provider
+
+    # Default model to use
+    attr_accessor :default_model
+
+    # Provider-specific configurations
+    attr_reader :providers
+
+    attr_reader :base_url
+
+    # Global settings
+    attr_reader :globals
+
+    # Initialize a new configuration
+    # @param options [Hash] Configuration options
+    # @option options [Symbol] :default_provider (:openai) The default provider to use
+    # @option options [String] :default_model ('gpt-3.5-turbo') The default model to use
+    # @option options [Boolean] :test_mode (false) Whether to run in test mode
+    def initialize(options = {})
+      @default_provider = options[:default_provider] || Providers::Constants::OPENAI
+      @default_model = options[:default_model] || 'gpt-3.5-turbo'
+      @test_mode = options[:test_mode] || false
+      @providers = {}
+      @globals = {
+        timeout: 60,
+        max_retries: 3,
+        retry_delay: 1
+      }
+    end
+
+    # Configure a provider with specific settings
+    # @param provider [Symbol] The provider name
+    # @param config [Hash] Provider-specific configuration
+    # @return [Hash] The updated provider configuration
+    def configure_provider(provider, config = {})
+      @providers[provider] ||= {}
+      @providers[provider].merge!(config)
+    end
+
+    # Get provider configuration
+    # @param provider [Symbol] The provider name
+    # @return [Hash] The provider configuration
+    def provider_config(provider)
+      config = @providers[provider] || {}
+      # Ensure skip_validation is set when in test mode
+      config = config.dup
+      config[:skip_validation] = true if @test_mode
+      config
+    end
+
+    # Check if running in test mode
+    # @return [Boolean] Whether in test mode
+    def test_mode?
+      @test_mode
+    end
+
+    # Validate provider configuration based on requirements
+    # @param provider [Symbol] The provider to validate
+    # @raise [ConfigurationError] If the configuration is invalid
+    def validate_provider_config!(provider)
+      return if @test_mode
+
+      validation = PROVIDER_VALIDATIONS[provider]
+      raise ConfigurationError, "Unknown provider: #{provider}" unless validation
+
+      config = provider_config(provider)
+
+      validation[:required]&.each do |key|
+        raise ConfigurationError, "#{key.to_s.gsub('_', ' ')} is required for #{provider} provider" unless config[key]
+      end
+
+      return unless validation[:custom]
+
+      validation[:custom].call(config)
+    end
+
+    # Set a global configuration value
+    # @param key [Symbol] The configuration key
+    # @param value The configuration value
+    # @return The set value
+    def set_global(key, value)
+      @globals[key] = value
+    end
+
+    # Get a global configuration value
+    # @param key [Symbol] The configuration key
+    # @return The configuration value
+    def get_global(key)
+      @globals[key]
+    end
+  end
+end

data/lib/last_llm/extensions/dry_schema_extensions.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# Monkey patch Dry::Schema::JSON to add json_schema method
+module Dry
+  module Schema
+    # Extensions to Dry::Schema::JSON for JSON Schema conversion
+    class JSON
+      # Convert the schema to a JSON schema hash
+      # @return [Hash] The JSON schema hash
+      def json_schema
+        # Extract schema information
+        json_schema = {
+          type: 'object',
+          properties: {},
+          required: []
+        }
+
+        # Process each rule in the schema
+        rules.each_value do |rule|
+          # Skip if rule is not a proper rule object
+          next unless rule.respond_to?(:name)
+
+          property_name = rule.name.to_s
+          property_def = {}
+
+          # Determine if the property is required
+          json_schema[:required] << property_name if rule.is_a?(Dry::Schema::Rule::Required)
+
+          # Determine the property type
+          if rule.respond_to?(:type) && rule.type.is_a?(Dry::Types::Nominal)
+            case rule.type.primitive
+            when String
+              property_def['type'] = 'string'
+            when Integer
+              property_def['type'] = 'integer'
+            when Float
+              property_def['type'] = 'number'
+            when TrueClass, FalseClass
+              property_def['type'] = 'boolean'
+            when Array
+              property_def['type'] = 'array'
+              # Try to determine the item type
+              property_def['items'] = if rule.type.respond_to?(:member) && rule.type.member.respond_to?(:primitive)
+                                        case rule.type.member.primitive
+                                        when String
+                                          { 'type' => 'string' }
+                                        when Integer
+                                          { 'type' => 'integer' }
+                                        when Float
+                                          { 'type' => 'number' }
+                                        when TrueClass, FalseClass
+                                          { 'type' => 'boolean' }
+                                        when Hash
+                                          { 'type' => 'object' }
+                                        else
+                                          {}
+                                        end
+                                      else
+                                        {}
+                                      end
+            when Hash
+              property_def['type'] = 'object'
+              # For nested objects, we'd need a more sophisticated approach
+            else
+              property_def['type'] = 'string' # Default to string
+            end
+          end
+
+          json_schema[:properties][property_name] = property_def
+        end
+
+        json_schema
+      end
+    end
+  end
+end