Class: Geminize::Embeddings

Inherits:
Object
  • Object
show all
Defined in:
lib/geminize/embeddings.rb

Overview

Class for embedding generation functionality

Constant Summary collapse

DEFAULT_MAX_BATCH_SIZE =

Default maximum batch size

100

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(client = nil, options = {}) ⇒ Embeddings

Initialize a new embeddings instance

Parameters:

  • client (Geminize::Client, nil) (defaults to: nil) —

    The client to use (optional)

  • options (Hash) (defaults to: {}) —

    Additional options



18
19
20
21
 
# File 'lib/geminize/embeddings.rb', line 18

def initialize(client = nil, options = {})
  @client = client || Client.new(options)
  @options = options
end

Instance Attribute Details

#client ⇒ Geminize::Client (readonly)

Returns The client instance.

Returns:



13
14
15
 
# File 'lib/geminize/embeddings.rb', line 13

def client
  @client
end

Instance Method Details

#batch_process_embeddings(texts, model_name, params, batch_size) ⇒ Geminize::Models::EmbeddingResponse

Process multiple texts in batches

Parameters:

  • texts (Array<String>) —

    List of texts to process

  • model_name (String, nil) —

    Model name

  • params (Hash) —

    Additional parameters

  • batch_size (Integer) —

    Maximum batch size

Returns:



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/geminize/embeddings.rb', line 72

def batch_process_embeddings(texts, model_name, params, batch_size)
  batches = texts.each_slice(batch_size).to_a
  responses = []

  batches.each do |batch|
    request = Models::EmbeddingRequest.new(
      model_name: model_name,
      text: batch,
      task_type: params[:task_type] || Geminize::Models::EmbeddingRequest::RETRIEVAL_DOCUMENT,
      params: params
    )
    responses << generate(request)
  end

  # Combine all responses into a single response object
  combine_responses(responses)
end

#generate(embedding_request) ⇒ Geminize::Models::EmbeddingResponse

Generate embeddings based on an embedding request

Parameters:

Returns:

Raises:



27
28
29
30
31
32
33
 
# File 'lib/geminize/embeddings.rb', line 27

def generate(embedding_request)
  endpoint = build_embedding_endpoint(embedding_request.model_name, embedding_request.batch?)
  payload = embedding_request.to_hash

  response_data = @client.post(endpoint, payload)
  Models::EmbeddingResponse.from_hash(response_data)
end

#generate_embedding(text, model_name = nil, params = {}) ⇒ Geminize::Models::EmbeddingResponse

Generate embeddings from text with optional parameters

Parameters:

  • text (String, Array<String>) —

    The input text or array of texts

  • model_name (String, nil) (defaults to: nil) —

    The model to use (optional)

  • params (Hash) (defaults to: {}) —

    Additional generation parameters

Options Hash (params):

  • :dimensions (Integer) —

    Desired dimensionality of the embeddings

  • :task_type (String) —

    The embedding task type

  • :batch_size (Integer) —

    Maximum number of texts to process in one batch

Returns:

Raises:



44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/geminize/embeddings.rb', line 44

def generate_embedding(text, model_name = nil, params = {})
  model = model_name || Geminize.configuration.default_embedding_model

  # Check if we need to handle batching
  if text.is_a?(Array) && text.length > 1
    batch_size = params.delete(:batch_size) || DEFAULT_MAX_BATCH_SIZE
    if text.length > batch_size
      return batch_process_embeddings(text, model, params, batch_size)
    end
  end

  # Regular processing for a single text or a small batch
  embedding_request = Models::EmbeddingRequest.new(
    model_name: model,
    text: text,
    task_type: params[:task_type] || Geminize::Models::EmbeddingRequest::RETRIEVAL_DOCUMENT,
    params: params
  )

  generate(embedding_request)
end