Visão geral da API Gemini

A API Gemini oferece acesso aos modelos generativos mais recentes do Google. Depois de se familiarizar com os recursos gerais disponíveis por meio da API, teste um tutorial na sua linguagem preferida para começar a desenvolver.

Modelos

Gemini é uma série de modelos de IA generativa multimodais desenvolvidos pelo Google. Os modelos do Gemini aceitam texto e imagem em comandos, dependendo da variação escolhida, e geram respostas de texto.

Para informações mais detalhadas sobre o modelo, consulte a página Modelos do Genmini. Também é possível usar o método list_models para listar todos os modelos disponíveis e, em seguida, o método get_model para receber os metadados de um modelo específico.

Dados e design do comando

Modelos específicos do Gemini aceitam dados de texto e arquivos de mídia como entrada. Esse recurso cria muitas outras possibilidades para gerar conteúdo, analisar dados e resolver problemas. Há algumas limitações e requisitos a serem considerados, incluindo o limite geral de tokens de entrada para o modelo que você está usando. Para informações sobre os limites de token para modelos específicos, consulte Modelos do Genmini.

As solicitações que usam a API Gemini não podem exceder 20 MB. A API Gemini fornece uma API File para armazenar temporariamente arquivos de mídia a serem usados em solicitações, o que permite fornecer dados de solicitação além do limite de 20 MB. Para saber mais sobre como usar a API Files e formatos de arquivo compatíveis com solicitações, consulte Prompts com arquivos de mídia.

Design de comandos e entrada de texto

A criação de comandos eficazes, ou engenharia de comando, é uma combinação de arte e ciência. Consulte a introdução à criação de comandos para orientações sobre como abordar a criação de comandos e o guia Noções básicas de instruções para saber mais sobre as diferentes abordagens de comandos.

Geração de conteúdo

A API Gemini permite usar dados de texto e imagem para criar comandos, dependendo da variação do modelo que você usar. Por exemplo, é possível gerar texto usando comandos de texto com o modelo gemini-pro e usar dados de texto e imagem para solicitar o modelo gemini-pro-vision. Esta seção fornece exemplos de código simples de cada um. Consulte a referência da API generateContent para ver um exemplo mais detalhado que abrange todos os parâmetros.

Entrada de texto e imagem

Envie um comando de texto com uma imagem ao modelo gemini-pro-vision para executar uma tarefa relacionada à visão. Por exemplo, legendar uma imagem ou identificar o que está nela.

Os exemplos de código a seguir demonstram uma implementação simples de um prompt de texto e imagem para cada linguagem compatível:

Python

model = genai.GenerativeModel('gemini-pro-vision')

cookie_picture = [{
    'mime_type': 'image/png',
    'data': pathlib.Path('cookie.png').read_bytes()
}]
prompt = "Do these look store-bought or homemade?"

response = model.generate_content(
    model="gemini-pro-vision",
    content=[prompt, cookie_picture]
)
print(response.text)

Consulte o tutorial do Python para ver o snippet de código completo.

Go 

vmodel := client.GenerativeModel("gemini-pro-vision")

data, err := os.ReadFile(filepath.Join("path-to-image", imageFile))
if err != nil {
  log.Fatal(err)
}
resp, err := vmodel.GenerateContent(ctx, genai.Text("Do these look store-bought or homemade?"), genai.ImageData("jpeg", data))
if err != nil {
  log.Fatal(err)
}

Veja o tutorial do Go para um exemplo completo.

Node.js

const model = genAI.getGenerativeModel({ model: "gemini-pro-vision" });

const prompt = "Do these look store-bought or homemade?";
const image = {
  inlineData: {
    data: Buffer.from(fs.readFileSync("cookie.png")).toString("base64"),
    mimeType: "image/png",
  },
};

const result = await model.generateContent([prompt, image]);
console.log(result.response.text());

Consulte o tutorial do Node.js para um exemplo completo.

Web

const model = genAI.getGenerativeModel({ model: "gemini-pro-vision" });

const prompt = "Do these look store-bought or homemade?";
const image = {
  inlineData: {
    data: base64EncodedImage /* see JavaScript quickstart for details */,
    mimeType: "image/png",
  },
};

const result = await model.generateContent([prompt, image]);
console.log(result.response.text());

Consulte o tutorial da Web para ver um exemplo completo.

Dart (Flutter) 

final model = GenerativeModel(model: 'gemini-pro-vision', apiKey: apiKey);
final prompt = 'Do these look store-bought or homemade?';
final imageBytes = await File('cookie.png').readAsBytes();
final content = [
  Content.multi([
    TextPart(prompt),
    DataPart('image/png', imageBytes),
  ])
];

final response = await model.generateContent(content);
print(response.text);

Consulte o tutorial do Dart (Flutter) para um exemplo completo.

Swift

let model = GenerativeModel(name: "gemini-pro-vision", apiKey: "API_KEY")
let cookieImage = UIImage(...)
let prompt = "Do these look store-bought or homemade?"

let response = try await model.generateContent(prompt, cookieImage)

Consulte o tutorial do Swift para ver um exemplo completo.

Android

val generativeModel = GenerativeModel(
    modelName = "gemini-pro-vision",
    apiKey = BuildConfig.apiKey
)

val cookieImage: Bitmap = // ...
val inputContent = content() {
  image(cookieImage)
  text("Do these look store-bought or homemade?")
}

val response = generativeModel.generateContent(inputContent)
print(response.text)

Consulte o tutorial do Android para ver um exemplo completo.

cURL

curl https://generativelanguage.googleapis.com/v1/models/gemini-pro-vision:generateContent?key=${API_KEY} \
    -H 'Content-Type: application/json' \
    -X POST \
    -d @<(echo'{
          "contents":[
            { "parts":[
                {"text": "Do these look store-bought or homemade?"},
                { "inlineData": {
                    "mimeType": "image/png",
                    "data": "'$(base64 -w0 cookie.png)'"
                  }
                }
              ]
            }
          ]
         }')

Consulte o tutorial da API REST para mais detalhes.

Entrada apenas de texto

A API Gemini também pode processar entradas somente de texto. Esse recurso permite executar tarefas de processamento de linguagem natural (PLN), como preenchimento e resumo de texto.

Os exemplos de código a seguir demonstram uma implementação simples de um prompt somente de texto para cada linguagem compatível:

Python

model = genai.GenerativeModel('gemini-pro-vision')

prompt = "Write a story about a magic backpack."

response = model.generate_content(prompt)

Consulte o tutorial do Python para ver o exemplo completo.

Go 

ctx := context.Background()
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

model := client.GenerativeModel("gemini-pro")
resp, err := model.GenerateContent(ctx, genai.Text("Write a story about a magic backpack."))
if err != nil {
  log.Fatal(err)
}

Veja o tutorial do Go para um exemplo completo.

Node.js

const model = genAI.getGenerativeModel({ model: "gemini-pro" });
const prompt = "Write a story about a magic backpack.";

const result = await model.generateContent(prompt);
console.log(result.response.text());

Consulte o tutorial do Node.js para um exemplo completo.

Web

const model = genAI.getGenerativeModel({ model: "gemini-pro" });
const prompt = "Write a story about a magic backpack.";

const result = await model.generateContent(prompt);
console.log(result.response.text());

Consulte o tutorial da Web para ver um exemplo completo.

Dart (Flutter) 

final model = GenerativeModel(model: 'gemini-pro', apiKey: apiKey);
final prompt = 'Write a story about a magic backpack.';
final content = [Content.text(prompt)];
final response = await model.generateContent(content);
print(response.text);

Consulte o tutorial do Dart (Flutter) para um exemplo completo.

Swift

let model = GenerativeModel(name: "gemini-pro", apiKey: "API_KEY")
let prompt = "Write a story about a magic backpack."

let response = try await model.generateContent(prompt)

Consulte o tutorial do Swift para ver um exemplo completo.

Android

val generativeModel = GenerativeModel(
    modelName = "gemini-pro",
    apiKey = BuildConfig.apiKey
)

val prompt = "Write a story about a magic backpack."
val response = generativeModel.generateContent(prompt)
print(response.text)

Consulte o tutorial do Android para ver um exemplo completo.

cURL

curl https://generativelanguage.googleapis.com/v1/models/gemini-pro:generateContent?key=$API_KEY \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{ "contents":[
      { "parts":[{"text": "Write a story about a magic backpack"}]}
    ]
}'

Consulte o tutorial da API REST para mais detalhes.

Conversas com várias interações (chat)

Use a API Gemini para criar experiências de chat interativas para seus usuários. O uso do recurso de chat da API permite coletar várias rodadas de perguntas e respostas, permitindo que os usuários sigam gradualmente em busca de respostas ou recebam ajuda com problemas de várias partes. Esse recurso é ideal para aplicativos que exigem comunicação contínua, como bots de chat, tutores interativos ou assistentes de suporte ao cliente.

Os exemplos de código a seguir demonstram uma implementação simples de interação de chat para cada linguagem com suporte:

Python

  model = genai.GenerativeModel('gemini-pro')
  chat = model.start_chat(history=[])

  response = chat.send_message(
      "Pretend you\'re a snowman and stay in character for each response.")
  print(response.text)

  response = chat.send_message(
      "What\'s your favorite season of the year?")
  print(response.text)

Consulte a demonstração do chat no tutorial do Python para ver um exemplo completo.

Go 

model := client.GenerativeModel("gemini-pro")
cs := model.StartChat()
cs.History = []*genai.Content{
  &genai.Content{
    Parts: []genai.Part{
      genai.Text("Pretend you're a snowman and stay in character for each response."),
    },
    Role: "user",
  },
  &genai.Content{
    Parts: []genai.Part{
      genai.Text("Hello! It's cold! Isn't that great?"),
    },
    Role: "model",
  },
}

resp, err := cs.SendMessage(ctx, genai.Text("What's your favorite season of the year?"))
if err != nil {
  log.Fatal(err)
}

Veja a demonstração do chat no tutorial do Go para um exemplo completo.

Node.js

const model = genAI.getGenerativeModel({ model: "gemini-pro"});

const chat = model.startChat({
  history: [
    {
      role: "user",
      parts: "Pretend you're a snowman and stay in character for each response.",
    },
    {
      role: "model",
      parts: "Hello! It's cold! Isn't that great?",
    },
  ],
  generationConfig: {
    maxOutputTokens: 100,
  },
});

const msg = "What's your favorite season of the year?";
const result = await chat.sendMessage(msg);
console.log(result.response.text());

Veja a demonstração do chat no tutorial do Node.js para um exemplo completo.

Web

const model = genAI.getGenerativeModel({ model: "gemini-pro"});

const chat = model.startChat({
  history: [
    {
      role: "user",
      parts: "Pretend you're a snowman and stay in character for each response.",
    },
    {
      role: "model",
      parts: "Hello! It's so cold! Isn't that great?",
    },
  ],
  generationConfig: {
    maxOutputTokens: 100,
  },
});

const msg = "What's your favorite season of the year?";
const result = await chat.sendMessage(msg);
console.log(result.response.text());

Veja a demonstração do chat no tutorial da Web para ver um exemplo completo.

Dart (Flutter) 

final model = GenerativeModel(model: 'gemini-pro', apiKey: apiKey);
final chat = model.startChat(history: [
  Content.text(
      "Pretend you're a snowman and stay in character for each response."),
  Content.model([TextPart("Hello! It's cold! Isn't that great?")]),
]);
final content = Content.text("What's your favorite season of the year?");
final response = await chat.sendMessage(content);
print(response.text);

Veja a demonstração do chat no tutorial do Dart (Flutter) para um exemplo completo.

Swift

let model = GenerativeModel(name: "gemini-pro", apiKey: "API_KEY")
let chat = model.startChat()

var message = "Pretend you're a snowman and stay in character for each response."
var response = try await chat.sendMessage(message)

message = "What\'s your favorite season of the year?"
response = try await chat.sendMessage(message)

Veja a demonstração do chat no tutorial do Swift para ver um exemplo completo.

Android

val generativeModel = GenerativeModel(
    modelName = "gemini-pro",
    apiKey = BuildConfig.apiKey
)

val chat = generativeModel.startChat()
val response = chat.sendMessage("Pretend you're a snowman and stay in
        character for each response.")
print(response.text)

Consulte o tutorial do Android para ver um exemplo completo.

cURL

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent?key=$API_KEY \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [
        {"role":"user",
         "parts":[{
           "text": "Pretend you're a snowman and stay in character for each
        {"role": "model",
            response."}]},
         "parts":[{
           "text": "Hello! It's so cold! Isn't that great?"}]},
        {"role": "user",
         "parts":[{
           "text": "What\'s your favorite season of the year?"}]},
       ]
    }' 2> /dev/null | grep "text"
# response example:
"text": "Winter, of course!"

Consulte o tutorial da API REST para mais detalhes.

Respostas transmitidas

A API Gemini oferece outra maneira de receber respostas de modelos de IA generativa: como um fluxo de dados. Esse tipo de resposta envia dados incrementais de volta para o aplicativo conforme são gerados pelo modelo. Esse recurso permite responder rapidamente a uma solicitação do usuário para mostrar o progresso e criar uma experiência mais interativa.

O streaming de respostas é uma opção para comandos e chats em formato livre com modelos do Gemini. Os exemplos de código a seguir mostram como solicitar uma resposta transmitida por streaming para uma solicitação em cada idioma compatível:

Python

prompt = "Write a story about a magic backpack."

response = genai.stream_generate_content(
    model="models/gemini-pro",
    prompt=prompt
)

Consulte o tutorial do Python para ver o snippet de código completo.

Go 

ctx := context.Background()
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

model := client.GenerativeModel("gemini-pro")

iter := model.GenerateContentStream(ctx, genai.Text("Write a story about a magic backpack."))
for {
  resp, err := iter.Next()
  if err == iterator.Done {
    break
  }
  if err != nil {
    log.Fatal(err)
  }

  // print resp
}

Veja o tutorial do Go para um exemplo completo.

Node.js

const model = genAI.getGenerativeModel({ model: "gemini-pro" });
const prompt = "Write a story about a magic backpack.";

const result = await model.generateContentStream([prompt]);
// print text as it comes in
for await (const chunk of result.stream) {
  const chunkText = chunk.text();
  console.log(chunkText);
}

Consulte o tutorial do Node.js para um exemplo completo.

Web

const model = genAI.getGenerativeModel({ model: "gemini-pro" });
const prompt = "Write a story about a magic backpack.";

const result = await model.generateContentStream([prompt]);
// print text as it comes in
for await (const chunk of result.stream) {
  const chunkText = chunk.text();
  console.log(chunkText);
}

Consulte o tutorial da Web para ver um exemplo completo.

Dart (Flutter) 

final model = GenerativeModel(model: 'gemini-pro', apiKey: apiKey);
final prompt = 'Write a story about a magic backpack.';
final content = [Content.text(prompt)];
final response = model.generateContentStream(content);
await for (final chunk in response) {
  print(chunk.text);
}

Consulte o tutorial do Dart (Flutter) para um exemplo completo.

Swift

let model = GenerativeModel(name: "gemini-pro", apiKey: "API_KEY")
let prompt = "Write a story about a magic backpack."

let stream = model.generateContentStream(prompt)
for try await chunk in stream {
  print(chunk.text ?? "No content")
}

Consulte o tutorial do Swift para ver um exemplo completo.

Android

val generativeModel = GenerativeModel(
    modelName = "gemini-pro",
    apiKey = BuildConfig.apiKey
)

val inputContent = content {
  text("Write a story about a magic backpack.")
}

var fullResponse = ""
generativeModel.generateContentStream(inputContent).collect { chunk ->
  print(chunk.text)
  fullResponse += chunk.text
}

Consulte o tutorial do Android para ver um exemplo completo.

cURL

curl https://generativelanguage.googleapis.com/v1/models/gemini-pro:streamGenerateContent?key=${API_KEY} \
    -H 'Content-Type: application/json' \
    --no-buffer \
    -d '{ "contents":[
            {"role": "user",
              "parts":[{"text": "Write a story about a magic backpack."}]
            }
          ]
        }' > response.json

Consulte o tutorial da API REST para mais detalhes.

Respostas no formato JSON

Dependendo do seu aplicativo, talvez você queira que a resposta a um prompt seja retornada em um formato de dados estruturados, principalmente se você estiver usando as respostas para preencher interfaces de programação. A API Gemini fornece um parâmetro de configuração para solicitar uma resposta no formato JSON.

Para usar esse recurso de saída, defina a opção de configuração response_mime_type como application/json e inclua uma especificação de formato JSON no corpo da solicitação. O exemplo de código a seguir mostra como solicitar uma resposta JSON para um prompt:

cURL

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-pro-latest:generateContent?key=$API_KEY \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{ "contents":[{
            "parts":[{"text": "List 5 popular cookie recipes using this JSON schema: \{ \"type\": \"object\", \"properties\": \{ \"recipe_name\": \{ \"type\": \"string\" \},\}\}"}] }],
          "generationConfig": {
            "response_mime_type": "application/json",
          } }'

Embeddings

O serviço de embedding na API Gemini gera embeddings de última geração para palavras, frases e sentenças. Os embeddings resultantes podem ser usados para tarefas de PLN, como pesquisa semântica, classificação de texto e clustering, entre muitos outros. Consulte o guia de embeddings para saber o que são embeddings e alguns casos de uso importantes do serviço de embeddings para ajudar você a começar.

Próximas etapas