intelli_agent 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3fca7e6fcb2e2360ccd76c9d09506f73db72dd525dfd771322a19a6982eedd52
+  data.tar.gz: 2bcb9b1cc62b6dfb9a6c4ecc634dab04e9c1c27a2941dd2feb6a0f8aad858934
+SHA512:
+  metadata.gz: 3de9eaddade5b5d5f16e385ef4cbff9bd7e7eade087b4bbc04c5c8ae2c3d0cc15ef79b518536d023f3153b62a4b748e53f735b7f33a338450db403d824c86f06
+  data.tar.gz: aa27675fcfc8c0bcab9701b1f0e8ca6ec09eb03f8c4fd141b9c0b63465c196f9bfcf85ad8c401eeb2c32e82930f310c3ae0fbac445f43f1e5d4dd6aa6c1622e7

data/README.md

@@ -0,0 +1 @@
+# AI Agent

data/lib/ai/agent.rb

@@ -0,0 +1,71 @@
+class AI::Agent
+  attr_reader :assistant, :thread, :instructions, :vector_store_id
+
+  def initialize(assistant_id: nil, thread_id: nil, thread_instructions: nil, vector_store_id: nil)
+    @openai_client = OpenAI::Client.new
+
+    assistant_id ||= ENV.fetch('OPENAI_AKAPU_CORE_ASSISTANT_ID')
+    @assistant = @openai_client.assistants.retrieve(id: assistant_id)
+
+    thread_params = {}
+
+    # Only one vector store can be attached, according to the OpenAI API documentation
+    @vector_store_id = vector_store_id
+    thread_params = { tool_resources: { file_search: { vector_store_ids: [vector_store_id] } } } if @vector_store_id
+
+    thread_id ||= @openai_client.threads.create(parameters: thread_params)['id']
+    @thread = @openai_client.threads.retrieve(id: thread_id)
+
+    @instructions = thread_instructions || @assistant['instructions']
+  end
+
+  def add_message(text, role: 'user')
+    @openai_client.messages.create(thread_id: @thread['id'], parameters: { role: role, content: text })
+  end
+
+  def messages
+    @openai_client.messages.list(thread_id: @thread['id'])
+  end
+
+  def last_message
+    messages['data'].first['content'].first['text']['value']
+  end
+
+  def run(instructions: nil, additional_instructions: nil, additional_message: nil, model: nil, tool_choice: nil)
+    params = { assistant_id: @assistant['id'] }
+
+    params[:instructions] = instructions || @instructions
+    params[:additional_instructions] = additional_instructions unless additional_instructions.nil?
+    params[:tool_choice] = tool_choice unless tool_choice.nil?
+
+    params[:additional_messages] = [{ role: :user, content: additional_message }] unless additional_message.nil?
+
+    params[:model] = model || @assistant['model']
+
+    run_id = @openai_client.runs.create(thread_id: @thread['id'], parameters: params)['id']
+
+    loop do
+      response = @openai_client.runs.retrieve(id: run_id, thread_id: @thread['id'])
+
+      case response['status']
+      when 'queued', 'in_progress', 'cancelling'
+        puts 'Status: Waiting AI Processing finish'
+        sleep 1
+      when 'completed'
+        puts last_message
+        break
+      when 'requires_action'
+        # Handle tool calls (see below)
+      when 'cancelled', 'failed', 'expired'
+        puts response['last_error'].inspect
+        break # or `exit`
+      else
+        puts "Unknown status response: #{status}"
+      end
+    end
+  end
+
+  def runs
+    @openai_client.runs.list(thread_id: @thread['id'])
+  end
+end

data/lib/ai/agent_test.rb_

@@ -0,0 +1,77 @@
+require 'test_helper'
+require 'openai'
+
+class AI::AgentTest < ActiveSupport::TestCase
+  def setup
+    @assistant_id = 'your_assistant_id'
+    @thread_id = 'your_thread_id'
+    @thread_instructions = 'your_thread_instructions'
+    @agent = AI::Agent.new(assistant_id: @assistant_id, thread_id: @thread_id, thread_instructions: @thread_instructions)
+  end
+
+  test 'add_message should create a new message in the thread' do
+    text = 'Hello, world!'
+    role = 'user'
+    message_params = { thread_id: @thread_id, parameters: { role: role, content: text } }
+
+    OpenAI::Client.any_instance.expects(:messages).returns(stub(create: true))
+    @agent.add_message(text, role: role)
+
+    assert_received(OpenAI::Client) { |expect| expect.messages.create(message_params) }
+  end
+
+  test 'messages should return a list of messages in the thread' do
+    messages_params = { thread_id: @thread_id }
+
+    OpenAI::Client.any_instance.expects(:messages).returns(stub(list: true))
+    @agent.messages
+
+    assert_received(OpenAI::Client) { |expect| expect.messages.list(messages_params) }
+  end
+
+  test 'last_message should return the content of the last message in the thread' do
+    message_content = 'Hello, world!'
+    messages_response = { 'data' => [{ 'content' => [{ 'text' => { 'value' => message_content } }] }] }
+
+    OpenAI::Client.any_instance.expects(:messages).returns(stub(list: messages_response))
+    assert_equal message_content, @agent.last_message
+  end
+
+  test 'run should create a new run in the thread' do
+    instructions = 'your_instructions'
+    additional_instructions = 'your_additional_instructions'
+    model = 'your_model'
+    run_params = { assistant_id: @assistant_id, instructions: instructions, additional_instructions: additional_instructions, model: model }
+
+    OpenAI::Client.any_instance.expects(:runs).returns(stub(create: true))
+    @agent.run(instructions: instructions, additional_instructions: additional_instructions, model: model)
+
+    assert_received(OpenAI::Client) { |expect| expect.runs.create(run_params) }
+  end
+
+  test 'runs should return a list of runs in the thread' do
+    runs_params = { thread_id: @thread_id }
+
+    OpenAI::Client.any_instance.expects(:runs).returns(stub(list: true))
+    @agent.runs
+
+    assert_received(OpenAI::Client) { |expect| expect.runs.list(runs_params) }
+  end
+endrequire 'test_helper'
+require 'artificial_intelligence/ai/agent'
+
+class AI::AgentTest < ActiveSupport::TestCase
+  def setup
+    @agent = AI::Agent.new
+  end
+
+  test "agent can perform action" do
+    # Add your test logic here
+  end
+
+  test "agent can learn from experience" do
+    # Add your test logic here
+  end
+
+  # Add more tests as needed
+end

data/lib/ai.rb

@@ -0,0 +1,56 @@
+# In the future, this became a bus to more than one AI provider
+module AI
+  BASIC_MODEL = ENV.fetch('OPENAI_BASIC_MODEL')
+  ADVANCED_MODEL = ENV.fetch('OPENAI_ADVANCED_MODEL')
+
+  def self.embed(input, model: 'text-embedding-3-large')
+    response = OpenAI::Client.new.embeddings(parameters: { input:, model: })
+    response.dig('data', 0, 'embedding')
+  end
+
+  def self.single_prompt(prompt:, model: AI::BASIC_MODEL, response_format: nil)
+    parameters = { model:, messages: [{ role: 'user', content: prompt }] }
+
+    parameters[:response_format] = { type: 'json_object' } if response_format.eql?(:json)
+
+    response = OpenAI::Client.new.chat(parameters:)
+    response.dig('choices', 0, 'message', 'content').strip
+  end
+
+  def self.vision(prompt:, image_url:, response_format: nil)
+    messages = [{ type: :text, text: prompt },
+                { type: :image_url, image_url: { url: image_url } }]
+
+    parameters = { model: AI::ADVANCED_MODEL, messages: [{ role: :user, content: messages }] }
+    parameters[:response_format] = { type: 'json_object' } if response_format.eql?(:json)
+
+    response = OpenAI::Client.new.chat(parameters:)
+
+    response.dig('choices', 0, 'message', 'content').strip
+  end
+
+  def self.single_chat(system:, user:, model: AI::BASIC_MODEL, response_format: nil)
+    parameters = { model:,
+                   messages: [
+                     { role: 'system', content: system },
+                     { role: 'user', content: user }
+                   ] }
+
+    parameters[:response_format] = { type: 'json_object' } if response_format.eql?(:json)
+
+    response = OpenAI::Client.new.chat(parameters:)
+    response.dig('choices', 0, 'message', 'content').strip
+  end
+
+  def self.chat(messages, model: AI::BASIC_MODEL, response_format: nil)
+    parameters = { model:, messages: }
+    parameters[:response_format] = { type: 'json_object' } if response_format.eql?(:json)
+
+    response = OpenAI::Client.new.chat(parameters:)
+    response.dig('choices', 0, 'message', 'content').strip
+  end
+
+  def self.models
+    OpenAI::Client.new.models.list
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: intelli_agent
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gedean Dias
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-07-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-openai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+description: AI Agent.
+email: gedean.dias@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/ai.rb
+- lib/ai.rb:Zone.Identifier
+- lib/ai/agent.rb
+- lib/ai/agent.rb:Zone.Identifier
+- lib/ai/agent_test.rb_
+- lib/ai/agent_test.rb_:Zone.Identifier
+homepage: https://github.com/gedean/intelli_agent
+licenses:
+- MIT
+metadata: {}
+post_install_message: Please check readme file for use instructions.
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key: 
+specification_version: 4
+summary: AI Agent
+test_files: []