ollama-ruby 0.0.0

data/bin/ollama_chat

@@ -0,0 +1,258 @@
+#!/usr/bin/env ruby
+
+require 'ollama'
+include Ollama
+require 'term/ansicolor'
+include Term::ANSIColor
+require 'tins/go'
+include Tins::GO
+require 'reline'
+
+class FollowChat
+  include Ollama::Handlers::Concern
+  include Term::ANSIColor
+
+  def initialize(messages:, markdown: false, voice: nil, output: $stdout)
+    super(output:)
+    @output.sync = true
+    @markdown = markdown
+    @say = voice ? Ollama::Handlers::Say.new(voice:) : NOP
+    @messages = messages
+    @user     = nil
+  end
+
+  def call(response)
+    ENV['DEBUG'].to_i == 1 and jj response
+    if response&.message&.role == 'assistant'
+      if @messages.last.role != 'assistant'
+        @messages << Ollama::Message.new(role: 'assistant', content: '')
+        @user = message_type(@messages.last.images) + " " +
+          bold { color(111) { 'assistant:' } }
+        puts @user unless @markdown
+      end
+      content = response.message&.content
+      @messages.last.content << content
+      if @markdown and @messages.last.content.present?
+        markdown_content = Ollama::Utils::ANSIMarkdown.parse(@messages.last.content)
+        @output.print clear_screen, move_home, @user, ?\n, markdown_content
+      else
+        @output.print content
+      end
+      @say.call(response)
+    end
+    response.done and @output.puts
+    self
+  end
+end
+
+def pull_model_unless_present(client, model, options)
+  retried = false
+  begin
+    client.show(name: model) { |response|
+      puts green {
+        "Model with architecture #{response.model_info['general.architecture']} found."
+      }
+      if options
+        puts "Model options are:"
+        jj options
+      end
+      if system = response.system
+        puts "Configured model system prompt is:\n#{italic { system }}"
+        return system
+      else
+        return
+      end
+    }
+  rescue Errors::NotFoundError
+    puts "Model #{model} not found, attempting to pull it now…"
+    client.pull(name: model)
+    if retried
+      exit 1
+    else
+      retried = true
+      retry
+    end
+  rescue Errors::Error => e
+    warn "Caught #{e.class}: #{e} => Exiting."
+    exit 1
+  end
+end
+
+def load_conversation(filename)
+  unless File.exist?(filename)
+    puts "File #{filename} doesn't exist. Choose another filename."
+    return
+  end
+  File.open(filename, 'r') do |output|
+    return JSON(output.read, create_additions: true)
+  end
+end
+
+def save_conversation(filename, messages)
+  if File.exist?(filename)
+    puts "File #{filename} already exists. Choose another filename."
+    return
+  end
+  File.open(filename, 'w') do |output|
+    output.puts JSON(messages)
+  end
+end
+
+def message_type(images)
+  if images.present?
+    ?📸
+  else
+    ?📨
+  end
+end
+
+def list_conversation(messages, markdown)
+  messages.each do |m|
+    role_color = case m.role
+                 when 'user' then 172
+                 when 'assistant' then 111
+                 when 'system' then 213
+                 else 210
+                 end
+    content = if markdown && m.content.present?
+                Ollama::Utils::ANSIMarkdown.parse(m.content)
+              else
+                m.content
+              end
+    puts message_type(m.images) + " " +
+      bold { color(role_color) { m.role } } + ":\n#{content}"
+  end
+end
+
+def display_chat_help
+  puts <<~end
+      /paste          to paste content
+      /list           list the messages of the conversation
+      /clear          clear the conversation messages
+      /pop n          pop the last n message, defaults to 1
+      /regenerate     the last answer message
+      /save filename  store conversation messages
+      /load filename  load conversation messages
+      /image filename attach image to the next message
+      /quit           to quit.
+      /help           to view this help.
+  end
+end
+
+def usage
+  puts <<~end
+    #{File.basename($0)} [OPTIONS]
+
+      -u URL     the ollama base url, OLLAMA_URL
+      -m MODEL   the ollama model to chat with, OLLAMA_MODEL
+      -M OPTIONS the model options as JSON file, see Ollama::Options
+      -s SYSTEM  the system prompt to use as a file
+      -c CHAT    a saved chat conversation to load
+      -v VOICE   use VOICE (e. g. Samantha) to speak with say command
+      -d         use markdown to display the chat messages
+      -h         this help
+
+  end
+  exit 0
+end
+
+opts = go 'u:m:M:s:c:v:dh'
+
+opts[?h] and usage
+
+base_url = opts[?u] || ENV['OLLAMA_URL'] || 'http://%s' % ENV.fetch('OLLAMA_HOST')
+model    = opts[?m] || ENV.fetch('OLLAMA_MODEL', 'llama3.1')
+options = if options_file = opts[?M]
+            JSON(File.read(options_file), create_additions: true)
+          end
+
+client   = Client.new(base_url:)
+
+model_system = pull_model_unless_present(client, model, options)
+
+puts green { "Connecting to #{model}@#{base_url} now…" }
+
+messages = []
+
+if opts[?c]
+  messages.concat load_conversation(opts[?c])
+else
+  system = nil
+  if system_prompt_file = opts[?s]
+    system = File.read(system_prompt_file)
+  end
+  system ||= ENV['OLLAMA_SYSTEM']
+
+  if system
+    messages << Message.new(role: 'system', content: system)
+    puts "Configured system prompt is:\n#{italic { system }}"
+  elsif model_system.present?
+    puts "Using model system prompt."
+  end
+end
+
+puts "Type /help to display the chat help."
+
+images = nil
+loop do
+  prompt = bold { color(172) { message_type(images) + " user" } } + bold { "> " }
+  case content = Reline.readline(prompt, true)&.chomp
+  when %r(^/paste$)
+    puts bold { "Paste your content and then press C-d!" }
+    content = STDIN.read
+  when %r(^/quit$)
+    puts "Goodbye."
+    exit 0
+  when %r(^/list$)
+    list_conversation(messages, opts[?d])
+    next
+  when %r(^/clear$)
+    messages.clear
+    puts "Cleared messages."
+    next
+  when %r(^/pop\s*(\d*)$)
+    n = $1.to_i.clamp(1, Float::INFINITY)
+    messages.pop(n)
+    puts "Popped the last #{n} messages."
+    next
+  when %r(^/regenerate$)
+    if content = messages[-2]&.content
+      images = messages[-2]&.images
+      messages.pop(2)
+    else
+      puts "Not enough messages in this conversation."
+      redo
+    end
+  when %r(^/save (.+)$)
+    save_conversation($1, messages)
+    puts "Saved conversation to #$1."
+    next
+  when %r(^/load (.+)$)
+    messages = load_conversation($1)
+    puts "Loaded conversation from #$1."
+    next
+  when %r(^/image (.+)$)
+    filename = File.expand_path($1)
+    if File.exist?(filename)
+      images = Image.for_filename(filename)
+      puts "Attached image #$1 to the next message."
+      redo
+    else
+      puts "Filename #$1 doesn't exist. Choose another one."
+      next
+    end
+  when %r(^/help$)
+    display_chat_help
+    next
+  when nil
+    puts "Type /quit to quit."
+    next
+  end
+  messages << Message.new(role: 'user', content:, images:)
+  handler = FollowChat.new(messages:, markdown: opts[?d], voice: opts[?v])
+  client.chat(model:, messages:, options:, stream: true, &handler)
+  ENV['DEBUG'].to_i == 1 and jj messages
+  images = nil
+rescue Interrupt
+  puts "Type /quit to quit."
+end

data/bin/ollama_console

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require 'ollama'
+include Ollama
+require 'irb'
+require 'irb/history'
+
+base_url = ENV['OLLAMA_URL'] || 'http://%s' % ENV.fetch('OLLAMA_HOST')
+client = Client.new(base_url:)
+IRB.setup nil
+IRB.conf[:MAIN_CONTEXT] = IRB::Irb.new.context
+IRB.conf[:HISTORY_FILE] = File.join(ENV.fetch('HOME'), '.ollama_console-history')
+IRB.conf[:SAVE_HISTORY] = 1000
+require 'irb/ext/multi-irb'
+if io = IRB.conf[:MAIN_CONTEXT].io and io.support_history_saving?
+  io.load_history
+  at_exit { io.save_history }
+end
+client.help
+IRB.irb nil, client

data/lib/ollama/client/command.rb

@@ -0,0 +1,25 @@
+module Ollama::Client::Command
+  extend Tins::Concern
+
+  module ClassMethods
+    # Create Command +name+, if +stream+ was true, set stream_handler as
+    # default, otherwise default_handler.
+    def command(name, default_handler:, stream_handler: nil)
+      klass = Ollama::Commands.const_get(name.to_s.camelize)
+      doc Ollama::Client::Doc.new(name)
+      define_method(name) do |**parameters, &handler|
+        instance = klass.new(**parameters)
+        instance.client = self
+        unless handler
+          instance.stream and stream_handler and
+            handler ||= stream_handler
+          handler ||= default_handler
+        end
+        handler.is_a?(Class) and handler = handler.new
+        instance.perform(handler)
+        handler.result if handler.respond_to?(:result)
+      end
+      self
+    end
+  end
+end

data/lib/ollama/client/doc.rb

@@ -0,0 +1,26 @@
+require 'term/ansicolor'
+
+class Ollama::Client::Doc
+  include Term::ANSIColor
+
+  def initialize(name)
+    @name = name
+    @url  = Hash.new('https://github.com/ollama/ollama/blob/main/docs/api.md').merge(
+      generate:         'https://github.com/ollama/ollama/blob/main/docs/api.md#generate-a-completion',
+      chat:             'https://github.com/ollama/ollama/blob/main/docs/api.md#generate-a-chat-completion',
+      create:           'https://github.com/ollama/ollama/blob/main/docs/api.md#create-a-model',
+      tags:             'https://github.com/ollama/ollama/blob/main/docs/api.md#list-local-models',
+      show:             'https://github.com/ollama/ollama/blob/main/docs/api.md#show-model-information',
+      copy:             'https://github.com/ollama/ollama/blob/main/docs/api.md#copy-a-model',
+      delete:           'https://github.com/ollama/ollama/blob/main/docs/api.md#delete-a-model',
+      pull:             'https://github.com/ollama/ollama/blob/main/docs/api.md#pull-a-model',
+      push:             'https://github.com/ollama/ollama/blob/main/docs/api.md#push-a-model',
+      embeddings:       'https://github.com/ollama/ollama/blob/main/docs/api.md#generate-embeddings',
+      ps:               'https://github.com/ollama/ollama/blob/main/docs/api.md#list-running-models',
+    )[name]
+  end
+
+  def to_s
+    (hyperlink(@url) { @name } if @url).to_s
+  end
+end

data/lib/ollama/client.rb

@@ -0,0 +1,137 @@
+require 'tins/xt/string_camelize'
+require 'tins/annotate'
+require 'excon'
+
+class Ollama::Client
+end
+require 'ollama/client/doc'
+require 'ollama/client/command'
+
+class Ollama::Client
+  include Tins::Annotate
+  include Ollama::Handlers
+  include Ollama::Client::Command
+
+  annotate :doc
+
+  def initialize(base_url: nil, output: $stdout, connect_timeout: nil, read_timeout: nil, write_timeout: nil, debug: nil)
+    base_url.nil? and base_url = ENV.fetch('OLLAMA_URL') do
+      raise ArgumentError,
+        'missing :base_url parameter or OLLAMA_URL environment variable'
+    end
+    base_url.is_a? URI or base_url = URI.parse(base_url)
+		base_url.is_a?(URI::HTTP) || base_url.is_a?(URI::HTTPS) or
+			raise ArgumentError, "require #{base_url.inspect} to be http/https-URI"
+    @ssl_verify_peer = base_url.query.to_s.split(?&).inject({}) { |h, l|
+      h.merge Hash[*l.split(?=)]
+    }['ssl_verify_peer'] != 'false'
+    @base_url, @output, @connect_timeout, @read_timeout, @write_timeout, @debug =
+      base_url, output, connect_timeout, read_timeout, write_timeout, debug
+  end
+
+  attr_accessor :output
+
+  def ssl_verify_peer?
+    !!@ssl_verify_peer
+  end
+
+  command(:chat, default_handler: Single, stream_handler: Collector)
+
+  command(:generate, default_handler: Single, stream_handler: Collector)
+
+  command(:tags, default_handler: Single)
+
+  command(:show, default_handler: Single)
+
+  command(:create, default_handler: Single, stream_handler: Progress)
+
+  command(:copy, default_handler: Single)
+
+  command(:delete, default_handler: Single)
+
+  command(:pull, default_handler: Single, stream_handler: Progress)
+
+  command(:push, default_handler: Single, stream_handler: Progress)
+
+  command(:embed, default_handler: Single)
+
+  command(:embeddings, default_handler: Single)
+
+  command(:ps, default_handler: Single)
+
+  def commands
+    doc_annotations.sort_by(&:first).transpose.last
+  end
+
+  doc Doc.new(:help)
+  def help
+    @output.puts "Commands: %s" % commands.join(?,)
+  end
+
+  def request(method:, path:, handler:, body: nil, stream: nil)
+    url = @base_url + path
+    responses = Enumerator.new do |yielder|
+      if stream
+        response_block = -> chunk, remaining_bytes, total_bytes do
+          response_line = parse_json(chunk)
+          response_line and yielder.yield response_line
+        end
+        response = excon(url).send(method, headers:, body:, response_block:)
+      else
+        response = excon(url).send(method, headers:, body:)
+      end
+
+      case response.status
+      when 200
+        response.body.each_line do |l|
+          response_line = parse_json(l)
+          response_line and yielder.yield response_line
+        end
+      when 404
+        raise Ollama::Errors::NotFoundError, "#{response.status} #{response.body.inspect}"
+      else
+        raise Ollama::Errors::Error, "#{response.status} #{response.body.inspect}"
+      end
+    end
+    responses.each { |response| handler.call(response) }
+    self
+  rescue Excon::Errors::SocketError => e
+    raise Ollama::Errors::SocketError, "Caught #{e.class} #{e.message.inspect} for #{url.to_s.inspect}"
+  rescue Excon::Errors::Timeout => e
+    raise Ollama::Errors::TimeoutError, "Caught #{e.class} #{e.message.inspect} for #{url.to_s.inspect}"
+  rescue Excon::Error => e
+    raise Ollama::Errors::Error, "Caught #{e.class} #{e.message.inspect} for #{url.to_s.inspect}"
+  end
+
+  def inspect
+    "#<#{self.class}@#{@base_url.to_s}>"
+  end
+
+  alias to_s inspect
+
+  private
+
+  def headers
+    {
+      'User-Agent'   => '%s/%s' % [ self.class, Ollama::VERSION ],
+      'Content-Type' => 'application/json; charset=utf-8',
+    }
+  end
+
+  def excon(url)
+    params = {
+      connect_timeout: @connect_timeout,
+      read_timeout:    @read_timeout,
+      write_timeout:   @write_timeout,
+      ssl_verify_peer: @ssl_verify_peer,
+      debug:           @debug,
+    }.compact
+    Excon.new(url, params)
+  end
+
+  def parse_json(string)
+    JSON.parse(string, object_class: Ollama::Response)
+  rescue JSON::ParserError
+    return
+  end
+end

data/lib/ollama/commands/chat.rb

@@ -0,0 +1,21 @@
+class Ollama::Commands::Chat
+  include Ollama::DTO
+
+  def self.path
+    '/api/chat'
+  end
+
+  def initialize(model:, messages:, tools: nil, format: nil, options: nil, stream: nil, keep_alive: nil)
+    @model, @messages, @tools, @format, @options, @stream, @keep_alive =
+      model, as_array_of_hashes(messages), as_array_of_hashes(tools),
+      format, options, stream, keep_alive
+  end
+
+  attr_reader :model, :messages, :tools, :format, :options, :stream, :keep_alive
+
+  attr_writer :client
+
+  def perform(handler)
+    @client.request(method: :post, path: self.class.path, body: to_json, stream:, handler:)
+  end
+end

data/lib/ollama/commands/copy.rb

@@ -0,0 +1,19 @@
+class Ollama::Commands::Copy
+  include Ollama::DTO
+
+  def self.path
+    '/api/copy'
+  end
+
+  def initialize(source:, destination:)
+    @source, @destination, @stream = source, destination, false
+  end
+
+  attr_reader :source, :destination, :stream
+
+  attr_writer :client
+
+  def perform(handler)
+    @client.request(method: :post, path: self.class.path, body: to_json, stream:, handler:)
+  end
+end

data/lib/ollama/commands/create.rb

@@ -0,0 +1,20 @@
+class Ollama::Commands::Create
+  include Ollama::DTO
+
+  def self.path
+    '/api/create'
+  end
+
+  def initialize(name:, modelfile: nil, quantize: nil, stream: nil, path: nil)
+    @name, @modelfile, @quantize, @stream, @path =
+      name, modelfile, quantize, stream, path
+  end
+
+  attr_reader :name, :modelfile, :quantize, :stream, :path
+
+  attr_writer :client
+
+  def perform(handler)
+    @client.request(method: :post, path: self.class.path, body: to_json, stream:, handler:)
+  end
+end

data/lib/ollama/commands/delete.rb

@@ -0,0 +1,19 @@
+class Ollama::Commands::Delete
+  include Ollama::DTO
+
+  def self.path
+    '/api/delete'
+  end
+
+  def initialize(name:)
+    @name, @stream = name, false
+  end
+
+  attr_reader :name, :stream
+
+  attr_writer :client
+
+  def perform(handler)
+    @client.request(method: :delete, path: self.class.path, body: to_json, stream:, handler:)
+  end
+end

data/lib/ollama/commands/embed.rb

@@ -0,0 +1,21 @@
+class Ollama::Commands::Embed
+  include Ollama::DTO
+
+  def self.path
+    '/api/embed'
+  end
+
+  def initialize(model:, input:, truncate: nil, keep_alive: nil)
+    @model, @input, @truncate, @keep_alive =
+      model, input, truncate, keep_alive
+    @stream = false
+  end
+
+  attr_reader :model, :input, :truncate, :keep_alive, :stream
+
+  attr_writer :client
+
+  def perform(handler)
+    @client.request(method: :post, path: self.class.path, body: to_json, stream:, handler:)
+  end
+end

data/lib/ollama/commands/embeddings.rb

@@ -0,0 +1,20 @@
+class Ollama::Commands::Embeddings
+  include Ollama::DTO
+
+  def self.path
+    '/api/embeddings'
+  end
+
+  def initialize(model:, prompt:, options: nil, keep_alive: nil)
+    @model, @prompt, @options, @keep_alive, @stream =
+      model, prompt, options, keep_alive, false
+  end
+
+  attr_reader :model, :prompt, :options, :keep_alive, :stream
+
+  attr_writer :client
+
+  def perform(handler)
+    @client.request(method: :post, path: self.class.path, body: to_json, stream:, handler:)
+  end
+end

data/lib/ollama/commands/generate.rb

@@ -0,0 +1,21 @@
+class Ollama::Commands::Generate
+  include Ollama::DTO
+
+  def self.path
+    '/api/generate'
+  end
+
+  def initialize(model:, prompt:, suffix: nil, images: nil, format: nil, options: nil, system: nil, template: nil, context: nil, stream: nil, raw: nil, keep_alive: nil)
+    @model, @prompt, @suffix, @images, @format, @options, @system, @template, @context, @stream, @raw, @keep_alive =
+      model, prompt, suffix, (Array(images) if images), format, options, system, template, context, stream, raw, keep_alive
+  end
+
+  attr_reader :model, :prompt, :suffix, :images, :format, :options, :system,
+    :template, :context, :stream, :raw, :keep_alive
+
+  attr_writer :client
+
+  def perform(handler)
+    @client.request(method: :post, path: self.class.path, body: to_json, stream:, handler:)
+  end
+end

data/lib/ollama/commands/ps.rb

@@ -0,0 +1,19 @@
+class Ollama::Commands::Ps
+  def self.path
+    '/api/ps'
+  end
+
+  def initialize(**parameters)
+    parameters.empty? or raise ArgumentError,
+      "Invalid parameters: #{parameters.keys * ' '}"
+    @stream = false
+  end
+
+  attr_reader :stream
+
+  attr_writer :client
+
+  def perform(handler)
+    @client.request(method: :get, path: self.class.path, stream:, handler:)
+  end
+end

data/lib/ollama/commands/pull.rb

@@ -0,0 +1,19 @@
+class Ollama::Commands::Pull
+  include Ollama::DTO
+
+  def self.path
+    '/api/pull'
+  end
+
+  def initialize(name:, insecure: nil, stream: true)
+    @name, @insecure, @stream = name, insecure, stream
+  end
+
+  attr_reader :name, :insecure, :stream
+
+  attr_writer :client
+
+  def perform(handler)
+    @client.request(method: :post, path: self.class.path, body: to_json, stream:, handler:)
+  end
+end

data/lib/ollama/commands/push.rb

@@ -0,0 +1,19 @@
+class Ollama::Commands::Push
+  include Ollama::DTO
+
+  def self.path
+    '/api/push'
+  end
+
+  def initialize(name:, insecure: nil, stream: true)
+    @name, @insecure, @stream = name, insecure, stream
+  end
+
+  attr_reader :name, :insecure, :stream
+
+  attr_writer :client
+
+  def perform(handler)
+    @client.request(method: :post, path: self.class.path, body: to_json, stream:, handler:)
+  end
+end