Guia para desenvolvedores do Gemini 3

O Gemini 3 é nossa família de modelos mais inteligente até o momento, criada com base em um raciocínio de última geração. Ele foi projetado para transformar qualquer ideia em realidade, dominando fluxos de trabalho baseados em agentes, programação autônoma e tarefas multimodais complexas. Este guia aborda os principais recursos da família de modelos Gemini 3 e como aproveitar ao máximo.

Conheça nossa coleção de apps do Gemini 3 para saber como o modelo lida com raciocínio avançado, programação autônoma e tarefas multimodais complexas.

Comece com algumas linhas de código:

from google import genai

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3-pro-preview",
    contents="Find the race condition in this multi-threaded C++ snippet: [code here]",
)

print(response.text)

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({});

async function run() {
  const response = await ai.models.generateContent({
    model: "gemini-3-pro-preview",
    contents: "Find the race condition in this multi-threaded C++ snippet: [code here]",
  });

  console.log(response.text);
}

run();

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3-pro-preview:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "contents": [{
      "parts": [{"text": "Find the race condition in this multi-threaded C++ snippet: [code here]"}]
    }]
  }'

Conheça a série Gemini 3

O Gemini 3 Pro, o primeiro modelo da nova série, é ideal para tarefas complexas que exigem amplo conhecimento geral e raciocínio avançado em várias modalidades.

O Gemini 3 Flash é nosso modelo mais recente da série 3, com inteligência de nível Pro na velocidade e nos preços do Flash.

O Nano Banana Pro (também conhecido como Gemini 3 Pro para imagens) é nosso modelo de geração de imagens mais avançado.

Todos os modelos do Gemini 3 estão em pré-lançamento.

* Os preços são por 1 milhão de tokens, a menos que indicado de outra forma. ** O preço das imagens varia de acordo com a resolução. Consulte a página de preços para mais detalhes.

Para limites detalhados, preços e mais informações, consulte a página de modelos.

Novos recursos da API no Gemini 3

O Gemini 3 apresenta novos parâmetros projetados para dar aos desenvolvedores mais controle sobre latência, custo e fidelidade multimodal.

Nível de pensamento

Os modelos da série Gemini 3 usam o raciocínio dinâmico por padrão para analisar os comandos. Você pode usar o parâmetro thinking_level, que controla a profundidade máxima do processo de raciocínio interno do modelo antes de produzir uma resposta. O Gemini 3 trata esses níveis como permissões relativas para pensar, e não como garantias estritas de token.

Se thinking_level não for especificado, o Gemini 3 vai usar high como padrão. Para respostas mais rápidas e com menor latência quando não é necessário um raciocínio complexo, você pode restringir o nível de pensamento do modelo a low.

Níveis de pensamento do Gemini 3 Pro e Flash:

Os seguintes níveis de raciocínio são compatíveis com o Gemini 1.5 Pro e o Flash:

• low: minimiza a latência e o custo. Ideal para seguir instruções simples, conversar ou aplicativos de alta capacidade de processamento
• high (padrão, dinâmico): maximiza a profundidade do raciocínio. O modelo pode levar muito mais tempo para alcançar um primeiro token, mas a saída será mais bem fundamentada.

Níveis de raciocínio do Gemini 3 Flash

Além dos níveis acima, o Gemini 3 Flash também é compatível com os seguintes níveis de raciocínio, que não são aceitos pelo Gemini 3 Pro:

• minimal: corresponde à configuração "sem pensar" para a maioria das consultas. O modelo pode pensar de forma muito minimalista para tarefas de programação complexas. Minimiza a latência para aplicativos de chat ou de alta capacidade de processamento.

• medium: pensamento equilibrado para a maioria das tarefas.

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3-pro-preview",
    contents="How does AI work?",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_level="low")
    ),
)

print(response.text)

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({});

const response = await ai.models.generateContent({
    model: "gemini-3-pro-preview",
    contents: "How does AI work?",
    config: {
      thinkingConfig: {
        thinkingLevel: "low",
      }
    },
  });

console.log(response.text);

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3-pro-preview:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "contents": [{
      "parts": [{"text": "How does AI work?"}]
    }],
    "generationConfig": {
      "thinkingConfig": {
        "thinkingLevel": "low"
      }
    }
  }'

Resolução da mídia

O Gemini 3 apresenta controle granular sobre o processamento de visão multimodal usando o parâmetro media_resolution. Resoluções mais altas melhoram a capacidade do modelo de ler textos pequenos ou identificar detalhes pequenos, mas aumentam o uso de tokens e a latência. O parâmetro media_resolution determina o número máximo de tokens alocados por imagem de entrada ou frame de vídeo.

Agora é possível definir a resolução como media_resolution_low, media_resolution_medium, media_resolution_high ou media_resolution_ultra_high para cada parte de mídia ou globalmente (via generation_config, global não disponível para ultra alta). Se não for especificado, o modelo usará padrões ideais com base no tipo de mídia.

Configurações recomendadas

from google import genai
from google.genai import types
import base64

# The media_resolution parameter is currently only available in the v1alpha API version.
client = genai.Client(http_options={'api_version': 'v1alpha'})

response = client.models.generate_content(
    model="gemini-3-pro-preview",
    contents=[
        types.Content(
            parts=[
                types.Part(text="What is in this image?"),
                types.Part(
                    inline_data=types.Blob(
                        mime_type="image/jpeg",
                        data=base64.b64decode("..."),
                    ),
                    media_resolution={"level": "media_resolution_high"}
                )
            ]
        )
    ]
)

print(response.text)

import { GoogleGenAI } from "@google/genai";

// The media_resolution parameter is currently only available in the v1alpha API version.
const ai = new GoogleGenAI({ apiVersion: "v1alpha" });

async function run() {
  const response = await ai.models.generateContent({
    model: "gemini-3-pro-preview",
    contents: [
      {
        parts: [
          { text: "What is in this image?" },
          {
            inlineData: {
              mimeType: "image/jpeg",
              data: "...",
            },
            mediaResolution: {
              level: "media_resolution_high"
            }
          }
        ]
      }
    ]
  });

  console.log(response.text);
}

run();

curl "https://generativelanguage.googleapis.com/v1alpha/models/gemini-3-pro-preview:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "contents": [{
      "parts": [
        { "text": "What is in this image?" },
        {
          "inlineData": {
            "mimeType": "image/jpeg",
            "data": "..."
          },
          "mediaResolution": {
            "level": "media_resolution_high"
          }
        }
      ]
    }]
  }'

Temperatura

Para o Gemini 3, recomendamos manter o parâmetro de temperatura no valor padrão de 1.0.

Embora os modelos anteriores geralmente se beneficiassem do ajuste da temperatura para controlar a criatividade em relação ao determinismo, as capacidades de raciocínio do Gemini 3 são otimizadas para a configuração padrão. Mudar a temperatura (definindo-a abaixo de 1,0) pode levar a um comportamento inesperado, como looping ou desempenho degradado, principalmente em tarefas matemáticas ou de raciocínio complexas.

Assinaturas de pensamento

O Gemini 3 usa assinaturas de pensamento para manter o contexto de raciocínio em todas as chamadas de API. Essas assinaturas são representações criptografadas do processo de raciocínio interno do modelo. Para garantir que o modelo mantenha as capacidades de raciocínio, retorne essas assinaturas ao modelo na sua solicitação exatamente como foram recebidas:

• Chamada de função (estrita): a API aplica validação estrita na "rodada atual". A falta de assinaturas vai resultar em um erro 400.

• Texto/Chat:a validação não é estritamente aplicada, mas omitir assinaturas vai prejudicar o raciocínio e a qualidade das respostas do modelo.

• Geração/edição de imagens (restrita): a API aplica validação restrita em todas as partes do modelo, incluindo um thoughtSignature. A falta de assinaturas vai resultar em um erro 400.

Chamada de função (validação estrita)

Quando o Gemini gera um functionCall, ele depende do thoughtSignature para processar a saída da ferramenta corretamente na próxima vez. O "Turno atual" inclui todas as etapas do modelo (functionCall) e do usuário (functionResponse) que ocorreram desde a última mensagem padrão Usuário text.

• Chamada de função única:a parte functionCall contém uma assinatura. Você precisa devolver o dispositivo.
• Chamadas de função paralelas:apenas a primeira parte functionCall na lista vai conter a assinatura. Você precisa devolver as peças na ordem exata em que foram recebidas.
• Várias etapas (sequencial): se o modelo chamar uma ferramenta, receber um resultado e chamar outra ferramenta (na mesma vez), ambas as chamadas de função terão assinaturas. Você precisa retornar todas as assinaturas acumuladas no histórico.

Texto e streaming

Para conversas padrão ou geração de texto, não há garantia de que uma assinatura vai aparecer.

• Não streaming: a parte final do conteúdo da resposta pode conter um thoughtSignature, embora nem sempre esteja presente. Se um for retornado, envie-o de volta para manter o melhor desempenho.
• Streaming: se uma assinatura for gerada, ela poderá chegar em um bloco final que contém uma parte de texto vazia. Verifique se o analisador de fluxo procura assinaturas mesmo que o campo de texto esteja vazio.

Geração e edição de imagens

Para gemini-3-pro-image-preview, as assinaturas de pensamento são essenciais para a edição conversacional. Quando você pede para o modelo modificar uma imagem, ele usa o thoughtSignature da vez anterior para entender a composição e a lógica da imagem original.

• Edição:as assinaturas são garantidas na primeira parte após os pensamentos da resposta (text ou inlineData) e em todas as partes inlineData subsequentes. É necessário retornar todas essas assinaturas para evitar erros.

Exemplos de código

// Model Response (Turn 1, Step 1)
  {
    "role": "model",
    "parts": [
      {
        "functionCall": { "name": "check_flight", "args": {...} },
        "thoughtSignature": "<Sig_A>" // SAVE THIS
      }
    ]
  }

// User Request (Turn 1, Step 2)
[
  { "role": "user", "parts": [{ "text": "Check flight AA100..." }] },
  { 
    "role": "model", 
    "parts": [
      { 
        "functionCall": { "name": "check_flight", "args": {...} }, 
        "thoughtSignature": "<Sig_A>" // REQUIRED
      } 
    ]
  },
  { "role": "user", "parts": [{ "functionResponse": { "name": "check_flight", "response": {...} } }] }
]

// Model Response (Turn 1, Step 3)
{
  "role": "model",
  "parts": [
    {
      "functionCall": { "name": "book_taxi", "args": {...} },
      "thoughtSignature": "<Sig_B>" // SAVE THIS
    }
  ]
}

// User Request (Turn 1, Step 4)
[
  // ... previous history ...
  { 
    "role": "model", 
    "parts": [
       { "functionCall": { "name": "check_flight", ... }, "thoughtSignature": "<Sig_A>" } 
    ]
  },
  { "role": "user", "parts": [{ "functionResponse": {...} }] },
  { 
    "role": "model", 
    "parts": [
       { "functionCall": { "name": "book_taxi", ... }, "thoughtSignature": "<Sig_B>" } 
    ]
  },
  { "role": "user", "parts": [{ "functionResponse": {...} }] }
]

// User Request (Sending Parallel Results)
[
  {
    "role": "user",
    "parts": [
      { "text": "Check the weather in Paris and London." }
    ]
  },
  {
    "role": "model",
    "parts": [
      // 1. First Function Call has the signature
      {
        "functionCall": { "name": "check_weather", "args": { "city": "Paris" } },
        "thoughtSignature": "<Signature_A>" 
      },
      // 2. Subsequent parallel calls DO NOT have signatures
      {
        "functionCall": { "name": "check_weather", "args": { "city": "London" } }
      } 
    ]
  },
  {
    "role": "user",
    "parts": [
      // 3. Function Responses are grouped together in the next block
      {
        "functionResponse": { "name": "check_weather", "response": { "temp": "15C" } }
      },
      {
        "functionResponse": { "name": "check_weather", "response": { "temp": "12C" } }
      }
    ]
  }
]

// User Request (Follow-up question)
[
  { 
    "role": "user", 
    "parts": [{ "text": "What are the risks of this investment?" }] 
  },
  { 
    "role": "model", 
    "parts": [
      {
        "text": "I need to calculate the risk step-by-step. First, I'll look at volatility...",
        "thoughtSignature": "<Signature_C>" // Recommended to include
      }
    ]
  },
  { 
    "role": "user", 
    "parts": [{ "text": "Summarize that in one sentence." }] 
  }
]

// Model Response (Turn 1)
{
  "role": "model",
  "parts": [
    // 1. First part ALWAYS has a signature (even if text)
    {
      "text": "I will generate a cyberpunk city...",
      "thoughtSignature": "<Signature_D>" 
    },
    // 2. ALL InlineData (Image) parts ALWAYS have signatures
    {
      "inlineData": { ... }, 
      "thoughtSignature": "<Signature_E>" 
    },
  ]
}

// User Request (Turn 2 - Requesting an Edit)
{
  "contents": [
    // History must include ALL signatures received
    {
      "role": "user",
      "parts": [{ "text": "Generate a cyberpunk city" }]
    },
    {
      "role": "model",
      "parts": [
         { "text": "...", "thoughtSignature": "<Signature_D>" },
         { "inlineData": "...", "thoughtSignature": "<Signature_E>" },
      ]
    },
    // New User Prompt
    {
      "role": "user",
      "parts": [{ "text": "Make it daytime." }]
    }
  ]
}

Migração de outros modelos

Se você estiver transferindo um rastreamento de conversa de outro modelo (por exemplo, Gemini 2.5) ou injetar uma chamada de função personalizada que não foi gerada pelo Gemini 3, você não terá uma assinatura válida.

Para ignorar a validação estrita nesses cenários específicos, preencha o campo com esta string fictícia específica: "thoughtSignature": "context_engineering_is_the_way_to_go"

Saídas estruturadas com ferramentas

Os modelos do Gemini 3 permitem combinar saídas estruturadas com ferramentas integradas, incluindo Como basear com a Pesquisa Google, Contexto de URL e Execução de código.

from google import genai
from google.genai import types
from pydantic import BaseModel, Field
from typing import List

class MatchResult(BaseModel):
    winner: str = Field(description="The name of the winner.")
    final_match_score: str = Field(description="The final match score.")
    scorers: List[str] = Field(description="The name of the scorer.")

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3-pro-preview",
    contents="Search for all details for the latest Euro.",
    config={
        "tools": [
            {"google_search": {}},
            {"url_context": {}}
        ],
        "response_mime_type": "application/json",
        "response_json_schema": MatchResult.model_json_schema(),
    },  
)

result = MatchResult.model_validate_json(response.text)
print(result)

import { GoogleGenAI } from "@google/genai";
import { z } from "zod";
import { zodToJsonSchema } from "zod-to-json-schema";

const ai = new GoogleGenAI({});

const matchSchema = z.object({
  winner: z.string().describe("The name of the winner."),
  final_match_score: z.string().describe("The final score."),
  scorers: z.array(z.string()).describe("The name of the scorer.")
});

async function run() {
  const response = await ai.models.generateContent({
    model: "gemini-3-pro-preview",
    contents: "Search for all details for the latest Euro.",
    config: {
      tools: [
        { googleSearch: {} },
        { urlContext: {} }
      ],
      responseMimeType: "application/json",
      responseJsonSchema: zodToJsonSchema(matchSchema),
    },
  });

  const match = matchSchema.parse(JSON.parse(response.text));
  console.log(match);
}

run();

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3-pro-preview:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "contents": [{
      "parts": [{"text": "Search for all details for the latest Euro."}]
    }],
    "tools": [
      {"googleSearch": {}},
      {"urlContext": {}}
    ],
    "generationConfig": {
        "responseMimeType": "application/json",
        "responseJsonSchema": {
            "type": "object",
            "properties": {
                "winner": {"type": "string", "description": "The name of the winner."},
                "final_match_score": {"type": "string", "description": "The final score."},
                "scorers": {
                    "type": "array",
                    "items": {"type": "string"},
                    "description": "The name of the scorer."
                }
            },
            "required": ["winner", "final_match_score", "scorers"]
        }
    }
  }'

Geração de imagens

Com o Gemini 3 Pro Imagem, você pode gerar e editar imagens com base em comandos de texto. Ele usa o raciocínio para "pensar" em um comando e pode recuperar dados em tempo real, como previsões do tempo ou gráficos de ações, antes de usar a ancoragem da Pesquisa Google e gerar imagens de alta fidelidade.

Novos recursos e melhorias:

• Renderização de texto e 4K:gere texto e diagramas nítidos e legíveis com resoluções de até 2K e 4K.
• Geração embasada:use a ferramenta google_search para verificar fatos e gerar imagens com base em informações do mundo real.
• Edição conversacional:edição de imagens em várias etapas apenas pedindo mudanças (por exemplo, "Deixe o plano de fundo como um pôr do sol"). Esse fluxo de trabalho usa assinaturas de pensamento para preservar o contexto visual entre as conversas.

Para detalhes completos sobre proporções, fluxos de trabalho de edição e opções de configuração, consulte o guia de geração de imagens.

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3-pro-image-preview",
    contents="Generate an infographic of the current weather in Tokyo.",
    config=types.GenerateContentConfig(
        tools=[{"google_search": {}}],
        image_config=types.ImageConfig(
            aspect_ratio="16:9",
            image_size="4K"
        )
    )
)

image_parts = [part for part in response.parts if part.inline_data]

if image_parts:
    image = image_parts[0].as_image()
    image.save('weather_tokyo.png')
    image.show()

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

const ai = new GoogleGenAI({});

async function run() {
  const response = await ai.models.generateContent({
    model: "gemini-3-pro-image-preview",
    contents: "Generate a visualization of the current weather in Tokyo.",
    config: {
      tools: [{ googleSearch: {} }],
      imageConfig: {
        aspectRatio: "16:9",
        imageSize: "4K"
      }
    }
  });

  for (const part of response.candidates[0].content.parts) {
    if (part.inlineData) {
      const imageData = part.inlineData.data;
      const buffer = Buffer.from(imageData, "base64");
      fs.writeFileSync("weather_tokyo.png", buffer);
    }
  }
}

run();

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3-pro-image-preview:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "contents": [{
      "parts": [{"text": "Generate a visualization of the current weather in Tokyo."}]
    }],
    "tools": [{"googleSearch": {}}],
    "generationConfig": {
        "imageConfig": {
          "aspectRatio": "16:9",
          "imageSize": "4K"
      }
    }
  }'

Exemplo de resposta

Migrar do Gemini 2.5

O Gemini 3 é nossa família de modelos mais avançada até o momento e oferece uma melhoria gradual em relação ao Gemini 2.5. Ao migrar, considere o seguinte:

• Raciocínio:se você usava engenharia de comandos complexa (como cadeia de pensamento) para forçar o Gemini 2.5 a raciocinar, teste o Gemini 3 com thinking_level: "high" e comandos simplificados.
• Configurações de temperatura:se o código atual definir explicitamente a temperatura (principalmente para valores baixos em saídas determinísticas), recomendamos remover esse parâmetro e usar o padrão do Gemini 3 de 1,0 para evitar possíveis problemas de loop ou degradação de desempenho em tarefas complexas.
• Compreensão de documentos e PDFs:a resolução padrão de OCR para PDFs mudou. Se você dependia de um comportamento específico para a análise de documentos densos, teste a nova configuração media_resolution_high para garantir a precisão contínua.
• Consumo de tokens:a migração para os padrões do Gemini 3 pode aumentar o uso de tokens para PDFs, mas diminuir o uso de tokens para vídeos. Se as solicitações excederem a janela de contexto devido a resoluções padrão mais altas, recomendamos reduzir explicitamente a resolução da mídia.
• Segmentação de imagens:os recursos de segmentação de imagens (que retornam máscaras no nível de pixel para objetos) não são compatíveis com o Gemini 3 Pro ou o Gemini 3 Flash. Para cargas de trabalho que exigem segmentação de imagem nativa, recomendamos continuar usando o Gemini 2.5 Flash com o modo de pensamento desativado ou o Gemini Robotics-ER 1.5.
• Suporte a ferramentas: as ferramentas de embasamento do Maps e de uso do computador ainda não são compatíveis com os modelos do Gemini 3 e, portanto, não serão migradas. Além disso, ainda não é possível combinar ferramentas integradas com a chamada de função.

Compatibilidade com a OpenAI

Para usuários que utilizam a camada de compatibilidade do OpenAI, os parâmetros padrão são mapeados automaticamente para equivalentes do Gemini:

• reasoning_effort (OAI) é mapeado para thinking_level (Gemini). Observe que o meio reasoning_effort é mapeado para o alto thinking_level.

Práticas recomendadas para a solicitação

O Gemini 3 é um modelo de raciocínio, o que muda a forma como você precisa dar comandos.

• Instruções precisas:seja conciso nos comandos de entrada. O Gemini 3 responde melhor a instruções diretas e claras. Ela pode analisar demais técnicas de engenharia de comandos detalhadas ou muito complexas usadas em modelos mais antigos.
• Nível de detalhe da saída:por padrão, o Gemini 3 é menos detalhista e prefere fornecer respostas diretas e eficientes. Se o caso de uso exigir uma personalidade mais conversacional ou "falante", você precisará direcionar explicitamente o modelo no comando (por exemplo, "Explique isso como um assistente simpático e falante").
• Gerenciamento de contexto:ao trabalhar com conjuntos de dados grandes (por exemplo, livros inteiros, bases de código ou vídeos longos), coloque suas instruções ou perguntas específicas no final do comando, depois do contexto dos dados. Ancore o raciocínio do modelo nos dados fornecidos começando sua pergunta com uma frase como "Com base nas informações acima...".

Saiba mais sobre estratégias de design de comandos no guia de engenharia de comandos.

Perguntas frequentes

1. Qual é o corte de conhecimento do Gemini 3? Os modelos do Gemini 3 têm um corte de conhecimento de janeiro de 2025. Para informações mais recentes, use a ferramenta Embasamento da pesquisa.

2. Quais são os limites da janela de contexto? Os modelos do Gemini 3 oferecem suporte a uma janela de contexto de entrada de 1 milhão de tokens e até 64 mil tokens de saída.

3. Existe um nível sem custo financeiro para o Gemini 3? O Gemini 3 Flash gemini-3-flash-preview tem um nível sem custo financeiro na API Gemini. Você pode testar o Gemini 3 Pro e o Flash sem custos financeiros no Google AI Studio, mas, no momento, não há um nível sem custo financeiro disponível para gemini-3-pro-preview na API Gemini.

4. Meu código thinking_budget antigo ainda vai funcionar? Sim, thinking_budget ainda é compatível com versões anteriores, mas recomendamos migrar para thinking_level para ter uma performance mais previsível. Não use os dois na mesma solicitação.

5. O Gemini 3 é compatível com a API Batch? Sim, o Gemini 3 é compatível com a API Batch.

6. O armazenamento em cache de contexto é compatível? Sim, o armazenamento em cache de contexto é compatível com o Gemini 3. O número mínimo de tokens necessário para iniciar o armazenamento em cache é de 2.048.

7. Quais ferramentas são compatíveis com o Gemini 3? O Gemini 3 é compatível com a Pesquisa Google, a Pesquisa de arquivos, a Execução de código e o Contexto de URL. Ele também oferece suporte à chamada de função padrão para suas próprias ferramentas personalizadas, mas não com ferramentas integradas. No momento, não é possível usar os recursos Fundamentação com o Google Maps e Uso de computador.

Próximas etapas

• Comece a usar o Cookbook do Gemini 3
• Confira o guia dedicado do Cookbook sobre níveis de pensamento e como migrar do orçamento de pensamento para os níveis de pensamento.