chatgpt-ruby 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a246b757af45ec2b58fd7fad4cda501d6408f273f62c697705a4b85b824c07e
-  data.tar.gz: b314a13e482bf33e88d2dd7adec626850612cb1da247ed0a247492dc40bd09af
+  metadata.gz: adc49f5bb5b5d4862838cbb111ecd00bccf7a4adc3b7edb23b8f4e5157da2a8b
+  data.tar.gz: f4ec243a9aeeb0ee03c82b58241d9df097a2985ca7ba15a77707645b3922ff13
 SHA512:
-  metadata.gz: 2cd02878303337251add7d71e82bd9d29504313217dfeb6bcc2228a9d61f14abe0306523e55374465d431e65f438106b8054936b22d9d2a6de9aaa7b1d1e8a29
-  data.tar.gz: b30e1470736ccfd7ebd26c380792eb1759707bb630bbb3d4ad2dc446968d6e414c3ace6ac3164e7681ff57f07445a50d9025e72b5c497f77e6b3de949a537b79
+  metadata.gz: 8b7edafba1fdf4d46adada02994ea92ced8c510b11bfe03fadcf4445e39813b169a594f4baae6ae5cddb44d2146d8111827a328f5e424174826ab4eecbb2d0c0
+  data.tar.gz: d5c1d54f84fe5c478bbffc2d85571e9f139072a460272152088dc85e84bbbfa8b24a5b53df3030602ba22de0cbcdad019fef0f7a5ef99f718c8d1e89d18bfbf5

data/CHANGELOG.md

@@ -1,4 +1,18 @@
-## [Unreleased]
+## [2.0.0] - 2023-07-08
+
+### Added
+
+- Added support for chat interactions with the GPT-3.5-turbo model.
+- Introduced a new `chat` method to the `ChatGPT::Client` class, which sends an array of chat messages to the API and receives the generated messages in return.
+- Updated the README to provide usage instructions for the new `chat` method.
+
+## [1.0.0] - 2023-04-30
+
+### Added
+
+- Initial release of the `chatgpt-ruby` gem.
+- Implements ChatGPT Client with methods for completions, search, classification, summary, and answer generation.
+- Includes unit tests for each method.
 
 ## [0.1.0] - 2023-03-22
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    chatgpt-ruby (0.6.0)
+    chatgpt-ruby (1.0.0)
       rest-client
 
 GEM

data/README.md

@@ -2,7 +2,7 @@
 
 [![Gem Version](https://badge.fury.io/rb/chatgpt-ruby.svg)](https://badge.fury.io/rb/chatgpt-ruby) [![License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Maintainability](https://api.codeclimate.com/v1/badges/08c7e7b58e9fbe7156eb/maintainability)](https://codeclimate.com/github/nagstler/chatgpt-ruby/maintainability) [![Test Coverage](https://api.codeclimate.com/v1/badges/08c7e7b58e9fbe7156eb/test_coverage)](https://codeclimate.com/github/nagstler/chatgpt-ruby/test_coverage) [![CI](https://github.com/nagstler/chatgpt-ruby/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/nagstler/chatgpt-ruby/actions/workflows/ci.yml) [![GitHub contributors](https://img.shields.io/github/contributors/nagstler/chatgpt-ruby)](https://github.com/nagstler/chatgpt-ruby/graphs/contributors)
 
-The `chatgpt-ruby` is a Ruby SDK for the OpenAI API, including methods for generating text, completing prompts, and more ❤️
+The `chatgpt-ruby` is a Ruby SDK for the OpenAI API, providing methods for generating text and completing prompts using the ChatGPT model.
 
 ## Installation
 
@@ -12,16 +12,12 @@ Add this line to your application's Gemfile:
 gem 'chatgpt-ruby'
 ```
 
-
-
 And then execute:
 
 ```ruby
 $ bundle install
 ```
 
-
-
 Or install it yourself as:
 
 ```ruby
@@ -41,8 +37,7 @@ api_key = 'your-api-key'
 client = ChatGPT::Client.new(api_key)
 ```
 
-
-### Completions
+## Completions
 
 To generate completions given a prompt, you can use the `completions` method:
 
@@ -53,8 +48,6 @@ 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
@@ -65,99 +58,59 @@ params = {
 }
 completions = client.completions(prompt, params)
 
+puts completions["choices"].map { |c| c["text"] }
 # Output: an array of completion strings
 ```
 
+## Chat
 
-### Search
-
-To perform a search query given a set of documents and a search query, you can use the `search` method:
+The `chat` method allows for a dynamic conversation with the GPT model. It requires an array of messages where each message is a hash with two properties: `role` and `content`.
 
-```ruby
-documents = ['Document 1', 'Document 2', 'Document 3']
-query = 'Search query'
-results = client.search(documents, query)
-
-# Output: an array of search result objects
-```
+`role` can be: 
+- `'system'`: Used for instructions that guide the conversation. 
+- `'user'`: Represents the user's input. 
+- `'assistant'`: Represents the model's output.
 
+`content` contains the text message from the corresponding role.
 
-
-You can customize the search process by passing in additional parameters as a hash:
+Here is how you would start a chat:
 
 ```ruby
-params = {
-  engine: 'ada',
-  max_rerank: 100
-}
-results = client.search(documents, query, params)
 
-# Output: an array of search result objects
+# Define the conversation messages
+messages = [
+  {
+    role: "system",
+    content: "You are a helpful assistant."
+  },
+  {
+    role: "user",
+    content: "Who won the world series in 2020?"
+  }
+]
+
+# Start a chat
+response = client.chat(messages)
 ```
 
-
-### Classify
-
-To classify a given text, you can use the `classify` method:
+The response will be a hash containing the model's message(s). You can extract the assistant's message like this:
 
 ```ruby
-text = 'This is a sample text'
-label = client.classify(text)
 
-# Output: a string representing the classified label
+puts response['choices'][0]['message']['content'] # Outputs the assistant's message
 ```
 
-
-
-You can customize the classification process by passing in additional parameters as a hash:
+The conversation can be continued by extending the `messages` array and calling the `chat` method again:
 
 ```ruby
-params = {
-  model: 'text-davinci-002'
-}
-label = client.classify(text, params)
 
-# Output: a string representing the classified label
-```
+messages << {role: "user", content: "Tell me more about it."}
 
-
-### 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
+response = client.chat(messages)
+puts response['choices'][0]['message']['content'] # Outputs the assistant's new message
 ```
 
-
-### 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
-```
+With this method, you can build an ongoing conversation with the model.
 
 ## Development
 

data/lib/chatgpt/client.rb

@@ -1,16 +1,20 @@
-# lib/chatgpt/client.rb
-
 require 'rest-client'
 require 'json'
 
 module ChatGPT
   class Client
+    # Initialize the client with the API key
+    #
+    # @param api_key [String] The API key for the GPT-3 service
     def initialize(api_key)
       @api_key = api_key
+      # Base endpoint for the OpenAI API
       @endpoint = 'https://api.openai.com/v1'
     end
 
-    # Helper method to prepare headers
+    # Prepare headers for the API request
+    #
+    # @return [Hash] The headers for the API request
     def headers
       {
         'Content-Type' => 'application/json',
@@ -18,15 +22,24 @@ module ChatGPT
       }
     end
 
-    # Completion-related methods
+    # Generate completions based on a given prompt
+    #
+    # @param prompt [String] The prompt to be completed
+    # @param params [Hash] Additional parameters for the completion request
+    #
+    # @return [Hash] The completion results from the API
     def completions(prompt, params = {})
+      # Set default parameters
       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
 
+      # Construct the URL for the completion request
       url = "#{@endpoint}/engines/#{engine}/completions"
+      
+      # Prepare the data for the request
       data = {
         prompt: prompt,
         max_tokens: max_tokens,
@@ -34,86 +47,65 @@ module ChatGPT
         top_p: top_p,
         n: n
       }
+      
+      # Make the request to the API
       request_api(url, data)
     end
 
-    # Search-related methods
-    def search(documents, query, params = {})
-      engine = params[:engine] || 'ada'
-      max_rerank = params[:max_rerank] || 200
 
-      url = "#{@endpoint}/engines/#{engine}/search"
-      data = {
-        documents: documents,
-        query: query,
-        max_rerank: max_rerank
-      }
-      response = request_api(url, data)
-      response['data']
-    end
+    # This method sends a chat message to the API
+    #
+    # @param messages [Array<Hash>] The array of messages for the conversation. 
+    # Each message is a hash with a `role` and `content` key. The `role` key can be 'system', 'user', or 'assistant',
+    # and the `content` key contains the text of the message.
+    #
+    # @param params [Hash] Optional parameters for the chat request. This can include the 'model' key to specify 
+    # the model to be used for the chat. If no 'model' key is provided, 'gpt-3.5-turbo' is used by default.
+    #
+    # @return [Hash] The response from the API.
+    def chat(messages, params = {})
+      # Set default parameters
+      model = params[:model] || 'gpt-3.5-turbo'
 
-    # Classification-related methods
-    def classify(text, params = {})
-      model = params[:model] || 'text-davinci-002'
+      # Construct the URL for the chat request
+      url = "#{@endpoint}/chat/completions"
 
-      url = "#{@endpoint}/classifications/#{model}"
+      # Prepare the data for the request. The data is a hash with 'model' and 'messages' keys.
       data = {
         model: model,
-        input: text
+        messages: messages
       }
-      response = request_api(url, data)
-      response['data'][0]['label']
-    end
-
-    # Summary-related methods
-    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"
-      data = {
-        prompt: '',
-        max_tokens: max_tokens,
-        temperature: temperature,
-        top_p: top_p,
-        frequency_penalty: frequency_penalty,
-        presence_penalty: presence_penalty,
-        documents: documents
-      }
-      response = request_api(url, data)
-      response['choices'][0]['text']
+      
+      # Make the API request and return the response.
+      request_api(url, data)
     end
 
-    # Answer-generation-related methods
-    def generate_answers(prompt, documents, params = {})
-      model = params[:model] || 'text-davinci-002'
-      max_tokens = params[:max_tokens] || 5
-
-      url = "#{@endpoint}/engines/#{model}/answers"
-      data = {
-        prompt: prompt,
-        documents: documents,
-        max_tokens: max_tokens
-      }
-      response = request_api(url, data)
-      response['data'][0]['answer']
-    end
 
     private
-
-    # Helper method to make API requests
-    def request_api(url, data)
+    # Make a request to the API
+    #
+    # @param url [String] The URL for the request
+    # @param data [Hash] The data to be sent in the request
+    # @param method [Symbol] The HTTP method for the request (:post by default)
+    #
+    # @return [Hash] The response from the API
+    #
+    # @raise [RestClient::ExceptionWithResponse] If the API request fails
+    def request_api(url, data, method = :post)
       begin
-        response = RestClient.post(url, data.to_json, headers)
+        # Execute the request
+        response = RestClient::Request.execute(method: method, url: url, payload: data.to_json, headers: headers)
+        
+        # Parse and return the response body
         JSON.parse(response.body)
       rescue RestClient::ExceptionWithResponse => e
+        # Parse the error message from the API response
         error_msg = JSON.parse(e.response.body)['error']['message']
+        
+        # Raise an exception with the API error message
         raise RestClient::ExceptionWithResponse.new("#{e.message}: #{error_msg} (#{e.http_code})"), nil, e.backtrace
       end
     end
+  
   end
 end

data/lib/chatgpt/ruby/version.rb

@@ -2,6 +2,6 @@
 
 module Chatgpt
   module Ruby
-    VERSION = "1.0.0"
+    VERSION = "2.0.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chatgpt-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Nagendra Dhanakeerthi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-04-30 00:00:00.000000000 Z
+date: 2023-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client