gemini-ai Ruby Gem

Function calling allows the model to request execution of specific tools. This is currently supported only by the vertex-ai-api service and the gemini-pro model.

1. Define tools using function_declarations in the tools key, providing a name, description, and JSON Schema for parameters.
2. The model returns a functionCall in its response.
3. You must execute the function locally and then send the result back to the model using a message with role: 'function' and the functionResponse key.

# 1. Define tool and request
input = {
  tools: { function_declarations: [{ name: 'get_time', parameters: { ... } }] },
  contents: [{ role: 'user', parts: { text: 'What time is it?' } }]
}
result = client.stream_generate_content(input)

# 2. Handle functionCall and prepare response
# ... (execute local code) ...

# 3. Send response back
input[:contents] << result.dig(0, 'candidates', 0, 'content')
input[:contents] << { role: 'function', parts: [{ functionResponse: { name: 'get_time', response: { content: '...' } } }] }

# 4. Final request
final_result = client.stream_generate_content(input)

Tool calling allows the model to request execution of specific functions. You define these using tools with function_declarations (using JSON Schema for parameters).

Workflow:

1. Send request with tools definition.
2. Model returns a functionCall in the response.
3. Execute the function in your code.
4. Send a new request containing the original conversation history plus a new message with role: 'function' and the functionResponse.

# 1. Define tool and request
input = {
  tools: {
    function_declarations: [
      {
        name: 'get_weather',
        description: 'Returns weather for a location',
        parameters: { type: 'object', properties: { location: { type: 'string' } } }
      }
    ]
  },
  contents: [{ role: 'user', parts: { text: 'What is the weather in London?' } }]
}
result = client.stream_generate_content(input)

# 2. Handle functionCall and prepare response
# (Extract functionCall from result, execute logic, then...)

# 3. Send response back to model
input[:contents] << result.dig(0, 'candidates', 0, 'content')
input[:contents] << { 
  role: 'function', 
  parts: [{ 
    functionResponse: { 
      name: 'get_weather', 
      response: { name: 'get_weather', content: 'sunny' } 
    } 
  }] 
}
client.stream_generate_content(input)

The Gemini.new constructor accepts a credentials hash to define the service and authentication method. You can use one of the following four patterns:

1. Generative Language API (using an API Key)

Best for AI Studio users. Set the service to 'generative-language-api' and provide an api_key.

2. Vertex AI API (using a Service Account File)

Best for Google Cloud users. Set the service to 'vertex-ai-api', provide a file_path to your JSON credentials, and specify a region.

3. Vertex AI API (using Service Account File contents)

Useful for environments where you prefer to pass credentials via environment variables. Set service to 'vertex-ai-api', provide file_contents (the raw string of the JSON), and specify a region.

4. Vertex AI API (using Application Default Credentials)

If you are running in a Google Cloud environment (like GCE, Cloud Run, or GKE) with configured ADC, simply provide the service and region.

Note: You can also use the global region for a global endpoint.

require 'gemini-ai'

# 1. API Key
client = Gemini.new(
  credentials: {
    service: 'generative-language-api',
    api_key: ENV['GOOGLE_API_KEY']
  },
  options: { model: 'gemini-pro', server_sent_events: true }
)

# 2. Service Account File
client = Gemini.new(
  credentials: {
    service: 'vertex-ai-api',
    file_path: 'google-credentials.json',
    region: 'us-east4'
  },
  options: { model: 'gemini-pro', server_sent_events: true }
)

# 3. Service Account File Contents
client = Gemini.new(
  credentials: {
    service: 'vertex-ai-api',
    file_contents: File.read('google-credentials.json'),
    region: 'us-east4'
  },
  options: { model: 'gemini-pro', server_sent_events: true }
)

# 4. Application Default Credentials
client = Gemini.new(
  credentials: {
    service: 'vertex-ai-api',
    region: 'us-east4'
  },
  options: { model: 'gemini-pro', server_sent_events: true }
)

# Global Endpoint
client = Gemini.new(credentials: { region: 'global' })

To use the gem, create a new Gemini client by providing a credentials hash and an options hash. The credentials hash requires a service key, which can be either 'generative-language-api' or 'vertex-ai-api'.

Depending on the service, you can authenticate using:

• API Key: Use service: 'generative-language-api' and provide api_key.
• Service Account File: Use service: 'vertex-ai-api' and provide file_path or file_contents.
• Application Default Credentials: Use service: 'vertex-ai-api' and omit specific credential keys (requires environment setup).

Common options include model (e.g., 'gemini-pro') and server_sent_events: true for streaming.

require 'gemini-ai'

# Example: Using an API Key
client = Gemini.new(
  credentials: {
    service: 'generative-language-api',
    api_key: ENV['GOOGLE_API_KEY']
  },
  options: { model: 'gemini-pro', server_sent_events: true }
)