chatgpt-ruby 0.3.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f01f292bb8825b0d36f4474f988a1cee11a9f065eb9f02643de9e4b9d4c433b
-  data.tar.gz: c5ef2ddfeaccacfcb68be33257384facc83b33f983233acda917c9962bef0826
+  metadata.gz: 7aa91296be7cab7d9f1f5f1b2b6e55fa784c4a8760fabebbaac3cf903268da1d
+  data.tar.gz: cd8a13397002dec2a38da0ad766ce3b9301ca3d6bc5efa2669b30851d3ebc4ca
 SHA512:
-  metadata.gz: 27062bcbbba5cdc8804235ea72d305e4699e8b40faef562693428007f3564b227db2ec13ddc8100bafa955c9234f85d9bc1582f8a88aa9b486207b9daaf8965a
-  data.tar.gz: 5b60cc1a80ff20fcb4f6f2b45452758847c1585a02541658c49e8a432a0fa62145a0bde1fcb81ff5a5e92ab7ddf67ca373c52fe0cb96f705c6bd24e33b6628fc
+  metadata.gz: adf9e9cdc0e6b3e834d86e388b2c6319a42292c302333cc4a039817c9b4136e1394e00dff859c9f2359674728bf550171a22d64387089accdf48aed2d023658f
+  data.tar.gz: f1d0932b4ad810440543fa9b538a52190f6355ef892356519373748eb002f94a4d3de35f234fbd120c0bcd959b1f609fd6f35bbd27cd2125009a0b84e11dd8bd

data/Gemfile

@@ -11,5 +11,4 @@ gem "minitest", "~> 5.0"
 
 gem "rubocop", "~> 1.21"
 
-gem 'httparty'
-gem 'json'
+gem 'rest-client'

data/Gemfile.lock

@@ -1,25 +1,35 @@
 PATH
   remote: .
   specs:
-    chatgpt-ruby (0.3.0)
+    chatgpt-ruby (0.6.0)
+      rest-client
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
-    httparty (0.21.0)
-      mini_mime (>= 1.0.0)
-      multi_xml (>= 0.5.2)
+    domain_name (0.5.20190701)
+      unf (>= 0.0.5, < 1.0.0)
+    http-accept (1.7.0)
+    http-cookie (1.0.5)
+      domain_name (~> 0.5)
     json (2.6.3)
-    mini_mime (1.1.2)
+    mime-types (3.4.1)
+      mime-types-data (~> 3.2015)
+    mime-types-data (3.2023.0218.1)
     minitest (5.18.0)
-    multi_xml (0.6.0)
+    netrc (0.11.0)
     parallel (1.22.1)
     parser (3.2.1.1)
       ast (~> 2.4.1)
     rainbow (3.1.1)
     rake (13.0.6)
     regexp_parser (2.7.0)
+    rest-client (2.1.0)
+      http-accept (>= 1.7.0, < 2.0)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 4.0)
+      netrc (~> 0.8)
     rexml (3.2.5)
     rubocop (1.48.1)
       json (~> 2.3)
@@ -34,6 +44,9 @@ GEM
     rubocop-ast (1.27.0)
       parser (>= 3.2.1.0)
     ruby-progressbar (1.13.0)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.8.2)
     unicode-display_width (2.4.2)
 
 PLATFORMS
@@ -41,10 +54,9 @@ PLATFORMS
 
 DEPENDENCIES
   chatgpt-ruby!
-  httparty
-  json
   minitest (~> 5.0)
   rake (~> 13.0)
+  rest-client
   rubocop (~> 1.21)
 
 BUNDLED WITH

data/README.md

@@ -1,46 +1,161 @@
 # ChatGPTRuby
 
-The `chatgpt-ruby` gem is a simple Ruby SDK for accessing the OpenAI ChatGPT API. This client makes it easy to integrate the ChatGPT API into your Ruby applications.
+The `chatgpt-ruby` is a Ruby SDK for the OpenAI API, including methods for generating text, completing prompts, and more.
 
-### Bundler
+## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "chatgpt-ruby"
+gem 'chatgpt-ruby'
 ```
 
+
+
 And then execute:
 
+```ruby
 $ bundle install
+```
+
 
-### Gem install
 
-Or install with:
+Or install it yourself as:
 
+```ruby
 $ gem install chatgpt-ruby
+```
 
 ## Usage
 
-To use the gem in a Ruby script or application, simply require it and initialize the client:
+To use the ChatGPT API SDK, you will need an API key from OpenAI. You can obtain an API key by signing up for the [OpenAI API beta program](https://beta.openai.com/signup/) .
+
+Once you have an API key, you can create a new `ChatGPT::Client` instance with your API key:
+
+```ruby
+require 'chatgpt_api'
+
+api_key = 'your-api-key'
+client = ChatGPT::Client.new(api_key)
+```
+
+
+### Completions
+
+To generate completions given a prompt, you can use the `completions` method:
+
+```ruby
+prompt = 'Hello, my name is'
+completions = client.completions(prompt)
+
+# Output: an array of completion strings
+```
+
+
+
+You can customize the generation process by passing in additional parameters as a hash:
+
+```ruby
+params = {
+  engine: 'text-davinci-002',
+  max_tokens: 50,
+  temperature: 0.7
+}
+completions = client.completions(prompt, params)
+
+# Output: an array of completion strings
+```
+
+
+### Search
+
+To perform a search query given a set of documents and a search query, you can use the `search` method:
+
+```ruby
+documents = ['Document 1', 'Document 2', 'Document 3']
+query = 'Search query'
+results = client.search(documents, query)
+
+# Output: an array of search result objects
+```
+
+
+
+You can customize the search process by passing in additional parameters as a hash:
+
 ```ruby
-require 'chatgpt_client'
+params = {
+  engine: 'ada',
+  max_rerank: 100
+}
+results = client.search(documents, query, params)
 
-client = ChatGPTClient::Client.new('your_api_key')
-response = client.chat('Please translate the following English text to French: "Hello, how are you?"')
-puts response
+# Output: an array of search result objects
 ```
 
-Replace 'your_api_key' with your actual ChatGPT API key.
 
-### Parameters
+### Classify
+
+To classify a given text, you can use the `classify` method:
+
+```ruby
+text = 'This is a sample text'
+label = client.classify(text)
+
+# Output: a string representing the classified label
+```
+
 
-The `chat` method accepts a mandatory `prompt` parameter and an optional `options` parameter.
 
-The `prompt` parameter is a string representing the input you want to send to the ChatGPT API.
+You can customize the classification process by passing in additional parameters as a hash:
 
-The `options` parameter is a hash that can include the following keys: 
-- `max_tokens`: The maximum number of tokens
+```ruby
+params = {
+  model: 'text-davinci-002'
+}
+label = client.classify(text, params)
+
+# Output: a string representing the classified label
+```
+
+
+### Generate Summaries
+
+To generate summaries given a set of documents, you can use the `generate_summaries` method:
+
+```ruby
+documents = ['Document 1', 'Document 2', 'Document 3']
+summary = client.generate_summaries(documents)
+
+# Output: a string representing the generated summary
+```
+
+
+
+You can customize the summary generation process by passing in additional parameters as a hash:
+
+```ruby
+params = {
+  model: 'text-davinci-002',
+  max_tokens: 100
+}
+summary = client.generate_summaries(documents, params)
+
+# Output: a string representing the generated summary
+```
+
+
+### Generate Answers
+
+To generate answers given a prompt and a set of documents, you can use the `generate_answers` method:
+
+```ruby
+prompt = 'What is the capital of France?'
+documents = ['France is a country in Europe', 'Paris is the capital of France']
+answer = client.generate_answers(prompt, documents)
+
+# Output
+```
 
 ## Development
 

data/lib/chatgpt/client.rb

@@ -1,45 +1,114 @@
-# chatgpt_client.rb
-require 'httparty'
+# lib/chatgpt/client.rb
+
+require 'rest-client'
 require 'json'
 
-module ChatGPTRuby
+module ChatGPT
   class Client
-    include HTTParty
-    base_uri 'https://api.openai.com/v1'
-
     def initialize(api_key)
       @api_key = api_key
-      @headers = {
-        'Authorization' => "Bearer #{@api_key}",
-        'Content-Type' => 'application/json'
+      @endpoint = 'https://api.openai.com/v1'
+    end
+
+    def completions(prompt, params = {})
+      engine = params[:engine] || 'text-davinci-002'
+      max_tokens = params[:max_tokens] || 16
+      temperature = params[:temperature] || 0.5
+      top_p = params[:top_p] || 1.0
+      n = params[:n] || 1
+
+      url = "#{@endpoint}/engines/#{engine}/completions"
+      headers = {
+        'Content-Type' => 'application/json',
+        'Authorization' => "Bearer #{@api_key}"
+      }
+      data = {
+        prompt: prompt,
+        max_tokens: max_tokens,
+        temperature: temperature,
+        top_p: top_p,
+        n: n
       }
+      response = RestClient.post(url, data.to_json, headers)
+      JSON.parse(response.body)
     end
 
-    # Methods to interact with the API
-    def generate(prompt, options = {})
-      body = {
-        'prompt' => prompt,
-        'max_tokens' => options.fetch(:max_tokens, 100),
-        'n' => options.fetch(:n, 1),
-        'stop' => options.fetch(:stop, nil),
-        'temperature' => options.fetch(:temperature, 1.0),
-        'top_p' => options.fetch(:top_p, 1.0),
-        'frequency_penalty' => options.fetch(:frequency_penalty, 0.0),
-        'presence_penalty' => options.fetch(:presence_penalty, 0.0),
-      }.to_json
-
-      response = self.class.post('/davinci-codex/completions', headers: @headers, body: body)
-      handle_response(response)
+    def search(documents, query, params = {})
+      engine = params[:engine] || 'ada'
+      max_rerank = params[:max_rerank] || 200
+
+      url = "#{@endpoint}/engines/#{engine}/search"
+      headers = {
+        'Content-Type' => 'application/json',
+        'Authorization' => "Bearer #{@api_key}"
+      }
+      data = {
+        documents: documents,
+        query: query,
+        max_rerank: max_rerank
+      }
+      response = RestClient.post(url, data.to_json, headers)
+      JSON.parse(response.body)['data']
     end
 
-    private
+    def classify(text, params = {})
+      model = params[:model] || 'text-davinci-002'
 
-    def handle_response(response)
-      if response.code == 200
-        JSON.parse(response.body)
-      else
-        raise "Error: #{response.code} - #{response.message}"
-      end
+      url = "#{@endpoint}/classifications/#{model}"
+      headers = {
+        'Content-Type' => 'application/json',
+        'Authorization' => "Bearer #{@api_key}"
+      }
+      data = {
+        model: model,
+        input: text
+      }
+      response = RestClient.post(url, data.to_json, headers)
+      JSON.parse(response.body)['data'][0]['label']
+    end
+
+    def generate_summaries(documents, params = {})
+      model = params[:model] || 'text-davinci-002'
+      max_tokens = params[:max_tokens] || 60
+      temperature = params[:temperature] || 0.5
+      top_p = params[:top_p] || 1.0
+      frequency_penalty = params[:frequency_penalty] || 0.0
+      presence_penalty = params[:presence_penalty] || 0.0
+
+      url = "#{@endpoint}/engines/#{model}/generate"
+      headers = {
+        'Content-Type' => 'application/json',
+        'Authorization' => "Bearer #{@api_key}"
+      }
+      data = {
+        prompt: '',
+        max_tokens: max_tokens,
+        temperature: temperature,
+        top_p: top_p,
+        frequency_penalty: frequency_penalty,
+        presence_penalty: presence_penalty,
+        documents: documents
+      }
+      response = RestClient.post(url, data.to_json, headers)
+      JSON.parse(response.body)['choices'][0]['text']
+    end
+
+    def generate_answers(prompt, documents, params = {})
+      model = params[:model] || 'text-davinci-002'
+      max_tokens = params[:max_tokens] || 5
+
+      url = "#{@endpoint}/engines/#{model}/answers"
+      headers = {
+        'Content-Type' => 'application/json',
+        'Authorization' => "Bearer #{@api_key}"
+      }
+      data = {
+        prompt: prompt,
+        documents: documents,
+        max_tokens: max_tokens
+      }
+      response = RestClient.post(url, data.to_json, headers)
+      JSON.parse(response.body)['data'][0]['answer']
     end
   end
 end

data/lib/chatgpt/ruby/version.rb

@@ -2,6 +2,6 @@
 
 module Chatgpt
   module Ruby
-    VERSION = "0.1.0"
+    VERSION = "0.6.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chatgpt-ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Nagendra Dhanakeerthi
@@ -9,8 +9,23 @@ autorequire:
 bindir: exe
 cert_chain: []
 date: 2023-03-22 00:00:00.000000000 Z
-dependencies: []
-description: Write a longer description or delete this line.
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-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: This gem provides a Ruby SDK for interacting with the OpenAI API, including
+  methods for generating text, completing prompts, and more.
 email:
 - nagendra.dhanakeerthi@gmail.com
 executables: []
@@ -29,10 +44,13 @@ files:
 - lib/chatgpt/ruby.rb
 - lib/chatgpt/ruby/version.rb
 - sig/chatgpt/ruby.rbs
-homepage:
+homepage: https://github.com/nagstler/chatgpt-ruby.git
 licenses:
 - MIT
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/nagstler/chatgpt-ruby.git
+  source_code_uri: https://github.com/nagstler/chatgpt-ruby.git
+  changelog_uri: https://github.com/nagstler/chatgpt-ruby/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -51,5 +69,5 @@ requirements: []
 rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
-summary: Write a short summary, because RubyGems requires one.
+summary: A Ruby SDK for the OpenAI API
 test_files: []