API-ja Gemini Batch është projektuar për të përpunuar vëllime të mëdha kërkesash në mënyrë asinkrone me 50% të kostos standarde . Koha e synuar e përpunimit është 24 orë, por në shumicën e rasteve, është shumë më e shpejtë.
Përdorni Batch API për detyra në shkallë të gjerë, jo-urgjente, të tilla si përpunimi paraprak i të dhënave ose ekzekutimi i vlerësimeve ku nuk kërkohet një përgjigje e menjëhershme.
Krijimi i një pune në grup
Ju keni dy mënyra për të paraqitur kërkesat tuaja në Batch API:
- Kërkesat në linjë : Një listë e objekteve
GenerateContentRequesttë përfshira direkt në kërkesën tuaj të krijimit të grupeve. Kjo është e përshtatshme për grupe më të vogla që e mbajnë madhësinë totale të kërkesës nën 20MB. Rezultati i kthyer nga modeli është një listë e objekteveinlineResponse. - Skedari hyrës : Një skedar JSON Lines (JSONL) ku çdo rresht përmban një objekt të plotë
GenerateContentRequest. Kjo metodë rekomandohet për kërkesa më të mëdha. Rezultati i kthyer nga modeli është një skedar JSONL ku çdo rresht është ose njëGenerateContentResponseose një objekt statusi.
Kërkesat brenda linjës
Për një numër të vogël kërkesash, mund të ngulitni drejtpërdrejt objektet GenerateContentRequest brenda BatchGenerateContentRequest tuaj. Shembulli i mëposhtëm thërret metodën BatchGenerateContent me kërkesa të integruara:
Python
from google import genai
from google.genai import types
client = genai.Client()
# A list of dictionaries, where each is a GenerateContentRequest
inline_requests = [
{
'contents': [{
'parts': [{'text': 'Tell me a one-sentence joke.'}],
'role': 'user'
}]
},
{
'contents': [{
'parts': [{'text': 'Why is the sky blue?'}],
'role': 'user'
}]
}
]
inline_batch_job = client.batches.create(
model="models/gemini-2.5-flash",
src=inline_requests,
config={
'display_name': "inlined-requests-job-1",
},
)
print(f"Created batch job: {inline_batch_job.name}")
JavaScript
import {GoogleGenAI} from '@google/genai';
const GEMINI_API_KEY = process.env.GEMINI_API_KEY;
const ai = new GoogleGenAI({apiKey: GEMINI_API_KEY});
const inlinedRequests = [
{
contents: [{
parts: [{text: 'Tell me a one-sentence joke.'}],
role: 'user'
}]
},
{
contents: [{
parts: [{'text': 'Why is the sky blue?'}],
role: 'user'
}]
}
]
const response = await ai.batches.create({
model: 'gemini-2.5-flash',
src: inlinedRequests,
config: {
displayName: 'inlined-requests-job-1',
}
});
console.log(response);
PUSHTIM
curl https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:batchGenerateContent \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-X POST \
-H "Content-Type:application/json" \
-d '{
"batch": {
"display_name": "my-batch-requests",
"input_config": {
"requests": {
"requests": [
{
"request": {"contents": [{"parts": [{"text": "Describe the process of photosynthesis."}]}]},
"metadata": {
"key": "request-1"
}
},
{
"request": {"contents": [{"parts": [{"text": "Describe the process of photosynthesis."}]}]},
"metadata": {
"key": "request-2"
}
}
]
}
}
}
}'
Skedari i hyrjes
Për grupe më të mëdha kërkesash, përgatitni një skedar JSON Lines (JSONL). Çdo rresht në këtë skedar duhet të jetë një objekt JSON që përmban një çelës të përcaktuar nga përdoruesi dhe një objekt kërkese, ku kërkesa është një objekt i vlefshëm GenerateContentRequest . Çelësi i përcaktuar nga përdoruesi përdoret në përgjigje për të treguar se cili rezultat është rezultati i cilës kërkesë. Për shembull, kërkesa me çelësin e përcaktuar si request-1 do ta ketë përgjigjen e saj të shënuar me të njëjtin emër çelësi.
Ky skedar është ngarkuar duke përdorur API-n e Skedarëve . Madhësia maksimale e lejuar e skedarit për një skedar hyrës është 2 GB.
Më poshtë është një shembull i një skedari JSONL. Mund ta ruani në një skedar të quajtur my-batch-requests.json :
{"key": "request-1", "request": {"contents": [{"parts": [{"text": "Describe the process of photosynthesis."}]}], "generation_config": {"temperature": 0.7}}}
{"key": "request-2", "request": {"contents": [{"parts": [{"text": "What are the main ingredients in a Margherita pizza?"}]}]}}
Ngjashëm me kërkesat brenda linjës, mund të specifikoni parametra të tjerë si udhëzimet e sistemit, mjetet ose konfigurime të tjera në secilin JSON të kërkesës.
Mund ta ngarkoni këtë skedar duke përdorur File API siç tregohet në shembullin e mëposhtëm. Nëse po punoni me të dhëna multimodale, mund t'i referoheni skedarëve të tjerë të ngarkuar brenda skedarit tuaj JSONL.
Python
import json
from google import genai
from google.genai import types
client = genai.Client()
# Create a sample JSONL file
with open("my-batch-requests.jsonl", "w") as f:
requests = [
{"key": "request-1", "request": {"contents": [{"parts": [{"text": "Describe the process of photosynthesis."}]}]}},
{"key": "request-2", "request": {"contents": [{"parts": [{"text": "What are the main ingredients in a Margherita pizza?"}]}]}}
]
for req in requests:
f.write(json.dumps(req) + "\n")
# Upload the file to the File API
uploaded_file = client.files.upload(
file='my-batch-requests.jsonl',
config=types.UploadFileConfig(display_name='my-batch-requests', mime_type='jsonl')
)
print(f"Uploaded file: {uploaded_file.name}")
JavaScript
import {GoogleGenAI} from '@google/genai';
import * as fs from "fs";
import * as path from "path";
import { fileURLToPath } from 'url';
const GEMINI_API_KEY = process.env.GEMINI_API_KEY;
const ai = new GoogleGenAI({apiKey: GEMINI_API_KEY});
const fileName = "my-batch-requests.jsonl";
// Define the requests
const requests = [
{ "key": "request-1", "request": { "contents": [{ "parts": [{ "text": "Describe the process of photosynthesis." }] }] } },
{ "key": "request-2", "request": { "contents": [{ "parts": [{ "text": "What are the main ingredients in a Margherita pizza?" }] }] } }
];
// Construct the full path to file
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const filePath = path.join(__dirname, fileName); // __dirname is the directory of the current script
async function writeBatchRequestsToFile(requests, filePath) {
try {
// Use a writable stream for efficiency, especially with larger files.
const writeStream = fs.createWriteStream(filePath, { flags: 'w' });
writeStream.on('error', (err) => {
console.error(`Error writing to file ${filePath}:`, err);
});
for (const req of requests) {
writeStream.write(JSON.stringify(req) + '\n');
}
writeStream.end();
console.log(`Successfully wrote batch requests to ${filePath}`);
} catch (error) {
// This catch block is for errors that might occur before stream setup,
// stream errors are handled by the 'error' event.
console.error(`An unexpected error occurred:`, error);
}
}
// Write to a file.
writeBatchRequestsToFile(requests, filePath);
// Upload the file to the File API.
const uploadedFile = await ai.files.upload({file: 'my-batch-requests.jsonl', config: {
mimeType: 'jsonl',
}});
console.log(uploadedFile.name);
PUSHTIM
tmp_batch_input_file=batch_input.tmp
echo -e '{"contents": [{"parts": [{"text": "Describe the process of photosynthesis."}]}], "generationConfig": {"temperature": 0.7}}\n{"contents": [{"parts": [{"text": "What are the main ingredients in a Margherita pizza?"}]}]}' > batch_input.tmp
MIME_TYPE=$(file -b --mime-type "${tmp_batch_input_file}")
NUM_BYTES=$(wc -c < "${tmp_batch_input_file}")
DISPLAY_NAME=BatchInput
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 "https://generativelanguage.googleapis.com/upload/v1beta/files" \
-D "${tmp_header_file}" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-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/jsonl" \
-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 "@${tmp_batch_input_file}" 2> /dev/null > file_info.json
file_uri=$(jq ".file.uri" file_info.json)
Shembulli i mëposhtëm thërret metodën BatchGenerateContent me skedarin hyrës të ngarkuar duke përdorur File API:
Python
from google import genai
# Assumes `uploaded_file` is the file object from the previous step
client = genai.Client()
file_batch_job = client.batches.create(
model="gemini-2.5-flash",
src=uploaded_file.name,
config={
'display_name': "file-upload-job-1",
},
)
print(f"Created batch job: {file_batch_job.name}")
JavaScript
// Assumes `uploadedFile` is the file object from the previous step
const fileBatchJob = await ai.batches.create({
model: 'gemini-2.5-flash',
src: uploadedFile.name,
config: {
displayName: 'file-upload-job-1',
}
});
console.log(fileBatchJob);
PUSHTIM
# Set the File ID taken from the upload response.
BATCH_INPUT_FILE='files/123456'
curl https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:batchGenerateContent \
-X POST \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H "Content-Type:application/json" \
-d "{
'batch': {
'display_name': 'my-batch-requests',
'input_config': {
'file_name': '${BATCH_INPUT_FILE}'
}
}
}"
Kur krijoni një punë në grup, do t'ju kthehet një emër pune. Përdoreni këtë emër për të monitoruar statusin e punës, si dhe për të marrë rezultatet pasi puna të përfundojë.
Më poshtë është një shembull i një rezultati që përmban një emër pune:
Created batch job from file: batches/123456789
Mbështetje për integrimin në grup
Mund të përdorni Batch API për të bashkëvepruar me modelin Embeddings për rendiment më të lartë. Për të krijuar një punë batch të embeddings me kërkesa të brendshme ose skedarë hyrës , përdorni batches.create_embeddings API dhe specifikoni modelin e embeddings.
Python
from google import genai
client = genai.Client()
# Creating an embeddings batch job with an input file request:
file_job = client.batches.create_embeddings(
model="gemini-embedding-001",
src={'file_name': uploaded_batch_requests.name},
config={'display_name': "Input embeddings batch"},
)
# Creating an embeddings batch job with an inline request:
batch_job = client.batches.create_embeddings(
model="gemini-embedding-001",
# For a predefined list of requests `inlined_requests`
src={'inlined_requests': inlined_requests},
config={'display_name': "Inlined embeddings batch"},
)
JavaScript
// Creating an embeddings batch job with an input file request:
let fileJob;
fileJob = await client.batches.createEmbeddings({
model: 'gemini-embedding-001',
src: {fileName: uploadedBatchRequests.name},
config: {displayName: 'Input embeddings batch'},
});
console.log(`Created batch job: ${fileJob.name}`);
// Creating an embeddings batch job with an inline request:
let batchJob;
batchJob = await client.batches.createEmbeddings({
model: 'gemini-embedding-001',
// For a predefined a list of requests `inlinedRequests`
src: {inlinedRequests: inlinedRequests},
config: {displayName: 'Inlined embeddings batch'},
});
console.log(`Created batch job: ${batchJob.name}`);
Lexoni seksionin Embeddings në librin e gatimit Batch API për më shumë shembuj.
Kërkesë për konfigurim
Mund të përfshini çdo konfigurim kërkese që do të përdornit në një kërkesë standarde jo-grumbulluese. Për shembull, mund të specifikoni temperaturën, udhëzimet e sistemit ose edhe të kaloni në modalitete të tjera. Shembulli i mëposhtëm tregon një shembull kërkese të integruar që përmban një udhëzim sistemi për njërën nga kërkesat:
Python
inline_requests_list = [
{'contents': [{'parts': [{'text': 'Write a short poem about a cloud.'}]}]},
{'contents': [{
'parts': [{
'text': 'Write a short poem about a cat.'
}]
}],
'config': {
'system_instruction': {'parts': [{'text': 'You are a cat. Your name is Neko.'}]}}
}
]
JavaScript
inlineRequestsList = [
{contents: [{parts: [{text: 'Write a short poem about a cloud.'}]}]},
{contents: [{parts: [{text: 'Write a short poem about a cat.'}]}],
config: {systemInstruction: {parts: [{text: 'You are a cat. Your name is Neko.'}]}}}
]
Në mënyrë të ngjashme mund të specifikohen mjetet që do të përdoren për një kërkesë. Shembulli i mëposhtëm tregon një kërkesë që aktivizon mjetin e Kërkimit në Google :
Python
inlined_requests = [
{'contents': [{'parts': [{'text': 'Who won the euro 1998?'}]}]},
{'contents': [{'parts': [{'text': 'Who won the euro 2025?'}]}],
'config':{'tools': [{'google_search': {}}]}}]
JavaScript
inlineRequestsList = [
{contents: [{parts: [{text: 'Who won the euro 1998?'}]}]},
{contents: [{parts: [{text: 'Who won the euro 2025?'}]}],
config: {tools: [{googleSearch: {}}]}}
]
Mund të specifikoni edhe rezultate të strukturuara . Shembulli i mëposhtëm tregon se si të specifikoni për kërkesat tuaja në grup.
Python
import time
from google import genai
from pydantic import BaseModel, TypeAdapter
class Recipe(BaseModel):
recipe_name: str
ingredients: list[str]
client = genai.Client()
# A list of dictionaries, where each is a GenerateContentRequest
inline_requests = [
{
'contents': [{
'parts': [{'text': 'List a few popular cookie recipes, and include the amounts of ingredients.'}],
'role': 'user'
}],
'config': {
'response_mime_type': 'application/json',
'response_schema': list[Recipe]
}
},
{
'contents': [{
'parts': [{'text': 'List a few popular gluten free cookie recipes, and include the amounts of ingredients.'}],
'role': 'user'
}],
'config': {
'response_mime_type': 'application/json',
'response_schema': list[Recipe]
}
}
]
inline_batch_job = client.batches.create(
model="models/gemini-2.5-flash",
src=inline_requests,
config={
'display_name': "structured-output-job-1"
},
)
# wait for the job to finish
job_name = inline_batch_job.name
print(f"Polling status for job: {job_name}")
while True:
batch_job_inline = client.batches.get(name=job_name)
if batch_job_inline.state.name in ('JOB_STATE_SUCCEEDED', 'JOB_STATE_FAILED', 'JOB_STATE_CANCELLED', 'JOB_STATE_EXPIRED'):
break
print(f"Job not finished. Current state: {batch_job_inline.state.name}. Waiting 30 seconds...")
time.sleep(30)
print(f"Job finished with state: {batch_job_inline.state.name}")
# print the response
for i, inline_response in enumerate(batch_job_inline.dest.inlined_responses, start=1):
print(f"\n--- Response {i} ---")
# Check for a successful response
if inline_response.response:
# The .text property is a shortcut to the generated text.
print(inline_response.response.text)
JavaScript
import {GoogleGenAI, Type} from '@google/genai';
const GEMINI_API_KEY = process.env.GEMINI_API_KEY;
const ai = new GoogleGenAI({apiKey: GEMINI_API_KEY});
const inlinedRequests = [
{
contents: [{
parts: [{text: 'List a few popular cookie recipes, and include the amounts of ingredients.'}],
role: 'user'
}],
config: {
responseMimeType: 'application/json',
responseSchema: {
type: Type.ARRAY,
items: {
type: Type.OBJECT,
properties: {
'recipeName': {
type: Type.STRING,
description: 'Name of the recipe',
nullable: false,
},
'ingredients': {
type: Type.ARRAY,
items: {
type: Type.STRING,
description: 'Ingredients of the recipe',
nullable: false,
},
},
},
required: ['recipeName'],
},
},
}
},
{
contents: [{
parts: [{text: 'List a few popular gluten free cookie recipes, and include the amounts of ingredients.'}],
role: 'user'
}],
config: {
responseMimeType: 'application/json',
responseSchema: {
type: Type.ARRAY,
items: {
type: Type.OBJECT,
properties: {
'recipeName': {
type: Type.STRING,
description: 'Name of the recipe',
nullable: false,
},
'ingredients': {
type: Type.ARRAY,
items: {
type: Type.STRING,
description: 'Ingredients of the recipe',
nullable: false,
},
},
},
required: ['recipeName'],
},
},
}
}
]
const inlinedBatchJob = await ai.batches.create({
model: 'gemini-2.5-flash',
src: inlinedRequests,
config: {
displayName: 'inlined-requests-job-1',
}
});
Monitorimi i statusit të punës
Përdorni emrin e operacionit të marrë gjatë krijimit të punës në grup për të vlerësuar statusin e saj. Fusha e gjendjes së punës në grup do të tregojë statusin e saj aktual. Një punë në grup mund të jetë në njërën nga gjendjet e mëposhtme:
-
JOB_STATE_PENDING: Puna është krijuar dhe është në pritje të përpunohet nga shërbimi. -
JOB_STATE_RUNNING: Puna është në vazhdim. -
JOB_STATE_SUCCEEDED: Puna përfundoi me sukses. Tani mund të merrni rezultatet. -
JOB_STATE_FAILED: Puna dështoi. Kontrolloni detajet e gabimit për më shumë informacion. -
JOB_STATE_CANCELLED: Puna u anulua nga përdoruesi. -
JOB_STATE_EXPIRED: Puna ka skaduar sepse ka qenë në ekzekutim ose në pritje për më shumë se 48 orë. Puna nuk do të ketë rezultate për të marrë. Mund të provoni ta dorëzoni përsëri punën ose t'i ndani kërkesat në grupe më të vogla.
Mund ta anketoni statusin e punës periodikisht për të kontrolluar nëse është përfunduar.
Python
import time
from google import genai
client = genai.Client()
# Use the name of the job you want to check
# e.g., inline_batch_job.name from the previous step
job_name = "YOUR_BATCH_JOB_NAME" # (e.g. 'batches/your-batch-id')
batch_job = client.batches.get(name=job_name)
completed_states = set([
'JOB_STATE_SUCCEEDED',
'JOB_STATE_FAILED',
'JOB_STATE_CANCELLED',
'JOB_STATE_EXPIRED',
])
print(f"Polling status for job: {job_name}")
batch_job = client.batches.get(name=job_name) # Initial get
while batch_job.state.name not in completed_states:
print(f"Current state: {batch_job.state.name}")
time.sleep(30) # Wait for 30 seconds before polling again
batch_job = client.batches.get(name=job_name)
print(f"Job finished with state: {batch_job.state.name}")
if batch_job.state.name == 'JOB_STATE_FAILED':
print(f"Error: {batch_job.error}")
JavaScript
// Use the name of the job you want to check
// e.g., inlinedBatchJob.name from the previous step
let batchJob;
const completedStates = new Set([
'JOB_STATE_SUCCEEDED',
'JOB_STATE_FAILED',
'JOB_STATE_CANCELLED',
'JOB_STATE_EXPIRED',
]);
try {
batchJob = await ai.batches.get({name: inlinedBatchJob.name});
while (!completedStates.has(batchJob.state)) {
console.log(`Current state: ${batchJob.state}`);
// Wait for 30 seconds before polling again
await new Promise(resolve => setTimeout(resolve, 30000));
batchJob = await client.batches.get({ name: batchJob.name });
}
console.log(`Job finished with state: ${batchJob.state}`);
if (batchJob.state === 'JOB_STATE_FAILED') {
// The exact structure of `error` might vary depending on the SDK
// This assumes `error` is an object with a `message` property.
console.error(`Error: ${batchJob.state}`);
}
} catch (error) {
console.error(`An error occurred while polling job ${batchJob.name}:`, error);
}
Duke marrë rezultatet
Pasi statusi i punës tregon se puna juaj në grup ka përfunduar me sukses, rezultatet janë të disponueshme në fushën response .
Python
import json
from google import genai
client = genai.Client()
# Use the name of the job you want to check
# e.g., inline_batch_job.name from the previous step
job_name = "YOUR_BATCH_JOB_NAME"
batch_job = client.batches.get(name=job_name)
if batch_job.state.name == 'JOB_STATE_SUCCEEDED':
# If batch job was created with a file
if batch_job.dest and batch_job.dest.file_name:
# Results are in a file
result_file_name = batch_job.dest.file_name
print(f"Results are in file: {result_file_name}")
print("Downloading result file content...")
file_content = client.files.download(file=result_file_name)
# Process file_content (bytes) as needed
print(file_content.decode('utf-8'))
# If batch job was created with inline request
# (for embeddings, use batch_job.dest.inlined_embed_content_responses)
elif batch_job.dest and batch_job.dest.inlined_responses:
# Results are inline
print("Results are inline:")
for i, inline_response in enumerate(batch_job.dest.inlined_responses):
print(f"Response {i+1}:")
if inline_response.response:
# Accessing response, structure may vary.
try:
print(inline_response.response.text)
except AttributeError:
print(inline_response.response) # Fallback
elif inline_response.error:
print(f"Error: {inline_response.error}")
else:
print("No results found (neither file nor inline).")
else:
print(f"Job did not succeed. Final state: {batch_job.state.name}")
if batch_job.error:
print(f"Error: {batch_job.error}")
JavaScript
// Use the name of the job you want to check
// e.g., inlinedBatchJob.name from the previous step
const jobName = "YOUR_BATCH_JOB_NAME";
try {
const batchJob = await ai.batches.get({ name: jobName });
if (batchJob.state === 'JOB_STATE_SUCCEEDED') {
console.log('Found completed batch:', batchJob.displayName);
console.log(batchJob);
// If batch job was created with a file destination
if (batchJob.dest?.fileName) {
const resultFileName = batchJob.dest.fileName;
console.log(`Results are in file: ${resultFileName}`);
console.log("Downloading result file content...");
const fileContentBuffer = await ai.files.download({ file: resultFileName });
// Process fileContentBuffer (Buffer) as needed
console.log(fileContentBuffer.toString('utf-8'));
}
// If batch job was created with inline responses
else if (batchJob.dest?.inlinedResponses) {
console.log("Results are inline:");
for (let i = 0; i < batchJob.dest.inlinedResponses.length; i++) {
const inlineResponse = batchJob.dest.inlinedResponses[i];
console.log(`Response ${i + 1}:`);
if (inlineResponse.response) {
// Accessing response, structure may vary.
if (inlineResponse.response.text !== undefined) {
console.log(inlineResponse.response.text);
} else {
console.log(inlineResponse.response); // Fallback
}
} else if (inlineResponse.error) {
console.error(`Error: ${inlineResponse.error}`);
}
}
}
// If batch job was an embedding batch with inline responses
else if (batchJob.dest?.inlinedEmbedContentResponses) {
console.log("Embedding results found inline:");
for (let i = 0; i < batchJob.dest.inlinedEmbedContentResponses.length; i++) {
const inlineResponse = batchJob.dest.inlinedEmbedContentResponses[i];
console.log(`Response ${i + 1}:`);
if (inlineResponse.response) {
console.log(inlineResponse.response);
} else if (inlineResponse.error) {
console.error(`Error: ${inlineResponse.error}`);
}
}
} else {
console.log("No results found (neither file nor inline).");
}
} else {
console.log(`Job did not succeed. Final state: ${batchJob.state}`);
if (batchJob.error) {
console.error(`Error: ${typeof batchJob.error === 'string' ? batchJob.error : batchJob.error.message || JSON.stringify(batchJob.error)}`);
}
}
} catch (error) {
console.error(`An error occurred while processing job ${jobName}:`, error);
}
PUSHTIM
BATCH_NAME="batches/123456" # Your batch job name
curl https://generativelanguage.googleapis.com/v1beta/$BATCH_NAME \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H "Content-Type:application/json" 2> /dev/null > batch_status.json
if jq -r '.done' batch_status.json | grep -q "false"; then
echo "Batch has not finished processing"
fi
batch_state=$(jq -r '.metadata.state' batch_status.json)
if [[ $batch_state = "JOB_STATE_SUCCEEDED" ]]; then
if [[ $(jq '.response | has("inlinedResponses")' batch_status.json) = "true" ]]; then
jq -r '.response.inlinedResponses' batch_status.json
exit
fi
responses_file_name=$(jq -r '.response.responsesFile' batch_status.json)
curl https://generativelanguage.googleapis.com/download/v1beta/$responses_file_name:download?alt=media \
-H "x-goog-api-key: $GEMINI_API_KEY" 2> /dev/null
elif [[ $batch_state = "JOB_STATE_FAILED" ]]; then
jq '.error' batch_status.json
elif [[ $batch_state == "JOB_STATE_CANCELLED" ]]; then
echo "Batch was cancelled by the user"
elif [[ $batch_state == "JOB_STATE_EXPIRED" ]]; then
echo "Batch expired after 48 hours"
fi
Anulimi i një pune në grup
Mund të anuloni një punë në grup që është në vazhdim duke përdorur emrin e saj. Kur një punë anulohet, ajo ndalon përpunimin e kërkesave të reja.
Python
from google import genai
client = genai.Client()
# Cancel a batch job
client.batches.cancel(name=batch_job_to_cancel.name)
JavaScript
await ai.batches.cancel({name: batchJobToCancel.name});
PUSHTIM
BATCH_NAME="batches/123456" # Your batch job name
# Cancel the batch
curl https://generativelanguage.googleapis.com/v1beta/$BATCH_NAME:cancel \
-H "x-goog-api-key: $GEMINI_API_KEY" \
# Confirm that the status of the batch after cancellation is JOB_STATE_CANCELLED
curl https://generativelanguage.googleapis.com/v1beta/$BATCH_NAME \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H "Content-Type:application/json" 2> /dev/null | jq -r '.metadata.state'
Fshirja e një pune në grup
Mund të fshini një punë ekzistuese në grup duke përdorur emrin e saj. Kur një punë fshihet, ajo ndalon përpunimin e kërkesave të reja dhe hiqet nga lista e punëve në grup.
Python
from google import genai
client = genai.Client()
# Delete a batch job
client.batches.delete(name=batch_job_to_delete.name)
JavaScript
await ai.batches.delete({name: batchJobToDelete.name});
PUSHTIM
BATCH_NAME="batches/123456" # Your batch job name
# Delete the batch job
curl https://generativelanguage.googleapis.com/v1beta/$BATCH_NAME:delete \
-H "x-goog-api-key: $GEMINI_API_KEY"
Detajet teknike
- Modelet e mbështetura: Batch API mbështet një gamë modelesh Gemini. Referojuni faqes Modele për mbështetjen e secilit model për Batch API. Modalitetet e mbështetura për Batch API janë të njëjta me ato që mbështeten në API-në interaktive (ose jo-batch).
- Çmimi: Përdorimi i API-t në grup ka një çmim prej 50% të kostos standarde të API-t interaktiv për modelin ekuivalent. Shihni faqen e çmimeve për detaje. Referojuni faqes së kufijve të tarifave për detaje mbi kufijtë e tarifave për këtë veçori.
- Objektivi i Nivelit të Shërbimit (SLO): Punët në grup janë të dizajnuara për t'u përfunduar brenda një kohe kthimi 24-orësh. Shumë punë mund të përfundojnë shumë më shpejt në varësi të madhësisë së tyre dhe ngarkesës aktuale të sistemit.
- Ruajtja në memorje: Ruajtja në memorje e kontekstit është aktivizuar për kërkesat në grup. Nëse një kërkesë në grupin tuaj rezulton në një goditje në memorje, tokenët e ruajtur në memorje kanë të njëjtin çmim si për trafikun e API-t jo-në-grup.
Praktikat më të mira
- Përdorni skedarë hyrës për kërkesa të mëdha: Për një numër të madh kërkesash, përdorni gjithmonë metodën e hyrjes së skedarit për menaxhueshmëri më të mirë dhe për të shmangur arritjen e kufijve të madhësisë së kërkesës për vetë thirrjen
BatchGenerateContent. Vini re se ekziston një limit prej 2 GB për skedar hyrës. - Trajtimi i gabimeve: Kontrolloni
batchStatspërfailedRequestCountpasi të përfundojë një punë. Nëse përdorni rezultatin e skedarit, analizoni çdo rresht për të kontrolluar nëse është njëGenerateContentResponseose një objekt statusi që tregon një gabim për atë kërkesë specifike. Shihni udhëzuesin e zgjidhjes së problemeve për një set të plotë të kodeve të gabimeve. - Dorëzo punët një herë: Krijimi i një pune në grup nuk është idempotent. Nëse dërgoni të njëjtën kërkesë krijimi dy herë, do të krijohen dy punë të ndara në grup.
- Ndani grupe shumë të mëdha: Ndërsa koha e synuar e përpunimit është 24 orë, koha aktuale e përpunimit mund të ndryshojë në varësi të ngarkesës së sistemit dhe madhësisë së punës. Për punë të mëdha, merrni në konsideratë ndarjen e tyre në grupe më të vogla nëse rezultatet e ndërmjetme nevojiten më shpejt.
Çfarë vjen më pas
- Shikoni fletoren e shënimeve të Batch API për më shumë shembuj.
- Shtresa e përputhshmërisë OpenAI mbështet Batch API. Lexoni shembujt në faqen e Përputhshmërisë OpenAI .