net-llm 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28baf2a76420a22be944c1a46aab05d8dfceda575bbb9f341260e592a9e7711f
-  data.tar.gz: f746ecda882d6f08336753fd45319aa28d133c36f43fea9334e83564735d11cd
+  metadata.gz: 5fc7c8401eba4ab7b254b1247280c97f61db7fd7ed9b562c90bae0bc4066fbbc
+  data.tar.gz: a74469b7086118a424b20f688a1ed899a28cb8652bbc5683c65d5bfba8d748ea
 SHA512:
-  metadata.gz: fb6e7aebda0fbb74e06892f2eacc6812c428922743e5130ef5fde3e5ef235bbb9156a73234fdd57be04afba3ef9d62d438345dfd044a8db03798ef17b41344e4
-  data.tar.gz: 61d7e73ea24484b1c7115ae19f192579370f66e925fd80c1337a6e94ef54af16b05d465d3a83a8d5a6fcff45eaac01d38d73ceaed8ff0973db6ccaa3787b264d
+  metadata.gz: fcbb8722b6d6c2d9414ce49ded2a4abff7da0051e924483f6900676d6602ae64f5c1437f152b025b4a84a7c1700a2c9874254521f9b39206ab757955e18e042f
+  data.tar.gz: bea9a981fead23269fdc12f0012030187dfbd7da1bc444a8d23eee75fe4eba1dae68a9f1570e54352a8fe3c84bd3abd1d6563b88612342d48ffd425fbb6b95d4

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 ## [Unreleased]
 
+## [0.3.0] - 2025-10-08
+### Changed
+- Refactored all providers to use net-hippie HTTP client
+- Reduced code duplication across providers
+- Improved error handling consistency
+
+### Added
+- Added net-hippie dependency for cleaner HTTP interactions
+
+## [0.2.0] - 2025-10-08
+
+- Add Ollama provider with streaming support
+  - `/api/chat` endpoint with streaming
+  - `/api/generate` endpoint with streaming
+  - `/api/embed` endpoint for embeddings
+  - `/api/tags` endpoint to list models
+  - `/api/show` endpoint for model info
+- Add Anthropic (Claude) provider with streaming support
+  - `/v1/messages` endpoint with streaming
+  - Support for system prompts
+  - Support for tools/function calling
+- Extend OpenAI provider
+  - Add `/v1/models` endpoint
+  - Add `/v1/embeddings` endpoint
+
 ## [0.1.0] - 2025-10-07
 
 - Initial release

data/README.md

@@ -69,16 +69,140 @@ tools = [
 response = client.chat(messages, tools)
 ```
 
+### Ollama
+
+```ruby
+require 'net/llm'
+
+client = Net::Llm::Ollama.new(
+  host: 'localhost:11434',
+  model: 'gpt-oss:latest'
+)
+
+messages = [
+  { role: 'user', content: 'Hello!' }
+]
+
+response = client.chat(messages)
+puts response['message']['content']
+```
+
+#### Streaming
+
+```ruby
+client.chat(messages) do |chunk|
+  print chunk.dig('message', 'content')
+end
+```
+
+#### Generate
+
+```ruby
+response = client.generate('Write a haiku')
+puts response['response']
+
+client.generate('Write a haiku') do |chunk|
+  print chunk['response']
+end
+```
+
+#### Other Endpoints
+
+```ruby
+client.embeddings('Hello world')
+client.tags
+client.show('llama2')
+```
+
+### Anthropic (Claude)
+
+```ruby
+require 'net/llm'
+
+client = Net::Llm::Anthropic.new(
+  api_key: ENV['ANTHROPIC_API_KEY'],
+  model: 'claude-3-5-sonnet-20241022'
+)
+
+messages = [
+  { role: 'user', content: 'Hello!' }
+]
+
+response = client.messages(messages)
+puts response.dig('content', 0, 'text')
+```
+
+#### With System Prompt
+
+```ruby
+response = client.messages(
+  messages,
+  system: 'You are a helpful assistant'
+)
+```
+
+#### Streaming
+
+```ruby
+client.messages(messages) do |event|
+  if event['type'] == 'content_block_delta'
+    print event.dig('delta', 'text')
+  end
+end
+```
+
+#### With Tools
+
+```ruby
+tools = [
+  {
+    name: 'get_weather',
+    description: 'Get current weather',
+    input_schema: {
+      type: 'object',
+      properties: {
+        location: { type: 'string' }
+      },
+      required: ['location']
+    }
+  }
+]
+
+response = client.messages(messages, tools: tools)
+```
+
+## Error Handling
+
+All non-streaming API methods return error information as a hash when requests fail:
+
+```ruby
+response = client.chat(messages, tools)
+
+if response["code"]
+  puts "Error #{response["code"]}: #{response["body"]}"
+else
+  puts response.dig('choices', 0, 'message', 'content')
+end
+```
+
+Streaming methods still raise exceptions on HTTP errors.
+
 ## API Coverage
 
 ### OpenAI
 - `/v1/chat/completions` (with tools support)
+- `/v1/models`
+- `/v1/embeddings`
 
 ### Ollama
-Coming soon
+- `/api/chat` (with streaming)
+- `/api/generate` (with streaming)
+- `/api/embed`
+- `/api/tags`
+- `/api/show`
 
 ### Anthropic (Claude)
-Coming soon
+- `/v1/messages` (with streaming and tools)
 
 ## Development
 

data/lib/net/llm/anthropic.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Net
+  module Llm
+    class Anthropic
+      attr_reader :api_key, :model, :http
+
+      def initialize(api_key:, model: "claude-3-5-sonnet-20241022", http: Net::Llm.http)
+        @api_key = api_key
+        @model = model
+        @http = http
+      end
+
+      def messages(messages, system: nil, max_tokens: 1024, tools: nil, &block)
+        url = "https://api.anthropic.com/v1/messages"
+        payload = build_payload(messages, system, max_tokens, tools, block_given?)
+
+        if block_given?
+          stream_request(url, payload, &block)
+        else
+          post_request(url, payload)
+        end
+      end
+
+      private
+
+      def build_payload(messages, system, max_tokens, tools, stream)
+        payload = {
+          model: model,
+          max_tokens: max_tokens,
+          messages: messages,
+          stream: stream
+        }
+        payload[:system] = system if system
+        payload[:tools] = tools if tools
+        payload
+      end
+
+      def headers
+        {
+          "x-api-key" => api_key,
+          "anthropic-version" => "2023-06-01"
+        }
+      end
+
+      def post_request(url, payload)
+        handle_response(http.post(url, headers: headers, body: payload))
+      end
+
+      def handle_response(response)
+        if response.is_a?(Net::HTTPSuccess)
+          JSON.parse(response.body)
+        else
+          { "code" => response.code, "body" => response.body }
+        end
+      end
+
+      def stream_request(url, payload, &block)
+        http.post(url, headers: headers, body: payload) do |response|
+          raise "HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+          buffer = ""
+          response.read_body do |chunk|
+            buffer += chunk
+
+            while (event = extract_sse_event(buffer))
+              next if event[:data].nil? || event[:data].empty?
+              next if event[:data] == "[DONE]"
+
+              json = JSON.parse(event[:data])
+              block.call(json)
+
+              break if json["type"] == "message_stop"
+            end
+          end
+        end
+      end
+
+      def extract_sse_event(buffer)
+        event_end = buffer.index("\n\n")
+        return nil unless event_end
+
+        event_data = buffer[0...event_end]
+        buffer.replace(buffer[(event_end + 2)..-1] || "")
+
+        event = {}
+        event_data.split("\n").each do |line|
+          if line.start_with?("event: ")
+            event[:event] = line[7..-1]
+          elsif line.start_with?("data: ")
+            event[:data] = line[6..-1]
+          elsif line == "data:"
+            event[:data] = ""
+          end
+        end
+
+        event
+      end
+    end
+  end
+end

data/lib/net/llm/ollama.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Net
+  module Llm
+    class Ollama
+      attr_reader :host, :model, :http
+
+      def initialize(host: "localhost:11434", model: "llama2", http: Net::Llm.http)
+        @host = host
+        @model = model
+        @http = http
+      end
+
+      def chat(messages, &block)
+        url = build_url("/api/chat")
+        payload = { model: model, messages: messages, stream: block_given? }
+
+        if block_given?
+          stream_request(url, payload, &block)
+        else
+          post_request(url, payload)
+        end
+      end
+
+      def generate(prompt, &block)
+        url = build_url("/api/generate")
+        payload = { model: model, prompt: prompt, stream: block_given? }
+
+        if block_given?
+          stream_request(url, payload, &block)
+        else
+          post_request(url, payload)
+        end
+      end
+
+      def embeddings(input)
+        url = build_url("/api/embed")
+        payload = { model: model, input: input }
+        post_request(url, payload)
+      end
+
+      def tags
+        url = build_url("/api/tags")
+        response = http.get(url)
+        handle_response(response)
+      end
+
+      def show(name)
+        url = build_url("/api/show")
+        payload = { name: name }
+        post_request(url, payload)
+      end
+
+      private
+
+      def build_url(path)
+        base = host.start_with?("http://", "https://") ? host : "http://#{host}"
+        "#{base}#{path}"
+      end
+
+      def post_request(url, payload)
+        response = http.post(url, body: payload)
+        handle_response(response)
+      end
+
+      def handle_response(response)
+        if response.is_a?(Net::HTTPSuccess)
+          JSON.parse(response.body)
+        else
+          { "code" => response.code, "body" => response.body }
+        end
+      end
+
+      def stream_request(url, payload, &block)
+        http.post(url, body: payload) do |response|
+          raise "HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+          buffer = ""
+          response.read_body do |chunk|
+            buffer += chunk
+
+            while (message = extract_message(buffer))
+              next if message.empty?
+
+              json = JSON.parse(message)
+              block.call(json)
+
+              break if json["done"]
+            end
+          end
+        end
+      end
+
+      def extract_message(buffer)
+        message_end = buffer.index("\n")
+        return nil unless message_end
+
+        message = buffer[0...message_end]
+        buffer.replace(buffer[(message_end + 1)..-1] || "")
+        message
+      end
+    end
+  end
+end

data/lib/net/llm/openai.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Net
+  module Llm
+    class OpenAI
+      attr_reader :api_key, :base_url, :model, :http
+
+      def initialize(api_key:, base_url: "https://api.openai.com/v1", model: "gpt-4o-mini", http: Net::Llm.http)
+        @api_key = api_key
+        @base_url = base_url
+        @model = model
+        @http = http
+      end
+
+      def chat(messages, tools)
+        handle_response(http.post(
+          "#{base_url}/chat/completions",
+          headers: headers,
+          body: { model: model, messages: messages, tools: tools, tool_choice: "auto" }
+        ))
+      end
+
+      def models
+        handle_response(http.get("#{base_url}/models", headers: headers))
+      end
+
+      def embeddings(input, model: "text-embedding-ada-002")
+        handle_response(http.post(
+          "#{base_url}/embeddings",
+          headers: headers,
+          body: { model: model, input: input },
+        ))
+      end
+
+      private
+
+      def headers
+        { "Authorization" => Net::Hippie.bearer_auth(api_key) }
+      end
+
+      def handle_response(response)
+        if response.is_a?(Net::HTTPSuccess)
+          JSON.parse(response.body)
+        else
+          { "code" => response.code, "body" => response.body }
+        end
+      end
+    end
+  end
+end

data/lib/net/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Net
   module Llm
-    VERSION = "0.1.0"
+    VERSION = "0.3.0"
   end
 end

data/lib/net/llm.rb

@@ -1,38 +1,21 @@
 # frozen_string_literal: true
 
 require_relative "llm/version"
+require_relative "llm/openai"
+require_relative "llm/ollama"
+require_relative "llm/anthropic"
+require "net/hippie"
+require "json"
 
 module Net
   module Llm
     class Error < StandardError; end
-    DEFAULT_TIMEOUT = 60 * 2
 
-    class OpenAI
-      attr_reader :api_key, :base_url, :model
-
-      def initialize(api_key:, base_url: "https://api.openai.com/v1", model: "gpt-4o-mini")
-        @api_key = api_key
-        @base_url = base_url
-        @model = model
-      end
-
-      def chat(messages, tools, timeout: DEFAULT_TIMEOUT)
-        uri = URI("#{base_url}/chat/completions")
-        request = Net::HTTP::Post.new(uri)
-        request["Authorization"] = "Bearer #{api_key}"
-        request["Content-Type"] = "application/json"
-        request.body = { model: model, messages: messages, tools: tools, tool_choice: "auto" }.to_json
-
-        http = Net::HTTP.new(uri.hostname, uri.port)
-        http.use_ssl = true
-        http.open_timeout = timeout
-        http.read_timeout = timeout
-        http.write_timeout = timeout if http.respond_to?(:write_timeout=)
-
-        response = http.start { |h| h.request(request) }
-        raise "HTTP #{response.code}: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
-        JSON.parse(response.body)
-      end
+    def self.http
+      @http ||= Net::Hippie::Client.new(
+        read_timeout: 3600,
+        open_timeout: 10
+      )
     end
   end
 end

metadata

@@ -1,14 +1,56 @@
 --- !ruby/object:Gem::Specification
 name: net-llm
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - mo khan
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: uri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: net-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
 description: A minimal Ruby gem providing interfaces to connect to OpenAI, Ollama,
   and Anthropic (Claude) LLM APIs
 email:
@@ -22,6 +64,9 @@ files:
 - README.md
 - Rakefile
 - lib/net/llm.rb
+- lib/net/llm/anthropic.rb
+- lib/net/llm/ollama.rb
+- lib/net/llm/openai.rb
 - lib/net/llm/version.rb
 - sig/net/llm.rbs
 homepage: https://github.com/xlgmokha/net-llm