geminize 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9b29587f96d7535a7db3ad010684fd9fa7e7a765d83d71a1cd645bdf323af69
-  data.tar.gz: 90adc36f2b5acbdb6e45904ebbd7847d1a895a614d4aee6ace5af028d8812045
+  metadata.gz: 276d207ee68fba0c8b4ea894c819254d660cd1c8b520df5d21a6de89d2cf0b25
+  data.tar.gz: b9447a5ce82b5f10bfda7c09cdd2a658a5d540f1482a741f8ae7651826cce8bd
 SHA512:
-  metadata.gz: 0b303213d67decca74c5f14c1a94625275febe0fc50d1ca24dc5a12fd65cd148077ef50e6ca27f1e720e05e88101f76047088db2707b71f2318036b7351335f9
-  data.tar.gz: 981b130896dd8a0f8824602d0adb51fe60b8cfcab9124b3e7322795b6cfc9c8140031a6ca144e042c478182e78d2f3f00a9e35daa3c763a2f6d794171f4773ed
+  metadata.gz: 8f0f49ad1678d7edd5e39329ae5dd11749094bdbc4c5fa11676af9c5962a316baf9b96f78967cc159e1de9839ee21bc3693b8e9c5d130eae4bba70fe81e5dcc5
+  data.tar.gz: bb0b7e7437cbbfeda3b522ab737c9521f78fe2252a6cb8b885bbb34b33bc402230dbb24bc9c761857c005c1d595a7c7aa85fe214a338f53a8a1bc4d6fee4305f

data/README.md

@@ -124,23 +124,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 +149,52 @@ puts response.text
 
 ## Multimodal Support
 
-Geminize allows you to send mixed content including text and images to the Gemini API:
+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
-```
-
-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 +230,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,24 +281,34 @@ 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
+  # 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
 ```
 
 ## Rails Integration

data/examples/embeddings.rb

@@ -36,24 +36,26 @@ 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,9 +83,9 @@ 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 # 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}" }
@@ -101,6 +103,8 @@ begin
 rescue => e
   puts "Error: #{e.message}"
 end
+=end
+puts "# Example 4 skipped due to potential issues with batch embedding support."
 
 puts "\n============================================================"
 puts "Example 5: Vector operations with embeddings"
@@ -141,7 +145,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 +161,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 +178,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 +189,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}"
 

data/examples/multimodal.rb

@@ -8,7 +8,8 @@ Geminize.configure do |config|
   config.api_key = ENV["GEMINI_API_KEY"] || "your-api-key-here"
 
   # Specify the model to use (optional)
-  config.default_model = "gemini-2.0-flash" # This model supports multimodal inputs
+  # Use a model that supports multimodal input, like gemini-1.5-flash-latest
+  config.default_model = "gemini-1.5-flash-latest"
 end
 
 puts "============================================================"
@@ -19,7 +20,7 @@ begin
   # 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"}]
+    [{source_type: "file", data: "./examples/ruby.png"}] # Updated path
   )
 
   puts "Response:"
@@ -27,7 +28,7 @@ begin
   puts "\nFinish reason: #{response.finish_reason}"
 rescue => e
   puts "Error: #{e.message}"
-  puts "Make sure to update the image path to a real image on your system."
+  puts "Make sure the path './examples/ruby.png' is correct relative to the project root."
 end
 
 puts "\n============================================================"
@@ -38,7 +39,7 @@ begin
   # Generate content with an image from a URL
   response = Geminize.generate_text_multimodal(
     "What's in this image?",
-    [{source_type: "url", data: "https://example.com/sample-image.jpg"}],
+    [{source_type: "url", data: "https://miro.medium.com/v2/resize:fit:720/format:webp/1*zkA1cWgJDlMUxI5TRcIHdQ.jpeg"}], # Updated URL
     nil, # Use default model
     temperature: 0.7
   )
@@ -47,7 +48,7 @@ begin
   puts response.text
 rescue => e
   puts "Error: #{e.message}"
-  puts "Make sure to use a valid image URL."
+  puts "Make sure the URL is valid and accessible."
 end
 
 puts "\n============================================================"
@@ -55,12 +56,12 @@ puts "Example 3: Multiple images comparison"
 puts "============================================================"
 
 begin
-  # Generate content comparing multiple images
+  # Generate content comparing multiple images (using the same image twice here for simplicity)
   response = Geminize.generate_text_multimodal(
-    "Compare these two images and describe the differences:",
+    "Compare these two images and describe the differences (they might be the same):",
     [
-      {source_type: "file", data: "path/to/image1.jpg"},
-      {source_type: "file", data: "path/to/image2.jpg"}
+      {source_type: "file", data: "./examples/ruby.png"}, # Updated path
+      {source_type: "file", data: "./examples/ruby.png"}  # Updated path
     ],
     "gemini-1.5-pro-latest", # Explicitly specify model
     max_tokens: 500
@@ -70,7 +71,7 @@ begin
   puts response.text
 rescue => e
   puts "Error: #{e.message}"
-  puts "Make sure to update the image paths to real images on your system."
+  puts "Make sure the path './examples/ruby.png' is correct."
 end
 
 puts "\n============================================================"
@@ -79,19 +80,19 @@ puts "============================================================"
 
 begin
   # Read image directly into bytes
-  image_bytes = File.binread("path/to/image.jpg")
+  image_bytes = File.binread("./examples/ruby.png") # Updated path
 
   # Generate content with raw image bytes
   response = Geminize.generate_text_multimodal(
     "Analyze this image:",
-    [{source_type: "bytes", data: image_bytes, mime_type: "image/jpeg"}]
+    [{source_type: "bytes", data: image_bytes, mime_type: "image/png"}] # Updated MIME type
   )
 
   puts "Response for raw bytes input:"
   puts response.text
 rescue => e
   puts "Error: #{e.message}"
-  puts "Make sure to update the image path to a real image on your system."
+  puts "Make sure the path './examples/ruby.png' is correct."
 end
 
 puts "\n============================================================"
@@ -111,16 +112,22 @@ begin
   )
 
   # Add multiple images using different methods
-  request.add_image_from_file("path/to/image1.jpg")
-  request.add_image_from_url("https://example.com/image2.jpg")
+  request.add_image_from_file("./examples/ruby.png") # Updated path
+  request.add_image_from_url("https://miro.medium.com/v2/resize:fit:720/format:webp/1*zkA1cWgJDlMUxI5TRcIHdQ.jpeg") # Updated URL
 
   # Generate the response
   response = generator.generate(request)
 
   puts "Response using ContentRequest directly:"
   puts response.text
-  puts "\nUsed #{response.usage.total_tokens} tokens total"
+
+  # Check if usage data is available before accessing it
+  if response.usage && response.usage.total_tokens
+    puts "\nUsed #{response.usage.total_tokens} tokens total"
+  else
+    puts "\nUsage data not available in the response."
+  end
 rescue => e
   puts "Error: #{e.message}"
-  puts "Make sure to update the paths to real images."
+  puts "Make sure paths and URLs are valid."
 end

data/lib/geminize/models/content_request.rb

@@ -211,30 +211,31 @@ module Geminize
       # Convert the request to a hash suitable for the API
       # @return [Hash] The request as a hash
       def to_hash
-        request = if multimodal?
-          {
-            contents: [
-              {
-                parts: @content_parts
-              }
-            ],
-            generationConfig: generation_config
-          }.compact
-        else
-          # Keep backward compatibility for text-only requests
-          {
-            contents: [
-              {
-                parts: [
-                  {
-                    text: @prompt
-                  }
-                ]
+        # Map content_parts to the structure the API expects
+        api_parts = @content_parts.map do |part|
+          if part[:type] == "text"
+            { text: part[:text] }
+          elsif part[:type] == "image"
+            {
+              inlineData: {
+                mimeType: part[:mime_type],
+                data: part[:data]
               }
-            ],
-            generationConfig: generation_config
-          }.compact
-        end
+            }
+          else
+            # Handle potential future types or raise error
+            nil # Or raise an error for unknown part types
+          end
+        end.compact # Remove any nil parts from unknown types
+
+        request = {
+          contents: [
+            {
+              parts: api_parts # Use the correctly formatted parts
+            }
+          ],
+          generationConfig: generation_config
+        }.compact
 
         # Add system_instruction if provided
         if @system_instruction

data/lib/geminize/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Geminize
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: geminize
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Nhat Long Nguyen
 bindir: exe
 cert_chain: []
-date: 2025-05-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -149,7 +149,9 @@ files:
 - examples/rails_chat/app/views/chat/index.html.erb
 - examples/rails_chat/config/routes.rb
 - examples/rails_initializer.rb
+- examples/ruby.png
 - examples/system_instructions.rb
+- geminize-0.1.0.gem
 - lib/geminize.rb
 - lib/geminize/chat.rb
 - lib/geminize/client.rb
@@ -212,7 +214,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.8
 specification_version: 4
 summary: Ruby interface for Google's Gemini AI API
 test_files: []