Os modelos do Gemini podem ser acessados usando as bibliotecas OpenAI (Python e TypeScript / Javascript) com a API REST. Para isso, atualize três linhas de código e use sua chave de API do Gemini. Se você ainda não usa as bibliotecas OpenAI, recomendamos chamar a API Gemini diretamente.
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-2.5-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-2.0-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-2.0-flash", "messages": [ {"role": "user", "content": "Explain to me how AI works"} ] }' O que mudou? Apenas três linhas!
api_key="GEMINI_API_KEY": substitua "GEMINI_API_KEY" pela sua chave de API Gemini, que você pode acessar no Google AI Studio.base_url="https://generativelanguage.googleapis.com/v1beta/openai/":isso informa à biblioteca OpenAI para enviar solicitações ao endpoint da API Gemini em vez do URL padrão.model="gemini-2.0-flash": escolha um modelo do Gemini compatível
Pensando
Os modelos do Gemini 2.5 são treinados para pensar em problemas complexos, o que melhora muito o raciocínio. A API Gemini vem com um parâmetro de"orçamento de pensamento" que oferece controle refinado sobre o quanto o modelo vai pensar.
Ao contrário da API Gemini, a API OpenAI oferece três níveis de controle de pensamento: "low", "medium" e "high", que correspondem a 1.024, 8.192 e 24.576 tokens, respectivamente.
Se quiser desativar o pensamento, defina reasoning_effort como "none". Não é possível desativar o raciocínio para modelos 2.5 Pro.
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-2.5-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-2.5-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-2.5-flash", "reasoning_effort": "low", "messages": [ {"role": "user", "content": "Explain to me how AI works"} ] }' Os modelos de pensamento do Gemini também produzem resumos de pensamento e podem usar orçamentos de pensamento exatos. Use o campo extra_body para incluir esses campos na sua solicitação.
Como reasoning_effort e thinking_budget têm funcionalidades semelhantes, não é possível usar os dois ao mesmo tempo.
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-2.5-flash", messages=[{"role": "user", "content": "Explain to me how AI works"}], extra_body={ 'extra_body': { "google": { "thinking_config": { "thinking_budget": 800, "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-2.5-flash", messages: [{role: "user", content: "Explain to me how AI works",}], extra_body: { "google": { "thinking_config": { "thinking_budget": 800, "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-2.5-flash", "messages": [{"role": "user", "content": "Explain to me how AI works"}], "extra_body": { "google": { "thinking_config": { "include_thoughts": true } } } }' Streaming
A API Gemini oferece suporte a respostas de streaming.
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-2.0-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-2.0-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-2.0-flash", "messages": [ {"role": "user", "content": "Explain to me how AI works"} ], "stream": true }' Chamadas de função
Com as chamadas de função, fica mais fácil receber saídas de dados estruturados de modelos generativos, e elas são compatíveis com a API Gemini.
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-2.0-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-2.0-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-2.0-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" }' Compreensão de imagens
Os modelos do Gemini são multimodais nativos e oferecem o melhor desempenho da categoria em muitas tarefas comuns de visão.
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-2.0-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-2.0-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-2.0-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}\" } } ] } ] }" ' Gerar uma imagem
Gerar uma imagem:
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="imagen-3.0-generate-002", 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: "imagen-3.0-generate-002", 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": "imagen-3.0-generate-002", "prompt": "a portrait of a sheepadoodle wearing a cape", "response_format": "b64_json", "n": 1, }' Compreensão de áudio
Analisar entrada de áudio:
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-2.0-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-2.0-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-2.0-flash\", \"messages\": [ { \"role\": \"user\", \"content\": [ { \"type\": \"text\", \"text\": \"Transcribe this audio file.\" }, { \"type\": \"input_audio\", \"input_audio\": { \"data\": \"${base64_audio}\", \"format\": \"wav\" } } ] } ] }" ' Resposta estruturada
Os modelos do Gemini podem gerar objetos JSON em qualquer estrutura que você definir.
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-2.0-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-2.0-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); Embeddings
Os embeddings de texto medem a relação entre strings de texto e podem ser gerados usando a API Gemini.
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-001" ) 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-001", 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-001" }' API Batch
É possível criar jobs em lote, enviá-los e verificar o status deles usando a biblioteca OpenAI.
Você precisa preparar o arquivo JSONL no formato de entrada da OpenAI. Exemplo:
{"custom_id": "request-1", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "gemini-2.5-flash", "messages": [{"role": "user", "content": "Tell me a one-sentence joke."}]}} {"custom_id": "request-2", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "gemini-2.5-flash", "messages": [{"role": "user", "content": "Why is the sky blue?"}]}} A compatibilidade com a OpenAI para o Batch permite criar um lote, monitorar o status do job e conferir os resultados do lote.
No momento, não há compatibilidade para upload e download. Em vez disso, o exemplo a seguir usa o cliente genai para fazer upload e download de arquivos, assim como ao usar a API Batch do 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) O SDK da OpenAI também é compatível com a geração de incorporações com a API Batch. Para fazer isso, troque o campo endpoint do método create por um endpoint de incorporações, bem como as chaves url e model no arquivo 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" ) Consulte a seção Geração de incorporação em lote do livro de receitas de compatibilidade com a OpenAI para ver um exemplo completo.
extra_body
Há vários recursos compatíveis com o Gemini que não estão disponíveis nos modelos da OpenAI, mas podem ser ativados usando o campo extra_body.
Recursos do extra_body
cached_content | Corresponde ao GenerateContentRequest.cached_content do Gemini. |
thinking_config | Corresponde ao ThinkingConfig do Gemini. |
cached_content
Confira um exemplo de como usar extra_body para definir 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-2.5-pro", 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()) Listar modelos
Confira uma lista dos modelos do Gemini disponíveis:
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" Recuperar um modelo
Recuperar um modelo do 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-2.0-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-2.0-flash"); console.log(model.id); } main(); REST
curl https://generativelanguage.googleapis.com/v1beta/openai/models/gemini-2.0-flash \ -H "Authorization: Bearer GEMINI_API_KEY" Limitações atuais
O suporte às bibliotecas da OpenAI ainda está em versão Beta enquanto ampliamos a compatibilidade de recursos.
Se tiver dúvidas sobre parâmetros compatíveis, recursos futuros ou problemas ao começar a usar o Gemini, participe do nosso fórum para desenvolvedores.
A seguir
Teste nosso Colab de compatibilidade com a OpenAI para conferir exemplos mais detalhados.