geminize 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9b29587f96d7535a7db3ad010684fd9fa7e7a765d83d71a1cd645bdf323af69
-  data.tar.gz: 90adc36f2b5acbdb6e45904ebbd7847d1a895a614d4aee6ace5af028d8812045
+  metadata.gz: c08ca1105b496592ec06cd7b7aab2b1b9a1dde2cb0f1c31be6feda85281683a2
+  data.tar.gz: ae7352a06b607dbd1e98cf30cd069551765156d088513a4cf780f94033d8ab89
 SHA512:
-  metadata.gz: 0b303213d67decca74c5f14c1a94625275febe0fc50d1ca24dc5a12fd65cd148077ef50e6ca27f1e720e05e88101f76047088db2707b71f2318036b7351335f9
-  data.tar.gz: 981b130896dd8a0f8824602d0adb51fe60b8cfcab9124b3e7322795b6cfc9c8140031a6ca144e042c478182e78d2f3f00a9e35daa3c763a2f6d794171f4773ed
+  metadata.gz: 9041ba768b03996f4b2a6fdd9d45dd9a1430298d6d555e54951a9736e24ac713397b1010ffb640bd3a3bcb5b647eb37d15193852e0df31cdfb9bafe6da6a6779
+  data.tar.gz: 3a99e5d5a7e2a7b1d3b8ac7d6ca3450a8a54dd4636b614fa53b4e6175e0ead68981ecb7390b00f9d6c7f5f4fd3bcb9bb44e46b84d9e97702cdca7803227fc022

data/CHANGELOG.md

@@ -1,4 +1,10 @@
-## [Unreleased]
+## [1.0.0] - 2025-05-02
+
+### Removed
+
+- Removed Rails-related integration from the gem, simplifying usage.
+
+## [0.1.1] - 2025-05-01
 
 ### Added
 

data/README.md

@@ -11,7 +11,6 @@ A convenient and robust Ruby interface for the Google Gemini API, enabling easy
 - Embeddings generation
 - Support for streaming responses
 - Comprehensive error handling
-- Rails integration with controller concerns and view helpers
 
 ## Installation
 
@@ -124,23 +123,24 @@ Geminize.reset_configuration!
 ```ruby
 require 'geminize'
 
-# Configure with API key if not set via environment variables
-Geminize.configure do |config|
-  config.api_key = "your-api-key-here"
-end
+# 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
+# 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-2.0-flash")
+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-2.0-flash",
+  "gemini-1.5-flash-latest",
   system_instruction: "You are a pirate named Captain Codebeard. Always respond in pirate language."
 )
 puts response.text
@@ -148,58 +148,52 @@ puts response.text
 
 ## Multimodal Support
 
-Geminize allows you to send mixed content including text and images to the Gemini API:
-
-```ruby
-# Generate content with an image from a file
-response = Geminize.generate_text_multimodal(
-  "Describe this image in detail:",
-  [{ source_type: 'file', data: 'path/to/image.jpg' }]
-)
-puts response.text
-
-# Using an image URL
-response = Geminize.generate_text_multimodal(
-  "What's in this image?",
-  [{ source_type: 'url', data: 'https://example.com/sample-image.jpg' }]
-)
-puts response.text
-
-# Using multiple images
-response = Geminize.generate_text_multimodal(
-  "Compare these two images:",
-  [
-    { source_type: 'file', data: 'path/to/image1.jpg' },
-    { source_type: 'file', data: 'path/to/image2.jpg' }
-  ]
-)
-puts response.text
-```
+Geminize allows you to send mixed content including text and images to the Gemini API.
 
-Alternatively, you can use the more flexible ContentRequest API:
+Here is a working example using the `ContentRequest` API:
 
 ```ruby
-# Create a content request
-request = Geminize::Models::ContentRequest.new(
-  "Tell me about these images:",
-  "gemini-2.0-flash"
-)
-
-# Add images using different methods
-request.add_image_from_file('path/to/image1.jpg')
-request.add_image_from_url('https://example.com/image2.jpg')
-
-# Read image directly into bytes
-image_bytes = File.binread('path/to/image3.jpg')
-request.add_image_from_bytes(image_bytes, 'image/jpeg')
+require 'geminize'
 
-# Set a system instruction to guide model behavior
-request.system_instruction = "You are a professional photography critic. Analyze the composition and technical aspects of these images."
+# 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
 
-# Generate the response
-generator = Geminize::TextGeneration.new
-response = generator.generate(request)
-puts response.text
+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
 ```
 
 Supported image formats include JPEG, PNG, GIF, and WEBP. Maximum image size is 10MB.
@@ -235,26 +229,39 @@ Generate numerical vector representations for text:
 
 ```ruby
 # Generate an embedding for a single text
-embedding = Geminize.generate_embedding("Ruby is a dynamic, object-oriented programming language")
-vector = embedding.values.first.value
+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
+# Generate embeddings for multiple texts (by iterating)
 texts = ["Ruby", "Python", "JavaScript"]
-embeddings = Geminize.generate_embedding(texts)
+embeddings = texts.map do |text|
+  Geminize.generate_embedding(text).embedding
+end
+puts "Generated #{embeddings.size} embeddings individually."
 
 # Calculate similarity between vectors
-vector1 = embeddings.values[0].value
-vector2 = embeddings.values[1].value
+vector1 = embeddings[0]
+vector2 = embeddings[1]
 similarity = Geminize.cosine_similarity(vector1, vector2)
-puts "Similarity: #{similarity}"
-
-# Specify a task type for optimized embeddings
-question_embedding = Geminize.generate_embedding(
-  "How do I install Ruby gems?",
-  task_type: Geminize::Models::EmbeddingRequest::QUESTION_ANSWERING
-)
+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:
+# 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
@@ -273,140 +280,50 @@ See the `examples/embeddings.rb` file for more comprehensive examples of working
 Get real-time, token-by-token responses:
 
 ```ruby
+require 'geminize'
+# Assumes API key is configured via .env
+
 Geminize.generate_text_stream("Write a short poem about coding") do |chunk|
-  print chunk.text
+  # 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
 ```
 
 You can also use system instructions with streaming responses:
 
 ```ruby
+require 'geminize'
+# Assumes API key is configured via .env
+
 Geminize.generate_text_stream(
   "Tell me a story",
-  "gemini-2.0-flash",
+  "gemini-1.5-flash-latest",
   {
     stream_mode: :delta,
     system_instruction: "You are a medieval bard telling epic tales."
   }
 ) do |chunk|
-  print chunk
-end
-```
-
-## Rails Integration
-
-Geminize provides seamless integration with Rails applications.
-
-### Setup
-
-1. Add Geminize to your Gemfile:
-
-```ruby
-gem 'geminize'
-```
-
-2. Run the installer generator:
-
-```bash
-rails generate geminize:install
-```
-
-This creates a configuration initializer at `config/initializers/geminize.rb`
-
-3. Add your API key to the initializer or via environment variables.
-
-### Controller Integration
-
-In your controllers, include the Geminize controller concern:
-
-```ruby
-class ChatController < ApplicationController
-  # Add Geminize functionality to this controller
-  geminize_controller
-
-  def index
-    # Optionally reset the conversation
-    # reset_gemini_conversation("New chat session") if params[:reset]
-  end
-
-  def create
-    # Send a message to Gemini and get the response
-    @response = send_gemini_message(params[:message])
-
-    respond_to do |format|
-      format.html { redirect_to chat_path }
-      format.turbo_stream
-      format.json { render json: { message: @response.text } }
-    end
-  end
-end
-```
-
-The concern provides the following methods:
-
-- `current_gemini_conversation` - Access the current conversation (stored in session)
-- `send_gemini_message(message, model_name=nil, params={})` - Send a message in the current conversation
-- `generate_gemini_text(prompt, model_name=nil, params={})` - Generate text with Gemini
-- `generate_gemini_multimodal(prompt, images, model_name=nil, params={})` - Generate text with images
-- `generate_gemini_embedding(text, model_name=nil, params={})` - Generate embeddings
-- `reset_gemini_conversation(title=nil)` - Start a new conversation
-
-### View Integration
-
-Include the Geminize view helpers in your application:
-
-```ruby
-# In app/helpers/application_helper.rb
-module ApplicationHelper
-  # Include Geminize view helpers
-  geminize_helper
+  # 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
 ```
 
-This provides the following helper methods:
-
-- `render_gemini_conversation(conversation=nil, options={})` - Render the conversation as HTML
-- `render_gemini_message(message, options={})` - Render a single message
-- `gemini_chat_form(options={})` - Create a chat form
-- `markdown_to_html(text, options={})` - Render Markdown as HTML (requires redcarpet gem)
-- `highlight_code(html)` - Add syntax highlighting to code blocks (requires rouge gem)
-
-Example view:
-
-```erb
-<%# app/views/chat/index.html.erb %>
-<div class="chat-container">
-  <h1>Chat with Gemini</h1>
-
-  <div class="conversation">
-    <%= render_gemini_conversation %>
-  </div>
-
-  <div class="chat-form">
-    <%= gemini_chat_form(placeholder: "Ask me anything...", submit_text: "Send") %>
-  </div>
-</div>
-```
-
-## Example Applications
-
 Check out these example applications to see Geminize in action:
 
 - [Configuration Example](examples/configuration.rb)
 - [Embeddings Example](examples/embeddings.rb)
 - [Multimodal Example](examples/multimodal.rb)
-- [Rails Initializer Example](examples/rails_initializer.rb)
 - [System Instructions Example](examples/system_instructions.rb)
-- [Rails Chat Application](examples/rails_chat)
 
 ## Compatibility
 
 Ruby version: 3.1.0 or later
-Rails version: 6.0 or later (for Rails integration)
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`.
 

data/examples/README.md

@@ -11,10 +11,9 @@ Before running these examples, ensure you have:
 3.  **Project dependencies installed**: Run `bundle install` from the project root directory (`../`).
 4.  **Google Gemini API Key configured**: Create a `.env` file in the project root (`../`) by copying `.env.example` and adding your API key:
     ```bash
-    # In ../.env
-    GOOGLE_AI_API_KEY=your_api_key_here
+    # In .env
+    GEMINI_API_KEY=your_api_key_here
     ```
-    Alternatively, ensure the `GEMINI_API_KEY` environment variable is set.
 
 ## Running Examples
 
@@ -25,7 +24,7 @@ All examples should be run from the **project root directory** (the directory co
 Demonstrates different ways to configure the Geminize client.
 
 ```bash
-ruby examples/configuration.rb
+bundle exec ruby examples/configuration.rb
 ```
 
 ### 2. Embeddings (`embeddings.rb`)
@@ -33,7 +32,7 @@ ruby examples/configuration.rb
 Shows how to generate text embeddings and calculate cosine similarity.
 
 ```bash
-ruby examples/embeddings.rb
+bundle exec ruby examples/embeddings.rb
 ```
 
 ### 3. Multimodal (`multimodal.rb`)
@@ -43,33 +42,13 @@ Illustrates sending text and image inputs to the Gemini API.
 _Note: You may need to update the image file paths within the script (`path/to/image.jpg`) to point to actual image files on your system._
 
 ```bash
-ruby examples/multimodal.rb
+bundle exec ruby examples/multimodal.rb
 ```
 
-### 4. Rails Initializer (`rails_initializer.rb`)
-
-Shows the configuration structure typically used in a Rails initializer (this script is meant for illustration and doesn't require a Rails app to run).
-
-```bash
-ruby examples/rails_initializer.rb
-```
-
-### 5. System Instructions (`system_instructions.rb`)
+### 4. System Instructions (`system_instructions.rb`)
 
 Demonstrates using system instructions to guide the model's behavior and personality.
 
 ```bash
-ruby examples/system_instructions.rb
+bundle exec ruby examples/system_instructions.rb
 ```
-
-### 6. Rails Chat Application (`rails_chat/`)
-
-This directory contains a sample Rails application demonstrating Geminize integration. It requires a separate setup:
-
-1.  Navigate into the directory: `cd examples/rails_chat`
-2.  Install dependencies: `bundle install`
-3.  Run database migrations (if applicable): `rails db:migrate`
-4.  Start the Rails server: `rails server`
-5.  Open your web browser to `http://localhost:3000`
-
-Refer to the README within the `rails_chat/` directory (if available) for more specific instructions.

data/examples/embeddings.rb

@@ -36,24 +36,25 @@ puts "Example 2: Generate embeddings for multiple texts"
 puts "============================================================"
 
 begin
-  # Generate embeddings for multiple texts in a single API call
+  # Generate embeddings for multiple texts by calling the API for each
   texts = [
     "What is the meaning of life?",
     "How much wood would a woodchuck chuck?",
     "How does the brain work?"
   ]
 
-  response = Geminize.generate_embedding(texts)
-
-  puts "Generated #{response.batch_size} embeddings, each with #{response.embedding_size} dimensions"
-
-  # Access individual embeddings
-  texts.each_with_index do |text, i|
+  puts "Generating embeddings individually:"
+  total_tokens = 0
+  embeddings = texts.map do |text|
+    response = Geminize.generate_embedding(text)
+    total_tokens += response.total_tokens if response.total_tokens
     puts "\nText: \"#{text}\""
-    puts "First 5 values: #{response.embedding_at(i).take(5).inspect}"
+    puts "First 5 values: #{response.embedding.take(5).inspect}"
+    response.embedding # Collect the embedding vector
   end
 
-  puts "\nTotal tokens: #{response.total_tokens}"
+  puts "\nGenerated #{embeddings.size} embeddings."
+  puts "Total tokens (approximated by summing individual calls): #{total_tokens}"
 rescue => e
   puts "Error: #{e.message}"
 end
@@ -81,26 +82,27 @@ rescue => e
 end
 
 puts "\n============================================================"
-puts "Example 4: Batch processing for large arrays"
+puts "Example 4: Batch processing for large arrays (COMMENTED OUT)"
 puts "============================================================"
-
-begin
-  # Create a larger array of texts
-  many_texts = Array.new(120) { |i| "This is sample text number #{i}" }
-
-  # Generate embeddings with automatic batch processing
-  response = Geminize.generate_embedding(
-    many_texts,
-    nil, # Use default model
-    batch_size: 40 # Process in batches of 40 texts each
-  )
-
-  puts "Generated embeddings for #{response.batch_size} texts"
-  puts "First text embedding dimensions: #{response.embedding_size}"
-  puts "Total tokens processed: #{response.total_tokens}"
-rescue => e
-  puts "Error: #{e.message}"
-end
+# # Commenting out Example 4 due to potential model/API limitations with batching
+# begin
+#   # Create a larger array of texts
+#   many_texts = Array.new(120) { |i| "This is sample text number #{i}" }
+#
+#   # Generate embeddings with automatic batch processing
+#   response = Geminize.generate_embedding(
+#     many_texts,
+#     nil, # Use default model
+#     batch_size: 40 # Process in batches of 40 texts each
+#   )
+#
+#   puts "Generated embeddings for #{response.batch_size} texts"
+#   puts "First text embedding dimensions: #{response.embedding_size}"
+#   puts "Total tokens processed: #{response.total_tokens}"
+# rescue => e
+#   puts "Error: #{e.message}"
+# end
+puts "# Example 4 skipped due to potential issues with batch embedding support."
 
 puts "\n============================================================"
 puts "Example 5: Vector operations with embeddings"
@@ -141,7 +143,7 @@ puts "============================================================"
 begin
   # Sample texts for different use cases
   question = "What is the capital of France?"
-  code_query = "how to sort an array in javascript"
+  # code_query = "how to sort an array in javascript" # Removed for compatibility
   document = "Paris is the capital and most populous city of France, with an estimated population of 2,175,601 residents."
   fact = "The Earth revolves around the Sun."
 
@@ -157,15 +159,15 @@ begin
   puts "   Text: \"#{question}\""
   puts "   First 5 values: #{qa_response.embedding.take(5).inspect}"
 
-  # Code retrieval
-  code_response = Geminize.generate_embedding(
-    code_query,
-    nil, # Use default model
-    task_type: Geminize::Models::EmbeddingRequest::CODE_RETRIEVAL_QUERY
-  )
-  puts "\n2. CODE_RETRIEVAL_QUERY task type:"
-  puts "   Text: \"#{code_query}\""
-  puts "   First 5 values: #{code_response.embedding.take(5).inspect}"
+  # Code retrieval - REMOVED as CODE_RETRIEVAL_QUERY seems unsupported by text-embedding-004
+  # code_response = Geminize.generate_embedding(
+  #   code_query,
+  #   nil, # Use default model
+  #   task_type: Geminize::Models::EmbeddingRequest::CODE_RETRIEVAL_QUERY
+  # )
+  # puts "\n2. CODE_RETRIEVAL_QUERY task type:"
+  # puts "   Text: \"#{code_query}\""
+  # puts "   First 5 values: #{code_response.embedding.take(5).inspect}"
 
   # Document retrieval
   document_response = Geminize.generate_embedding(
@@ -174,7 +176,8 @@ begin
     task_type: Geminize::Models::EmbeddingRequest::RETRIEVAL_DOCUMENT,
     title: "Paris Facts" # Titles can be used with RETRIEVAL_DOCUMENT
   )
-  puts "\n3. RETRIEVAL_DOCUMENT task type with title:"
+  # Adjusting print index due to removal above
+  puts "\n2. RETRIEVAL_DOCUMENT task type with title:" # Index changed from 3 to 2
   puts "   Title: \"Paris Facts\""
   puts "   First 5 values: #{document_response.embedding.take(5).inspect}"
 
@@ -184,7 +187,8 @@ begin
     nil, # Use default model
     task_type: Geminize::Models::EmbeddingRequest::FACT_VERIFICATION
   )
-  puts "\n4. FACT_VERIFICATION task type:"
+  # Adjusting print index due to removal above
+  puts "\n3. FACT_VERIFICATION task type:" # Index changed from 4 to 3
   puts "   Text: \"#{fact}\""
   puts "   First 5 values: #{fact_response.embedding.take(5).inspect}"