Generate text using images from a local and Google Cloud Storage

  import 
  
 ( 
  
 "context" 
  
 "fmt" 
  
 "io" 
  
 "os" 
  
 genai 
  
 "google.golang.org/genai" 
 ) 
 // generateWithMultiImg shows how to generate text using multiple image inputs. 
 func 
  
 generateWithMultiImg 
 ( 
 w 
  
 io 
 . 
 Writer 
 ) 
  
 error 
  
 { 
  
 ctx 
  
 := 
  
 context 
 . 
 Background 
 () 
  
 client 
 , 
  
 err 
  
 := 
  
 genai 
 . 
 NewClient 
 ( 
 ctx 
 , 
  
& genai 
 . 
 ClientConfig 
 { 
  
 HTTPOptions 
 : 
  
 genai 
 . 
 HTTPOptions 
 { 
 APIVersion 
 : 
  
 "v1" 
 }, 
  
 }) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 fmt 
 . 
 Errorf 
 ( 
 "failed to create genai client: %w" 
 , 
  
 err 
 ) 
  
 } 
  
 // TODO(Developer): Update the path to file (image source: 
  
 //   https://storage.googleapis.com/cloud-samples-data/generative-ai/image/latte.jpg ) 
  
 imageBytes 
 , 
  
 err 
  
 := 
  
 os 
 . 
 ReadFile 
 ( 
 "./latte.jpg" 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 fmt 
 . 
 Errorf 
 ( 
 "failed to read image: %w" 
 , 
  
 err 
 ) 
  
 } 
  
 contents 
  
 := 
  
 [] 
 * 
 genai 
 . 
 Content 
 { 
  
 { 
 Parts 
 : 
  
 [] 
 * 
 genai 
 . 
 Part 
 { 
  
 { 
 Text 
 : 
  
 "Write an advertising jingle based on the items in both images." 
 }, 
  
 { 
 FileData 
 : 
  
& genai 
 . 
 FileData 
 { 
  
 // Image source: https://storage.googleapis.com/cloud-samples-data/generative-ai/image/scones.jpg 
  
 FileURI 
 : 
  
 "gs://cloud-samples-data/generative-ai/image/scones.jpg" 
 , 
  
 MIMEType 
 : 
  
 "image/jpeg" 
 , 
  
 }}, 
  
 { 
 InlineData 
 : 
  
& genai 
 . 
 Blob 
 { 
  
 Data 
 : 
  
 imageBytes 
 , 
  
 MIMEType 
 : 
  
 "image/jpeg" 
 , 
  
 }}, 
  
 }}, 
  
 } 
  
 modelName 
  
 := 
  
 "gemini-2.5-flash" 
  
 resp 
 , 
  
 err 
  
 := 
  
 client 
 . 
 Models 
 . 
 GenerateContent 
 ( 
 ctx 
 , 
  
 modelName 
 , 
  
 contents 
 , 
  
 nil 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 fmt 
 . 
 Errorf 
 ( 
 "failed to generate content: %w" 
 , 
  
 err 
 ) 
  
 } 
  
 respText 
  
 := 
  
 resp 
 . 
 Text 
 () 
  
 fmt 
 . 
 Fprintln 
 ( 
 w 
 , 
  
 respText 
 ) 
  
 // Example response: 
  
 // Okay, here's an advertising jingle inspired by the blueberry scones, coffee, flowers, chocolate cake, and latte: 
  
 // 
  
 // (Upbeat, jazzy music) 
  
 // ... 
  
 return 
  
 nil 
 } 
 

  import 
  
 com.google.genai.Client 
 ; 
 import 
  
 com.google.genai.types.Content 
 ; 
 import 
  
 com.google.genai.types.GenerateContentResponse 
 ; 
 import 
  
 com.google.genai.types.HttpOptions 
 ; 
 import 
  
 com.google.genai.types.Part 
 ; 
 import 
  
 java.io.IOException 
 ; 
 import 
  
 java.nio.file.Files 
 ; 
 import 
  
 java.nio.file.Paths 
 ; 
 public 
  
 class 
 TextGenerationWithMultiImage 
  
 { 
  
 public 
  
 static 
  
 void 
  
 main 
 ( 
 String 
 [] 
  
 args 
 ) 
  
 throws 
  
 IOException 
  
 { 
  
 // TODO(developer): Replace these variables before running the sample. 
  
 String 
  
 modelId 
  
 = 
  
 "gemini-2.5-flash" 
 ; 
  
 // Content from Google Cloud Storage 
  
 String 
  
 gcsFileImagePath 
  
 = 
  
 "gs://cloud-samples-data/generative-ai/image/scones.jpg" 
 ; 
  
 String 
  
 localImageFilePath 
  
 = 
  
 "resources/latte.jpg" 
 ; 
  
 generateContent 
 ( 
 modelId 
 , 
  
 gcsFileImagePath 
 , 
  
 localImageFilePath 
 ); 
  
 } 
  
 // Generates text with multiple images 
  
 public 
  
 static 
  
 String 
  
 generateContent 
 ( 
  
 String 
  
 modelId 
 , 
  
 String 
  
 gcsFileImagePath 
 , 
  
 String 
  
 localImageFilePath 
 ) 
  
 throws 
  
 IOException 
  
 { 
  
 // Initialize client that will be used to send requests. This client only needs to be created 
  
 // once, and can be reused for multiple requests. 
  
 try 
  
 ( 
 Client 
  
 client 
  
 = 
  
 Client 
 . 
 builder 
 () 
  
 . 
 location 
 ( 
 "global" 
 ) 
  
 . 
 vertexAI 
 ( 
 true 
 ) 
  
 . 
 httpOptions 
 ( 
 HttpOptions 
 . 
 builder 
 (). 
 apiVersion 
 ( 
 "v1" 
 ). 
 build 
 ()) 
  
 . 
 build 
 ()) 
  
 { 
  
 // Read content from a local file. 
  
 byte 
 [] 
  
 localFileImgBytes 
  
 = 
  
 Files 
 . 
 readAllBytes 
 ( 
 Paths 
 . 
 get 
 ( 
 localImageFilePath 
 )); 
  
 GenerateContentResponse 
  
 response 
  
 = 
  
 client 
 . 
 models 
 . 
 generateContent 
 ( 
  
 modelId 
 , 
  
 Content 
 . 
 fromParts 
 ( 
  
 Part 
 . 
 fromText 
 ( 
 "Generate a list of all the objects contained in both images" 
 ), 
  
 Part 
 . 
 fromBytes 
 ( 
 localFileImgBytes 
 , 
  
 "image/jpeg" 
 ), 
  
 Part 
 . 
 fromUri 
 ( 
 gcsFileImagePath 
 , 
  
 "image/jpeg" 
 )), 
  
 null 
 ); 
  
 System 
 . 
 out 
 . 
 print 
 ( 
 response 
 . 
 text 
 ()); 
  
 // Example response: 
  
 // Okay, here's the list of objects present in both images: 
  
 // 
  
 // **Image 1 (Scones):** 
  
 // 
  
 // *   Scones 
  
 // *   Plate 
  
 // *   Jam/Preserve 
  
 // *   Cream/Butter 
  
 // *   Table/Surface 
  
 // *   Napkin/Cloth (possibly) 
  
 // 
  
 // **Image 2 (Latte):** 
  
 // 
  
 // *   Latte/Coffee cup 
  
 // *   Saucer 
  
 // *   Spoon 
  
 // *   Table/Surface 
  
 // *   Foam/Latte art 
  
 // 
  
 // **Objects potentially in both (depending on interpretation and specific items):** 
  
 // 
  
 // *   Plate/Saucer (both are serving dishes) 
  
 // *   Table/Surface 
  
 return 
  
 response 
 . 
 text 
 (); 
  
 } 
  
 } 
 } 
 

  const 
  
 { 
 GoogleGenAI 
 } 
  
 = 
  
 require 
 ( 
 '@google/genai' 
 ); 
 const 
  
 GOOGLE_CLOUD_PROJECT 
  
 = 
  
 process 
 . 
 env 
 . 
 GOOGLE_CLOUD_PROJECT 
 ; 
 const 
  
 GOOGLE_CLOUD_LOCATION 
  
 = 
  
 process 
 . 
 env 
 . 
 GOOGLE_CLOUD_LOCATION 
  
 || 
  
 'global' 
 ; 
 async 
  
 function 
  
 generateContent 
 ( 
  
 projectId 
  
 = 
  
 GOOGLE_CLOUD_PROJECT 
 , 
  
 location 
  
 = 
  
 GOOGLE_CLOUD_LOCATION 
 ) 
  
 { 
  
 const 
  
 ai 
  
 = 
  
 new 
  
 GoogleGenAI 
 ({ 
  
 vertexai 
 : 
  
 true 
 , 
  
 project 
 : 
  
 projectId 
 , 
  
 location 
 : 
  
 location 
 , 
  
 }); 
  
 const 
  
 image1 
  
 = 
  
 { 
  
 fileData 
 : 
  
 { 
  
 fileUri 
 : 
  
 'gs://cloud-samples-data/generative-ai/image/scones.jpg' 
 , 
  
 mimeType 
 : 
  
 'image/jpeg' 
 , 
  
 }, 
  
 }; 
  
 const 
  
 image2 
  
 = 
  
 { 
  
 fileData 
 : 
  
 { 
  
 fileUri 
 : 
  
 'gs://cloud-samples-data/generative-ai/image/fruit.png' 
 , 
  
 mimeType 
 : 
  
 'image/png' 
 , 
  
 }, 
  
 }; 
  
 const 
  
 response 
  
 = 
  
 await 
  
 ai 
 . 
 models 
 . 
 generateContent 
 ({ 
  
 model 
 : 
  
 'gemini-2.5-flash' 
 , 
  
 contents 
 : 
  
 [ 
  
 image1 
 , 
  
 image2 
 , 
  
 'Generate a list of all the objects contained in both images.' 
 , 
  
 ], 
  
 }); 
  
 console 
 . 
 log 
 ( 
 response 
 . 
 text 
 ); 
  
 return 
  
 response 
 . 
 text 
 ; 
 } 
 

  from 
  
 google 
  
 import 
 genai 
 from 
  
 google.genai.types 
  
 import 
 HttpOptions 
 , 
 Part 
 client 
 = 
 genai 
 . 
 Client 
 ( 
 http_options 
 = 
 HttpOptions 
 ( 
 api_version 
 = 
 "v1" 
 )) 
 # Read content from GCS 
 gcs_file_img_path 
 = 
 "gs://cloud-samples-data/generative-ai/image/scones.jpg" 
 # Read content from a local file 
 with 
 open 
 ( 
 "test_data/latte.jpg" 
 , 
 "rb" 
 ) 
 as 
 f 
 : 
 local_file_img_bytes 
 = 
 f 
 . 
 read 
 () 
 response 
 = 
 client 
 . 
 models 
 . 
 generate_content 
 ( 
 model 
 = 
 "gemini-2.5-flash" 
 , 
 contents 
 = 
 [ 
 "Generate a list of all the objects contained in both images." 
 , 
 Part 
 . 
 from_uri 
 ( 
 file_uri 
 = 
 gcs_file_img_path 
 , 
 mime_type 
 = 
 "image/jpeg" 
 ), 
 Part 
 . 
 from_bytes 
 ( 
 data 
 = 
 local_file_img_bytes 
 , 
 mime_type 
 = 
 "image/jpeg" 
 ), 
 ], 
 ) 
 print 
 ( 
 response 
 . 
 text 
 ) 
 # Example response: 
 # Okay, here's the list of objects present in both images: 
 # ...