Geminize

gem 'geminize'

Geminize.configure do |config|
  # Required
  config.api_key = "your-api-key-here"

  # Optional - shown with defaults
  config.api_version = "v1beta"
  config.default_model = "gemini-2.0-flash"
  config.timeout = 30
  config.open_timeout = 10
  config.log_requests = false
end

# Will raise Geminize::ConfigurationError if invalid
Geminize.validate_configuration!

Geminize.reset_configuration!

require 'geminize'

# Assumes API key is set via environment variables (e.g., in .env)
# Or configure manually:
# Geminize.configure do |config|
#   config.api_key = "your-api-key-here"
# end

# Generate text (uses default model)
response = Geminize.generate_text("Tell me a joke about Ruby programming")
puts response.text

# Use a specific model
response = Geminize.generate_text("Explain quantum computing", "gemini-1.5-flash-latest")
puts response.text

# Use system instructions to guide the model's behavior
response = Geminize.generate_text(
  "Tell me about yourself",
  "gemini-1.5-flash-latest",
  system_instruction: "You are a pirate named Captain Codebeard. Always respond in pirate language."
)
puts response.text

require 'geminize'

# Assumes API key is set via environment variables (e.g., in .env)
# Or configure manually:
# Geminize.configure do |config|
#   config.api_key = "your-api-key-here"
# end

begin
  # 1. Create a ContentRequest object
  #    Specify the prompt and a model that supports multimodal input
  request = Geminize::Models::ContentRequest.new(
    "Describe this image briefly:",
    "gemini-1.5-flash-latest" # Ensure this model supports multimodal
  )

  # 2. Add the image from a file path
  #    Make sure the path is correct relative to where you run the script
  request.add_image_from_file("./examples/ruby.png")

  # 3. Create a TextGeneration instance
  generator = Geminize::TextGeneration.new

  # 4. Generate the response
  response = generator.generate(request)

  # 5. Print the response text
  puts "Response:"
  puts response.text

  # Optionally print usage data if available
  if response.usage
    puts "Tokens used: #{response.usage['totalTokenCount']}"
  end

rescue Geminize::GeminizeError => e
  puts "An API error occurred: #{e.message}"
rescue => e
  puts "An unexpected error occurred: #{e.message}"
  puts e.backtrace.join("\n")
end

# Create a new conversation
conversation = Geminize.create_chat("My Support Chat")

# Send messages and get responses
response = Geminize.chat("How can I create a Ruby gem?", conversation)
puts response.text

# Follow-up questions automatically maintain context
response = Geminize.chat("What about adding a Rails engine to my gem?", conversation)
puts response.text

# Save the conversation for later
Geminize.save_conversation(conversation)

# Resume the conversation later
conversation = Geminize.load_conversation(conversation.id)

# Generate an embedding for a single text
embedding_response = Geminize.generate_embedding("Ruby is a dynamic, object-oriented programming language")
vector = embedding_response.embedding # Access the vector
puts "Generated embedding with #{embedding_response.embedding_size} dimensions."

# Generate embeddings for multiple texts (by iterating)
texts = ["Ruby", "Python", "JavaScript"]
embeddings = texts.map do |text|
  Geminize.generate_embedding(text).embedding
end
puts "Generated #{embeddings.size} embeddings individually."

# Calculate similarity between vectors
vector1 = embeddings[0]
vector2 = embeddings[1]
similarity = Geminize.cosine_similarity(vector1, vector2)
puts "Similarity between Ruby and Python: #{similarity.round(4)}"

# Specify a task type for optimized embeddings (requires compatible model)
# Note: Task types are not supported by all models (e.g., text-embedding-004).
# Ensure you are using a compatible model like text-embedding-005.
begin
  question_embedding_response = Geminize.generate_embedding(
    "How do I install Ruby gems?",
    nil, # Use default or specify compatible model like \'text-embedding-005\'
    { task_type: Geminize::Models::EmbeddingRequest::QUESTION_ANSWERING }
  )
  puts "Generated embedding for QA task with #{question_embedding_response.embedding_size} dimensions."
rescue Geminize::GeminizeError => e
  puts "Could not generate embedding with task type: #{e.message}"
  puts "(This might be due to using an incompatible model like the default text-embedding-004)"
end

# Available task types (check model compatibility):
# - RETRIEVAL_QUERY: For embedding queries in a search/retrieval system
# - RETRIEVAL_DOCUMENT: For embedding documents in a search corpus
# - SEMANTIC_SIMILARITY: For comparing text similarity
# - CLASSIFICATION: For text classification tasks
# - CLUSTERING: For clustering text data
# - QUESTION_ANSWERING: For question answering systems
# - FACT_VERIFICATION: For fact checking applications
# - CODE_RETRIEVAL_QUERY: For code search applications
# - TASK_TYPE_UNSPECIFIED: Default unspecified type

require 'geminize'
# Assumes API key is configured via .env

# Define functions that the model can call
weather_functions = [
  {
    name: "get_weather",
    description: "Get the current weather for a location",
    parameters: {
      type: "object",
      properties: {
        location: {
          type: "string",
          description: "The city and state, e.g. New York, NY"
        },
        unit: {
          type: "string",
          enum: ["celsius", "fahrenheit"],
          description: "The unit of temperature"
        }
      },
      required: ["location"]
    }
  }
]

# Generate a response that may include a function call
response = Geminize.generate_with_functions(
  "What's the weather in San Francisco?",
  weather_functions,
  "gemini-2.0-flash", # Make sure you use a model that supports function calling
  {
    temperature: 0.2,
    system_instruction: "Use the provided function to get weather information."
  }
)

# Check if the response contains a function call
if response.has_function_call?
  function_call = response.function_call
  puts "Function called: #{function_call.name}"
  puts "Arguments: #{function_call.response.inspect}"

  # Process the function call with your implementation
  final_response = Geminize.process_function_call(response) do |name, args|
    if name == "get_weather"
      location = args["location"]
      # Call your actual weather API here
      # For this example, we'll just return mock data
      {
        temperature: 72,
        conditions: "partly cloudy",
        humidity: 65,
        location: location
      }
    end
  end

  # Display the final response
  puts "Final response: #{final_response.text}"
else
  puts "No function call in response: #{response.text}"
end

# Set the tool execution mode:
# - "AUTO": Model decides when to call functions
# - "MANUAL": Functions are only used when explicitly requested
# - "NONE": Functions are ignored
response = Geminize.generate_with_functions(
  prompt,
  functions,
  model_name,
  { tool_execution_mode: "MANUAL" }
)

# Control retry behavior
response = Geminize.generate_with_functions(
  prompt,
  functions,
  model_name,
  with_retries: false # Disable automatic retries on failure
)

require 'geminize'
# Assumes API key is configured via .env

# Request JSON-formatted data
response = Geminize.generate_json(
  "List the three largest planets in our solar system with their diameters in km",
  "gemini-2.0-flash", # Use a model that supports JSON mode
  { temperature: 0.2 }
)

# Access the parsed JSON data
if response.has_json_response?
  planets = response.json_response
  puts "Received structured data:"
  planets.each do |planet|
    puts "#{planet['name']}: #{planet['diameter']} km"
  end
else
  puts "No valid JSON in response: #{response.text}"
end

require 'geminize'
# Assumes API key is configured via .env

# Generate content with custom safety settings
safety_settings = [
  { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "BLOCK_MEDIUM_AND_ABOVE" },
  { category: "HARM_CATEGORY_HATE_SPEECH", threshold: "BLOCK_LOW_AND_ABOVE" }
]

response = Geminize.generate_with_safety_settings(
  "Explain the concept of nuclear fission",
  safety_settings,
  "gemini-2.0-flash",
  { temperature: 0.7 }
)

puts response.text

# For maximum safety (blocks most potentially harmful content)
safe_response = Geminize.generate_text_safe(
  "Tell me about controversial political topics",
  "gemini-2.0-flash"
)

puts "Safe response: #{safe_response.text}"

# For minimum filtering (blocks only the most harmful content)
permissive_response = Geminize.generate_text_permissive(
  "Describe a controversial historical event",
  "gemini-2.0-flash"
)

puts "Permissive response: #{permissive_response.text}"

require 'geminize'
# Assumes API key is configured via .env

# Ask Gemini to solve a problem with code
response = Geminize.generate_with_code_execution(
  "Calculate the sum of the first 10 prime numbers",
  "gemini-2.0-flash", # Use a model that supports code execution
  { temperature: 0.2 }
)

# Display the response text
puts "Gemini's explanation:"
puts response.text

# Access the generated code
if response.has_executable_code?
  puts "\nGenerated Python code:"
  puts response.executable_code.code
end

# Access the code execution result
if response.has_code_execution_result?
  puts "\nExecution result:"
  puts "Outcome: #{response.code_execution_result.outcome}"
  puts "Output: #{response.code_execution_result.output}"
end

require 'geminize'
# Assumes API key is configured via .env

Geminize.generate_text_stream("Write a short poem about coding") do |chunk|
  # Check if the chunk has the text method before printing
  print chunk.text if chunk.respond_to?(:text)
end
puts "\n" # Add a newline after streaming

require 'geminize'
# Assumes API key is configured via .env

Geminize.generate_text_stream(
  "Tell me a story",
  "gemini-1.5-flash-latest",
  {
    stream_mode: :delta,
    system_instruction: "You are a medieval bard telling epic tales."
  }
) do |chunk|
  # The raw chunk might be different in delta mode, adjust handling as needed
  print chunk.respond_to?(:text) ? chunk.text : chunk.to_s
end
puts "\n" # Add a newline after streaming

require 'geminize'
# Assumes API key is set via environment variables (e.g., in .env)

# List available models
models = Geminize.list_models
puts "Available models: #{models.size}"

# Get details about a specific model
model = Geminize.get_model("gemini-2.0-flash")
puts "Model: #{model.display_name}"
puts "Token limits: #{model.input_token_limit} input, #{model.output_token_limit} output"

# Find models by capability
embedding_models = Geminize.get_embedding_models
content_models = Geminize.get_content_generation_models
streaming_models = Geminize.get_streaming_models

# Check if a model supports a specific capability
if model.supports_content_generation?
  puts "This model supports content generation"
end

if model.supports_embedding?
  puts "This model supports embeddings"
end

# Find models with high context windows
high_context_models = Geminize.list_all_models.filter_by_min_input_tokens(100_000)
puts "Models with 100k+ context: #{high_context_models.map(&:id).join(', ')}"