monadic-chat 0.3.3 → 0.3.4

data/lib/monadic_chat/internals.rb

@@ -56,11 +56,9 @@ class MonadicApp
     end
   end
 
-  def prepare_params(input)
+  def prepare_params(input_role, input)
     params = @params.dup
 
-    @update_proc.call
-
     case @mode
     when :research
       messages = +""
@@ -71,19 +69,19 @@ class MonadicApp
         case role
         when "system"
           system << "#{content}\n"
-        when "assistant", "gpt"
-          messages << "- #{mes["role"].strip}: #{content}\n"
         else
-          messages << "- #{mes["role"].strip}: #{mes["content"]}\n"
+          messages << "- #{mes["role"].strip}: #{content}\n"
         end
       end
       template = @template.dup.sub("{{SYSTEM}}", system)
                           .sub("{{PROMPT}}", input)
                           .sub("{{MESSAGES}}", messages.strip)
 
+      @template_tokens = count_tokens(template)
+
       File.open(TEMP_MD, "w") { |f| f.write template }
 
-      @messages << { "role" => "user", "content" => input }
+      @messages << { "role" => input_role, "content" => input }
 
       case @method
       when "completions"
@@ -93,14 +91,16 @@ class MonadicApp
       end
 
     when :normal
-      @messages << { "role" => "user", "content" => input }
+      @messages << { "role" => input_role, "content" => input }
       params["messages"] = @messages
     end
 
+    @update_proc.call unless input_role == "system"
+
     params
   end
 
-  def update_template(res)
+  def update_template(res, role)
     case @mode
     when :research
       @metadata = res
@@ -111,15 +111,22 @@ class MonadicApp
     when :normal
       @messages << { "role" => "assistant", "content" => res }
     end
+    remove_intermediate_messages if role == "system"
+  end
+
+  def remove_intermediate_messages
+    @messages = @messages.reject { |ele| ele["role"] == "assistant" && /SEARCH\(.+\)/m =~ ele["content"] }
+    @messages = @messages.reject { |ele| ele["role"] == "system" && /^SEARCH SNIPPETS/ =~ ele["content"] }
   end
 
   ##################################################
   # function to bind data
   ##################################################
 
-  def bind(input, num_retry: 0)
+  def bind(input, role: "user", num_retry: 0)
+    @turns += 1 if role == "user"
     print PROMPT_ASSISTANT.prefix, "\n"
-    params = prepare_params(input)
+    params = prepare_params(role, input)
     research_mode = @mode == :research
 
     escaping = +""
@@ -145,7 +152,41 @@ class MonadicApp
     print last_chunk
     print "\n"
 
-    update_template(res)
-    set_html if @html
+    webdata = use_tool(res)
+    update_template(res, role) unless webdata
+    if webdata && role != "system"
+      bind(webdata, role: "system", num_retry: num_retry)
+    elsif @html
+      set_html
+    end
+  end
+
+  ##################################################
+  # function to have GPT use tools
+  ##################################################
+
+  def use_tool(res)
+    case @mode
+    when :normal
+      text = res
+    when :research
+      text = res.is_a?(Hash) ? res["response"] : res
+    end
+
+    case text
+    when /\bSEARCH_WIKI\((.+?)\)/m
+      search_key = Regexp.last_match(1)
+      search_keys = search_key.split(",").map do |key|
+        key.strip.sub(/^"(.+)"$/, '\1')
+      end
+      text = "SEARCH SNIPPETS\n#{wikipedia_search(*search_keys)}"
+      return text
+    when /\bSEARCH_WEB\("?(.+?)"?\)/m
+      search_key = Regexp.last_match(1)
+      text = "SEARCH SNIPPETS\n#{bing_search(search_key)}"
+      return text
+    end
+
+    false
   end
 end

data/lib/monadic_chat/menu.rb

@@ -57,6 +57,7 @@ class MonadicApp
     @params = @params_initial.dup
     @messages = @messages_initial.dup
     @template = @template_initial.dup
+    @template_tokens = 0
 
     if @placeholders.empty?
       print PROMPT_SYSTEM.prefix
@@ -68,7 +69,7 @@ class MonadicApp
 
   def ask_retrial(input, message = nil)
     print PROMPT_SYSTEM.prefix
-    print " Error: #{message.capitalize}\n" if message
+    print "Error: #{message.capitalize}\n" if message
     retrial = PROMPT_USER.select("Do you want to try again?",
                                  show_help: :never) do |menu|
                                    menu.choice "Yes", "yes"

data/lib/monadic_chat/open_ai.rb

@@ -10,7 +10,7 @@ require "tty-progressbar"
 Oj.mimic_JSON
 
 module OpenAI
-  def self.model_name(research_mode: false)
+  def self.default_model(research_mode: false)
     if research_mode
       "text-davinci-003"
     else
@@ -88,18 +88,8 @@ module OpenAI
   class Completion
     attr_reader :access_token
 
-    def initialize(access_token, normal_mode_model = nil, research_mode_model = nil)
+    def initialize(access_token)
       @access_token = access_token
-      @normal_mode_model = normal_mode_model || OpenAI.model_name(research_mode: false)
-      @research_mode_model = research_mode_model || OpenAI.model_name(research_mode: true)
-    end
-
-    def model_name(research_mode: false)
-      if research_mode
-        @research_mode_model
-      else
-        @normal_mode_model
-      end
     end
 
     def models
@@ -126,7 +116,7 @@ module OpenAI
       when 0
         raise e
       else
-        run(params, num_retry: num_retry - 1, &block)
+        run(params, research_mode: research_mode, num_retry: num_retry - 1, &block)
       end
     end
 

data/lib/monadic_chat/tools.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class MonadicApp
+  ##################################################
+  # method for web search
+  ##################################################
+
+  def bing_search(query, retrial: 5)
+    uri = "https://www.bing.com/search"
+    css_selector = "#b_results"
+
+    q = URI.encode_www_form(q: query)
+    doc = Nokogiri::HTML(URI.parse([uri, q].join("?")).read)
+    doc.css("script, link").each(&:remove)
+    doc.css(css_selector).text.squeeze(" \n")
+  rescue StandardError
+    return "SEARCH ENGINE NOT AVAILABLE" if retrial.zero?
+
+    sleep 1
+    retrial -= 1
+    bing_search(query, retrial: retrial)
+  end
+
+  def wikipedia_search(keywords, base_url = nil)
+    base_url ||= "https://en.wikipedia.org/w/api.php"
+    search_params = {
+      action: "query",
+      list: "search",
+      format: "json",
+      srsearch: keywords,
+      utf8: 1,
+      formatversion: 2
+    }
+
+    search_uri = URI(base_url)
+    search_uri.query = URI.encode_www_form(search_params)
+    search_response = Net::HTTP.get(search_uri)
+    search_data = JSON.parse(search_response)
+
+    raise if search_data["query"]["search"].empty?
+
+    title = search_data["query"]["search"][0]["title"]
+
+    content_params = {
+      action: "query",
+      prop: "extracts",
+      format: "json",
+      titles: title,
+      explaintext: 1,
+      utf8: 1,
+      formatversion: 2
+    }
+
+    content_uri = URI(base_url)
+    content_uri.query = URI.encode_www_form(content_params)
+    content_response = Net::HTTP.get(content_uri)
+    content_data = JSON.parse(content_response)
+
+    content_data["query"]["pages"][0]["extract"][0..1000]
+  rescue StandardError
+    "SEARCH RESULTS EMPTY"
+  end
+end

data/lib/monadic_chat/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MonadicChat
-  VERSION = "0.3.3"
+  VERSION = "0.3.4"
 end

data/lib/monadic_chat.rb

@@ -14,6 +14,9 @@ require "rouge"
 require "launchy"
 require "io/console"
 require "readline"
+require "nokogiri"
+require "open-uri"
+require "wikipedia"
 
 require_relative "./monadic_chat/version"
 require_relative "./monadic_chat/open_ai"
@@ -22,6 +25,8 @@ require_relative "./monadic_chat/helper"
 Oj.mimic_JSON
 
 module MonadicChat
+  SETTINGS = {}
+  MAX_CHARS_WIKI = 1000
   gpt2model_path = File.absolute_path(File.join(__dir__, "..", "assets", "gpt2.bin"))
   BLINGFIRE = BlingFire.load_model(gpt2model_path)
   CONFIG = File.join(Dir.home, "monadic_chat.conf")
@@ -111,38 +116,71 @@ module MonadicChat
     Launchy.open(url)
   end
 
+  def self.mdprint(str)
+    print TTY::Markdown.parse(str, indent: 0)
+  end
+
   def self.authenticate(overwrite: false, message: true)
-    check = lambda do |token, normal_mode_model, research_mode_model|
-      print "Checking configuration\n" if message
-      SPINNER.auto_spin
+    check = lambda do |token|
+      if message
+        print TTY::Cursor.restore
+        print TTY::Cursor.clear_screen_down
+        print "\n"
+        SPINNER.auto_spin
+      end
+
+      if !token || token.strip == ""
+        if message
+          SPINNER.stop
+          print TTY::Cursor.restore
+          print "\n"
+          mdprint "- Authentication: #{PASTEL.bold.red("Failure")}\n" if message
+        end
+        return false
+      end
+
       begin
         models = OpenAI.models(token)
         raise if models.empty?
 
-        SPINNER.stop
-
-        print "Success\n" if message
-
-        if normal_mode_model && !models.map { |m| m["id"] }.index(normal_mode_model)
+        if message
           SPINNER.stop
-          print "Normal mode model set in config file not available.\n" if message
-          normal_mode_model = false
+          print TTY::Cursor.restore, "\n"
+          mdprint "#{PASTEL.on_green(" System ")} Config file: `#{CONFIG}`\n"
+          print "\n"
+          mdprint "- Authentication: #{PASTEL.bold.green("Success")}\n"
         end
-        normal_mode_model ||= OpenAI.model_name(research_mode: false)
-        print "Normal mode model: #{normal_mode_model}\n" if message
 
-        if research_mode_model && !models.map { |m| m["id"] }.index(research_mode_model)
-          SPINNER.stop
-          print "Normal mode model set in config file not available.\n" if message
-          print "Fallback to the default model (#{OpenAI.model_name(research_mode: true)}).\n" if message
+        if SETTINGS["normal_model"] && !models.map { |m| m["id"] }.index(SETTINGS["normal_model"])
+          if message
+            SPINNER.stop
+            mdprint "- Normal mode model specified in config file not available\n"
+            mdprint "- Fallback to the default model (`#{OpenAI.default_model(research_mode: false)}`)\n"
+          end
+          SETTINGS["normal_model"] = false
+        end
+        SETTINGS["normal_model"] ||= OpenAI.default_model(research_mode: false)
+        mdprint "- Normal mode model: `#{SETTINGS["normal_model"]}`\n" if message
+
+        if SETTINGS["research_model"] && !models.map { |m| m["id"] }.index(SETTINGS["research_model"])
+          if message
+            SPINNER.stop
+            mdprint "- Research mode model specified in config file not available\n"
+            mdprint "- Fallback to the default model (`#{OpenAI.default_model(research_mode: true)}`)\n"
+          end
+          SETTINGS["research_model"] = false
         end
-        research_mode_model ||= OpenAI.model_name(research_mode: true)
-        print "Research mode model: #{research_mode_model}\n" if message
+        SETTINGS["research_model"] ||= OpenAI.default_model(research_mode: true)
+        mdprint "- Research mode model: `#{SETTINGS["research_model"]}`\n" if message
 
-        OpenAI::Completion.new(token, normal_mode_model, research_mode_model)
+        OpenAI::Completion.new(token)
       rescue StandardError
-        SPINNER.stop
-        print "Authentication: failure.\n" if message
+        if message
+          SPINNER.stop
+          print TTY::Cursor.restore
+          print "\n"
+          mdprint "- Authentication: #{PASTEL.bold.red("Failure")}\n" if message
+        end
         false
       end
     end
@@ -150,14 +188,18 @@ module MonadicChat
     completion = nil
 
     if overwrite
-      access_token = PROMPT_SYSTEM.ask(" Input your OpenAI access token:")
+      access_token = PROMPT_SYSTEM.ask("Input your OpenAI access token:")
       return false if access_token.to_s == ""
 
-      completion = check.call(access_token, nil, nil)
+      completion = check.call(access_token)
 
       if completion
         File.open(CONFIG, "w") do |f|
-          config = { "access_token" => access_token }
+          config = {
+            "access_token" => access_token,
+            "normal_model" => SETTINGS["normal_model"],
+            "research_model" => SETTINGS["research_model"]
+          }
           f.write(JSON.pretty_generate(config))
           print "New access token has been saved to #{CONFIG}\n" if message
         end
@@ -170,16 +212,22 @@ module MonadicChat
         puts "Error: config file does not contain a valid JSON object."
         exit
       end
+      SETTINGS["normal_model"] = config["normal_model"] if config["normal_model"]
+      SETTINGS["research_model"] = config["research_model"] if config["research_model"]
       access_token = config["access_token"]
-      normal_mode_model = config["normal_mode_model"]
-      research_mode_model = config["research_mode_model"]
-      completion = check.call(access_token, normal_mode_model, research_mode_model)
+      completion = check.call(access_token)
     else
-      access_token ||= PROMPT_SYSTEM.ask(" Input your OpenAI access token:")
-      completion = check.call(access_token, nil, nil)
+      access_token ||= PROMPT_SYSTEM.ask("Input your OpenAI access token:")
+      return false if access_token.to_s == ""
+
+      completion = check.call(access_token)
       if completion
         File.open(CONFIG, "w") do |f|
-          config = { "access_token" => access_token }
+          config = {
+            "access_token" => access_token,
+            "normal_model" => SETTINGS["normal_model"],
+            "research_model" => SETTINGS["research_model"]
+          }
           f.write(JSON.pretty_generate(config))
         end
         print "Access token has been saved to #{CONFIG}\n" if message

data/monadic_chat.gemspec

@@ -51,4 +51,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency "tty-prompt"
   spec.add_dependency "tty-screen"
   spec.add_dependency "tty-spinner"
+  spec.add_dependency "wikipedia-client"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monadic-chat
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors:
 - yohasebe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-27 00:00:00.000000000 Z
+date: 2023-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -248,6 +248,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: wikipedia-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 'Monadic Chat is a command-line client application program that uses
   OpenAI''s Text Completion API and Chat API to enable chat-style conversations with
   OpenAI''s artificial intelligence system in a ChatGPT-like style.
@@ -311,6 +325,7 @@ files:
 - lib/monadic_chat/menu.rb
 - lib/monadic_chat/open_ai.rb
 - lib/monadic_chat/parameters.rb
+- lib/monadic_chat/tools.rb
 - lib/monadic_chat/version.rb
 - monadic_chat.gemspec
 homepage: https://github.com/yohasebe/monadic-chat