scout-ai 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36833eaae86ac11476b39ac0f188cfa2106a9cad810fcdd53de37a9b356e15e0
-  data.tar.gz: 014a3927cb41bd99b28b866c442bacca65c21a27b79491e3bd790c1051115f4b
+  metadata.gz: 1c66f7d74bdf6583e77cb7dd132bfc7d677399cc5ddeb42d59cacdef2c432d72
+  data.tar.gz: 9dcdc99b701696dd724394124a02bac3bde5706d94d9efad81c0ab11641d4e47
 SHA512:
-  metadata.gz: 0d4ebfecd2e6ed94901b955536d6c6a36817ac7aa1eaafcfd657c563185b69c5eb03293aef2446a0444842c1d263dc79a951342e57fd3704f96b931ef02cb027
-  data.tar.gz: 45ed2228cca6bfeea3d0161ff766b1abfb2137def68eb1c3c142ee9b32a234a9b95223612026b3683d0f72aba308853e1bd9d92ca4e5cdbfdb9500555810a4fa
+  metadata.gz: a72b0575c3c92eb4dfa413bada73c4448f85434ee99fe446b204b29e789142ac7cdd0fab3f422b994c3eb663c254dbbb097ae2fe0bd27aa7c56815690ee79289
+  data.tar.gz: 15616e4363983823e17ace7c866f49772e954e75eeae5b6677fb32bda322d9608be508594393cd0e032b0bc1666fe2a561b444a0b2af27360577c86f51f6c028

data/.vimproject

@@ -1,10 +1,47 @@
-scout-ai=/$PWD filter="*.rb *.rake Rakefile *.rdoc *.R *.sh *.js *.haml *.sass *.txt *.conf" {
+scout-ai=$PWD filter="*.rb *.rake Rakefile *.rdoc *.R *.sh *.js *.haml *.sass *.txt *.conf" {
  Rakefile
  bin=bin filter="*"{
   scout-ai
  }
- etc=etc filter="*"{
-  config
+ agents=agents{
+  analyst.rb
+ }
+ chats=chats{
+  system=system{
+   scout-ai
+  }
+  doc=doc{
+   chat
+   model.analysis
+   model
+  }
+  develop=develop{
+   training=training{
+    intro
+    basics
+    data=data{
+     main
+     next_token
+    }
+    data.tmp
+    python
+   }
+   chat
+   model
+   causalLM
+   rf
+  }
+  refactor=refactor{
+   chat
+  }
+  help=help{
+   tools
+   from_pretrained
+   fine-tunning
+  }
+  test=test{
+   rf.rb
+  }
  }
  lib=lib {
   scout-ai.rb
@@ -12,24 +49,72 @@ scout-ai=/$PWD filter="*.rb *.rake Rakefile *.rdoc *.R *.sh *.js *.haml *.sass *
    llm=llm{
     utils.rb
     parse.rb
+    tools.rb
+    chat.rb
+
     backends=backends{
-     ollama.rb
      openai.rb
+     responses.rb
+     ollama.rb
      openwebui.rb
      huggingface.rb
      relay.rb
     }
+
     ask.rb
 
     embed.rb
 
     rag.rb
 
-    tools.rb
     agent.rb
    }
+   model=model{
+    util=util{
+     save.rb
+     run.rb
+    }
+    base.rb
+
+    python=python{
+     base.rb
+     torch.rb
+     torch=torch{
+      helpers.rb
+      dataloader.rb
+      introspection.rb
+      load_and_save.rb
+     }
+     huggingface.rb
+     huggingface=huggingface{
+      classification.rb
+      causal.rb
+      causal=causal{
+       next_token.rb
+      }
+     }
+    }
+   }
   }
  }
+ python=python filter="*"{
+  scout_ai=scout_ai{
+   __init__.py
+   language_model.py
+   util.py
+   huggingface=huggingface{
+    data.py
+    eval.py
+    model.py
+    train=train{
+     __init__.py
+     next_token.py
+    }
+    rlhf.py
+   }
+  }
+ }
+
  test=test {
   data=data filter="*"{
    person=person{
@@ -51,11 +136,7 @@ scout-ai=/$PWD filter="*.rb *.rake Rakefile *.rdoc *.R *.sh *.js *.haml *.sass *
   }
   agent=agent{
    ask
+   kb
   }
  }
- questions=questions filter="*"{
-  coach
-  evaluator
-  templater
- }
 }

data/Rakefile

@@ -16,6 +16,7 @@ Juwelier::Tasks.new do |gem|
   gem.authors = ["Miguel Vazquez"]
 
   # dependencies defined in Gemfile
+  gem.add_runtime_dependency 'scout-rig', '>= 0'
 end
 Juwelier::RubygemsDotOrgTasks.new
 require 'rake/testtask'

data/VERSION

@@ -1 +1 @@
-0.2.0
+1.0.0

data/bin/scout-ai

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
+$LOAD_PATH.unshift File.join(__dir__, '../lib')
+
 require 'scout-ai'
 
 load Scout.bin.scout.find

data/lib/scout/llm/agent/chat.rb

@@ -0,0 +1,24 @@
+module LLM
+  class Agent
+    def start_chat
+      @start_chat ||= Chat.setup []
+    end
+
+    def start(chat=nil)
+      if chat
+        (@current_chat || start_chat).annotate chat unless Chat === chat
+        @current_chat = chat
+      else
+        @current_chat = start_chat.branch
+      end
+    end
+
+    def current_chat
+      @current_chat ||= start
+    end
+
+    def method_missing(name,...)
+      current_chat.send(name, ...)
+    end
+  end
+end

data/lib/scout/llm/agent.rb

@@ -2,13 +2,12 @@ require_relative 'ask'
 
 module LLM
   class Agent
-    attr_accessor :system, :workflow, :knowledge_base
-    def initialize(system = nil, workflow: nil, knowledge_base: nil, model: nil, **kwargs)
-      @system = system
+    attr_accessor :workflow, :knowledge_base, :start_chat
+    def initialize(workflow: nil, knowledge_base: nil, start_chat: nil, **kwargs)
       @workflow = workflow
       @knowledge_base = knowledge_base
-      @model = model
       @other_options = kwargs
+      @start_chat = start_chat
     end
 
     def format_message(message, prefix = "user")
@@ -19,17 +18,17 @@ module LLM
 
     def system_prompt
       system = @system
+      system = [] if system.nil?
       system = [system] unless system.nil? || system.is_a?(Array)
+      system = [] if system.nil?
 
-      if @knowledge_base
+      if @knowledge_base and @knowledge_base.all_databases.any?
         system << <<-EOF
 You have access to the following databases associating entities:
         EOF
 
         knowledge_base.all_databases.each do |database|
-          system << <<-EOF.strip + (knowledge_base.undirected(database) ? ". Undirected" : "")
-* #{database}: #{knowledge_base.source(database)} => #{knowledge_base.target(database)}
-          EOF
+          system << knowledge_base.markdown(database)
         end
       end
 
@@ -45,21 +44,21 @@ You have access to the following databases associating entities:
     end
 
     # function: takes an array of messages and calls LLM.ask with them
-    def ask(messages, model = nil)
+    def ask(messages, model = nil, options = {})
       messages = [messages] unless messages.is_a? Array
-      model ||= @model
+      model ||= @model if model
 
       tools = []
       tools += LLM.workflow_tools(workflow) if workflow
-      tools += LLM.knowledge_base_tool_definition(knowledge_base) if knowledge_base
+      tools += LLM.knowledge_base_tool_definition(knowledge_base) if knowledge_base and knowledge_base.all_databases.any?
 
-      LLM.ask prompt(messages), @other_options.merge(model: model, log_errors: true, tools: tools) do |name,parameters|
+      LLM.ask prompt(messages), @other_options.merge(log_errors: true, tools: tools) do |name,parameters|
         case name
         when 'children'
           parameters = IndiferentHash.setup(parameters)
           database, entities = parameters.values_at "database", "entities"
           Log.high "Finding #{entities} children in #{database}"
-          knowledge_base.children(database, entities).target
+          knowledge_base.children(database, entities)
         else
           if workflow
             begin
@@ -76,3 +75,4 @@ You have access to the following databases associating entities:
     end
   end
 end
+require_relative 'agent/chat'

data/lib/scout/llm/ask.rb

@@ -2,32 +2,42 @@ require 'scout'
 require_relative 'backends/openai'
 require_relative 'backends/ollama'
 require_relative 'backends/openwebui'
+require_relative 'backends/bedrock'
 require_relative 'backends/relay'
+require_relative 'backends/responses'
 
 module LLM
   def self.ask(question, options = {}, &block)
-    endpoint = IndiferentHash.process_options options, :endpoint
+    messages = LLM.chat(question)
+    options = IndiferentHash.add_defaults LLM.options(messages), options
 
-    endpoint ||= Scout::Config.get :endpoint, :ask, :llm, env: 'ASK_ENDPOINT,LLM_ENDPOINT', default: :openai
+    endpoint, persist = IndiferentHash.process_options options, :endpoint, :persist, persist: true
+
+    endpoint ||= Scout::Config.get :endpoint, :ask, :llm, env: 'ASK_ENDPOINT,LLM_ENDPOINT'
     if endpoint && Scout.etc.AI[endpoint].exists?
       options = IndiferentHash.add_defaults options, Scout.etc.AI[endpoint].yaml
     end
 
-    backend = IndiferentHash.process_options options, :backend
-    backend ||= Scout::Config.get :backend, :ask, :llm, env: 'ASK_BACKEND,LLM_BACKEND', default: :openai
-
+    Persist.persist(endpoint, :json, prefix: "LLM ask", other: options.merge(messages: messages), persist: persist) do
+      backend = IndiferentHash.process_options options, :backend
+      backend ||= Scout::Config.get :backend, :ask, :llm, env: 'ASK_BACKEND,LLM_BACKEND', default: :openai
 
-    case backend
-    when :openai, "openai"
-      LLM::OpenAI.ask(question, options, &block)
-    when :ollama, "ollama"
-      LLM::OLlama.ask(question, options, &block)
-    when :openwebui, "openwebui"
-      LLM::OpenWebUI.ask(question, options, &block)
-    when :relay, "relay"
-      LLM::Relay.ask(question, options, &block)
-    else
-      raise "Unknown backend: #{backend}"
+      case backend
+      when :openai, "openai"
+        LLM::OpenAI.ask(messages, options, &block)
+      when :responses, "responses"
+        LLM::Responses.ask(messages, options, &block)
+      when :ollama, "ollama"
+        LLM::OLlama.ask(messages, options, &block)
+      when :openwebui, "openwebui"
+        LLM::OpenWebUI.ask(messages, options, &block)
+      when :relay, "relay"
+        LLM::Relay.ask(messages, options, &block)
+      when :bedrock, "bedrock"
+        LLM::Bedrock.ask(messages, options, &block)
+      else
+        raise "Unknown backend: #{backend}"
+      end
     end
   end
 

data/lib/scout/llm/backends/bedrock.rb

@@ -0,0 +1,129 @@
+require 'scout'
+require 'aws-sdk-bedrockruntime'
+require_relative '../parse'
+require_relative '../tools'
+require_relative '../utils'
+
+module LLM
+  module Bedrock
+    def self.client(region, access_key, secret_key)
+
+      credentials = Aws::Credentials.new(access_key, secret_key) if access_key and secret_key
+      options = {}
+      options[:region] = region if region
+      options[:credentials] = credentials if credentials
+      Aws::BedrockRuntime::Client.new(options)
+    end
+
+    def self.messages_to_prompt(messages)
+      system = []
+      user = []
+      messages.each do |info|
+        role, content = info.values_at :role, :content
+        if role.to_s == 'system'
+          system << content
+        else
+          user << content
+        end
+      end
+      [system*"\n", user*"\n"]
+    end
+
+    def self.ask(question, options = {}, &block)
+      client, region, access_key, secret_key, type = IndiferentHash.process_options options, :client, :region, :access_key, :secret_key, :type
+
+      model_options = IndiferentHash.pull_keys options, :model
+      model = IndiferentHash.process_options model_options, :model
+
+      if client.nil?
+        region ||= Scout::Config.get(:region, :bedrock_ask, :ask, :bedrock, env: 'AWS_REGION')
+        access_key ||= LLM.get_url_config(:access_key, nil, :bedrock_ask, :ask, :bedrock, env: 'AWS_ACCESS_KEY_ID')
+        secret_key ||= LLM.get_url_config(:secret_key, nil, :bedrock_ask, :ask, :bedrock, env: 'AWS_SECRET_ACCESS_KEY')
+        client = self.client(region, access_key, secret_key)
+      end
+
+      model ||= Scout::Config.get(:model, :bedrock_ask, :ask, :bedrock, env: 'BEDROCK_MODEL_ID')
+      type ||= Scout::Config.get(:type, model, default: :messages)
+
+      role = IndiferentHash.process_options options, :role
+      messages = LLM.parse(question, role)
+
+      case type.to_sym 
+      when :messages
+        body = model_options.merge({
+          system: messages.select{|m| m[:role] == 'system'}.collect{|m| m[:content]}*"\n",
+          messages: messages.select{|m| m[:role] == 'user'}
+        })
+      when :prompt
+        system, user = messages_to_prompt messages
+        body = model_options.merge({
+          prompt: user
+        })
+      else
+        raise "Unkown type #{type}"
+      end
+
+      Log.debug "Calling bedrock with model: #{model} parameters: #{Log.fingerprint body}"
+
+      response = client.invoke_model(
+        model_id: model,
+        content_type: 'application/json',
+        body: body.to_json
+      )
+
+      result = JSON.parse(response.body.string)
+      Log.debug "Response: #{Log.fingerprint result}"
+      message = result
+      tool_calls = message.dig('content').select{|m| m['tool_calls']}
+
+      while tool_calls && tool_calls.any?
+        messages << message
+
+        cpus = Scout::Config.get :cpus, :tool_calling, default: 3
+        tool_calls.each do |tool_call|
+          response_message = LLM.tool_response(tool_call, &block)
+          messages << response_message
+        end
+
+        body[:messages] = messages.compact
+        Log.debug "Calling bedrock with parameters: #{Log.fingerprint body}"
+        response = client.invoke_model(
+          model_id: model,
+          content_type: 'application/json',
+          body: body.to_json
+        )
+        result = JSON.parse(response.body.string)
+        Log.debug "Response: #{Log.fingerprint result}"
+
+        message = result
+        tool_calls = message.dig('content').select{|m| m['tool_calls']}
+      end
+
+      message.dig('content').collect{|m|
+        m['text']
+      } * "\n"
+    end
+
+    def self.embed(text, options = {})
+      client, region, access_key, secret_key, model = IndiferentHash.process_options options, :client, :region, :access_key, :secret_key, :model
+
+      if client.nil?
+        region ||= Scout::Config.get(:region, :bedrock_embed, :embed, :bedrock, env: 'AWS_REGION')
+        access_key ||= LLM.get_url_config(:access_key, nil, :bedrock_embed, :embed, :bedrock, env: 'AWS_ACCESS_KEY_ID')
+        secret_key ||= LLM.get_url_config(:secret_key, nil, :bedrock_embed, :embed, :bedrock, env: 'AWS_SECRET_ACCESS_KEY')
+        client = self.client(region, access_key, secret_key)
+      end
+
+      model ||= Scout::Config.get(:model, :bedrock_embed, :embed, :bedrock, env: 'BEDROCK_EMBED_MODEL_ID', default: 'amazon.titan-embed-text-v1')
+
+      response = client.invoke_model(
+        model_id: model,
+        content_type: 'application/json',
+        body: { inputText: text }.to_json
+      )
+
+      result = JSON.parse(response.body.string)
+      result['embedding']
+    end
+  end
+end

data/lib/scout/llm/backends/huggingface.rb

@@ -1,17 +1,18 @@
 require_relative '../parse'
 require_relative '../tools'
+require_relative '../chat'
 
 module LLM
   module Huggingface
 
     def self.model(model_options)
-      require 'rbbt-util'
-      require 'rbbt/vector/model/huggingface'
+      require 'scout/model/python/huggingface'
+      require 'scout/model/python/huggingface/causal'
 
       model, task, checkpoint, dir = IndiferentHash.process_options model_options, :model, :task, :checkpoint, :dir
       model ||= Scout::Config.get(:model, :huggingface, env: 'HUGGINGFACE_MODEL,HF_MODEL')
 
-      HuggingfaceModel.new task, model, dir, model_options
+      CausalModel.new model, dir, model_options
     end
 
     def self.ask(question, options = {}, &block)
@@ -20,7 +21,7 @@ module LLM
 
       model = self.model model_options
 
-      messages = LLM.parse(question)
+      messages = LLM.messages(question)
 
       system = []
       prompt = []
@@ -36,23 +37,7 @@ module LLM
       parameters = options.merge(messages: messages)
       Log.debug "Calling client with parameters: #{Log.fingerprint parameters}"
 
-      response = model.eval(messages)
-      message = response[-1]
-      while message["role"] == "assistant" && message["tool_calls"]
-        messages << message
-
-        message["tool_calls"].each do |tool_call|
-          response_message = LLM.tool_response(tool_call, &block)
-          messages << response_message
-        end
-
-        parameters[:messages] = messages
-        Log.debug "Calling client with parameters: #{Log.fingerprint parameters}"
-        response = model.eval(parameters)
-        message = response[-1]
-      end
-
-      message["content"]
+      model.eval(messages)
     end
 
     def self.embed(text, options = {})

data/lib/scout/llm/backends/ollama.rb

@@ -2,6 +2,7 @@ require 'ollama-ai'
 require_relative '../parse'
 require_relative '../tools'
 require_relative '../utils'
+require_relative '../chat'
 
 module LLM
   module OLlama
@@ -15,9 +16,34 @@ module LLM
       )
     end
 
+
+    def self.process_response(responses, &block)
+      responses.collect do |response|
+        Log.debug "Respose: #{Log.fingerprint response}"
+
+        message = response['message']
+        tool_calls = response.dig("tool_calls") ||
+          response.dig("message", "tool_calls")
+
+        if tool_calls && tool_calls.any?
+          LLM.call_tools tool_calls, &block
+        else
+          [message]
+        end
+      end.flatten
+    end
+
     def self.ask(question, options = {}, &block)
+      original_options = options.dup
 
-      client, url, key, model = IndiferentHash.process_options options, :client, :url, :key, :model
+      messages = LLM.chat(question)
+      options = options.merge LLM.options messages
+      tools = LLM.tools messages
+      associations = LLM.associations messages
+
+      client, url, key, model, return_messages, format, stream = IndiferentHash.process_options options,
+        :client, :url, :key, :model, :return_messages, :format, :stream,
+        stream: false
 
       if client.nil?
         url ||= Scout::Config.get(:url, :ollama_ask, :ask, :ollama, env: 'OLLAMA_URL', default: "http://localhost:11434")
@@ -30,51 +56,58 @@ module LLM
         model ||= LLM.get_url_config(:model, url, :ollama_ask, :ask, :ollama, env: 'OLLAMA_MODEL', default: "mistral")
       end
 
-      mode  = IndiferentHash.process_options options, :mode
 
-      messages = LLM.parse(question)
-
-      system = []
-      prompt = []
-      messages.each do |message|
-        role, content = message.values_at :role, :content
-        if role == 'system'
-          system << content
-        else
-          prompt << content
+      case format.to_sym
+      when :json, :json_object
+        options[:response_format] = {type: 'json_object'}
+      else
+        options[:response_format] = {type: format}
+      end if format
+
+      parameters = options.merge(model: model)
+
+      if tools.any? || associations.any?
+        parameters[:tools] = []
+        parameters[:tools] += tools.values.collect{|a| a.last } if tools
+        parameters[:tools] += associations.values.collect{|a| a.last } if associations
+        if not block_given?
+          block = Proc.new do |name,parameters|
+            IndiferentHash.setup parameters
+            if tools[name]
+              workflow = tools[name].first
+              jobname = parameters.delete :jobname
+              workflow.job(name, jobname, parameters).run
+            else
+              kb = associations[name].first
+              entities, reverse = IndiferentHash.process_options parameters, :entities, :reverse
+              if reverse
+                kb.parents(name, entities)
+              else
+                kb.children(name, entities)
+              end
+            end
+          end
         end
       end
 
-      case mode
-      when :chat, 'chat'
-        parameters = options.merge(model: model, messages: messages)
-        Log.debug "Calling client with parameters: #{Log.fingerprint parameters}"
+      Log.low "Calling client with parameters #{Log.fingerprint parameters}\n#{LLM.print messages}"
 
-        response = client.chat(parameters)
-        response.collect do |choice|
-          message=choice['message']
-          while message["role"] == "assistant" && message["tool_calls"]
-            messages << message
+      parameters[:messages] = LLM.tools_to_ollama messages
 
-            message["tool_calls"].each do |tool_call|
-              response_message = LLM.tool_response(tool_call, &block)
-              messages << response_message
-            end
+      parameters[:stream] = stream
 
-            parameters[:messages] = messages
-            Log.debug "Calling client with parameters: #{Log.fingerprint parameters}"
-            response = client.chat(parameters)
+      response = self.process_response client.chat(parameters), &block
 
-            message = response[0]['message']
-          end
+      res = if response.last[:role] == 'function_call_output' 
+              response + self.ask(messages + response, original_options.except(:tool_choice).merge(return_messages: true, tools: parameters[:tools]), &block)
+            else
+              response
+            end
 
-          message["content"]
-        end * ""
+      if return_messages
+        res
       else
-        parameters = options.merge(model: model, prompt: prompt * "\n", system: system*"\n")
-        Log.debug "Calling client with parameters: #{Log.fingerprint parameters}"
-        response = client.generate(parameters)
-        response.collect{|e| e['response']} * ""
+        res.last['content']
       end
     end