Generating content

from google import genai  client = genai.Client() response = client.models.generate_content(     model="gemini-2.0-flash", contents="Write a story about a magic backpack." ) print(response.text)
text_generation.py

// Make sure to include the following import: // import {GoogleGenAI} from '@google/genai'; const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });  const response = await ai.models.generateContent({   model: "gemini-2.0-flash",   contents: "Write a story about a magic backpack.", }); console.log(response.text);
text_generation.js

ctx := context.Background() client, err := genai.NewClient(ctx, &genai.ClientConfig{ 	APIKey:  os.Getenv("GEMINI_API_KEY"), 	Backend: genai.BackendGeminiAPI, }) if err != nil { 	log.Fatal(err) } contents := []*genai.Content{ 	genai.NewContentFromText("Write a story about a magic backpack.", genai.RoleUser), } response, err := client.Models.GenerateContent(ctx, "gemini-2.0-flash", contents, nil) if err != nil { 	log.Fatal(err) } printResponse(response)
text_generation.go

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \     -H 'Content-Type: application/json' \     -X POST \     -d '{       "contents": [{         "parts":[{"text": "Write a story about a magic backpack."}]         }]        }' 2> /dev/null
text_generation.sh

Client client = new Client();  GenerateContentResponse response =         client.models.generateContent(                 "gemini-2.0-flash",                 "Write a story about a magic backpack.",                 null);  System.out.println(response.text());
TextGeneration.java

from google import genai import PIL.Image  client = genai.Client() organ = PIL.Image.open(media / "organ.jpg") response = client.models.generate_content(     model="gemini-2.0-flash", contents=["Tell me about this instrument", organ] ) print(response.text)
text_generation.py

// Make sure to include the following import: // import {GoogleGenAI} from '@google/genai'; const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });  const organ = await ai.files.upload({   file: path.join(media, "organ.jpg"), });  const response = await ai.models.generateContent({   model: "gemini-2.0-flash",   contents: [     createUserContent([       "Tell me about this instrument",        createPartFromUri(organ.uri, organ.mimeType)     ]),   ], }); console.log(response.text);
text_generation.js

ctx := context.Background() client, err := genai.NewClient(ctx, &genai.ClientConfig{ 	APIKey:  os.Getenv("GEMINI_API_KEY"), 	Backend: genai.BackendGeminiAPI, }) if err != nil { 	log.Fatal(err) }  file, err := client.Files.UploadFromPath( 	ctx,  	filepath.Join(getMedia(), "organ.jpg"),  	&genai.UploadFileConfig{ 		MIMEType : "image/jpeg", 	}, ) if err != nil { 	log.Fatal(err) } parts := []*genai.Part{ 	genai.NewPartFromText("Tell me about this instrument"), 	genai.NewPartFromURI(file.URI, file.MIMEType), } contents := []*genai.Content{ 	genai.NewContentFromParts(parts, genai.RoleUser), }  response, err := client.Models.GenerateContent(ctx, "gemini-2.0-flash", contents, nil) if err != nil { 	log.Fatal(err) } printResponse(response)
text_generation.go

# Use a temporary file to hold the base64 encoded image data TEMP_B64=$(mktemp) trap 'rm -f "$TEMP_B64"' EXIT base64 $B64FLAGS $IMG_PATH > "$TEMP_B64"  # Use a temporary file to hold the JSON payload TEMP_JSON=$(mktemp) trap 'rm -f "$TEMP_JSON"' EXIT  cat > "$TEMP_JSON" << EOF {   "contents": [{     "parts":[       {"text": "Tell me about this instrument"},       {         "inline_data": {           "mime_type":"image/jpeg",           "data": "$(cat "$TEMP_B64")"         }       }     ]   }] } EOF  curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \     -H 'Content-Type: application/json' \     -X POST \     -d "@$TEMP_JSON" 2> /dev/null
text_generation.sh

Client client = new Client();  String path = media_path + "organ.jpg"; byte[] imageData = Files.readAllBytes(Paths.get(path));  Content content =         Content.fromParts(                 Part.fromText("Tell me about this instrument."),                 Part.fromBytes(imageData, "image/jpeg"));  GenerateContentResponse response = client.models.generateContent("gemini-2.0-flash", content, null);  System.out.println(response.text());
TextGeneration.java

from google import genai  client = genai.Client() sample_audio = client.files.upload(file=media / "sample.mp3") response = client.models.generate_content(     model="gemini-2.0-flash",     contents=["Give me a summary of this audio file.", sample_audio], ) print(response.text)
text_generation.py

// Make sure to include the following import: // import {GoogleGenAI} from '@google/genai'; const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });  const audio = await ai.files.upload({   file: path.join(media, "sample.mp3"), });  const response = await ai.models.generateContent({   model: "gemini-2.0-flash",   contents: [     createUserContent([       "Give me a summary of this audio file.",       createPartFromUri(audio.uri, audio.mimeType),     ]),   ], }); console.log(response.text);
text_generation.js

ctx := context.Background() client, err := genai.NewClient(ctx, &genai.ClientConfig{ 	APIKey:  os.Getenv("GEMINI_API_KEY"), 	Backend: genai.BackendGeminiAPI, }) if err != nil { 	log.Fatal(err) }  file, err := client.Files.UploadFromPath( 	ctx,  	filepath.Join(getMedia(), "sample.mp3"),  	&genai.UploadFileConfig{ 		MIMEType : "audio/mpeg", 	}, ) if err != nil { 	log.Fatal(err) }  parts := []*genai.Part{ 	genai.NewPartFromText("Give me a summary of this audio file."), 	genai.NewPartFromURI(file.URI, file.MIMEType), }  contents := []*genai.Content{ 	genai.NewContentFromParts(parts, genai.RoleUser), }  response, err := client.Models.GenerateContent(ctx, "gemini-2.0-flash", contents, nil) if err != nil { 	log.Fatal(err) } printResponse(response)
text_generation.go

# Use File API to upload audio data to API request. MIME_TYPE=$(file -b --mime-type "${AUDIO_PATH}") NUM_BYTES=$(wc -c < "${AUDIO_PATH}") DISPLAY_NAME=AUDIO  tmp_header_file=upload-header.tmp  # Initial resumable request defining metadata. # The upload url is in the response headers dump them to a file. curl "${BASE_URL}/upload/v1beta/files?key=${GEMINI_API_KEY}" \   -D upload-header.tmp \   -H "X-Goog-Upload-Protocol: resumable" \   -H "X-Goog-Upload-Command: start" \   -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \   -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \   -H "Content-Type: application/json" \   -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null  upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r") rm "${tmp_header_file}"  # Upload the actual bytes. curl "${upload_url}" \   -H "Content-Length: ${NUM_BYTES}" \   -H "X-Goog-Upload-Offset: 0" \   -H "X-Goog-Upload-Command: upload, finalize" \   --data-binary "@${AUDIO_PATH}" 2> /dev/null > file_info.json  file_uri=$(jq ".file.uri" file_info.json) echo file_uri=$file_uri  curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \     -H 'Content-Type: application/json' \     -X POST \     -d '{       "contents": [{         "parts":[           {"text": "Please describe this file."},           {"file_data":{"mime_type": "audio/mpeg", "file_uri": '$file_uri'}}]         }]        }' 2> /dev/null > response.json  cat response.json echo  jq ".candidates[].content.parts[].text" response.json
text_generation.sh

from google import genai import time  client = genai.Client() # Video clip (CC BY 3.0) from https://peach.blender.org/download/ myfile = client.files.upload(file=media / "Big_Buck_Bunny.mp4") print(f"{myfile=}")  # Poll until the video file is completely processed (state becomes ACTIVE). while not myfile.state or myfile.state.name != "ACTIVE":     print("Processing video...")     print("File state:", myfile.state)     time.sleep(5)     myfile = client.files.get(name=myfile.name)  response = client.models.generate_content(     model="gemini-2.0-flash", contents=[myfile, "Describe this video clip"] ) print(f"{response.text=}")
text_generation.py

// Make sure to include the following import: // import {GoogleGenAI} from '@google/genai'; const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });  let video = await ai.files.upload({   file: path.join(media, 'Big_Buck_Bunny.mp4'), });  // Poll until the video file is completely processed (state becomes ACTIVE). while (!video.state || video.state.toString() !== 'ACTIVE') {   console.log('Processing video...');   console.log('File state: ', video.state);   await sleep(5000);   video = await ai.files.get({name: video.name}); }  const response = await ai.models.generateContent({   model: "gemini-2.0-flash",   contents: [     createUserContent([       "Describe this video clip",       createPartFromUri(video.uri, video.mimeType),     ]),   ], }); console.log(response.text);
text_generation.js

ctx := context.Background() client, err := genai.NewClient(ctx, &genai.ClientConfig{ 	APIKey:  os.Getenv("GEMINI_API_KEY"), 	Backend: genai.BackendGeminiAPI, }) if err != nil { 	log.Fatal(err) }  file, err := client.Files.UploadFromPath( 	ctx,  	filepath.Join(getMedia(), "Big_Buck_Bunny.mp4"),  	&genai.UploadFileConfig{ 		MIMEType : "video/mp4", 	}, ) if err != nil { 	log.Fatal(err) }  // Poll until the video file is completely processed (state becomes ACTIVE). for file.State == genai.FileStateUnspecified || file.State != genai.FileStateActive { 	fmt.Println("Processing video...") 	fmt.Println("File state:", file.State) 	time.Sleep(5 * time.Second)  	file, err = client.Files.Get(ctx, file.Name, nil) 	if err != nil { 		log.Fatal(err) 	} }  parts := []*genai.Part{ 	genai.NewPartFromText("Describe this video clip"), 	genai.NewPartFromURI(file.URI, file.MIMEType), }  contents := []*genai.Content{ 	genai.NewContentFromParts(parts, genai.RoleUser), }  response, err := client.Models.GenerateContent(ctx, "gemini-2.0-flash", contents, nil) if err != nil { 	log.Fatal(err) } printResponse(response)
text_generation.go

# Use File API to upload audio data to API request. MIME_TYPE=$(file -b --mime-type "${VIDEO_PATH}") NUM_BYTES=$(wc -c < "${VIDEO_PATH}") DISPLAY_NAME=VIDEO  # Initial resumable request defining metadata. # The upload url is in the response headers dump them to a file. curl "${BASE_URL}/upload/v1beta/files?key=${GEMINI_API_KEY}" \   -D "${tmp_header_file}" \   -H "X-Goog-Upload-Protocol: resumable" \   -H "X-Goog-Upload-Command: start" \   -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \   -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \   -H "Content-Type: application/json" \   -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null  upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r") rm "${tmp_header_file}"  # Upload the actual bytes. curl "${upload_url}" \   -H "Content-Length: ${NUM_BYTES}" \   -H "X-Goog-Upload-Offset: 0" \   -H "X-Goog-Upload-Command: upload, finalize" \   --data-binary "@${VIDEO_PATH}" 2> /dev/null > file_info.json  file_uri=$(jq ".file.uri" file_info.json) echo file_uri=$file_uri  state=$(jq ".file.state" file_info.json) echo state=$state  name=$(jq ".file.name" file_info.json) echo name=$name  while [[ "($state)" = *"PROCESSING"* ]]; do   echo "Processing video..."   sleep 5   # Get the file of interest to check state   curl https://generativelanguage.googleapis.com/v1beta/files/$name > file_info.json   state=$(jq ".file.state" file_info.json) done  curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \     -H 'Content-Type: application/json' \     -X POST \     -d '{       "contents": [{         "parts":[           {"text": "Transcribe the audio from this video, giving timestamps for salient events in the video. Also provide visual descriptions."},           {"file_data":{"mime_type": "video/mp4", "file_uri": '$file_uri'}}]         }]        }' 2> /dev/null > response.json  cat response.json echo  jq ".candidates[].content.parts[].text" response.json
text_generation.sh

from google import genai  client = genai.Client() sample_pdf = client.files.upload(file=media / "test.pdf") response = client.models.generate_content(     model="gemini-2.0-flash",     contents=["Give me a summary of this document:", sample_pdf], ) print(f"{response.text=}")
text_generation.py

ctx := context.Background() client, err := genai.NewClient(ctx, &genai.ClientConfig{ 	APIKey:  os.Getenv("GEMINI_API_KEY"), 	Backend: genai.BackendGeminiAPI, }) if err != nil { 	log.Fatal(err) }  file, err := client.Files.UploadFromPath( 	ctx,  	filepath.Join(getMedia(), "test.pdf"),  	&genai.UploadFileConfig{ 		MIMEType : "application/pdf", 	}, ) if err != nil { 	log.Fatal(err) }  parts := []*genai.Part{ 	genai.NewPartFromText("Give me a summary of this document:"), 	genai.NewPartFromURI(file.URI, file.MIMEType), }  contents := []*genai.Content{ 	genai.NewContentFromParts(parts, genai.RoleUser), }  response, err := client.Models.GenerateContent(ctx, "gemini-2.0-flash", contents, nil) if err != nil { 	log.Fatal(err) } printResponse(response)
text_generation.go

MIME_TYPE=$(file -b --mime-type "${PDF_PATH}") NUM_BYTES=$(wc -c < "${PDF_PATH}") DISPLAY_NAME=TEXT   echo $MIME_TYPE tmp_header_file=upload-header.tmp  # Initial resumable request defining metadata. # The upload url is in the response headers dump them to a file. curl "${BASE_URL}/upload/v1beta/files?key=${GEMINI_API_KEY}" \   -D upload-header.tmp \   -H "X-Goog-Upload-Protocol: resumable" \   -H "X-Goog-Upload-Command: start" \   -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \   -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \   -H "Content-Type: application/json" \   -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null  upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r") rm "${tmp_header_file}"  # Upload the actual bytes. curl "${upload_url}" \   -H "Content-Length: ${NUM_BYTES}" \   -H "X-Goog-Upload-Offset: 0" \   -H "X-Goog-Upload-Command: upload, finalize" \   --data-binary "@${PDF_PATH}" 2> /dev/null > file_info.json  file_uri=$(jq ".file.uri" file_info.json) echo file_uri=$file_uri  # Now generate content using that file curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \     -H 'Content-Type: application/json' \     -X POST \     -d '{       "contents": [{         "parts":[           {"text": "Can you add a few more lines to this poem?"},           {"file_data":{"mime_type": "application/pdf", "file_uri": '$file_uri'}}]         }]        }' 2> /dev/null > response.json  cat response.json echo  jq ".candidates[].content.parts[].text" response.json
text_generation.sh

from google import genai from google.genai import types  client = genai.Client() # Pass initial history using the "history" argument chat = client.chats.create(     model="gemini-2.0-flash",     history=[         types.Content(role="user", parts=[types.Part(text="Hello")]),         types.Content(             role="model",             parts=[                 types.Part(                     text="Great to meet you. What would you like to know?"                 )             ],         ),     ], ) response = chat.send_message(message="I have 2 dogs in my house.") print(response.text) response = chat.send_message(message="How many paws are in my house?") print(response.text)
chat.py

// Make sure to include the following import: // import {GoogleGenAI} from '@google/genai'; const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY }); const chat = ai.chats.create({   model: "gemini-2.0-flash",   history: [     {       role: "user",       parts: [{ text: "Hello" }],     },     {       role: "model",       parts: [{ text: "Great to meet you. What would you like to know?" }],     },   ], });  const response1 = await chat.sendMessage({   message: "I have 2 dogs in my house.", }); console.log("Chat response 1:", response1.text);  const response2 = await chat.sendMessage({   message: "How many paws are in my house?", }); console.log("Chat response 2:", response2.text);
chat.js

ctx := context.Background() client, err := genai.NewClient(ctx, &genai.ClientConfig{ 	APIKey:  os.Getenv("GEMINI_API_KEY"), 	Backend: genai.BackendGeminiAPI, }) if err != nil { 	log.Fatal(err) }  // Pass initial history using the History field. history := []*genai.Content{ 	genai.NewContentFromText("Hello", genai.RoleUser), 	genai.NewContentFromText("Great to meet you. What would you like to know?", genai.RoleModel), }  chat, err := client.Chats.Create(ctx, "gemini-2.0-flash", nil, history) if err != nil { 	log.Fatal(err) }  firstResp, err := chat.SendMessage(ctx, genai.Part{Text: "I have 2 dogs in my house."}) if err != nil { 	log.Fatal(err) } fmt.Println(firstResp.Text())  secondResp, err := chat.SendMessage(ctx, genai.Part{Text: "How many paws are in my house?"}) if err != nil { 	log.Fatal(err) } fmt.Println(secondResp.Text())
chat.go

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY \     -H 'Content-Type: application/json' \     -X POST \     -d '{       "contents": [         {"role":"user",          "parts":[{            "text": "Hello"}]},         {"role": "model",          "parts":[{            "text": "Great to meet you. What would you like to know?"}]},         {"role":"user",          "parts":[{            "text": "I have two dogs in my house. How many paws are in my house?"}]},       ]     }' 2> /dev/null | grep "text"
chat.sh

Client client = new Client();  Content userContent = Content.fromParts(Part.fromText("Hello")); Content modelContent =         Content.builder()                 .role("model")                 .parts(                         Collections.singletonList(                                 Part.fromText("Great to meet you. What would you like to know?")                         )                 ).build();  Chat chat = client.chats.create(         "gemini-2.0-flash",         GenerateContentConfig.builder()                 .systemInstruction(userContent)                 .systemInstruction(modelContent)                 .build() );  GenerateContentResponse response1 = chat.sendMessage("I have 2 dogs in my house."); System.out.println(response1.text());  GenerateContentResponse response2 = chat.sendMessage("How many paws are in my house?"); System.out.println(response2.text()); 
ChatSession.java

from google import genai from google.genai import types  client = genai.Client() document = client.files.upload(file=media / "a11.txt") model_name = "gemini-1.5-flash-001"  cache = client.caches.create(     model=model_name,     config=types.CreateCachedContentConfig(         contents=[document],         system_instruction="You are an expert analyzing transcripts.",     ), ) print(cache)  response = client.models.generate_content(     model=model_name,     contents="Please summarize this transcript",     config=types.GenerateContentConfig(cached_content=cache.name), ) print(response.text)
cache.py

// Make sure to include the following import: // import {GoogleGenAI} from '@google/genai'; const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY }); const filePath = path.join(media, "a11.txt"); const document = await ai.files.upload({   file: filePath,   config: { mimeType: "text/plain" }, }); console.log("Uploaded file name:", document.name); const modelName = "gemini-1.5-flash-001";  const contents = [   createUserContent(createPartFromUri(document.uri, document.mimeType)), ];  const cache = await ai.caches.create({   model: modelName,   config: {     contents: contents,     systemInstruction: "You are an expert analyzing transcripts.",   }, }); console.log("Cache created:", cache);  const response = await ai.models.generateContent({   model: modelName,   contents: "Please summarize this transcript",   config: { cachedContent: cache.name }, }); console.log("Response text:", response.text);
cache.js

ctx := context.Background() client, err := genai.NewClient(ctx, &genai.ClientConfig{ 	APIKey:  os.Getenv("GEMINI_API_KEY"),  	Backend: genai.BackendGeminiAPI, }) if err != nil { 	log.Fatal(err) }  modelName := "gemini-1.5-flash-001" document, err := client.Files.UploadFromPath( 	ctx,  	filepath.Join(getMedia(), "a11.txt"),  	&genai.UploadFileConfig{ 		MIMEType : "text/plain", 	}, ) if err != nil { 	log.Fatal(err) } parts := []*genai.Part{ 	genai.NewPartFromURI(document.URI, document.MIMEType), } contents := []*genai.Content{ 	genai.NewContentFromParts(parts, genai.RoleUser), } cache, err := client.Caches.Create(ctx, modelName, &genai.CreateCachedContentConfig{ 	Contents: contents, 	SystemInstruction: genai.NewContentFromText( 		"You are an expert analyzing transcripts.", genai.RoleUser, 	), }) if err != nil { 	log.Fatal(err) } fmt.Println("Cache created:") fmt.Println(cache)  // Use the cache for generating content. response, err := client.Models.GenerateContent( 	ctx, 	modelName, 	genai.Text("Please summarize this transcript"), 	&genai.GenerateContentConfig{ 		CachedContent: cache.Name, 	}, ) if err != nil { 	log.Fatal(err) } printResponse(response)
cache.go

# With Gemini 2 we're launching a new SDK. See the following doc for details. # https://ai.google.dev/gemini-api/docs/migrate
README.md

from google import genai from google.genai import types from typing_extensions import TypedDict  class Recipe(TypedDict):     recipe_name: str     ingredients: list[str]  client = genai.Client() result = client.models.generate_content(     model="gemini-2.0-flash",     contents="List a few popular cookie recipes.",     config=types.GenerateContentConfig(         response_mime_type="application/json", response_schema=list[Recipe]     ), ) print(result)
controlled_generation.py

// Make sure to include the following import: // import {GoogleGenAI} from '@google/genai'; const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY }); const response = await ai.models.generateContent({   model: "gemini-2.0-flash",   contents: "List a few popular cookie recipes.",   config: {     responseMimeType: "application/json",     responseSchema: {       type: "array",       items: {         type: "object",         properties: {           recipeName: { type: "string" },           ingredients: { type: "array", items: { type: "string" } },         },         required: ["recipeName", "ingredients"],       },     },   }, }); console.log(response.text);
controlled_generation.js

ctx := context.Background() client, err := genai.NewClient(ctx, &genai.ClientConfig{ 	APIKey:  os.Getenv("GEMINI_API_KEY"),  	Backend: genai.BackendGeminiAPI, }) if err != nil { 	log.Fatal(err) }  schema := &genai.Schema{ 	Type: genai.TypeArray, 	Items: &genai.Schema{ 		Type: genai.TypeObject, 		Properties: map[string]*genai.Schema{ 			"recipe_name": {Type: genai.TypeString}, 			"ingredients": { 				Type:  genai.TypeArray, 				Items: &genai.Schema{Type: genai.TypeString}, 			}, 		}, 		Required: []string{"recipe_name"}, 	}, }  config := &genai.GenerateContentConfig{ 	ResponseMIMEType: "application/json", 	ResponseSchema:   schema, }  response, err := client.Models.GenerateContent( 	ctx, 	"gemini-2.0-flash", 	genai.Text("List a few popular cookie recipes."), 	config, ) if err != nil { 	log.Fatal(err) } printResponse(response)
controlled_generation.go

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \ -H 'Content-Type: application/json' \ -d '{     "contents": [{       "parts":[         {"text": "List 5 popular cookie recipes"}         ]     }],     "generationConfig": {         "response_mime_type": "application/json",         "response_schema": {           "type": "ARRAY",           "items": {             "type": "OBJECT",             "properties": {               "recipe_name": {"type":"STRING"},             }           }         }     } }' 2> /dev/null | head
controlled_generation.sh

Client client = new Client();  Schema recipeSchema = Schema.builder()         .type(Array.class.getSimpleName())         .items(Schema.builder()                 .type(Object.class.getSimpleName())                 .properties(                         Map.of("recipe_name", Schema.builder()                                         .type(String.class.getSimpleName())                                         .build(),                                 "ingredients", Schema.builder()                                         .type(Array.class.getSimpleName())                                         .items(Schema.builder()                                                 .type(String.class.getSimpleName())                                                 .build())                                         .build())                 )                 .required(List.of("recipe_name", "ingredients"))                 .build())         .build();  GenerateContentConfig config =         GenerateContentConfig.builder()                 .responseMimeType("application/json")                 .responseSchema(recipeSchema)                 .build();  GenerateContentResponse response =         client.models.generateContent(                 "gemini-2.0-flash",                 "List a few popular cookie recipes.",                 config);  System.out.println(response.text());
ControlledGeneration.java

from google import genai from google.genai import types  client = genai.Client() response = client.models.generate_content(     model="gemini-2.0-pro-exp-02-05",     contents=(         "Write and execute code that calculates the sum of the first 50 prime numbers. "         "Ensure that only the executable code and its resulting output are generated."     ), ) # Each part may contain text, executable code, or an execution result. for part in response.candidates[0].content.parts:     print(part, "\n")  print("-" * 80) # The .text accessor concatenates the parts into a markdown-formatted text. print("\n", response.text)
code_execution.py

ctx := context.Background() client, err := genai.NewClient(ctx, &genai.ClientConfig{ 	APIKey:  os.Getenv("GEMINI_API_KEY"), 	Backend: genai.BackendGeminiAPI, }) if err != nil { 	log.Fatal(err) }  response, err := client.Models.GenerateContent( 	ctx, 	"gemini-2.0-pro-exp-02-05", 	genai.Text( 		`Write and execute code that calculates the sum of the first 50 prime numbers. 		 Ensure that only the executable code and its resulting output are generated.`, 	), 	&genai.GenerateContentConfig{}, ) if err != nil { 	log.Fatal(err) }  // Print the response. printResponse(response)  fmt.Println("--------------------------------------------------------------------------------") fmt.Println(response.Text())
code_execution.go

Client client = new Client();  String prompt = """         Write and execute code that calculates the sum of the first 50 prime numbers.         Ensure that only the executable code and its resulting output are generated.         """;  GenerateContentResponse response =         client.models.generateContent(                 "gemini-2.0-pro-exp-02-05",                 prompt,                 null);  for (Part part : response.candidates().get().getFirst().content().get().parts().get()) {     System.out.println(part + "\n"); }  System.out.println("-".repeat(80)); System.out.println(response.text());
CodeExecution.java

from google import genai from google.genai import types  client = genai.Client()  def add(a: float, b: float) -> float:     """returns a + b."""     return a + b  def subtract(a: float, b: float) -> float:     """returns a - b."""     return a - b  def multiply(a: float, b: float) -> float:     """returns a * b."""     return a * b  def divide(a: float, b: float) -> float:     """returns a / b."""     return a / b  # Create a chat session; function calling (via tools) is enabled in the config. chat = client.chats.create(     model="gemini-2.0-flash",     config=types.GenerateContentConfig(tools=[add, subtract, multiply, divide]), ) response = chat.send_message(     message="I have 57 cats, each owns 44 mittens, how many mittens is that in total?" ) print(response.text)
function_calling.py

ctx := context.Background() client, err := genai.NewClient(ctx, &genai.ClientConfig{ 	APIKey:  os.Getenv("GEMINI_API_KEY"), 	Backend: genai.BackendGeminiAPI, }) if err != nil { 	log.Fatal(err) } modelName := "gemini-2.0-flash"  // Create the function declarations for arithmetic operations. addDeclaration := createArithmeticToolDeclaration("addNumbers", "Return the result of adding two numbers.") subtractDeclaration := createArithmeticToolDeclaration("subtractNumbers", "Return the result of subtracting the second number from the first.") multiplyDeclaration := createArithmeticToolDeclaration("multiplyNumbers", "Return the product of two numbers.") divideDeclaration := createArithmeticToolDeclaration("divideNumbers", "Return the quotient of dividing the first number by the second.")  // Group the function declarations as a tool. tools := []*genai.Tool{ 	{ 		FunctionDeclarations: []*genai.FunctionDeclaration{ 			addDeclaration, 			subtractDeclaration, 			multiplyDeclaration, 			divideDeclaration, 		}, 	}, }  // Create the content prompt. contents := []*genai.Content{ 	genai.NewContentFromText( 		"I have 57 cats, each owns 44 mittens, how many mittens is that in total?", genai.RoleUser, 	), }  // Set up the generate content configuration with function calling enabled. config := &genai.GenerateContentConfig{ 	Tools: tools, 	ToolConfig: &genai.ToolConfig{ 		FunctionCallingConfig: &genai.FunctionCallingConfig{ 			// The mode equivalent to FunctionCallingConfigMode.ANY in JS. 			Mode: genai.FunctionCallingConfigModeAny, 		}, 	}, }  genContentResp, err := client.Models.GenerateContent(ctx, modelName, contents, config) if err != nil { 	log.Fatal(err) }  // Assume the response includes a list of function calls. if len(genContentResp.FunctionCalls()) == 0 { 	log.Println("No function call returned from the AI.") 	return nil } functionCall := genContentResp.FunctionCalls()[0] log.Printf("Function call: %+v\n", functionCall)  // Marshal the Args map into JSON bytes. argsMap, err := json.Marshal(functionCall.Args) if err != nil { 	log.Fatal(err) }  // Unmarshal the JSON bytes into the ArithmeticArgs struct. var args ArithmeticArgs if err := json.Unmarshal(argsMap, &args); err != nil { 	log.Fatal(err) }  // Map the function name to the actual arithmetic function. var result float64 switch functionCall.Name { 	case "addNumbers": 		result = add(args.FirstParam, args.SecondParam) 	case "subtractNumbers": 		result = subtract(args.FirstParam, args.SecondParam) 	case "multiplyNumbers": 		result = multiply(args.FirstParam, args.SecondParam) 	case "divideNumbers": 		result = divide(args.FirstParam, args.SecondParam) 	default: 		return fmt.Errorf("unimplemented function: %s", functionCall.Name) } log.Printf("Function result: %v\n", result)  // Prepare the final result message as content. resultContents := []*genai.Content{ 	genai.NewContentFromText("The final result is " + fmt.Sprintf("%v", result), genai.RoleUser), }  // Use GenerateContent to send the final result. finalResponse, err := client.Models.GenerateContent(ctx, modelName, resultContents, &genai.GenerateContentConfig{}) if err != nil { 	log.Fatal(err) }  printResponse(finalResponse)
function_calling.go

  // Make sure to include the following import:   // import {GoogleGenAI} from '@google/genai';   const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });    /**    * The add function returns the sum of two numbers.    * @param {number} a    * @param {number} b    * @returns {number}    */   function add(a, b) {     return a + b;   }    /**    * The subtract function returns the difference (a - b).    * @param {number} a    * @param {number} b    * @returns {number}    */   function subtract(a, b) {     return a - b;   }    /**    * The multiply function returns the product of two numbers.    * @param {number} a    * @param {number} b    * @returns {number}    */   function multiply(a, b) {     return a * b;   }    /**    * The divide function returns the quotient of a divided by b.    * @param {number} a    * @param {number} b    * @returns {number}    */   function divide(a, b) {     return a / b;   }    const addDeclaration = {     name: "addNumbers",     parameters: {       type: "object",       description: "Return the result of adding two numbers.",       properties: {         firstParam: {           type: "number",           description:             "The first parameter which can be an integer or a floating point number.",         },         secondParam: {           type: "number",           description:             "The second parameter which can be an integer or a floating point number.",         },       },       required: ["firstParam", "secondParam"],     },   };    const subtractDeclaration = {     name: "subtractNumbers",     parameters: {       type: "object",       description:         "Return the result of subtracting the second number from the first.",       properties: {         firstParam: {           type: "number",           description: "The first parameter.",         },         secondParam: {           type: "number",           description: "The second parameter.",         },       },       required: ["firstParam", "secondParam"],     },   };    const multiplyDeclaration = {     name: "multiplyNumbers",     parameters: {       type: "object",       description: "Return the product of two numbers.",       properties: {         firstParam: {           type: "number",           description: "The first parameter.",         },         secondParam: {           type: "number",           description: "The second parameter.",         },       },       required: ["firstParam", "secondParam"],     },   };    const divideDeclaration = {     name: "divideNumbers",     parameters: {       type: "object",       description:         "Return the quotient of dividing the first number by the second.",       properties: {         firstParam: {           type: "number",           description: "The first parameter.",         },         secondParam: {           type: "number",           description: "The second parameter.",         },       },       required: ["firstParam", "secondParam"],     },   };    // Step 1: Call generateContent with function calling enabled.   const generateContentResponse = await ai.models.generateContent({     model: "gemini-2.0-flash",     contents:       "I have 57 cats, each owns 44 mittens, how many mittens is that in total?",     config: {       toolConfig: {         functionCallingConfig: {           mode: FunctionCallingConfigMode.ANY,         },       },       tools: [         {           functionDeclarations: [             addDeclaration,             subtractDeclaration,             multiplyDeclaration,             divideDeclaration,           ],         },       ],     },   });    // Step 2: Extract the function call.(   // Assuming the response contains a 'functionCalls' array.   const functionCall =     generateContentResponse.functionCalls &&     generateContentResponse.functionCalls[0];   console.log(functionCall);    // Parse the arguments.   const args = functionCall.args;   // Expected args format: { firstParam: number, secondParam: number }    // Step 3: Invoke the actual function based on the function name.   const functionMapping = {     addNumbers: add,     subtractNumbers: subtract,     multiplyNumbers: multiply,     divideNumbers: divide,   };   const func = functionMapping[functionCall.name];   if (!func) {     console.error("Unimplemented error:", functionCall.name);     return generateContentResponse;   }   const resultValue = func(args.firstParam, args.secondParam);   console.log("Function result:", resultValue);    // Step 4: Use the chat API to send the result as the final answer.   const chat = ai.chats.create({ model: "gemini-2.0-flash" });   const chatResponse = await chat.sendMessage({     message: "The final result is " + resultValue,   });   console.log(chatResponse.text);   return chatResponse; } 
function_calling.js

 cat > tools.json << EOF {   "function_declarations": [     {       "name": "enable_lights",       "description": "Turn on the lighting system."     },     {       "name": "set_light_color",       "description": "Set the light color. Lights must be enabled for this to work.",       "parameters": {         "type": "object",         "properties": {           "rgb_hex": {             "type": "string",             "description": "The light color as a 6-digit hex string, e.g. ff0000 for red."           }         },         "required": [           "rgb_hex"         ]       }     },     {       "name": "stop_lights",       "description": "Turn off the lighting system."     }   ] }  EOF  curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \   -H 'Content-Type: application/json' \   -d @<(echo '   {     "system_instruction": {       "parts": {         "text": "You are a helpful lighting system bot. You can turn lights on and off, and you can set the color. Do not perform any other tasks."       }     },     "tools": ['$(cat tools.json)'],      "tool_config": {       "function_calling_config": {"mode": "auto"}     },      "contents": {       "role": "user",       "parts": {         "text": "Turn on the lights please."       }     }   } ') 2>/dev/null |sed -n '/"content"/,/"finishReason"/p'
function_calling.sh

Client client = new Client();  FunctionDeclaration addFunction =         FunctionDeclaration.builder()                 .name("addNumbers")                 .parameters(                         Schema.builder()                                 .type("object")                                 .properties(Map.of(                                         "firstParam", Schema.builder().type("number").description("First number").build(),                                         "secondParam", Schema.builder().type("number").description("Second number").build()))                                 .required(Arrays.asList("firstParam", "secondParam"))                                 .build())                 .build();  FunctionDeclaration subtractFunction =         FunctionDeclaration.builder()                 .name("subtractNumbers")                 .parameters(                         Schema.builder()                                 .type("object")                                 .properties(Map.of(                                         "firstParam", Schema.builder().type("number").description("First number").build(),                                         "secondParam", Schema.builder().type("number").description("Second number").build()))                                 .required(Arrays.asList("firstParam", "secondParam"))                                 .build())                 .build();  FunctionDeclaration multiplyFunction =         FunctionDeclaration.builder()                 .name("multiplyNumbers")                 .parameters(                         Schema.builder()                                 .type("object")                                 .properties(Map.of(                                         "firstParam", Schema.builder().type("number").description("First number").build(),                                         "secondParam", Schema.builder().type("number").description("Second number").build()))                                 .required(Arrays.asList("firstParam", "secondParam"))                                 .build())                 .build();  FunctionDeclaration divideFunction =         FunctionDeclaration.builder()                 .name("divideNumbers")                 .parameters(                         Schema.builder()                                 .type("object")                                 .properties(Map.of(                                         "firstParam", Schema.builder().type("number").description("First number").build(),                                         "secondParam", Schema.builder().type("number").description("Second number").build()))                                 .required(Arrays.asList("firstParam", "secondParam"))                                 .build())                 .build();  GenerateContentConfig config = GenerateContentConfig.builder()         .toolConfig(ToolConfig.builder().functionCallingConfig(                 FunctionCallingConfig.builder().mode("ANY").build()         ).build())         .tools(                 Collections.singletonList(                         Tool.builder().functionDeclarations(                                 Arrays.asList(                                         addFunction,                                         subtractFunction,                                         divideFunction,                                         multiplyFunction                                 )                         ).build()                  )         )         .build();  GenerateContentResponse response =         client.models.generateContent(                 "gemini-2.0-flash",                 "I have 57 cats, each owns 44 mittens, how many mittens is that in total?",                 config);   if (response.functionCalls() == null || response.functionCalls().isEmpty()) {     System.err.println("No function call received");     return null; }  var functionCall = response.functionCalls().getFirst(); String functionName = functionCall.name().get(); var arguments = functionCall.args();  Map<String, BiFunction<Double, Double, Double>> functionMapping = new HashMap<>(); functionMapping.put("addNumbers", (a, b) -> a + b); functionMapping.put("subtractNumbers", (a, b) -> a - b); functionMapping.put("multiplyNumbers", (a, b) -> a * b); functionMapping.put("divideNumbers", (a, b) -> b != 0 ? a / b : Double.NaN);  BiFunction<Double, Double, Double> function = functionMapping.get(functionName);  Number firstParam = (Number) arguments.get().get("firstParam"); Number secondParam = (Number) arguments.get().get("secondParam"); Double result = function.apply(firstParam.doubleValue(), secondParam.doubleValue());  System.out.println(result);
FunctionCalling.java