All Gemini 1.5 models will be retired on September 24, 2025. To avoid service disruption, update to a newer model (for example, gemini-2.5-flash-lite). Learn more.

Esta página foi traduzida pela API Cloud Translation.

Execução do código

A execução de código é uma ferramenta que permite que o modelo gere e execute código em Python. O modelo pode aprender de forma iterativa com os resultados da execução de código até chegar a uma saída final.

Use a execução de código para criar recursos que usam o raciocínio baseado em código e geram saída de texto. Por exemplo, é possível usar a execução de código para resolver equações ou processar texto. Também é possível usar as bibliotecas incluídas no ambiente de execução de código para realizar tarefas mais especializadas.

Assim como acontece com todas as ferramentas que você fornece ao modelo, ele decide quando usar a execução de código.

Ir para a implementação do código

Comparação entre execução de código e chamada de função

A execução de código e a chamada de função são recursos semelhantes. Em geral, é melhor usar a execução de código se o modelo puder lidar com seu caso de uso. A execução de código também é mais simples de usar porque basta ativá-la.

Confira algumas diferenças adicionais entre a execução de código e a chamada de função:

Execução de código	Chamadas de função
Use a execução de código se quiser que o modelo escreva e execute código Python para você e retorne o resultado.	Use a chamada de função se você já tiver funções próprias que queira executar localmente.
A execução de código permite que o modelo execute código no back-end da API em um ambiente fixo e isolado.	Com a chamada de função, você pode executar as funções solicitadas pelo modelo no ambiente que quiser.
A execução de código é resolvida em uma única solicitação. Embora você possa usar a execução de código com o recurso de chat, isso não é obrigatório.	A chamada de função exige uma solicitação adicional para enviar de volta a saída de cada chamada de função. Portanto, é necessário usar o recurso de chat.

Modelos compatíveis

gemini-2.5-pro
gemini-2.5-flash
gemini-2.5-flash-lite
gemini-2.0-flash-001 (e o alias atualizado automaticamente gemini-2.0-flash)
gemini-2.0-flash-live-preview-04-09

Usar a execução de código

É possível usar a execução de código com entradas somente de texto e multimodais, mas a resposta será sempre apenas texto ou código.

Antes de começar

Clique no seu provedor de Gemini API para conferir o conteúdo e o código específicos do provedor nesta página.

Se ainda não tiver feito isso, conclua o guia de primeiros passos, que descreve como configurar seu projeto do Firebase, conectar seu app ao Firebase, adicionar o SDK, inicializar o serviço de back-end para o provedor Gemini API escolhido e criar uma instância GenerativeModel.

Para testar e iterar em comandos e até receber um snippet de código gerado, recomendamos usar Google AI Studio.

Ativar a execução de código

Antes de testar esta amostra, conclua a seção Antes de começar deste guia para configurar seu projeto e app.
Nessa seção, clique também em um botão do provedor de Gemini API escolhido para ver o conteúdo específico do provedor nesta página.

Ao criar a instância GenerativeModel, forneça CodeExecution como uma ferramenta que o modelo pode usar para gerar a resposta. Isso permite que o modelo gere e execute código Python.

Swift


import FirebaseAI

// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` instance with a model that supports your use case
let model = ai.generativeModel(
  modelName: "GEMINI_MODEL_NAME",
  // Provide code execution as a tool that the model can use to generate its response.
  tools: [.codeExecution()]
)

let prompt = """
What is the sum of the first 50 prime numbers?
Generate and run code for the calculation, and make sure you get all 50.
"""

let response = try await model.generateContent(prompt)

guard let candidate = response.candidates.first else {
  print("No candidates in response.")
  return
}
for part in candidate.content.parts {
  if let textPart = part as? TextPart {
    print("Text = \(textPart.text)")
  } else if let executableCode = part as? ExecutableCodePart {
    print("Code = \(executableCode.code), Language = \(executableCode.language)")
  } else if let executionResult = part as? CodeExecutionResultPart {
    print("Outcome = \(executionResult.outcome), Result = \(executionResult.output ?? "no output")")
  }
}

Kotlin


// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
    modelName = "GEMINI_MODEL_NAME",
    // Provide code execution as a tool that the model can use to generate its response.
    tools = listOf(Tool.codeExecution())
)

val prompt =  "What is the sum of the first 50 prime numbers? " +
        "Generate and run code for the calculation, and make sure you get all 50."

val response = model.generateContent(prompt)

response.candidates.first().content.parts.forEach {
    if(it is TextPart) {
        println("Text = ${it.text}")
    }
    if(it is ExecutableCodePart) {
        println("Code = ${it.code}, Language = ${it.language}")
    }
    if(it is CodeExecutionResultPart) {
       println("Outcome = ${it.outcome}, Result = ${it.output}")
    }
}

Java


// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
                .generativeModel("GEMINI_MODEL_NAME",
                        null,
                        null,
                        // Provide code execution as a tool that the model can use to generate its response.
                        List.of(Tool.codeExecution()));

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);

String text = "What is the sum of the first 50 prime numbers? " +
        "Generate and run code for the calculation, and make sure you get all 50.";

Content prompt = new Content.Builder()
    .addText(text)
    .build();

ListenableFuture response = model.generateContent(prompt);

Futures.addCallback(response, new FutureCallback() {
   @Override
public void onSuccess(GenerateContentResponse response)   {
    // Access the first candidate's content parts
    List parts = response.getCandidates().get(0).getContent().getParts();
    for (Part part : parts) {
        if (part instanceof TextPart) {
            TextPart textPart = (TextPart) part;
            System.out.println("Text = " + textPart.getText());
        } else if (part instanceof ExecutableCodePart) {
            ExecutableCodePart codePart = (ExecutableCodePart) part;
            System.out.println("Code = " + codePart.getCode() + ", Language = " + codePart.getLanguage());
        } else if (part instanceof CodeExecutionResultPart) {
            CodeExecutionResultPart resultPart = (CodeExecutionResultPart) part;
            System.out.println("Outcome = " + resultPart.getOutcome() + ", Result = " + resultPart.getOutput());
        }
    }
}

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Web


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(
  ai,
  {
    model: "GEMINI_MODEL_NAME",
    // Provide code execution as a tool that the model can use to generate its response.
    tools: [{ codeExecution: {} }]
  }
);

const prompt =  "What is the sum of the first 50 prime numbers? " +
        "Generate and run code for the calculation, and make sure you get all 50."

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

const parts = response.candidates?.[0].content.parts;

if (parts) {
  parts.forEach((part) => {
    if (part.text) {
        console.log(`Text: ${part.text}`);
    } else if (part.executableCode) {
      console.log(
        `Code: ${part.executableCode.code}, Language: ${part.executableCode.language}`
      );
    } else if (part.codeExecutionResult) {
      console.log(
        `Outcome: ${part.codeExecutionResult.outcome}, Result: ${part.codeExecutionResult.output}`
      );
    }
  });
}

Dart

O suporte para Flutter será disponibilizado na próxima versão.

Unity

O suporte ao Unity será disponibilizado na próxima versão.

Saiba como escolher um modelo adequado para seu caso de uso e app.

Ver exemplo de saída

A saída pode ser semelhante a esta, que foi formatada para facilitar a leitura:

Okay, I need to calculate the sum of the first 50 prime numbers. Here's how I'll
approach this:

1.  **Generate Prime Numbers:** I'll use an iterative method to find prime
    numbers. I'll start with 2 and check if each subsequent number is divisible
    by any number between 2 and its square root. If not, it's a prime.
2.  **Store Primes:** I'll store the prime numbers in a list until I have 50 of
    them.
3.  **Calculate the Sum:**  Finally, I'll sum the prime numbers in the list.

Here's the Python code to do this:

def is_prime(n):
  """Efficiently checks if a number is prime."""
  if n <= 1:
    return False
  if n <= 3:
    return True
  if n % 2 == 0 or n % 3 == 0:
    return False
  i = 5
  while i * i <= n:
    if n % i == 0 or n % (i + 2) == 0:
      return False
    i += 6
  return True

primes = []
num = 2
while len(primes) < 50:
  if is_prime(num):
    primes.append(num)
  num += 1

sum_of_primes = sum(primes)
print(f'{primes=}')
print(f'{sum_of_primes=}')

primes=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67,
71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229]
sum_of_primes=5117

The sum of the first 50 prime numbers is 5117.

Essa saída combina várias partes de conteúdo que o modelo retorna ao usar a execução de código:

text: texto inline gerado pelo modelo
executableCode: código gerado pelo modelo para ser executado
codeExecutionResult: resultado do código executado.

As convenções de nomenclatura dessas partes variam de acordo com a linguagem de programação.

Usar a execução de código na conversa

Você também pode usar a execução de código como parte de uma conversa:

Swift


import FirebaseAI

// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` instance with a model that supports your use case
let model = ai.generativeModel(
  modelName: "GEMINI_MODEL_NAME",
  // Provide code execution as a tool that the model can use to generate its response.
  tools: [.codeExecution()]
)

let prompt = """
What is the sum of the first 50 prime numbers?
Generate and run code for the calculation, and make sure you get all 50.
"""
let chat = model.startChat()

let response = try await chat.sendMessage(prompt)

guard let candidate = response.candidates.first else {
  print("No candidates in response.")
  return
}
for part in candidate.content.parts {
  if let textPart = part as? TextPart {
    print("Text = \(textPart.text)")
  } else if let executableCode = part as? ExecutableCodePart {
    print("Code = \(executableCode.code), Language = \(executableCode.language)")
  } else if let executionResult = part as? CodeExecutionResultPart {
    print("Outcome = \(executionResult.outcome), Result = \(executionResult.output ?? "no output")")
  }
}

Kotlin


// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
    modelName = "GEMINI_MODEL_NAME",
    // Provide code execution as a tool that the model can use to generate its response.
    tools = listOf(Tool.codeExecution())
)

val prompt =  "What is the sum of the first 50 prime numbers? " +
        "Generate and run code for the calculation, and make sure you get all 50."
val chat = model.startChat()
val response = chat.sendMessage(prompt)

response.candidates.first().content.parts.forEach {
    if(it is TextPart) {
        println("Text = ${it.text}")
    }
    if(it is ExecutableCodePart) {
        println("Code = ${it.code}, Language = ${it.language}")
    }
    if(it is CodeExecutionResultPart) {
       println("Outcome = ${it.outcome}, Result = ${it.output}")
    }
}

Java


// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
                .generativeModel("GEMINI_MODEL_NAME",
                        null,
                        null,
                        // Provide code execution as a tool that the model can use to generate its response.
                        List.of(Tool.codeExecution()));

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);
String text = "What is the sum of the first 50 prime numbers? " +
        "Generate and run code for the calculation, and make sure you get all 50.";

Content prompt = new Content.Builder()
    .addText(text)
    .build();

ChatFutures chat = model.startChat();
ListenableFuture response = chat.sendMessage(prompt);

Futures.addCallback(response, new FutureCallback() {
   @Override
public void onSuccess(GenerateContentResponse response)   {
    // Access the first candidate's content parts
    List parts = response.getCandidates().get(0).getContent().getParts();
    for (Part part : parts) {
        if (part instanceof TextPart) {
            TextPart textPart = (TextPart) part;
            System.out.println("Text = " + textPart.getText());
        } else if (part instanceof ExecutableCodePart) {
            ExecutableCodePart codePart = (ExecutableCodePart) part;
            System.out.println("Code = " + codePart.getCode() + ", Language = " + codePart.getLanguage());
        } else if (part instanceof CodeExecutionResultPart) {
            CodeExecutionResultPart resultPart = (CodeExecutionResultPart) part;
            System.out.println("Outcome = " + resultPart.getOutcome() + ", Result = " + resultPart.getOutput());
        }
    }
}

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Web


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(
  ai,
  {
    model: "GEMINI_MODEL_NAME",
    // Provide code execution as a tool that the model can use to generate its response.
    tools: [{ codeExecution: {} }]
  }
);

const prompt =  "What is the sum of the first 50 prime numbers? " +
        "Generate and run code for the calculation, and make sure you get all 50."
const chat = model.startChat()
const result = await chat.sendMessage(prompt);
const response = await result.response;

const parts = response.candidates?.[0].content.parts;

if (parts) {
  parts.forEach((part) => {
    if (part.text) {
        console.log(`Text: ${part.text}`);
    } else if (part.executableCode) {
      console.log(
        `Code: ${part.executableCode.code}, Language: ${part.executableCode.language}`
      );
    } else if (part.codeExecutionResult) {
      console.log(
        `Outcome: ${part.codeExecutionResult.outcome}, Result: ${part.codeExecutionResult.output}`
      );
    }
  });
}

Dart

O suporte para Flutter será disponibilizado na próxima versão.

Unity

O suporte ao Unity será disponibilizado na próxima versão.

Saiba como escolher um modelo adequado para seu caso de uso e app.

Preços

Não há cobrança extra para ativar a execução de código e disponibilizá-la como uma ferramenta para o modelo. Se o modelo decidir usar a execução de código, você vai receber uma cobrança na taxa atual de tokens de entrada e saída com base no modelo do Gemini que estiver usando.

O diagrama a seguir mostra o modelo de faturamento para execução de código:

Diagrama mostrando como os tokens são faturados quando um modelo usa a execução de código.

Confira um resumo de como os tokens são faturados quando um modelo usa a execução de código:

O comando original é faturado uma vez. Os tokens são rotulados como intermediários e são cobrados como tokens de entrada.
O código gerado e o resultado do código executado são faturados da seguinte forma:
- Quando são usados durante a execução do código, eles são rotulados como tokens intermediários, que são faturados como tokens de entrada.
- Quando incluídos como parte da resposta final, eles são cobrados como tokens de saída.
O resumo final na resposta final é faturado como tokens de saída.

O Gemini API inclui uma contagem de tokens intermediários na resposta da API para que você saiba por que está recebendo cobranças por tokens de entrada além do comando inicial.

O código gerado pode incluir texto e saídas multimodais, como imagens.

Limitações e práticas recomendadas

O modelo só pode gerar e executar código Python. Ele não pode retornar outros artefatos, como arquivos de mídia.
A execução do código pode durar no máximo 30 segundos antes de atingir o tempo limite.
Em alguns casos, ativar a execução de código pode levar a regressões em outras áreas da saída do modelo (por exemplo, escrever uma história).
A ferramenta de execução de código não é compatível com URIs de arquivo como entrada/saída. No entanto, a ferramenta de execução de código é compatível com entrada de arquivos e saída de gráficos como bytes inline. Ao usar esses recursos de entrada e saída, você pode fazer upload de arquivos CSV e de texto, fazer perguntas sobre eles e gerar gráficos do Matplotlib como parte do resultado da execução do código. Os tipos MIME aceitos para bytes inline são .cpp, .csv, .java, .jpeg, .js, .png, .py, .ts e .xml.

Bibliotecas permitidas

O ambiente de execução de código inclui as seguintes bibliotecas. Não é possível instalar suas próprias bibliotecas.

Ver bibliotecas compatíveis com o Gemini Developer API

attrs
xadrez
contourpy
fpdf
geopandas
imageio
jinja2
joblib
jsonschema
jsonschema-specifications
lxml
matplotlib
mpmath
numpy
opencv-python
openpyxl
empacotamento
pandas
pillow
protobuf
pylatex
pyparsing
PyPDF2
python-dateutil
python-docx
python-pptx
reportlab
scikit-learn
scipy
seaborn
six
striprtf
sympy
tabulate
tensorflow
toolz
xlrd

Ver bibliotecas compatíveis com o Vertex AI Gemini API

Altair
Xadrez
Cv2
Matplotlib
Mpmath (link em inglês)
NumPy
Pandas
Pdfminer
Reportlab (em inglês)
Seaborn (em inglês)
Sklearn
Statsmodels (em inglês)
Striprtf
SymPy
Tabulate (em inglês)

Enviar feedback sobre sua experiência com Firebase AI Logic

Execução do código Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Comparação entre execução de código e chamada de função

Modelos compatíveis

Usar a execução de código

Antes de começar

Ativar a execução de código

Swift

Kotlin

Java

Web

Dart

Unity

Usar a execução de código na conversa

Swift

Kotlin

Java

Web

Dart

Unity

Preços

Limitações e práticas recomendadas

Bibliotecas permitidas

Execução do código