scout-ai 0.2.0

data/lib/scout/llm/embed.rb

@@ -0,0 +1,31 @@
+require 'scout'
+require_relative 'backends/ollama'
+require_relative 'backends/openai'
+require_relative 'backends/openwebui'
+require_relative 'backends/relay'
+
+module LLM
+  def self.embed(text, options = {})
+    endpoint = IndiferentHash.process_options options, :endpoint
+    endpoint ||= Scout::Config.get :endpoint, :embed, :llm, env: 'EMBED_ENDPOINT,LLM_ENDPOINT', default: :openai
+    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, :embed, :llm, env: 'EMBED_BACKEND,LLM_BACKEND', default: :openai
+
+    case backend
+    when :openai, "openai"
+      LLM::OpenAI.embed(text, options)
+    when :ollama, "ollama"
+      LLM::OLlama.embed(text, options)
+    when :openwebui, "openwebui"
+      LLM::OpenWebUI.embed(text, options)
+    when :relay, "relay"
+      LLM::Relay.embed(text, options)
+    else
+      raise "Unknown backend: #{backend}"
+    end
+  end
+end

data/lib/scout/llm/parse.rb

@@ -0,0 +1,33 @@
+module LLM
+  def self.parse(question, role = nil)
+    role = :user if role.nil?
+
+    if Array === question
+      question.collect do |q|
+        Hash === q ? q : {role: role, content: q}
+      end
+    else
+      if m = question.match(/(.*?)\[\[(.*?)\]\](.*)/m)
+        pre = m[1]
+        inside = m[2]
+        post = m[3]
+        messages = parse(pre, role)
+        messages.last[:content] += "\n" + inside
+        messages.concat parse(post, role)
+      else
+        question.split("\n").collect do |line|
+          if line.include?("\t")
+            question_role, _sep, q = line.partition("\t")
+          elsif m = line.match(/^([^\s]*): ?(.*)/)
+            question_role, q = m.values_at 1, 2
+          else
+            question_role = role
+            q = line
+          end
+          next if q.empty?
+          {role: question_role, content: q}
+        end.compact
+      end
+    end
+  end
+end

data/lib/scout/llm/rag.rb

@@ -0,0 +1,16 @@
+module LLM
+  class RAG
+    def self.index(data)
+      require 'hnswlib'
+
+      dim = data.first.length
+      t = Hnswlib::HierarchicalNSW.new(space: 'l2', dim: dim)
+      t.init_index(max_elements: data.length)
+
+      data.each_with_index do |vector,i|
+        t.add_point vector, i
+      end
+      t
+    end
+  end
+end

data/lib/scout/llm/tools.rb

@@ -0,0 +1,104 @@
+require 'scout/workflow'
+require 'scout/knowledge_base'
+module LLM
+  def self.tool_response(tool_call, &block)
+    tool_call_id = tool_call.dig("id")
+    function_name = tool_call.dig("function", "name")
+    function_arguments = tool_call.dig("function", "arguments")
+    function_arguments = JSON.parse(function_arguments, { symbolize_names: true }) if String === function_arguments
+    function_response = block.call function_name, function_arguments
+
+    #content = String === function_response ? function_response : function_response.to_json,
+    content = case function_response
+              when String
+                function_response
+              when nil
+                "success"
+              else
+                function_response.to_json
+              end
+    {
+      tool_call_id: tool_call_id,
+      role: "tool",
+      content: content
+    }
+  end
+
+  def self.task_tool_definition(workflow, task_name)
+    task_info = workflow.task_info(task_name)
+
+    properties = task_info[:inputs].inject({}) do |acc,input|
+      type = task_info[:input_types][input]
+      description = task_info[:input_descriptions][input]
+
+      type = :string if type == :select
+
+      acc[input] = {
+        "type": type,
+        "description": description
+      }
+
+      if input_options = task_info[:input_options][input]
+        if select_options = input_options[:select_options]
+          select_options = select_options.values if Hash === select_options
+          acc[input]["enum"] = select_options
+        end
+      end
+
+      acc
+    end
+
+    required_inputs = task_info[:inputs].select do |input|
+      task_info[:input_options].include?(input) && task_info[:input_options][:required]
+    end
+
+    {
+      type: "function",
+      function: {
+        name: task_name,
+        description: task_info[:description],
+        parameters: {
+          type: "object",
+          properties: properties,
+          required: required_inputs
+        }
+      }
+    }
+  end
+
+  def self.workflow_tools(workflow, tasks = nil)
+    tasks ||= workflow.tasks.keys
+    tasks.collect{|task_name| self.task_tool_definition(workflow, task_name) }
+  end
+
+  def self.knowledge_base_tool_definition(knowledge_base)
+
+    databases = knowledge_base.all_databases.collect{|d| d.to_s }
+
+    properties = {
+      database: {
+        type: "string",
+        enum: databases,
+        description: "Database to traverse"
+      },
+      entities: {
+        type: "array",
+        items: { type: :string },
+        description: "Parent entities to find children for"
+      }
+    }
+
+    [{
+      type: "function",
+      function: {
+        name: 'children',
+        description: "Find the graph children for a list of entities in a format like parent~child. Returns a list.",
+        parameters: {
+          type: "object",
+          properties: properties,
+          required: ['database', 'entities']
+        }
+      }
+    }]
+  end
+end

data/lib/scout/llm/utils.rb

@@ -0,0 +1,35 @@
+module LLM
+  def self.get_url_server_tokens(url, prefix=nil)
+    return get_url_server_tokens(url).collect{|e| prefix.to_s + "." + e } if prefix
+
+    server = url.match(/(?:https?:\/\/)?([^\/:]*)/)[1] || "NOSERVER"
+    parts = server.split(".")
+    parts.pop if parts.last.length <= 3
+    combinations = []
+    (1..parts.length).each do |l|
+      parts.each_cons(l){|p| combinations << p*"."}
+    end
+    (parts + combinations + [server]).uniq
+  end
+
+  def self.get_url_config(key, url = nil, *tokens)
+    hash = tokens.pop if Hash === tokens.last 
+    if url
+      url_tokens = tokens.inject([]){|acc,prefix| acc.concat(get_url_server_tokens(url, prefix))}
+      all_tokens = url_tokens + tokens
+    else
+      all_tokens = tokens
+    end
+    Scout::Config.get(key, *all_tokens, hash)
+  end
+
+  def self
+    if workflow.root.etc.AI[@model || 'default'].exists?
+      workflow.root.etc.AI[@model || 'default'].json
+    elsif Scout.etc.AI[@model || 'default'].exists?
+      Scout.etc.AI[@model || 'default'].json
+    else
+      {}
+    end
+  end
+end

data/lib/scout-ai.rb

@@ -0,0 +1,7 @@
+require 'scout'
+require 'scout/path'
+require 'scout/resource'
+Path.add_path :scout_ai, File.join(Path.caller_lib_dir(__FILE__), "{TOPLEVEL}/{SUBPATH}")
+
+require 'scout/llm/ask'
+require 'scout/llm/embed'

data/questions/coach

@@ -0,0 +1,2 @@
+system: You write prompts to give instructions to a coding LLM to perform certain task
+user: ???

data/scout_commands/agent/ask

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+require 'scout'
+require 'scout-ai'
+require 'scout/workflow'
+require 'scout/knowledge_base'
+require 'scout/llm/agent'
+
+$0 = "scout #{$previous_commands.any? ? $previous_commands*" " + " " : "" }#{ File.basename(__FILE__) }" if $previous_commands
+
+options = SOPT.setup <<EOF
+
+Ask GPT
+
+$ #{$0} [<options>] [question]
+
+Use STDIN to add context to the question
+
+-h--help Print this help
+-l--log* Log level
+-t--template* Use a template
+-m--model* Model to use
+-f--file* Incorporate file at the start
+EOF
+if options[:help]
+  if defined? scout_usage
+    scout_usage 
+  else
+    puts SOPT.doc
+  end
+  exit 0
+end
+
+Log.severity = options.delete(:log).to_i if options.include? :log
+
+file = options.delete(:file)
+
+agent, *question_parts = ARGV
+
+
+workflow = begin
+             Workflow.require_workflow agent
+           rescue
+           end
+
+knowledge_base = begin workflow.knowledge_base rescue nil end || KnowledgeBase.new(Scout.var.Agent[agent])
+
+agent = LLM::Agent.new workflow: workflow, knowledge_base: knowledge_base
+
+question = question_parts * " " 
+
+if template = options.delete(:template)
+  if Open.exists?(template)
+    template_question = Open.read(template)
+  else
+    template_question = Scout.questions[template].read
+  end
+  if template_question.include?('???')
+    question = template_question.sub('???', question)
+  else
+    question = template_question
+  end
+end
+
+if question.include?('...')
+  context = file ? Open.read(file) : STDIN.read 
+  question = question.sub('...', context)
+end
+
+puts LLM.ask(question, options)

data/scout_commands/llm/ask

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+require 'scout'
+require 'scout-ai'
+
+$0 = "scout #{$previous_commands.any? ? $previous_commands*" " + " " : "" }#{ File.basename(__FILE__) }" if $previous_commands
+
+options = SOPT.setup <<EOF
+
+Ask GPT
+
+$ #{$0} [<options>] [question]
+
+Use STDIN to add context to the question
+
+-h--help Print this help
+-l--log* Log level
+-t--template* Use a template
+-m--model* Model to use
+-e--endpoint* Endpoint to use
+-f--file* Incorporate file at the start
+EOF
+if options[:help]
+  if defined? scout_usage
+    scout_usage 
+  else
+    puts SOPT.doc
+  end
+  exit 0
+end
+
+Log.severity = options.delete(:log).to_i if options.include? :log
+
+file = options.delete(:file)
+
+question = ARGV * " "
+
+if template = options.delete(:template)
+  if Open.exists?(template)
+    template_question = Open.read(template)
+  else
+    template_question = Scout.questions[template].read
+  end
+  if template_question.include?('???')
+    question = template_question.sub('???', question)
+  else
+    question = template_question
+  end
+end
+
+if question.include?('...')
+  context = file ? Open.read(file) : STDIN.read 
+  question = question.sub('...', context)
+end
+
+puts LLM.ask(question, options)

data/scout_commands/llm/process

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+require 'scout'
+require 'scout-ai'
+require 'scout/llm/backends/relay'
+
+$0 = "scout #{$previous_commands.any? ? $previous_commands*" " + " " : "" }#{ File.basename(__FILE__) }" if $previous_commands
+
+options = SOPT.setup <<EOF
+
+Ask GPT
+
+$ #{$0} [<options>] [<directory>]
+
+Use STDIN to add context to the question
+
+-h--help Print this help
+EOF
+if options[:help]
+  if defined? scout_usage
+    scout_usage 
+  else
+    puts SOPT.doc
+  end
+  exit 0
+end
+
+Log.severity = options.delete(:log).to_i if options.include? :log
+
+directory = ARGV.first || Scout.var.ask.find
+
+directory = Path.setup directory
+
+while true
+  directory.glob('*.json').each do |file|
+    target = directory.reply[id + '.json']
+
+    if ! File.exist?(target)
+      id = File.basename(file, '.json')
+      options = IndiferentHash.setup(JSON.parse(Open.read(file)))
+      question = options.delete(:question)
+      reply = LLM.ask(question, options)
+      Open.write(target, reply.to_json)
+    end
+
+    Open.rm(file)
+  end
+
+  sleep 1
+end

data/scout_commands/llm/template

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'scout'
+
+$0 = "scout #{$previous_commands.any? ? $previous_commands*" " + " " : "" }#{ File.basename(__FILE__) }" if $previous_commands
+
+options = SOPT.setup <<EOF
+
+List all ask templates
+
+$ #{$0} [<options>] <filename> [<other|->]*
+
+-h--help Print this help
+EOF
+if options[:help]
+  if defined? scout_usage
+    scout_usage 
+  else
+    puts SOPT.doc
+  end
+  exit 0
+end
+
+puts Scout.questions.glob_all("*") * "\n"
+
+

data/test/data/person/brothers

@@ -0,0 +1,4 @@
+#: :sep=,#:type=:list
+#Older (Alias),Younger (Alias)
+Clei,Guille
+Isa,Miki

data/test/data/person/identifiers

@@ -0,0 +1,10 @@
+#: :sep=,#:type=:list
+#Name,Alias,ID
+Miguel,Miki,001
+Cleia,Clei,002
+Isabel,Isa,003
+Guillermo,Guille,004
+Juan Luis,Juan,005
+Maria Luz,Mariluz,006
+Domingo,Domingo,007
+Gloria,Gloria,008

data/test/data/person/marriages

@@ -0,0 +1,3 @@
+#: :type=:list
+#Husband (ID)	Wife (ID)	Date
+001	002	2021

data/test/data/person/parents

@@ -0,0 +1,6 @@
+#: :sep=,#:type=:double
+#Child (Alias),Parent (Alias),Type of parent
+Miki,Juan|Mariluz,father|mother
+Isa,Juan|Mariluz,father|mother
+Guille,Domingo|Gloria,father|mother
+Clei,Domingo|Gloria,father|mother

data/test/scout/llm/backends/test_huggingface.rb

@@ -0,0 +1,73 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+class TestLLMHF < Test::Unit::TestCase
+
+  def test_ask
+    Log.severity = 0
+    prompt =<<-EOF
+system: you are a coding helper that only write code and inline comments. No extra explanations or comentary
+system: Avoid using backticks ``` to format code.
+user: write a script that sorts files in a directory 
+    EOF
+    ppp LLM::Huggingface.ask prompt, model: 'HuggingFaceTB/SmolLM2-135M-Instruct'
+  end
+
+  def test_embeddings
+    Log.severity = 0
+    text =<<-EOF
+Some text
+    EOF
+    emb = LLM::Huggingface.embed text, model: 'distilbert-base-uncased-finetuned-sst-2-english'
+    assert(Float === emb.first)
+  end
+
+  def test_embedding_array
+    Log.severity = 0
+    text =<<-EOF
+Some text
+    EOF
+    emb = LLM::Huggingface.embed [text], model: 'distilbert-base-uncased-finetuned-sst-2-english'
+    assert(Float === emb.first.first)
+  end
+
+  def test_tool
+    prompt =<<-EOF
+What is the weather in London. Should I take an umbrella?
+    EOF
+
+    tools = [
+      {
+        "type": "function",
+        "function": {
+          "name": "get_current_temperature",
+          "description": "Get the current temperature for a specific location",
+          "parameters": {
+            "type": "object",
+            "properties": {
+              "location": {
+                "type": "string",
+                "description": "The city and state, e.g., San Francisco, CA"
+              },
+              "unit": {
+                "type": "string",
+                "enum": ["Celsius", "Fahrenheit"],
+                "description": "The temperature unit to use. Infer this from the user's location."
+              }
+            },
+            "required": ["location", "unit"]
+          }
+        }
+      },
+    ]
+
+    sss 0
+    respose = LLM::Huggingface.ask prompt, model: 'HuggingFaceTB/SmolLM2-135M-Instruct', tool_choice: 'required', tools: tools do |name,arguments|
+      "It's raining cats and dogs"
+    end
+
+    ppp respose
+  end
+
+end
+

data/test/scout/llm/backends/test_ollama.rb

@@ -0,0 +1,72 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+class TestLLMOllama < Test::Unit::TestCase
+
+  def test_ask
+    Log.severity = 0
+    prompt =<<-EOF
+system: you are a coding helper that only write code and inline comments. No extra explanations or comentary
+system: Avoid using backticks ``` to format code.
+user: write a script that sorts files in a directory 
+    EOF
+    ppp LLM::OLlama.ask prompt, model: 'mistral', mode: 'chat'
+  end
+
+  def test_embeddings
+    Log.severity = 0
+    text =<<-EOF
+Some text
+    EOF
+    emb = LLM::OLlama.embed text, model: 'mistral'
+    assert(Float === emb.first)
+  end
+
+  def test_embedding_array
+    Log.severity = 0
+    text =<<-EOF
+Some text
+    EOF
+    emb = LLM::OLlama.embed [text], model: 'mistral'
+    assert(Float === emb.first.first)
+  end
+
+  def test_tool
+    prompt =<<-EOF
+What is the weather in London. Should I take an umbrella?
+    EOF
+
+    tools = [
+      {
+        "type": "function",
+        "function": {
+          "name": "get_current_temperature",
+          "description": "Get the current temperature for a specific location",
+          "parameters": {
+            "type": "object",
+            "properties": {
+              "location": {
+                "type": "string",
+                "description": "The city and state, e.g., San Francisco, CA"
+              },
+              "unit": {
+                "type": "string",
+                "enum": ["Celsius", "Fahrenheit"],
+                "description": "The temperature unit to use. Infer this from the user's location."
+              }
+            },
+            "required": ["location", "unit"]
+          }
+        }
+      },
+    ]
+
+    sss 0
+    respose = LLM::OLlama.ask prompt, model: 'mistral', tool_choice: 'required', tools: tools do |name,arguments|
+      "It's raining cats and dogs"
+    end
+
+    ppp respose
+  end
+end
+

data/test/scout/llm/backends/test_openai.rb

@@ -0,0 +1,68 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+class TestLLMOpenAI < Test::Unit::TestCase
+  def test_ask
+    prompt =<<-EOF
+system: you are a coding helper that only write code and comments without formatting so that it can work directly, avoid the initial and end commas ```.
+user: write a script that sorts files in a directory
+    EOF
+    sss 0
+    ppp LLM::OpenAI.ask prompt
+  end
+
+  def _test_argonne
+    prompt =<<-EOF
+user: write a script that sorts files in a directory
+    EOF
+    sss 0
+  end
+
+  def _test_embeddings
+    Log.severity = 0
+    text =<<-EOF
+Some text
+    EOF
+    emb = LLM::OpenAI.embed text, log_errors: true
+    assert(Float === emb.first)
+  end
+
+  def _test_tool
+    prompt =<<-EOF
+What is the weather in London. Should I take my umbrella?
+    EOF
+
+    tools = [
+      {
+        "type": "function",
+        "function": {
+          "name": "get_current_temperature",
+          "description": "Get the current temperature and raining conditions for a specific location",
+          "parameters": {
+            "type": "object",
+            "properties": {
+              "location": {
+                "type": "string",
+                "description": "The city and state, e.g., San Francisco, CA"
+              },
+              "unit": {
+                "type": "string",
+                "enum": ["Celsius", "Fahrenheit"],
+                "description": "The temperature unit to use. Infer this from the user's location."
+              }
+            },
+            "required": ["location", "unit"]
+          }
+        }
+      },
+    ]
+
+    sss 0
+    respose = LLM::OpenAI.ask prompt, tool_choice: 'required', tools: tools, model: "gpt-4o" do |name,arguments|
+      "It's 15 degrees and raining."
+    end
+
+    ppp respose
+  end
+end
+