fixes

Author: andreibondarev

.env.example

@@ -0,0 +1 @@
+COHERE_API_KEY=

.gitignore

@@ -9,3 +9,5 @@
 
 # rspec failure tracking
 .rspec_status
+
+.env

Gemfile

@@ -9,3 +9,4 @@ gem "rake", "~> 13.0"
 
 gem "rspec", "~> 3.0"
 gem "standard", "~> 1.28.0"
+gem "dotenv", "~> 3.1.4"

Gemfile.lock

@@ -9,6 +9,7 @@ GEM
   specs:
     ast (2.4.2)
     diff-lcs (1.5.0)
+    dotenv (3.1.4)
     faraday (2.7.10)
       faraday-net_http (>= 2.0, < 3.1)
       ruby2_keywords (>= 0.0.4)
@@ -74,6 +75,7 @@ PLATFORMS
 
 DEPENDENCIES
   cohere-ruby!
+  dotenv (~> 3.1.4)
   rake (~> 13.0)
   rspec (~> 3.0)
   standard (~> 1.28.0)

README.md

@@ -8,12 +8,12 @@
 
 Cohere API client for Ruby.
 
-Part of the [Langchain.rb](https://github.com/andreibondarev/langchainrb) stack.
+Part of the [Langchain.rb](https://github.com/patterns-ai-core/langchainrb) stack.
 
-![Tests status](https://github.com/andreibondarev/cohere-ruby/actions/workflows/ci.yml/badge.svg)
+![Tests status](https://github.com/patterns-ai-core/cohere-ruby/actions/workflows/ci.yml/badge.svg)
 [![Gem Version](https://badge.fury.io/rb/cohere-ruby.svg)](https://badge.fury.io/rb/cohere-ruby)
 [![Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://rubydoc.info/gems/cohere-ruby)
-[![License](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/andreibondarev/cohere-ruby/blob/main/LICENSE.txt)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/patterns-ai-core/cohere-ruby/blob/main/LICENSE.txt)
 [![](https://dcbadge.vercel.app/api/server/WDARp7J2n8?compact=true&style=flat)](https://discord.gg/WDARp7J2n8)
 
 ## Installation
@@ -50,14 +50,18 @@ client.generate(
 
 ```ruby
 client.chat(
-  message: "Hey! How are you?"
+  model: "command-r-plus-08-2024",
+  messages: [{role:"user", content: "Hey! How are you?"}]
 )
 ```
 
 `chat` supports a streaming option. You can pass a block to the `chat` method and it will yield a new chunk as soon as it is received.
 
 ```ruby
-client.chat(message: "Hey! How are you?", stream: true) do |chunk, overall_received_bytes|
+client.chat(
+  model: "command-r-plus-08-2024",
+  messages: [{role:"user", content: "Hey! How are you?"}]
+) do |chunk, overall_received_bytes|
   puts "Received #{overall_received_bytes} bytes: #{chunk.force_encoding(Encoding::UTF_8)}"
 end
 ```
@@ -68,25 +72,25 @@ end
 
 ```ruby
 tools = [
-   {
-     name: "query_daily_sales_report",
-     description: "Connects to a database to retrieve overall sales volumes and sales information for a given day.",
-     parameter_definitions: {
-       day: {
-         description: "Retrieves sales data for this day, formatted as YYYY-MM-DD.",
-         type: "str",
-         required: true
-       }
-     }
-   }
+  {
+    name: "query_daily_sales_report",
+    description: "Connects to a database to retrieve overall sales volumes and sales information for a given day.",
+    parameter_definitions: {
+      day: {
+        description: "Retrieves sales data for this day, formatted as YYYY-MM-DD.",
+        type: "str",
+        required: true
+      }
+    }
+  }
 ]
 
 message = "Can you provide a sales summary for 29th September 2023, and also give me some details about the products in the 'Electronics' category, for example their prices and stock levels?"
 
 client.chat(
   model: model,
-  message: message,
-  tools: tools,
+  messages: [{ role:"user", content: message }],
+  tools: tools
 )
 ```
 

bin/console

@@ -3,13 +3,7 @@
 
 require "bundler/setup"
 require "cohere"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
+require "dotenv/load"
 
 client = Cohere::Client.new(
   api_key: ENV['COHERE_API_KEY']

lib/cohere/client.rb

@@ -6,62 +6,56 @@ module Cohere
   class Client
     attr_reader :api_key, :connection
 
-    ENDPOINT_URL = "https://api.cohere.com/v2"
-
     def initialize(api_key:, timeout: nil)
       @api_key = api_key
       @timeout = timeout
     end
 
+    # Generates a text response to a user message and streams it down, token by token
     def chat(
-      message: nil,
-      model: nil,
+      model:,
+      messages:,
       stream: false,
-      preamble: nil,
-      preamble_override: nil,
-      chat_history: [],
-      conversation_id: nil,
-      prompt_truncation: nil,
-      connectors: [],
-      search_queries_only: false,
+      tools: [],
       documents: [],
-      citation_quality: nil,
-      temperature: nil,
+      citation_options: nil,
+      response_format: nil,
+      safety_mode: nil,
       max_tokens: nil,
-      k: nil,
-      p: nil,
+      stop_sequences: nil,
+      temperature: nil,
       seed: nil,
       frequency_penalty: nil,
       presence_penalty: nil,
-      tools: [],
+      k: nil,
+      p: nil,
+      logprops: nil,
       &block
     )
-      response = connection.post("chat") do |req|
+      response = v2_connection.post("chat") do |req|
         req.body = {}
 
-        req.body[:message] = message if message
-        req.body[:model] = model if model
-        if stream || block
-          req.body[:stream] = true
-          req.options.on_data = block if block
-        end
-        req.body[:preamble] = preamble if preamble
-        req.body[:preamble_override] = preamble_override if preamble_override
-        req.body[:chat_history] = chat_history if chat_history
-        req.body[:conversation_id] = conversation_id if conversation_id
-        req.body[:prompt_truncation] = prompt_truncation if prompt_truncation
-        req.body[:connectors] = connectors if connectors
-        req.body[:search_queries_only] = search_queries_only if search_queries_only
-        req.body[:documents] = documents if documents
-        req.body[:citation_quality] = citation_quality if citation_quality
-        req.body[:temperature] = temperature if temperature
+        req.body[:model] = model
+        req.body[:messages] = messages if messages
+        req.body[:tools] = tools if tools.any?
+        req.body[:documents] = documents if documents.any?
+        req.body[:citation_options] = citation_options if citation_options
+        req.body[:response_format] = response_format if response_format
+        req.body[:safety_mode] = safety_mode if safety_mode
         req.body[:max_tokens] = max_tokens if max_tokens
-        req.body[:k] = k if k
-        req.body[:p] = p if p
+        req.body[:stop_sequences] = stop_sequences if stop_sequences
+        req.body[:temperature] = temperature if temperature
         req.body[:seed] = seed if seed
         req.body[:frequency_penalty] = frequency_penalty if frequency_penalty
         req.body[:presence_penalty] = presence_penalty if presence_penalty
-        req.body[:tools] = tools if tools
+        req.body[:k] = k if k
+        req.body[:p] = p if p
+        req.body[:logprops] = logprops if logprops
+
+        if stream || block
+          req.body[:stream] = true
+          req.options.on_data = block if block
+        end
       end
       response.body
     end
@@ -104,36 +98,44 @@ def generate(
       response.body
     end
 
+    # This endpoint returns text embeddings. An embedding is a list of floating point numbers that captures semantic information about the text that it represents.
     def embed(
-      texts:,
-      model: nil,
-      input_type: nil,
+      model:,
+      input_type:,
+      embedding_types:,
+      texts: nil,
+      images: nil,
       truncate: nil
     )
-      response = connection.post("embed") do |req|
-        req.body = {texts: texts}
-        req.body[:model] = model if model
-        req.body[:input_type] = input_type if input_type
+      response = v2_connection.post("embed") do |req|
+        req.body = {
+          model: model,
+          input_type: input_type,
+          embedding_types: embedding_types
+        }
+        req.body[:texts] = texts if texts
+        req.body[:images] = images if images
         req.body[:truncate] = truncate if truncate
       end
       response.body
     end
 
+    # This endpoint takes in a query and a list of texts and produces an ordered array with each text assigned a relevance score.
     def rerank(
+      model:,
       query:,
       documents:,
-      model: nil,
       top_n: nil,
       rank_fields: nil,
       return_documents: nil,
       max_chunks_per_doc: nil
     )
-      response = connection.post("rerank") do |req|
+      response = v2_connection.post("rerank") do |req|
         req.body = {
+          model: model,
           query: query,
           documents: documents
         }
-        req.body[:model] = model if model
         req.body[:top_n] = top_n if top_n
         req.body[:rank_fields] = rank_fields if rank_fields
         req.body[:return_documents] = return_documents if return_documents
@@ -142,41 +144,44 @@ def rerank(
       response.body
     end
 
+    # This endpoint makes a prediction about which label fits the specified text inputs best.
     def classify(
+      model:,
       inputs:,
-      examples:,
-      model: nil,
-      present: nil,
+      examples: nil,
+      preset: nil,
       truncate: nil
     )
-      response = connection.post("classify") do |req|
+      response = v1_connection.post("classify") do |req|
         req.body = {
-          inputs: inputs,
-          examples: examples
+          model: model,
+          inputs: inputs
         }
-        req.body[:model] = model if model
-        req.body[:present] = present if present
+        req.body[:examples] = examples if examples
+        req.body[:preset] = preset if preset
         req.body[:truncate] = truncate if truncate
       end
       response.body
     end
 
-    def tokenize(text:, model: nil)
-      response = connection.post("tokenize") do |req|
-        req.body = model.nil? ? {text: text} : {text: text, model: model}
+    # This endpoint splits input text into smaller units called tokens using byte-pair encoding (BPE).
+    def tokenize(text:, model:)
+      response = v1_connection.post("tokenize") do |req|
+        req.body = {text: text, model: model}
       end
       response.body
     end
 
-    def detokenize(tokens:, model: nil)
-      response = connection.post("detokenize") do |req|
-        req.body = model.nil? ? {tokens: tokens} : {tokens: tokens, model: model}
+    # This endpoint takes tokens using byte-pair encoding and returns their text representation.
+    def detokenize(tokens:, model:)
+      response = v1_connection.post("detokenize") do |req|
+        req.body = {tokens: tokens, model: model}
       end
       response.body
     end
 
     def detect_language(texts:)
-      response = connection.post("detect-language") do |req|
+      response = v1_connection.post("detect-language") do |req|
         req.body = {texts: texts}
       end
       response.body
@@ -191,7 +196,7 @@ def summarize(
       temperature: nil,
       additional_command: nil
     )
-      response = connection.post("summarize") do |req|
+      response = v1_connection.post("summarize") do |req|
         req.body = {text: text}
         req.body[:length] = length if length
         req.body[:format] = format if format
@@ -205,17 +210,22 @@ def summarize(
 
     private
 
-    # standard:disable Lint/DuplicateMethods
-    def connection
-      @connection ||= Faraday.new(url: ENDPOINT_URL, request: {timeout: @timeout}) do |faraday|
-        if api_key
-          faraday.request :authorization, :Bearer, api_key
-        end
+    def v1_connection
+      @connection ||= Faraday.new(url: "https://api.cohere.ai/v1", request: {timeout: @timeout}) do |faraday|
+        faraday.request :authorization, :Bearer, api_key
+        faraday.request :json
+        faraday.response :json, content_type: /\bjson$/
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    def v2_connection
+      @connection ||= Faraday.new(url: "https://api.cohere.com/v2", request: {timeout: @timeout}) do |faraday|
+        faraday.request :authorization, :Bearer, api_key
         faraday.request :json
         faraday.response :json, content_type: /\bjson$/
         faraday.adapter Faraday.default_adapter
       end
     end
-    # standard:enable Lint/DuplicateMethods
   end
 end