mistral 0.1.0

data/examples/chatbot_with_streaming.rb

@@ -0,0 +1,289 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Simple chatbot example -- run with -h argument to see options.
+
+require 'bundler/setup'
+require 'dotenv/load'
+require 'readline'
+require 'optparse'
+require 'mistral'
+
+MODEL_LIST = %w[
+  mistral-tiny
+  mistral-small
+  mistral-medium
+].freeze
+DEFAULT_MODEL = 'mistral-small'
+DEFAULT_TEMPERATURE = 0.7
+LOG_FORMAT = '%(asctime)s - %(levelname)s - %(message)s'
+# A hash of all commands and their arguments, used for tab completion.
+COMMAND_LIST = {
+  '/new' => {},
+  '/help' => {},
+  '/model' => MODEL_LIST.map { |model| [model, {}] }.to_h, # Nested completions for models
+  '/system' => {},
+  '/temperature' => {},
+  '/config' => {},
+  '/quit' => {},
+  '/exit' => {}
+}.freeze
+
+$logger = Logger.new($stdout)
+$logger.level = Logger::INFO
+$logger.formatter = proc do |severity, datetime, _, msg|
+  "#{datetime.strftime("%Y-%m-%d %H:%M:%S")} - #{severity} - #{msg}\n"
+end
+
+def find_completions(command_dict, parts)
+  return command_dict.keys if parts.empty?
+
+  if command_dict.key?(parts[0])
+    find_completions(command_dict[parts[0]], parts[1..])
+  else
+    command_dict.keys.select { |cmd| cmd.start_with?(parts[0]) }
+  end
+end
+
+# Enable tab completion
+Readline.completion_proc = proc do |_input|
+  line_parts = Readline.line_buffer.lstrip.split(' ')
+  options = find_completions(COMMAND_LIST, line_parts[0..-2])
+  options.select { |option| option.start_with?(line_parts[-1]) }
+end
+
+class ChatBot
+  def initialize(api_key, model, system_message = nil, temperature = DEFAULT_TEMPERATURE)
+    raise ArgumentError, 'An API key must be provided to use the Mistral API.' if api_key.nil?
+
+    @client = Mistral::Client.new(api_key: api_key)
+    @model = model
+    @temperature = temperature
+    @system_message = system_message
+  end
+
+  def opening_instructions
+    puts '
+To chat: type your message and hit enter
+To start a new chat: /new
+To switch model: /model <model name>
+To switch system message: /system <message>
+To switch temperature: /temperature <temperature>
+To see current config: /config
+To exit: /exit, /quit, or hit CTRL+C
+To see this help: /help
+    '
+  end
+
+  def new_chat
+    puts ''
+    puts "Starting new chat with model: #{@model}, temperature: #{@temperature}"
+    puts ''
+    @messages = []
+    @messages << Mistral::ChatMessage.new(role: 'system', content: @system_message) if @system_message
+  end
+
+  def switch_model(input)
+    model = get_arguments(input)
+
+    if MODEL_LIST.include?(model)
+      @model = model
+      $logger.info("Switching model: #{model}")
+    else
+      $logger.error("Invalid model name: #{model}")
+    end
+  end
+
+  def switch_system_message(input)
+    system_message = get_arguments(input)
+
+    if system_message
+      @system_message = system_message
+      $logger.info("Switching system message: #{system_message}")
+      new_chat
+    else
+      $logger.error("Invalid system message: #{system_message}")
+    end
+  end
+
+  def switch_temperature(input)
+    temperature = get_arguments(input)
+
+    begin
+      temperature = Float(temperature)
+
+      raise ArgumentError if temperature.negative? || temperature > 1
+
+      @temperature = temperature
+      $logger.info("Switching temperature: #{temperature}")
+    rescue ArgumentError
+      $logger.error("Invalid temperature: #{temperature}")
+    end
+  end
+
+  def show_config
+    puts ''
+    puts "Current model: #{@model}"
+    puts "Current temperature: #{@temperature}"
+    puts "Current system message: #{@system_message}"
+    puts ''
+  end
+
+  def collect_user_input
+    puts ''
+    print 'YOU: '
+    gets.chomp
+  end
+
+  def run_inference(content)
+    puts ''
+    puts 'MISTRAL:'
+    puts ''
+
+    @messages << Mistral::ChatMessage.new(role: 'user', content: content)
+
+    assistant_response = ''
+
+    $logger.debug("Running inference with model: #{@model}, temperature: #{@temperature}")
+    $logger.debug("Sending messages: #{@messages}")
+
+    @client.chat_stream(model: @model, temperature: @temperature, messages: @messages).each do |chunk|
+      response = chunk.choices[0].delta.content
+
+      if response
+        print response
+        assistant_response += response
+      end
+    end
+
+    puts ''
+
+    @messages << Mistral::ChatMessage.new(role: 'assistant', content: assistant_response) if assistant_response
+
+    $logger.debug("Current messages: #{@messages}")
+  end
+
+  def get_command(input)
+    input.split[0].strip
+  end
+
+  def get_arguments(input)
+    input.split[1..].join(' ')
+  rescue IndexError
+    ''
+  end
+
+  def is_command?(input)
+    COMMAND_LIST.key?(get_command(input))
+  end
+
+  def execute_command(input)
+    command = get_command(input)
+    case command
+    when '/exit', '/quit'
+      exit
+    when '/help'
+      opening_instructions
+    when '/new'
+      new_chat
+    when '/model'
+      switch_model(input)
+    when '/system'
+      switch_system_message(input)
+    when '/temperature'
+      switch_temperature(input)
+    when '/config'
+      show_config
+    end
+  end
+
+  def start
+    opening_instructions
+    new_chat
+
+    loop do
+      input = collect_user_input
+
+      if is_command?(input)
+        execute_command(input)
+      else
+        run_inference(input)
+      end
+    rescue Interrupt
+      exit
+    end
+  end
+
+  def exit
+    $logger.debug('Exiting chatbot')
+    puts 'Goodbye!'
+    Kernel.exit(0)
+  end
+end
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = 'Usage: chatbot.rb [options]'
+
+  opts.on(
+    '--api-key KEY',
+    'Mistral API key. Defaults to environment variable MISTRAL_API_KEY'
+  ) do |key|
+    options[:api_key] = key
+  end
+
+  opts.on(
+    '-m',
+    '--model MODEL',
+    MODEL_LIST,
+    "Model for chat inference. Choices are #{MODEL_LIST.join(", ")}. Defaults to #{DEFAULT_MODEL}"
+  ) do |model|
+    options[:model] = model
+  end
+
+  opts.on(
+    '-s',
+    '--system-message MESSAGE',
+    'Optional system message to prepend'
+  ) do |message|
+    options[:system_message] = message
+  end
+
+  opts.on(
+    '-t',
+    '--temperature FLOAT',
+    Float,
+    "Optional temperature for chat inference. Defaults to #{DEFAULT_TEMPERATURE}"
+  ) do |temp|
+    options[:temperature] = temp
+  end
+
+  opts.on(
+    '-d',
+    '--debug',
+    'Enable debug logging'
+  ) do
+    options[:debug] = true
+  end
+end.parse!
+
+api_key = options[:api_key] || ENV.fetch('MISTRAL_API_KEY')
+model = options[:model] || DEFAULT_MODEL
+system_message = options[:system_message]
+temperature = options[:temperature] || DEFAULT_TEMPERATURE
+
+$logger.level = options[:debug] ? Logger::DEBUG : Logger::INFO
+
+$logger.debug(
+  "Starting chatbot with model: #{model}, " \
+  "temperature: #{temperature}, " \
+  "system message: #{system_message}"
+)
+
+begin
+  bot = ChatBot.new(api_key, model, system_message, temperature)
+  bot.start
+rescue StandardError => e
+  $logger.error(e)
+  exit(1)
+end

data/examples/embeddings.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'dotenv/load'
+require 'mistral'
+
+api_key = ENV.fetch('MISTRAL_API_KEY')
+client = Mistral::Client.new(api_key: api_key)
+
+embeddings_response = client.embeddings(
+  model: 'mistral-embed',
+  input: ['What is the best French cheese?'] * 10
+)
+
+puts embeddings_response.to_h

data/examples/function_calling.rb

@@ -0,0 +1,104 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'dotenv/load'
+require 'mistral'
+
+# Assuming we have the following data
+data = {
+  'transaction_id' => %w[T1001 T1002 T1003 T1004 T1005],
+  'customer_id' => %w[C001 C002 C003 C002 C001],
+  'payment_amount' => [125.50, 89.99, 120.00, 54.30, 210.20],
+  'payment_date' => %w[2021-10-05 2021-10-06 2021-10-07 2021-10-05 2021-10-08],
+  'payment_status' => %w[Paid Unpaid Paid Paid Pending]
+}
+
+def retrieve_payment_status(data, transaction_id)
+  data['transaction_id'].each_with_index do |r, i|
+    return { status: data['payment_status'][i] }.to_json if r == transaction_id
+  end
+
+  { status: 'Error - transaction id not found' }.to_json
+end
+
+def retrieve_payment_date(data, transaction_id)
+  data['transaction_id'].each_with_index do |r, i|
+    return { date: data['payment_date'][i] }.to_json if r == transaction_id
+  end
+
+  { status: 'Error - transaction id not found' }.to_json
+end
+
+names_to_functions = {
+  'retrieve_payment_status' => ->(transaction_id) { retrieve_payment_status(data, transaction_id) },
+  'retrieve_payment_date' => ->(transaction_id) { retrieve_payment_date(data, transaction_id) }
+}
+
+tools = [
+  {
+    'type' => 'function',
+    'function' => Mistral::Function.new(
+      name: 'retrieve_payment_status',
+      description: 'Get payment status of a transaction id',
+      parameters: {
+        'type' => 'object',
+        'required' => ['transaction_id'],
+        'properties' => {
+          'transaction_id' => {
+            'type' => 'string',
+            'description' => 'The transaction id.'
+          }
+        }
+      }
+    )
+  },
+  {
+    'type' => 'function',
+    'function' => Mistral::Function.new(
+      name: 'retrieve_payment_date',
+      description: 'Get payment date of a transaction id',
+      parameters: {
+        'type' => 'object',
+        'required' => ['transaction_id'],
+        'properties' => {
+          'transaction_id' => {
+            'type' => 'string',
+            'description' => 'The transaction id.'
+          }
+        }
+      }
+    )
+  }
+]
+
+api_key = ENV.fetch('MISTRAL_API_KEY')
+model = 'mistral-large-latest'
+
+client = Mistral::Client.new(api_key: api_key)
+
+messages = [Mistral::ChatMessage.new(role: 'user', content: "What's the status of my transaction?")]
+
+response = client.chat(model: model, messages: messages, tools: tools)
+
+puts response.choices[0].message.content
+
+messages << Mistral::ChatMessage.new(role: 'assistant', content: response.choices[0].message.content)
+messages << Mistral::ChatMessage.new(role: 'user', content: 'My transaction ID is T1001.')
+
+response = client.chat(model: model, messages: messages, tools: tools)
+
+tool_call = response.choices[0].message.tool_calls[0]
+function_name = tool_call.function.name
+function_params = JSON.parse(tool_call.function.arguments)
+
+puts "calling function_name: #{function_name}, with function_params: #{function_params}"
+
+function_result = names_to_functions[function_name].call(function_params['transaction_id'])
+
+messages << response.choices[0].message
+messages << Mistral::ChatMessage.new(role: 'tool', name: function_name, content: function_result)
+
+response = client.chat(model: model, messages: messages, tools: tools)
+
+puts response.choices[0].message.content

data/examples/json_format.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'dotenv/load'
+require 'mistral'
+
+api_key = ENV.fetch('MISTRAL_API_KEY')
+client = Mistral::Client.new(api_key: api_key)
+
+model = 'mistral-large-latest'
+
+chat_response = client.chat(
+  model: model,
+  response_format: { type: 'json_object' },
+  messages: [Mistral::ChatMessage.new(
+    role: 'user', content: 'What is the best French cheese? Answer shortly in JSON.'
+  )]
+)
+
+puts chat_response.choices[0].message.content

data/examples/list_models.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'dotenv/load'
+require 'mistral'
+
+api_key = ENV.fetch('MISTRAL_API_KEY')
+client = Mistral::Client.new(api_key: api_key)
+
+list_models_response = client.list_models
+
+puts list_models_response.to_h

data/lib/http/features/line_iterable_body.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module HTTP
+  module Features
+    class LineIterableBody < Feature
+      def wrap_response(response)
+        options = {
+          status: response.status,
+          version: response.version,
+          headers: response.headers,
+          proxy_headers: response.proxy_headers,
+          connection: response.connection,
+          body: IterableBodyWrapper.new(response.body, response.body.instance_variable_get(:@encoding)),
+          request: response.request
+        }
+
+        HTTP::Response.new(options)
+      end
+
+      class IterableBodyWrapper < HTTP::Response::Body
+        def initialize(body, encoding)
+          super(body, encoding: encoding)
+        end
+
+        def each_line(&block)
+          each do |chunk|
+            chunk.each_line(&block)
+          end
+        end
+      end
+    end
+  end
+
+  HTTP::Options.register_feature(:line_iterable_body, Features::LineIterableBody)
+end