Google Gen AI SDK

  from 
  
 google 
  
 import 
 genai 
 from 
  
 google.genai.types 
  
 import 
 HttpOptions 
 client 
 = 
 genai 
 . 
 Client 
 ( 
 http_options 
 = 
 HttpOptions 
 ( 
 api_version 
 = 
 "v1" 
 )) 
 response 
 = 
 client 
 . 
 models 
 . 
 generate_content 
 ( 
 model 
 = 
 "gemini-2.5-flash" 
 , 
 contents 
 = 
 "How does AI work?" 
 , 
 ) 
 print 
 ( 
 response 
 . 
 text 
 ) 
 # Example response: 
 # Okay, let's break down how AI works. It's a broad field, so I'll focus on the ... 
 # 
 # Here's a simplified overview: 
 # ... 
 

  from 
  
 google 
  
 import 
 genai 
 # TODO(developer): Update below line 
 API_KEY 
 = 
 "YOUR_API_KEY" 
 client 
 = 
 genai 
 . 
 Client 
 ( 
 vertexai 
 = 
 True 
 , 
 api_key 
 = 
 API_KEY 
 ) 
 response 
 = 
 client 
 . 
 models 
 . 
 generate_content 
 ( 
 model 
 = 
 "gemini-2.5-flash" 
 , 
 contents 
 = 
 "Explain bubble sort to me." 
 , 
 ) 
 print 
 ( 
 response 
 . 
 text 
 ) 
 # Example response: 
 # Bubble Sort is a simple sorting algorithm that repeatedly steps through the list 
 

  import 
  
 ( 
  
 "context" 
  
 "fmt" 
  
 "io" 
  
 "google.golang.org/genai" 
 ) 
 // generateWithText shows how to generate text using a text prompt. 
 func 
  
 generateWithText 
 ( 
 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 
 ) 
  
 } 
  
 resp 
 , 
  
 err 
  
 := 
  
 client 
 . 
 Models 
 . 
 GenerateContent 
 ( 
 ctx 
 , 
  
 "gemini-2.5-flash" 
 , 
  
 genai 
 . 
 Text 
 ( 
 "How does AI work?" 
 ), 
  
 nil 
 , 
  
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 fmt 
 . 
 Errorf 
 ( 
 "failed to generate content: %w" 
 , 
  
 err 
 ) 
  
 } 
  
 respText 
  
 := 
  
 resp 
 . 
 Text 
 () 
  
 fmt 
 . 
 Fprintln 
 ( 
 w 
 , 
  
 respText 
 ) 
  
 // Example response: 
  
 // That's a great question! Understanding how AI works can feel like ... 
  
 // ... 
  
 // **1. The Foundation: Data and Algorithms** 
  
 // ... 
  
 return 
  
 nil 
 } 
 

  /** 
 * @license 
 * Copyright 2025 Google LLC 
 * SPDX-License-Identifier: Apache-2.0 
 */ 
 import 
  
 { 
 GoogleGenAI 
 } 
  
 from 
  
 '@google/genai' 
 ; 
 const 
  
 GEMINI_API_KEY 
  
 = 
  
 process 
 . 
 env 
 . 
 GEMINI_API_KEY 
 ; 
 const 
  
 GOOGLE_CLOUD_PROJECT 
  
 = 
  
 process 
 . 
 env 
 . 
 GOOGLE_CLOUD_PROJECT 
 ; 
 const 
  
 GOOGLE_CLOUD_LOCATION 
  
 = 
  
 process 
 . 
 env 
 . 
 GOOGLE_CLOUD_LOCATION 
 ; 
 const 
  
 GOOGLE_GENAI_USE_VERTEXAI 
  
 = 
  
 process 
 . 
 env 
 . 
 GOOGLE_GENAI_USE_VERTEXAI 
 ; 
 async 
  
 function 
  
 generateContentFromMLDev 
 () 
  
 { 
  
 const 
  
 ai 
  
 = 
  
 new 
  
 GoogleGenAI 
 ({ 
 vertexai 
 : 
  
 false 
 , 
  
 apiKey 
 : 
  
 GEMINI_API_KEY 
 }); 
  
 const 
  
 response 
  
 = 
  
 await 
  
 ai 
 . 
 models 
 . 
 generateContent 
 ({ 
  
 model 
 : 
  
 'gemini-2.0-flash' 
 , 
  
 contents 
 : 
  
 'why is the sky blue?' 
 , 
  
 }); 
  
 console 
 . 
 debug 
 ( 
 response 
 . 
 text 
 ); 
 } 
 async 
  
 function 
  
 generateContentFromVertexAI 
 () 
  
 { 
  
 const 
  
 ai 
  
 = 
  
 new 
  
 GoogleGenAI 
 ({ 
  
 vertexai 
 : 
  
 true 
 , 
  
 project 
 : 
  
 GOOGLE_CLOUD_PROJECT 
 , 
  
 location 
 : 
  
 GOOGLE_CLOUD_LOCATION 
 , 
  
 }); 
  
 const 
  
 response 
  
 = 
  
 await 
  
 ai 
 . 
 models 
 . 
 generateContent 
 ({ 
  
 model 
 : 
  
 'gemini-2.0-flash' 
 , 
  
 contents 
 : 
  
 'why is the sky blue?' 
 , 
  
 }); 
  
 console 
 . 
 debug 
 ( 
 response 
 . 
 text 
 ); 
 } 
 async 
  
 function 
  
 main 
 () 
  
 { 
  
 if 
  
 ( 
 GOOGLE_GENAI_USE_VERTEXAI 
 ) 
  
 { 
  
 await 
  
 generateContentFromVertexAI 
 (). 
 catch 
 (( 
 e 
 ) 
  
 = 
>  
 console 
 . 
 error 
 ( 
 'got error' 
 , 
  
 e 
 ), 
  
 ); 
  
 } 
  
 else 
  
 { 
  
 await 
  
 generateContentFromMLDev 
 (). 
 catch 
 (( 
 e 
 ) 
  
 = 
>  
 console 
 . 
 error 
 ( 
 'got error' 
 , 
  
 e 
 ), 
  
 ); 
  
 } 
 } 
 main 
 (); 
 

  /* 
 * Copyright 2025 Google LLC 
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License. 
 * You may obtain a copy of the License at 
 * 
 *      https://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */ 
 /** 
 * Usage: 
 * 
 * <p>1a. If you are using Vertex AI, setup ADC to get credentials: 
 * https://cloud.google.com/docs/authentication/provide-credentials-adc#google-idp 
 * 
 * <p>Then set Project, Location, and USE_VERTEXAI flag as environment variables: 
 * 
 * <p>export GOOGLE_CLOUD_PROJECT=YOUR_PROJECT 
 * 
 * <p>export GOOGLE_CLOUD_LOCATION=YOUR_LOCATION 
 * 
 * <p>export GOOGLE_GENAI_USE_VERTEXAI=true 
 * 
 * <p>1b. If you are using Gemini Developer API, set an API key environment variable. You can find a 
 * list of available API keys here: https://aistudio.google.com/app/apikey 
 * 
 * <p>export GOOGLE_API_KEY=YOUR_API_KEY 
 * 
 * <p>2. Compile the java package and run the sample code. 
 * 
 * <p>mvn clean compile exec:java -Dexec.mainClass="com.google.genai.examples.GenerateContent" 
 * -Dexec.args="YOUR_MODEL_ID" 
 */ 
 package 
  
 com.google.genai.examples 
 ; 
 import 
  
 com.google.genai.Client 
 ; 
 import 
  
 com.google.genai.types.GenerateContentResponse 
 ; 
 /** An example of using the Unified Gen AI Java SDK to generate content. */ 
 public 
  
 final 
  
 class 
 GenerateContent 
  
 { 
  
 public 
  
 static 
  
 void 
  
 main 
 ( 
 String 
 [] 
  
 args 
 ) 
  
 { 
  
 final 
  
 String 
  
 modelId 
 ; 
  
 if 
  
 ( 
 args 
 . 
 length 
  
 != 
  
 0 
 ) 
  
 { 
  
 modelId 
  
 = 
  
 args 
 [ 
 0 
 ] 
 ; 
  
 } 
  
 else 
  
 { 
  
 modelId 
  
 = 
  
 Constants 
 . 
 GEMINI_MODEL_NAME 
 ; 
  
 } 
  
 // Instantiate the client. The client by default uses the Gemini Developer API. It gets the API 
  
 // key from the environment variable `GOOGLE_API_KEY`. Vertex AI API can be used by setting the 
  
 // environment variables `GOOGLE_CLOUD_LOCATION` and `GOOGLE_CLOUD_PROJECT`, as well as setting 
  
 // `GOOGLE_GENAI_USE_VERTEXAI` to "true". 
  
 // 
  
 // Note: Some services are only available in a specific API backend (Gemini or Vertex), you will 
  
 // get a `UnsupportedOperationException` if you try to use a service that is not available in 
  
 // the backend you are using. 
  
 Client 
  
 client 
  
 = 
  
 new 
  
 Client 
 (); 
  
 if 
  
 ( 
 client 
 . 
 vertexAI 
 ()) 
  
 { 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "Using Vertex AI" 
 ); 
  
 } 
  
 else 
  
 { 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "Using Gemini Developer API" 
 ); 
  
 } 
  
 GenerateContentResponse 
  
 response 
  
 = 
  
 client 
 . 
 models 
 . 
 generateContent 
 ( 
 modelId 
 , 
  
 "What is your name?" 
 , 
  
 null 
 ); 
  
 // Gets the text string from the response by the quick accessor method `text()`. 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "Unary response: " 
  
 + 
  
 response 
 . 
 text 
 ()); 
  
 // Gets the http headers from the response. 
  
 response 
  
 . 
 sdkHttpResponse 
 () 
  
 . 
 ifPresent 
 ( 
  
 httpResponse 
  
 - 
>  
 System 
 . 
 out 
 . 
 println 
 ( 
 "Response headers: " 
  
 + 
  
 httpResponse 
 . 
 headers 
 (). 
 orElse 
 ( 
 null 
 ))); 
  
 } 
  
 private 
  
 GenerateContent 
 () 
  
 {} 
 }