‫Gemini 4 Argon זמין עכשיו. רוצים לנסות?

‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

תאימות ל-OpenAI

אפשר לגשת למודלים של Gemini באמצעות ספריות OpenAI (‏Python ו-TypeScript או Javascript) יחד עם API בארכיטקטורת REST, על ידי עדכון של שלוש שורות קוד ושימוש במפתח Gemini API. אם אתם לא משתמשים כבר בספריות של OpenAI, מומלץ להתקשר ישירות אל Gemini API.

Python

from openai import OpenAI

client = OpenAI(
    api_key="GEMINI_API_KEY",
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)

response = client.chat.completions.create(
    model="gemini-3.8-flash",
    messages=[
        {   "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "Explain to me how AI works"
        }
    ]
)

print(response.choices[0].message)

JavaScript

import OpenAI from "openai";

const openai = new OpenAI({
    apiKey: "GEMINI_API_KEY",
    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/"
});

const response = await openai.chat.completions.create({
    model: "gemini-3.8-flash",
    messages: [
        {   role: "system",
            content: "You are a helpful assistant." 
        },
        {
            role: "user",
            content: "Explain to me how AI works",
        },
    ],
});

console.log(response.choices[0].message);

REST

curl "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $GEMINI_API_KEY" \
  -d '{
    "model": "gemini-3.8-flash",
    "messages": [
      {
        "role": "user",
        "content": "Explain to me how AI works"
      }
    ]
  }'

מה השתנה? רק שלוש שורות!

‫api_key="GEMINI_API_KEY": מחליפים את "GEMINI_API_KEY" במפתח ה-API של Gemini, שאפשר לקבל ב-Google AI Studio.
‫base_url="https://generativelanguage.googleapis.com/v1beta/openai/": ההגדרה הזו מורה לספריית OpenAI לשלוח בקשות לנקודת הקצה של Gemini API במקום לכתובת ה-URL שמוגדרת כברירת מחדל.
‫model="gemini-3.8-flash": בחירת מודל Gemini תואם

מעמיק

מודלי Gemini מאומנים לחשוב על בעיות מורכבות, מה שמוביל לשיפור משמעותי ביכולות החשיבה הרציונלית. ‫Gemini API כולל פרמטרים של חשיבה שמאפשרים שליטה מדויקת על משך החשיבה של המודל.

למודלים שונים של Gemini יש הגדרות שונות של חשיבה רציונלית. כך הם ממופים למאמצי החשיבה הרציונלית של OpenAI:

‫`reasoning_effort` (OpenAI)	‫`thinking_level` (Gemini 4 Argon)	`thinking_level` (Gemini 3.1 Flash-Lite)	`thinking_level` (Gemini 3 Flash)	‫`thinking_budget` (Gemini 2.5)
‫`reasoning_effort` (OpenAI)	‫`thinking_level` (Gemini 4 Argon)	`thinking_level` (Gemini 3.1 Flash-Lite)	`thinking_level` (Gemini 3 Flash)	‫`thinking_budget` (Gemini 2.5)	`minimal`	`low`	`minimal`	`minimal`	`1,024`
`low`	`low`	`low`	`low`	`1,024`
`medium`	`medium`	`medium`	`medium`	`8,192`
`high`	`high`	`high`	`high`	`24,576`

אם לא מציינים reasoning_effort, Gemini משתמש ברמה או בתקציב ברירת המחדל של המודל.

אם אתם רוצים להשבית את תהליך החשיבה, אתם יכולים להגדיר את reasoning_effort לערך "none" במודלים של Gemini 2.5. אי אפשר להשבית את ההסקה במודלים Gemini 2.5 Pro או 3.

Python

from openai import OpenAI

client = OpenAI(
    api_key="GEMINI_API_KEY",
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)

response = client.chat.completions.create(
    model="gemini-3.8-flash",
    reasoning_effort="low",
    messages=[
        {   "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "Explain to me how AI works"
        }
    ]
)

print(response.choices[0].message)

JavaScript

import OpenAI from "openai";

const openai = new OpenAI({
    apiKey: "GEMINI_API_KEY",
    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/"
});

const response = await openai.chat.completions.create({
    model: "gemini-3.8-flash",
    reasoning_effort: "low",
    messages: [
        {   role: "system",
            content: "You are a helpful assistant." 
        },
        {
            role: "user",
            content: "Explain to me how AI works",
        },
    ],
});

console.log(response.choices[0].message);

REST

curl "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $GEMINI_API_KEY" \
  -d '{
    "model": "gemini-3.8-flash",
    "reasoning_effort": "low",
    "messages": [
      {
        "role": "user",
        "content": "Explain to me how AI works"
      }
    ]
  }'

המודלים החושבים של Gemini גם יוצרים סיכומי תהליך חשיבה. אתם יכולים להשתמש בשדה extra_body כדי לכלול שדות של Gemini בבקשה.

שימו לב שהפונקציונליות של reasoning_effort ו-thinking_level/thinking_budget חופפת, ולכן אי אפשר להשתמש בהן בו-זמנית.

Python

from openai import OpenAI

client = OpenAI(
    api_key="GEMINI_API_KEY",
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)

response = client.chat.completions.create(
    model="gemini-3.8-flash",
    messages=[{"role": "user", "content": "Explain to me how AI works"}],
    extra_body={
      'extra_body': {
        "google": {
          "thinking_config": {
            "thinking_level": "low",
            "include_thoughts": True
          }
        }
      }
    }
)

print(response.choices[0].message)

JavaScript

import OpenAI from "openai";

const openai = new OpenAI({
    apiKey: "GEMINI_API_KEY",
    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/"
});

const response = await openai.chat.completions.create({
    model: "gemini-3.8-flash",
    messages: [{role: "user", content: "Explain to me how AI works",}],
    extra_body: {
      "google": {
        "thinking_config": {
          "thinking_level": "low",
          "include_thoughts": true
        }
      }
    }
});

console.log(response.choices[0].message);

REST

curl "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer GEMINI_API_KEY" \
  -d '{
      "model": "gemini-3.8-flash",
        "messages": [{"role": "user", "content": "Explain to me how AI works"}],
        "extra_body": {
          "google": {
            "thinking_config": {
              "thinking_level": "low",
              "include_thoughts": true
            }
          }
        }
      }'

‫Gemini 3 תומך בתאימות ל-OpenAI לחתימות מחשבה בממשקי API להשלמת צ'אט. הדוגמה המלאה מופיעה בדף חתימות מחשבה.

סטרימינג

‫Gemini API תומך בתשובות בסטרימינג.

Python

from openai import OpenAI

client = OpenAI(
    api_key="GEMINI_API_KEY",
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)

response = client.chat.completions.create(
  model="gemini-3.8-flash",
  messages=[
    {
        "role": "system",
        "content": "You are a helpful assistant."
    },
    {   "role": "user",
        "content": "Hello!"
    }
  ],
  stream=True
)

for chunk in response:
    print(chunk.choices[0].delta)

JavaScript

import OpenAI from "openai";

const openai = new OpenAI({
    apiKey: "GEMINI_API_KEY",
    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/"
});

async function main() {
  const completion = await openai.chat.completions.create({
    model: "gemini-3.8-flash",
    messages: [
      {
          "role": "system",
          "content": "You are a helpful assistant."
      },
      {
          "role": "user",
          "content": "Hello!"
      }
    ],
    stream: true,
  });

  for await (const chunk of completion) {
    console.log(chunk.choices[0].delta.content);
  }
}

main();

REST

curl "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer GEMINI_API_KEY" \
  -d '{
      "model": "gemini-3.8-flash",
      "messages": [
          {"role": "user", "content": "Explain to me how AI works"}
      ],
      "stream": true
    }'

בקשה להפעלת פונקציה

התכונה 'בקשה להפעלת פונקציה' מאפשרת לקבל בקלות פלט של נתונים מובְנים ממודלים גנרטיביים, והיא נתמכת ב-Gemini API.

Python

from openai import OpenAI

client = OpenAI(
    api_key="GEMINI_API_KEY",
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)

tools = [
  {
    "type": "function",
    "function": {
      "name": "get_weather",
      "description": "Get the weather in a given location",
      "parameters": {
        "type": "object",
        "properties": {
          "location": {
            "type": "string",
            "description": "The city and state, e.g. Chicago, IL",
          },
          "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
        },
        "required": ["location"],
      },
    }
  }
]

messages = [{"role": "user", "content": "What's the weather like in Chicago today?"}]
response = client.chat.completions.create(
  model="gemini-3.8-flash",
  messages=messages,
  tools=tools,
  tool_choice="auto"
)

print(response)

JavaScript

import OpenAI from "openai";

const openai = new OpenAI({
    apiKey: "GEMINI_API_KEY",
    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/"
});

async function main() {
  const messages = [{"role": "user", "content": "What's the weather like in Chicago today?"}];
  const tools = [
      {
        "type": "function",
        "function": {
          "name": "get_weather",
          "description": "Get the weather in a given location",
          "parameters": {
            "type": "object",
            "properties": {
              "location": {
                "type": "string",
                "description": "The city and state, e.g. Chicago, IL",
              },
              "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
            },
            "required": ["location"],
          },
        }
      }
  ];

  const response = await openai.chat.completions.create({
    model: "gemini-3.8-flash",
    messages: messages,
    tools: tools,
    tool_choice: "auto",
  });

  console.log(response);
}

main();

REST

curl "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer GEMINI_API_KEY" \
-d '{
  "model": "gemini-3.8-flash",
  "messages": [
    {
      "role": "user",
      "content": "What'\''s the weather like in Chicago today?"
    }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Get the current weather in a given location",
        "parameters": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "The city and state, e.g. Chicago, IL"
            },
            "unit": {
              "type": "string",
              "enum": ["celsius", "fahrenheit"]
            }
          },
          "required": ["location"]
        }
      }
    }
  ],
  "tool_choice": "auto"
}'

הבנת תמונות

מודלי Gemini הם מולטי-מודאליים מטבעם, ומספקים ביצועים ברמה הגבוהה ביותר במשימות ראייה נפוצות רבות.

Python

import base64
from openai import OpenAI

client = OpenAI(
    api_key="GEMINI_API_KEY",
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)

# Function to encode the image
def encode_image(image_path):
  with open(image_path, "rb") as image_file:
    return base64.b64encode(image_file.read()).decode('utf-8')

# Getting the base64 string
base64_image = encode_image("Path/to/agi/image.jpeg")

response = client.chat.completions.create(
  model="gemini-3.8-flash",
  messages=[
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "What is in this image?",
        },
        {
          "type": "image_url",
          "image_url": {
            "url":  f"data:image/jpeg;base64,{base64_image}"
          },
        },
      ],
    }
  ],
)

print(response.choices[0])

JavaScript

import OpenAI from "openai";
import fs from 'fs/promises';

const openai = new OpenAI({
  apiKey: "GEMINI_API_KEY",
  baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/"
});

async function encodeImage(imagePath) {
  try {
    const imageBuffer = await fs.readFile(imagePath);
    return imageBuffer.toString('base64');
  } catch (error) {
    console.error("Error encoding image:", error);
    return null;
  }
}

async function main() {
  const imagePath = "Path/to/agi/image.jpeg";
  const base64Image = await encodeImage(imagePath);

  const messages = [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "What is in this image?",
        },
        {
          "type": "image_url",
          "image_url": {
            "url": `data:image/jpeg;base64,${base64Image}`
          },
        },
      ],
    }
  ];

  try {
    const response = await openai.chat.completions.create({
      model: "gemini-3.8-flash",
      messages: messages,
    });

    console.log(response.choices[0]);
  } catch (error) {
    console.error("Error calling Gemini API:", error);
  }
}

main();

REST

bash -c '
  base64_image=$(base64 -i "Path/to/agi/image.jpeg");
  curl "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer GEMINI_API_KEY" \
    -d "{
      \"model\": \"gemini-3.8-flash\",
      \"messages\": [
        {
          \"role\": \"user\",
          \"content\": [
            { \"type\": \"text\", \"text\": \"What is in this image?\" },
            {
              \"type\": \"image_url\",
              \"image_url\": { \"url\": \"data:image/jpeg;base64,${base64_image}\" }
            }
          ]
        }
      ]
    }"
'

יצירת תמונה

יוצרים תמונה באמצעות gemini-2.5-flash-image או gemini-3-pro-image-preview. הפרמטרים הנתמכים כוללים את prompt,‏ model,‏ n,‏ size ו-response_format. שכבת התאימות תתעלם מכל פרמטר אחר שלא מופיע כאן או בקטע extra_body.

אתם יכולים להפעיל את העיגון באמצעות חיפוש Google ולקבוע את הגדרות הבטיחות באמצעות הפרמטר extra_body. בקטע extra_body מפורטים הפרמטרים הזמינים. העיגון באמצעות חיפוש Google זמין רק ב-Gemini 3 ובמודלים חדשים יותר.

Python

import base64
from openai import OpenAI
from PIL import Image
from io import BytesIO

client = OpenAI(
    api_key="GEMINI_API_KEY",
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
)

response = client.images.generate(
    model="gemini-2.5-flash-image",
    prompt="a portrait of a sheepadoodle wearing a cape",
    response_format='b64_json',
    n=1,
)

for image_data in response.data:
  image = Image.open(BytesIO(base64.b64decode(image_data.b64_json)))
  image.show()

JavaScript

import OpenAI from "openai";

const openai = new OpenAI({
  apiKey: "GEMINI_API_KEY",
  baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/",
});

async function main() {
  const image = await openai.images.generate(
    {
      model: "gemini-2.5-flash-image",
      prompt: "a portrait of a sheepadoodle wearing a cape",
      response_format: "b64_json",
      n: 1,
    }
  );

  console.log(image.data);
}

main();

REST

curl "https://generativelanguage.googleapis.com/v1beta/openai/images/generations" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer GEMINI_API_KEY" \
  -d '{
        "model": "gemini-2.5-flash-image",
        "prompt": "a portrait of a sheepadoodle wearing a cape",
        "response_format": "b64_json",
        "n": 1,
      }'

יצירת סרטון

יצירת סרטון באמצעות veo-3.1-generate-preview דרך נקודת הקצה /v1/videos שתואמת ל-Sora. הפרמטרים הנתמכים ברמה העליונה הם prompt ו-model. צריך להעביר פרמטרים נוספים כמו duration_seconds,‏ image ו-aspect_ratio עם extra_body. בקטע extra_body מפורטים כל הפרמטרים הזמינים.

יצירת סרטונים היא פעולה ממושכת שמחזירה מזהה פעולה שאפשר לדגום כדי לבדוק אם היא הסתיימה.

Python

from openai import OpenAI

client = OpenAI(
    api_key="GEMINI_API_KEY",
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)

# Returns a Long Running Operation (status: processing)
response = client.videos.create(
    model="veo-3.1-generate-preview",
    prompt="A cinematic drone shot of a waterfall",
)

print(f"Operation ID: {response.id}")
print(f"Status: {response.status}")

JavaScript

import OpenAI from "openai";

const openai = new OpenAI({
    apiKey: "GEMINI_API_KEY",
    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/"
});

async function main() {
    // Returns a Long Running Operation (status: processing)
    const response = await openai.videos.create({
        model: "veo-3.1-generate-preview",
        prompt: "A cinematic drone shot of a waterfall",
    });

    console.log(`Operation ID: ${response.id}`);
    console.log(`Status: ${response.status}`);
}

main();

REST

curl "https://generativelanguage.googleapis.com/v1beta/openai/videos" \
  -H "Authorization: Bearer $GEMINI_API_KEY" \
  -F "model=veo-3.1-generate-preview" \
  -F "prompt=A cinematic drone shot of a waterfall"

בדיקת סטטוס הסרטון

יצירת הסרטונים היא אסינכרונית. משתמשים ב-GET /v1/videos/{id} כדי לבדוק את הסטטוס ולאחזר את כתובת ה-URL הסופית של הסרטון כשהפעולה מסתיימת:

Python

import time
from openai import OpenAI

client = OpenAI(
    api_key="GEMINI_API_KEY",
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)

# Poll until video is ready
video_id = response.id  # From the create call
while True:
    video = client.videos.retrieve(video_id)
    if video.status == "completed":
        print(f"Video URL: {video.url}")
        break
    elif video.status == "failed":
        print(f"Generation failed: {video.error}")
        break
    print(f"Status: {video.status}. Waiting...")
    time.sleep(10)

JavaScript

import OpenAI from "openai";

const openai = new OpenAI({
    apiKey: "GEMINI_API_KEY",
    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/"
});

async function main() {
    // Poll until video is ready
    const videoId = response.id;  // From the create call
    while (true) {
        const video = await openai.videos.retrieve(videoId);
        if (video.status === "completed") {
            console.log(`Video URL: ${video.url}`);
            break;
        } else if (video.status === "failed") {
            console.log(`Generation failed: ${video.error}`);
            break;
        }
        console.log(`Status: ${video.status}. Waiting...`);
        await new Promise(resolve => setTimeout(resolve, 10000));
    }
}

main();

REST

curl "https://generativelanguage.googleapis.com/v1beta/openai/videos/VIDEO_ID" \
  -H "Authorization: Bearer $GEMINI_API_KEY"

הבנת אודיו

ניתוח קלט אודיו:

Python

import base64
from openai import OpenAI

client = OpenAI(
    api_key="GEMINI_API_KEY",
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)

with open("/path/to/your/audio/file.wav", "rb") as audio_file:
  base64_audio = base64.b64encode(audio_file.read()).decode('utf-8')

response = client.chat.completions.create(
    model="gemini-3.8-flash",
    messages=[
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Transcribe this audio",
        },
        {
              "type": "input_audio",
              "input_audio": {
                "data": base64_audio,
                "format": "wav"
          }
        }
      ],
    }
  ],
)

print(response.choices[0].message.content)

JavaScript

import fs from "fs";
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "GEMINI_API_KEY",
  baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/",
});

const audioFile = fs.readFileSync("/path/to/your/audio/file.wav");
const base64Audio = Buffer.from(audioFile).toString("base64");

async function main() {
  const response = await client.chat.completions.create({
    model: "gemini-3.8-flash",
    messages: [
      {
        role: "user",
        content: [
          {
            type: "text",
            text: "Transcribe this audio",
          },
          {
            type: "input_audio",
            input_audio: {
              data: base64Audio,
              format: "wav",
            },
          },
        ],
      },
    ],
  });

  console.log(response.choices[0].message.content);
}

main();

REST

bash -c '
  base64_audio=$(base64 -i "/path/to/your/audio/file.wav");
  curl "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer GEMINI_API_KEY" \
    -d "{
      \"model\": \"gemini-3.8-flash\",
      \"messages\": [
        {
          \"role\": \"user\",
          \"content\": [
            { \"type\": \"text\", \"text\": \"Transcribe this audio file.\" },
            {
              \"type\": \"input_audio\",
              \"input_audio\": {
                \"data\": \"${base64_audio}\",
                \"format\": \"wav\"
              }
            }
          ]
        }
      ]
    }"
'

פלט מובנה

מודלי Gemini יכולים להפיק אובייקטים מסוג JSON בכל מבנה שתגדירו.

Python

from pydantic import BaseModel
from openai import OpenAI

client = OpenAI(
    api_key="GEMINI_API_KEY",
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)

class CalendarEvent(BaseModel):
    name: str
    date: str
    participants: list[str]

completion = client.beta.chat.completions.parse(
    model="gemini-3.8-flash",
    messages=[
        {"role": "system", "content": "Extract the event information."},
        {"role": "user", "content": "John and Susan are going to an AI conference on Friday."},
    ],
    response_format=CalendarEvent,
)

print(completion.choices[0].message.parsed)

JavaScript

import OpenAI from "openai";
import { zodResponseFormat } from "openai/helpers/zod";
import { z } from "zod";

const openai = new OpenAI({
    apiKey: "GEMINI_API_KEY",
    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai"
});

const CalendarEvent = z.object({
  name: z.string(),
  date: z.string(),
  participants: z.array(z.string()),
});

const completion = await openai.chat.completions.parse({
  model: "gemini-3.8-flash",
  messages: [
    { role: "system", content: "Extract the event information." },
    { role: "user", content: "John and Susan are going to an AI conference on Friday" },
  ],
  response_format: zodResponseFormat(CalendarEvent, "event"),
});

const event = completion.choices[0].message.parsed;
console.log(event);

הטמעות

הטמעות טקסט מודדות את הקשר בין מחרוזות טקסט, ואפשר ליצור אותן באמצעות Gemini API. אפשר להשתמש ב-gemini-embedding-2-preview להטמעות מולטימודאליות או ב-gemini-embedding-001 להטמעות של טקסט בלבד.

Python

from openai import OpenAI

client = OpenAI(
    api_key="GEMINI_API_KEY",
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)

response = client.embeddings.create(
    input="Your text string goes here",
    model="gemini-embedding-2-preview"
)

print(response.data[0].embedding)

JavaScript

import OpenAI from "openai";

const openai = new OpenAI({
    apiKey: "GEMINI_API_KEY",
    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/"
});

async function main() {
  const embedding = await openai.embeddings.create({
    model: "gemini-embedding-2-preview",
    input: "Your text string goes here",
  });

  console.log(embedding);
}

main();

REST

curl "https://generativelanguage.googleapis.com/v1beta/openai/embeddings" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer GEMINI_API_KEY" \
-d '{
    "input": "Your text string goes here",
    "model": "gemini-embedding-2-preview"
  }'

Batch API

אתם יכולים ליצור משימות באצווה, לשלוח אותן ולבדוק את הסטטוס שלהן באמצעות ספריית OpenAI.

תצטרכו להכין את קובץ ה-JSONL בפורמט הקלט של OpenAI. לדוגמה:

{"custom_id": "request-1", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "gemini-3.8-flash", "messages": [{"role": "user", "content": "Tell me a one-sentence joke."}]}}
{"custom_id": "request-2", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "gemini-3.8-flash", "messages": [{"role": "user", "content": "Why is the sky blue?"}]}}

תאימות ל-OpenAI עבור Batch תומכת ביצירת אצווה, במעקב אחר סטטוס המשימה ובהצגת תוצאות האצווה.

כרגע אין תאימות להעלאה ולהורדה. במקום זאת, בדוגמה הבאה משתמשים בלקוח genai כדי להעלות ולהוריד קבצים, כמו כשמשתמשים ב-Batch API של Gemini.

Python

from openai import OpenAI

# Regular genai client for uploads & downloads
from google import genai
client = genai.Client()

openai_client = OpenAI(
    api_key="GEMINI_API_KEY",
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)

# Upload the JSONL file in OpenAI input format, using regular genai SDK
uploaded_file = client.files.upload(
    file='my-batch-requests.jsonl',
    config=types.UploadFileConfig(display_name='my-batch-requests', mime_type='jsonl')
)

# Create batch
batch = openai_client.batches.create(
    input_file_id=batch_input_file_id,
    endpoint="/v1/chat/completions",
    completion_window="24h"
)

# Wait for batch to finish (up to 24h)
while True:
    batch = client.batches.retrieve(batch.id)
    if batch.status in ('completed', 'failed', 'cancelled', 'expired'):
        break
    print(f"Batch not finished. Current state: {batch.status}. Waiting 30 seconds...")
    time.sleep(30)
print(f"Batch finished: {batch}")

# Download results in OpenAI output format, using regular genai SDK
file_content = genai_client.files.download(file=batch.output_file_id).decode('utf-8')

# See batch_output JSONL in OpenAI output format
for line in file_content.splitlines():
    print(line)

ב-OpenAI SDK יש גם תמיכה ביצירת הטמעות באמצעות Batch API. כדי לעשות את זה, מחליפים את השדה endpoint של השיטה create בנקודת קצה של הטמעות, וגם את המפתחות url ו-model בקובץ ה-JSONL:

# JSONL file using embeddings model and endpoint
# {"custom_id": "request-1", "method": "POST", "url": "/v1/embeddings", "body": {"model": "ggemini-embedding-001", "messages": [{"role": "user", "content": "Tell me a one-sentence joke."}]}}
# {"custom_id": "request-2", "method": "POST", "url": "/v1/embeddings", "body": {"model": "gemini-embedding-001", "messages": [{"role": "user", "content": "Why is the sky blue?"}]}}

# ...

# Create batch step with embeddings endpoint
batch = openai_client.batches.create(
    input_file_id=batch_input_file_id,
    endpoint="/v1/embeddings",
    completion_window="24h"
)

דוגמה מלאה מופיעה בקטע יצירת הטמעות באצווה במדריך לתאימות ל-OpenAI.

היקש ברמת Flex ו-Priority

‫Gemini API תואם לפרמטר service_tier של OpenAI בשם ובלוגיקה, אוכף מגבלות ומפנה תנועה בצורה חלקה גם לרמת ההסקה Flex וגם לרמת ההסקה Priority.

Python

from openai import OpenAI

client = OpenAI(
  api_key="GEMINI_API_KEY",
  base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)

completion = client.chat.completions.create(
  model="gemini-3.8-flash",
  messages=[
    {"role": "user", "content": "Write a short poem about clouds."}
  ],
  service_tier="priority" # Or service_tier="flex"
)

print(completion)

אם לא מקצים ערך במפורש, ברירת המחדל של service_tier היא standard, ששווה ל-default ב-OpenAI. מידע נוסף על רמות הסקה זמין במסמכי התיעוד בנושא אופטימיזציה.

הפעלת התכונות של Gemini באמצעות `extra_body`

יש כמה תכונות שנתמכות ב-Gemini ולא זמינות במודלים של OpenAI, אבל אפשר להפעיל אותן באמצעות השדה extra_body.

פרמטר	סוג	נקודת קצה	תיאור
`cached_content`	טקסט	צ'אט	תואם למטמון התוכן הכללי של Gemini.
`thinking_config`	אובייקט	צ'אט	תואם ל-ThinkingConfig של Gemini.
`aspect_ratio`	טקסט	תמונות	יחס הגובה-רוחב של הפלט (למשל, `"16:9"`, ‏ `"1:1"`, ‏ `"9:16"`).
`generation_config`	אובייקט	תמונות	אובייקט הגדרות ליצירה ב-Gemini (לדוגמה, `{"responseModalities": ["IMAGE"], "candidateCount": 2}`).
`safety_settings`	רשימה	תמונות	מסננים מותאמים אישית של סף הבטיחות (למשל, `[{"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"}]`).
`tools`	רשימה	תמונות	הפעלת ביסוס (למשל, `[{"google_search": {}}]`). רק עבור `gemini-3-pro-image-preview`.
`aspect_ratio`	טקסט	וידאו	מידות הסרטון שנוצר (`16:9` לרוחב, `9:16` לאורך). אם לא צוין ערך, המערכת ממפה מ-`size`.
`resolution`	טקסט	וידאו	רזולוציית הפלט (`720p`, ‏ `1080p`, ‏ `4K`). הערה: `1080p` ו-`4K` מפעילים את צינור עיבוד הנתונים של upsampler.
`duration_seconds`	מספר שלם	וידאו	אורך תהליך הייצור (ערכים: `4`,‏ `6`,‏ `8`). הערך חייב להיות `8` כשמשתמשים ב-`reference_images`, באינטרפולציה או בהרחבה.
`frame_rate`	טקסט	וידאו	קצב הפריימים של פלט הסרטון (למשל, `"24"`).
`input_reference`	טקסט	וידאו	קלט עזר ליצירת סרטונים.
`extend_video_id`	טקסט	וידאו	מזהה של סרטון קיים שרוצים להאריך.
`negative_prompt`	טקסט	וידאו	פריטים להחרגה (לדוגמה, `"shaky camera"`).
`seed`	מספר שלם	וידאו	מספר שלם ליצירה דטרמיניסטית.
`style`	טקסט	וידאו	סגנון חזותי (`cinematic` כברירת מחדל, `creative` לאופטימיזציה לרשתות חברתיות).
`person_generation`	טקסט	וידאו	ההגדרה קובעת אם ייווצרו תמונות של אנשים (`allow_adult`, `allow_all`, `dont_allow`).
`reference_images`	רשימה	וידאו	עד 3 תמונות כרפרנס לסגנון או לדמות (נכסי base64).
`image`	טקסט	וידאו	תמונת קלט ראשונית בקידוד Base64 כדי להתנות את יצירת הסרטון.
`last_frame`	אובייקט	וידאו	התמונה הסופית לאינטרפולציה (נדרש `image` כפריים הראשון).

דוגמה לשימוש ב-`extra_body`

הנה דוגמה לשימוש ב-extra_body כדי להגדיר את cached_content:

Python

from openai import OpenAI

client = OpenAI(
    api_key=MY_API_KEY,
    base_url="https://generativelanguage.googleapis.com/v1beta/"
)

stream = client.chat.completions.create(
    model="gemini-3.8-flash",
    n=1,
    messages=[
        {
            "role": "user",
            "content": "Summarize the video"
        }
    ],
    stream=True,
    stream_options={'include_usage': True},
    extra_body={
        'extra_body':
        {
            'google': {
              'cached_content': "cachedContents/0000aaaa1111bbbb2222cccc3333dddd4444eeee"
          }
        }
    }
)

for chunk in stream:
    print(chunk)
    print(chunk.usage.to_dict())

רשימת המודלים

כדי לקבל רשימה של המודלים הזמינים של Gemini:

Python

from openai import OpenAI

client = OpenAI(
  api_key="GEMINI_API_KEY",
  base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)

models = client.models.list()
for model in models:
  print(model.id)

JavaScript

import OpenAI from "openai";

const openai = new OpenAI({
  apiKey: "GEMINI_API_KEY",
  baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/",
});

async function main() {
  const list = await openai.models.list();

  for await (const model of list) {
    console.log(model);
  }
}
main();

REST

curl https://generativelanguage.googleapis.com/v1beta/openai/models \
-H "Authorization: Bearer GEMINI_API_KEY"

אחזור מודל

אחזור של מודל Gemini:

Python

from openai import OpenAI

client = OpenAI(
  api_key="GEMINI_API_KEY",
  base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)

model = client.models.retrieve("gemini-3.8-flash")
print(model.id)

JavaScript

import OpenAI from "openai";

const openai = new OpenAI({
  apiKey: "GEMINI_API_KEY",
  baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/",
});

async function main() {
  const model = await openai.models.retrieve("gemini-3.8-flash");
  console.log(model.id);
}

main();

REST

curl https://generativelanguage.googleapis.com/v1beta/openai/models/gemini-3.8-flash \
-H "Authorization: Bearer GEMINI_API_KEY"

מגבלות נוכחיות

התמיכה בספריות של OpenAI עדיין בגרסת בטא, ואנחנו מרחיבים את התמיכה בתכונות.

אם יש לכם שאלות לגבי הפרמטרים הנתמכים, תכונות עתידיות או בעיות בתחילת העבודה עם Gemini, אתם יכולים להצטרף לפורום המפתחים שלנו.

המאמרים הבאים

כדי לראות דוגמאות מפורטות יותר, אפשר לנסות את התאימות ל-OpenAI ב-Colab.

תאימות ל-OpenAI

Python

JavaScript

REST

מעמיק

Python

JavaScript

REST

Python

JavaScript

REST

סטרימינג

Python

JavaScript

REST

בקשה להפעלת פונקציה

Python

JavaScript

REST

הבנת תמונות

Python

JavaScript

REST

יצירת תמונה

Python

JavaScript

REST

יצירת סרטון

Python

JavaScript

REST

בדיקת סטטוס הסרטון

Python

JavaScript

REST

הבנת אודיו

Python

JavaScript

REST

פלט מובנה

Python

JavaScript

הטמעות

Python

JavaScript

REST

Batch API

Python

היקש ברמת Flex ו-Priority

Python

הפעלת התכונות של Gemini באמצעות extra_body

דוגמה לשימוש ב-extra_body

Python

רשימת המודלים

Python

JavaScript

REST

אחזור מודל

Python

JavaScript

REST

מגבלות נוכחיות

המאמרים הבאים

הפעלת התכונות של Gemini באמצעות `extra_body`

דוגמה לשימוש ב-`extra_body`