gigachat-ruby

# Gemfile
gem "gigachat-ruby"

require "gigachat"

client = GigaChat::Client.new(credentials: ENV["GIGACHAT_CREDENTIALS"], model: "GigaChat-2-Max")

completion = client.chat.create(messages: [{ role: "user", content: "Привет! Расскажи о себе." }])
puts completion.text

GigaChat.configure do |c|
  c.scope = "GIGACHAT_API_CORP"
  c.model = "GigaChat-2-Max"
end

client = GigaChat::Client.new # picks up the global config and GIGACHAT_* variables

completion = client.chat.create(
  messages: [
    { role: "system", content: "Ты — профессиональный переводчик на английский язык." },
    { role: "user", content: "GigaChat — это сервис для диалога с пользователем." }
  ],
  model_options: { temperature: 0.3 }
)

completion.text                # assistant text
completion.usage.total_tokens
completion.finish_reason       # "stop", "length", "function_call", ...
completion.request_id          # x-request-id, useful for support tickets

history = [{ role: "user", content: "Привет!" }]
reply = client.chat.create(messages: history)
history += [reply.message, { role: "user", content: "Расскажи анекдот" }]
client.chat.create(messages: history)

# A block streams events and returns the accumulated completion.
final = client.chat.stream(messages: [{ role: "user", content: "Напиши стих" }]) do |event|
  print event.text if event.delta?
end
final.usage

# Without a block you get a lazy, single-use stream.
stream = client.chat.stream(messages: [{ role: "user", content: "Напиши стих" }])
stream.text.each { print it } # text deltas only
stream.response               # accumulated completion

weather = {
  name: "weather_forecast",
  description: "Weather forecast for a city",
  parameters: { type: "object", properties: { location: { type: "string" } }, required: ["location"] }
}
tools = [{ functions: { specifications: [weather] } }]
messages = [{ role: "user", content: "Какая погода в Туле?" }]

first = client.chat.create(messages:, tools:)
if (call = first.function_call)
  result = { temperature: 12 } # call your code with call.arguments (a Hash)
  messages += [
    first.message, # carries tool_state_id, which ties the result to this call
    { role: "tool", content: [{ function_result: { name: call.name, result: JSON.generate(result) } }] }
  ]
  puts client.chat.create(messages:, tools:).text
end

client.chat.create(
  messages: [{ role: "user", content: "27 октября 2023 года у меня родился сын" }],
  model_options: {
    response_format: {
      type: "json_schema",
      schema: { type: "object", properties: { date: { type: "string" } }, required: ["date"] },
      strict: true
    }
  }
)

client.chat.v1.create(messages: [{ role: "user", content: "Привет!" }]).text
client.chat.v1.stream(messages: [{ role: "user", content: "Привет!" }]) { |chunk| print chunk.text }

client.embeddings.create(input: ["Первый текст", "Второй текст"]).vectors # model defaults to "Embeddings"
client.embeddings.create(input: "Текст", model: "EmbeddingsGigaR")

client.models.list.map(&:id)
client.models.retrieve("GigaChat-2-Max")

file = client.files.upload("report.pdf")                      # a path or Pathname
file = client.files.upload(io, filename: "notes.txt")        # any IO; filename needed when the IO has no path
client.chat.create(messages: [{ role: "user", content: [{ text: "Summarize", files: [{ id: file.id }] }] }])

client.files.list.map(&:filename)
client.files.retrieve(file.id)
client.files.content(image_id)                                # binary String, e.g. a generated image
client.files.delete(file.id).deleted?

client.tokens_count(input: ["Я к вам пишу — чего же боле?"]).map(&:tokens)
client.balance.map { [it.usage, it.value] } # prepaid packages only (403 on pay-as-you-go)

client.ai_check(input: text, model: "GigaCheckClassification").category # "ai", "human" or "mixed"

result = client.functions.validate(weather)
result.valid?
result.warnings.map(&:description)

requests = [
  { id: "1", request: { model: "GigaChat-2", messages: [{ role: "user", content: "Привет" }] } }
]
batch = client.batches.create(requests, method: :chat_completions) # or method: :embedder
batch = client.batches.retrieve(batch.id)
batch.batch_method                                                # "chat_completions"
client.batches.results(batch) if batch.completed?                 # parsed JSONL lines

client.chat.create(messages:, request_options: { timeout: 300, max_retries: 0, headers: { "X-Client-ID" => "u-1" } })
client.with_options(session_id: "chat-42").chat.create(messages:) # a copy that reuses the access token

client = GigaChat::Client.new(logger: Logger.new($stdout))
# GigaChat: POST https://api.giga.chat/v2/chat/completions 200 812ms req=…

client.request(method: :get, path: "models") # auth, retries and error mapping included