|

Como integrar o Gemini Tool Retrieval? 3 passos para implementar o carregamento de ferramentas sob demanda usando Python, tool_search e defer_loading

Como integrar o Gemini Tool Retrieval? 3 passos para implementar o carregamento de ferramentas sob demanda usando Python, tool_search e defer_loading

Integrar o Gemini Tool Retrieval exige três coisas. Primeiro, adicione {"type": "tool_search"} ao array tools e defina defer_loading: True para funções de negócio pouco usadas. Segundo, faça a requisição usando a Interactions API na versão v1beta e depois encontre o function_call em interaction.steps. Terceiro, execute a função localmente, monte o function_result com base no call_id e envie de volta junto com o array tools completo. Não é preciso criar seu próprio pesquisador de ferramentas: o servidor faz a busca de ferramentas e o carregamento do Schema de parâmetros.

Antes de mais nada, é importante deixar claro: o Tool Retrieval só muda “quando as definições dos parâmetros das ferramentas entram no contexto do modelo”; as funções continuam sendo executadas pelo desenvolvedor. Ele também não garante economia. Em cenários com poucas ferramentas e contexto longo, o consumo de tokens pode até aumentar.

O que você vai encontrar neste artigo?

  • Quais modelos o Gemini Tool Retrieval suporta, qual versão do SDK é necessária e por que é obrigatório especificar v1beta
  • Um exemplo Python completo com nomes de variáveis consistentes: duas ferramentas com carregamento adiado, inventário e pedidos, da busca até a resposta final
  • Quem trata tool_search_call, tool_search_result, function_call e function_result
  • As diferenças entre três rotas de expansão: carregamento adiado via MCP remoto, busca no cliente e um Tool Registry próprio
  • Como investigar erros comuns como HTTP 400 de forma centralizada, e como avaliar se vale a pena antes de habilitar

Índice: primeiro, uma tabela To Know para explicar os campos principais; depois, “Visão rápida de impacto” para mostrar o que esse recurso de preview significa para diferentes perfis. A seção “Fatos objetivos” segue a ordem de integração: preparar o ambiente, definir ferramentas, observar as etapas de busca, retornar os resultados das funções e, por fim, expandir para MCP e busca no cliente; a investigação de erros fica concentrada no final dessa parte. A seção “Análise e julgamento” usa dois exemplos hipotéticos fornecidos pelo Google para discutir cenários em que o Tool Retrieval é e não é adequado.

gemini-tool-retrieval-python-tool-search-defer-loading-pt-pt-image-0


Conceitos-chave do Gemini Tool Retrieval (To Know)

Conceito Explicação resumida
google-genai Nome do pacote do SDK oficial em Python do Google; a importação é feita com from google import genai
v1beta Versão de interface de pré-visualização, obrigatória para o Tool Retrieval; neste artigo ela é especificada explicitamente na inicialização do cliente
Interactions API Interface do Google voltada para fluxos de trabalho de agentes, com suporte a conversas com estado e etapas de execução observáveis
tool_search Tipo especial de ferramenta que declara a ativação da recuperação de ferramentas; no máximo um por requisição
defer_loading Faz com que a definição completa dos parâmetros de uma função ou servidor MCP especificado entre no contexto do modelo só mais tarde (carregamento adiado)
short_description Breve descrição da função adiada que o modelo consegue ver no início; só pode ser usada em funções adiadas
tool_search_call Etapa de busca iniciada pelo modelo dentro do fluxo de recuperação do lado do servidor
tool_search_result Etapa em que o servidor retorna o Schema completo das ferramentas correspondentes
function_call Quando o modelo pede que o código do desenvolvedor execute alguma função, informando os parâmetros
function_result Tipo de entrada usado pela aplicação para devolver ao modelo o resultado da execução da função
call_id Identificador que associa o resultado da execução da função ao function_call.id original
previous_interaction_id Identificador que permite que as requisições seguintes continuem um registro de interação já salvo no servidor
signature Campo de assinatura que precisa ser devolvido exatamente como está, junto com a etapa original, quando uma sessão sem estado reproduz etapas do histórico

Visão rápida do impacto do Gemini Tool Retrieval

Público Impacto real
Desenvolvedores de Agents Agents com muitas ferramentas podem carregar ferramentas de cauda longa sob demanda, sem precisar construir sua própria busca vetorial — mas precisam trocar para a Interactions API
Equipes que já usam generateContent O método antigo não suporta Tool Retrieval, então é preciso migrar a interface e a análise da estrutura de retorno
Integradores de MCP Podem definir defer_loading de uma vez no nível do mcp_server, sem precisar declarar ferramenta por ferramenta
Responsáveis por custos Não existe uma taxa de recurso separada, mas cada busca no servidor gera uma chamada de modelo faturável adicional, então é preciso ficar de olho em total_tool_use_tokens
Projetos com pequenas bibliotecas de ferramentas Cenários com uma dúzia de ferramentas e contexto longo talvez não valham a pena; o carregamento estático pode sair mais barato

Fatos objetivos do Gemini Tool Retrieval: informações de lançamento e fluxo de integração

Status de lançamento e modelos compatíveis do Gemini Tool Retrieval

Em 19 de novembro de 2026 (madrugada de 20 de novembro no horário de Pequim), o Google publicou no blog oficial o artigo “Introducing Tool Retrieval in the Gemini API”, abrindo o Tool Retrieval em prévia na Interactions API. Os autores são Lucia Loher, gerente de produto da Gemini API, e Nora Kassner, pesquisadora do Google DeepMind. No momento, o recurso está em estado Preview, e a interface pode mudar antes do lançamento oficial.

A redação do anúncio é bastante ampla: “Gemini 3.6 e modelos mais recentes, incluindo todos os modelos Gemini 4”. Mas a documentação para desenvolvedores, até 20 de novembro de 2026, lista explicitamente apenas 4 IDs de modelo: gemini-4-hydrogen, gemini-4-argon, gemini-3.8-flash, gemini-3.6-flash. Ao integrar, use a lista da documentação como referência. Definir defer_loading para um modelo sem suporte retorna diretamente HTTP 400.

Preparação antes da integração do Gemini Tool Retrieval: SDK e v1beta

O SDK oficial em Python do Google, googleapis/python-genai, lançou a versão v3.6.0 em 18 de novembro de 2026, adicionando esquemas públicos relacionados ao Tool Retrieval e a resultados de funções. O comando de instalação é o seguinte:

pip install -U "google-genai>=3.6.0"
export GEMINI_API_KEY="your-key"   # Não coloque a chave real no código

Há uma pegadinha comum com o número da versão. A partir da v3.0.0, o cliente da Gemini Developer API do SDK usa v1 por padrão, enquanto o Tool Retrieval exige v1beta; por isso, é obrigatório especificar explicitamente na inicialização:

from google import genai

client = genai.Client(
    http_options={"api_version": "v1beta"}
)

O SDK lê as credenciais da variável de ambiente GEMINI_API_KEY. Se usar REST, o endpoint correspondente é POST https://generativelanguage.googleapis.com/v1beta/interactions, e o cabeçalho de autenticação é x-goog-api-key.

Primeiro passo: definir ferramentas Gemini com tool_search e defer_loading

O cenário de demonstração tem apenas duas ferramentas de negócio: get_inventory, que consulta o estoque de produtos, e get_order_status, que consulta o status de pedidos. Ambas são configuradas com carregamento diferido. A função de cada campo no array tools é a seguinte:

  • {"type": "tool_search"}: ativa a busca no lado do servidor, com execution padrão server. Sem ele, definir defer_loading gera o erro defer_loading requires tool_search.
  • defer_loading: True: o parameters completo não entra no contexto inicial; no começo, o modelo vê apenas o nome e a descrição curta.
  • short_description: descrição curta exibida na lista inicial. Se não for preenchida, usa a primeira frase de description. Preencher esse campo em uma função não diferida é considerado inválido.
  • parameters: ainda precisa ser enviado por completo. O que é diferido é o momento em que o schema entra no contexto do modelo; o servidor ainda precisa receber a definição completa.

Que ferramentas fazem sentido para carregamento diferido? A recomendação do Google é usar uma combinação: manter as ferramentas de alta frequência com carregamento direto e deixar as ferramentas de cauda longa, especializadas e de baixa frequência para carregamento diferido. Além disso, não configure como diferidas as ferramentas citadas diretamente nas instruções do sistema. Caso contrário, o modelo pode ignorar a busca e chamá-las diretamente, falhando por não ter o contexto carregado. Para ferramentas com nomes parecidos, vale a pena adicionar um namespace comercial, por exemplo billing_get_customer e crm_get_customer, em vez de usar get_customer para ambas.

Etapa 2: enviar a requisição e observar as etapas de recuperação de ferramentas do Gemini

Abaixo está o código de demonstração completo. Tanto o estoque (“12 unidades”) quanto o status do pedido demo_pending são dados simulados localmente — nada consulta sistemas reais. Para rodar o código, você precisa de uma chave API do Gemini válida e de permissão de acesso ao modelo.

import json
from google import genai

MODEL = "gemini-4-hydrogen"

client = genai.Client(
    http_options={"api_version": "v1beta"}
)

tools = [
    {"type": "tool_search"},
    {
        "type": "function",
        "name": "get_inventory",
        "description": "Retrieve the available inventory for a product SKU.",
        "short_description": "Check product inventory by SKU.",
        "defer_loading": True,
        "parameters": {
            "type": "object",
            "properties": {"sku": {"type": "string"}},
            "required": ["sku"]
        }
    },
    {
        "type": "function",
        "name": "get_order_status",
        "description": "Retrieve the status of a customer order.",
        "short_description": "Check an order's current status.",
        "defer_loading": True,
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"]
        }
    }
]

def execute_demo_tool(name, arguments):
    """Função de negócio simulada localmente — não consulta estoque nem pedidos reais."""
    if name == "get_inventory":
        return {"sku": arguments["sku"], "available": 12, "data_source": "local_demo"}
    if name == "get_order_status":
        return {"order_id": arguments["order_id"], "status": "demo_pending", "data_source": "local_demo"}
    raise ValueError(f"Unknown tool: {name}")

# Primeira requisição: o modelo descobre e escolhe as ferramentas de que precisa
interaction = client.interactions.create(
    model=MODEL,
    input="查询商品 SKU-42 的可用库存。",
    tools=tools
)

print("执行步骤:")
for step in interaction.steps:
    print(step.type, getattr(step, "name", ""))

Os interaction.steps impressos costumam aparecer na seguinte ordem. A ordem exata e os resultados da busca são decididos pelo modelo, e uma única rodada pode disparar várias buscas.

  1. tool_search_call: o modelo percebe que não tem, já carregada, uma ferramenta adequada para o momento e dispara uma busca do lado do servidor.
  2. tool_search_result: a API devolve o Schema completo de parâmetros do get_inventory correspondente.
  3. function_call: depois de ler o Schema, o modelo gera uma chamada como get_inventory(sku="SKU-42").

Essas três etapas acontecem na mesma requisição externa de API — a aplicação não precisa escrever um buscador próprio nem enviar de novo uma requisição de recuperação. As duas primeiras etapas exigem apenas observação e registro; não repita a busca localmente. Mas “mesma requisição” não quer dizer “apenas uma inferência”: cada busca do lado do servidor dispara chamadas adicionais ao modelo, e esses tokens são cobrados normalmente. Ao depurar, tem mais um detalhe de atenção: não olhe só para interaction.status. Mesmo quando o status não é requires_action, os steps podem conter um function_call à espera de execução.

gemini-tool-retrieval-python-tool-search-defer-loading-pt-pt-image-1

Terceiro passo: executar a função e retornar o function_result

O Tool Retrieval só é responsável por encontrar a ferramenta e carregar os parâmetros; a função de negócio real ainda é executada pela aplicação, seguindo o mecanismo padrão de Function Calling. Continuando o código acima:

# Executa apenas a chamada real de função de negócio; não execute tool_search_call no lado da aplicação
function_results = []

for step in interaction.steps:
    if step.type != "function_call":
        continue
    result = execute_demo_tool(step.name, step.arguments)
    function_results.append({
        "type": "function_result",
        "name": step.name,
        "call_id": step.id,
        "result": [{"type": "text", "text": json.dumps(result, ensure_ascii=False)}]
    })

# Envia os resultados das funções locais de volta ao Gemini
if function_results:
    followup = client.interactions.create(
        model=MODEL,
        previous_interaction_id=interaction.id,
        tools=tools,
        input=function_results
    )
    print("Resposta final: ", followup.output_text)
else:
    print("Resposta atual: ", interaction.output_text)

Há três pontos de atenção neste trecho de código. Primeiro, o call_id deve vir obrigatoriamente do step.id do function_call original. Quando há múltiplas chamadas em uma rodada, o modelo usa esse identificador para corresponder cada resultado. Segundo, previous_interaction_id=interaction.id faz com que o servidor continue o registro de interação já salvo, incluindo as ferramentas que já foram recuperadas. Terceiro, na segunda rodada ainda é preciso passar o array tools completo. A API mantém o histórico de passos, mas não mantém a declaração de ferramentas: tool_search, todas as ferramentas adiadas e não adiadas, e a configuração de MCP precisam ser reenviadas a cada rodada.

Este exemplo demonstra apenas um ciclo completo de uma chamada de função; ele não inclui um agendador genérico de Agent para múltiplas rodadas. Se ainda houver function_call no followup, basta continuar o processamento da mesma forma.

🎯 Dica técnica: O Tool Retrieval em si depende da API oficial v1beta Interactions do Google. Se você quiser primeiro validar suas funções de negócio com o Function Calling padrão e comparar o desempenho de diferentes modelos na escolha de ferramentas e no preenchimento de parâmetros, pode usar a mesma chave no APIYI apiyi.com para alternar entre Gemini, Claude, GPT e outros modelos e fazer testes de linha de base.

Extensão: MCP remoto e recuperação de ferramentas no cliente Gemini

Servidores MCP remotos podem configurar o carregamento sob demanda na camada do servidor; as ferramentas que eles expõem são carregadas conforme necessário:

mcp_tools = [
    {"type": "tool_search"},
    {
        "type": "mcp_server",
        "name": "weather_service",
        "url": "https://gemini-api-demos.uc.r.appspot.com/mcp",
        "defer_loading": True
    }
]

Diferentemente das funções personalizadas, as ferramentas MCP remotas são executadas pela API em nome do aplicativo; nos steps aparecem mcp_server_tool_call e mcp_server_tool_result, e o aplicativo não precisa devolver o resultado. A documentação oficial ainda não informa o “número máximo de ferramentas com carregamento diferido”.

Se a empresa já tem seu próprio registro de ferramentas, busca vetorial ou filtragem de permissões por usuário, pode optar pela recuperação no cliente: defina "execution": "client" e forneça name, description e parameters completos. Nesse caso, a primeira rodada retorna um function_call comum para search_tool_registry. Depois que o aplicativo fizer a busca, retorne em function_result.result um array de objetos completos de declaração de ferramentas, sem serializar em uma única string JSON. O modo cliente não usa defer_loading, e a mesma requisição não pode misturar os dois modos.

gemini-tool-retrieval-python-tool-search-defer-loading-pt-pt-image-2

Dimensão Recuperação no servidor Recuperação no cliente (Gemini) Tool Registry próprio (solução genérica)
Executor da recuperação Gemini API Aplicativo do desenvolvedor Aplicativo do desenvolvedor
Configuração principal tool_search + defer_loading tool_search + execution: client Function Calling comum
Declarar todas as ferramentas com antecedência Sim Não Não
Idas e voltas extras de rede Nenhuma +1 rodada a cada busca +1 rodada a cada busca
Adição dinâmica de ferramentas Inconveniente Suportado Suportado
Cenário típico Bibliotecas grandes e relativamente fixas de ferramentas Multi-inquilino, registro privado Reutilização entre modelos, troca entre vários provedores
Plataforma disponível v1beta oficial do Google v1beta oficial do Google APIYI apiyi.com e outras interfaces compatíveis com OpenAI

A última coluna não é o Gemini Tool Retrieval, mas uma implementação de engenharia com abordagem semelhante: primeiro exponha apenas uma função de busca e, após uma busca bem-sucedida, adicione o Schema correspondente em tools. Ela é adequada para equipes que precisam alternar entre vários modelos. A implementação mínima é a seguinte:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["APIYI_API_KEY"],
    base_url="https://api.apiyi.com/v1"  # Interface compatível com OpenAI da APIYI
)
MODEL = "your-model-name"  # Consulte a lista de modelos da plataforma

search_tool = {"type": "function", "function": {
    "name": "search_tool_registry",
    "description": "Search internal business tools by keyword.",
    "parameters": {"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]}}}
Ver a chamada completa em duas etapas do Tool Registry próprio
import json, os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["APIYI_API_KEY"],
    base_url="https://api.apiyi.com/v1"
)
MODEL = "your-model-name"  # consulte a lista de modelos da plataforma

TOOL_REGISTRY = {
    "get_inventory": {"type": "function", "function": {
        "name": "get_inventory",
        "description": "Retrieve the available inventory for a product SKU.",
        "parameters": {"type": "object", "properties": {"sku": {"type": "string"}}, "required": ["sku"]}}},
    "get_order_status": {"type": "function", "function": {
        "name": "get_order_status",
        "description": "Retrieve the status of a customer order.",
        "parameters": {"type": "object", "properties": {"order_id": {"type": "string"}}, "required": ["order_id"]}}},
}
search_tool = {"type": "function", "function": {
    "name": "search_tool_registry",
    "description": "Search internal business tools (inventory, orders) by keyword.",
    "parameters": {"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]}}}

def search_registry(query):
    q = query.lower()
    return [name for name, t in TOOL_REGISTRY.items()
            if any(w in t["function"]["description"].lower() for w in q.split())]

def execute_demo_tool(name, args):
    if name == "get_inventory":
        return {"sku": args["sku"], "available": 12, "data_source": "local_demo"}
    if name == "get_order_status":
        return {"order_id": args["order_id"], "status": "demo_pending", "data_source": "local_demo"}
    raise ValueError(name)

messages = [{"role": "user", "content": "查询商品 SKU-42 的可用库存。"}]
tools = [search_tool]

for _ in range(4):  # limite simples de iterações, para evitar loop infinito
    resp = client.chat.completions.create(model=MODEL, messages=messages, tools=tools)
    msg = resp.choices[0].message
    if not msg.tool_calls:
        print("最终回答:", msg.content)
        break
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        if call.function.name == "search_tool_registry":
            names = search_registry(args["query"])
            tools += [TOOL_REGISTRY[n] for n in names if TOOL_REGISTRY[n] not in tools]
            content = json.dumps({"loaded_tools": names})
        else:
            content = json.dumps(execute_demo_tool(call.function.name, args), ensure_ascii=False)
        messages.append({"role": "tool", "tool_call_id": call.id, "content": content})

💡 Sugestão de escolha: a qualidade da busca na abordagem por registro depende da sua função de pesquisa; a correspondência por palavras-chave do exemplo serve apenas para demonstração. No APIYI apiyi.com, troque de modelo rodando o mesmo conjunto de tarefas e compare “conseguiu encontrar a ferramenta correta” e “os parâmetros foram preenchidos corretamente” — assim você descobre qual modelo se adapta melhor ao seu conjunto de ferramentas.

Investigação centralizada de erros comuns no Gemini Tool Retrieval

Sintoma Causa Tratamento
defer_loading requires tool_search Você declarou uma função adiada, mas não há tool_search no servidor Adicione {"type": "tool_search"} em tools
short_description inválido Foi definido em uma função que não é adiada Use apenas em funções com defer_loading=True
HTTP 400 unsupported model O modelo não está na lista de suportados Use os 4 IDs de modelo listados na documentação
A requisição não tem efeito ou acusa erro de versão O SDK usa v1 por padrão, ou você chamou generateContent Defina explicitamente api_version="v1beta" e passe a usar a Interactions API
HTTP 400 na segunda rodada Com store=False, faltou a etapa de busca ou o signature Reproduza literalmente tool_search_call/result e todas as assinaturas
O modelo usa ferramentas antigas por engano, ou a ferramenta fica indisponível As requisições seguintes não enviam tools Reenvie o array tools completo a cada rodada
Parâmetros vazios após a busca A ferramenta adiada enviou apenas o nome e a descrição curta Ferramentas adiadas também precisam enviar parameters completos
Falha na configuração de busca do cliente Faltam campos como name, description Complete a definição da função de busca do cliente

O modo stateless (store=False) merece uma explicação à parte. Nesse caso, não dá para contar com previous_interaction_id: a aplicação precisa salvar e reproduzir literalmente a entrada do usuário, tool_search_call, tool_search_result, function_call, function_result e todos os signature. Se qualquer uma dessas etapas for removida ou alterada, o servidor pode não conseguir reconstruir o contexto de busca. Além disso, quando o servidor não encontra ferramentas compatíveis, ele pode simplesmente devolver um texto em vez de um erro estruturado. Então, “a requisição não deu erro” não significa “a busca funcionou” — na validação, confira item por item se as etapas de busca e as chamadas de função esperadas aparecem em steps.

Análise do Gemini Tool Retrieval: quando vale a pena integrar

Julgamento 1: o ganho depende do tamanho da biblioteca de ferramentas e do comprimento do contexto — não basta ligar e economizar. A documentação do Google traz dois exemplos hipotéticos que apontam em direções opostas, deixando claro que não são benchmarks de produção. No primeiro: 200 ferramentas, 400 tokens cada, contexto base de 2.000 tokens e 2 requisições. O carregamento estático fica em cerca de 164.000 tokens e o Tool Retrieval em cerca de 23.650 — pela conta do exemplo, uma queda de aproximadamente 85,6%. No segundo: 10 ferramentas com contexto base de 30.000 tokens. O estático fica em 68.000 tokens e o Tool Retrieval chega a 92.830, um aumento de cerca de 36,5%. O motivo é que a inferência extra de busca precisa reprocessar todo aquele contexto longo. A recomendação de engenharia do Google é objetiva: com menos de aproximadamente 20 ferramentas estáveis, o carregamento estático costuma ser suficiente.

gemini-tool-retrieval-python-tool-search-defer-loading-pt-pt-image-3

Julgamento 2: para avaliar custo, olhe para total_tool_use_tokens, não apenas para a entrada do primeiro turno. Nos testes iniciais oficiais, a descrição curta de cada ferramenta adiada ocupava em média cerca de 26 tokens; com 100 ferramentas, isso dá aproximadamente 2.600 tokens — valores aproximados. O que realmente precisa ser observado são as invocações extras do modelo provocadas pela busca, e o acúmulo dos Schemas já carregados ao longo da sessão. A documentação atual não oferece nenhum mecanismo para descarregar ferramentas já recuperadas: quanto mais ferramentas são recuperadas numa sessão longa, maior fica o contexto. O cache também não beneficia incondicionalmente: com o comando inicial mais curto, ele pode ficar abaixo do limite mínimo do cache implícito.

Julgamento 3: o carregamento de ferramentas sob demanda já é consenso no setor, mas os números de cada fornecedor não podem ser transplantados. A Anthropic lançou o Tool Search Tool em novembro de 2025 e a OpenAI lançou o Tool Search junto com o GPT-5.4 em março de 2026, e as duas divulgaram dados de economia medidos sob as próprias condições. O Google, desta vez, apresentou apenas exemplos hipotéticos. Até 20 de novembro de 2026, não existe nenhum teste independente em produção do Gemini Tool Retrieval que possa ser verificado. Portanto, afirmações do tipo “o Gemini mediu 85% de economia” não se sustentam por enquanto.

Recomendação para quem desenvolve: comece classificando as ferramentas do seu agente atual por frequência de uso — as de uso intenso entram no carregamento direto, as de cauda longa ficam para o carregamento sob demanda. Depois, rode o mesmo lote de tarefas comparando carregamento estático e Tool Retrieval em tokens totais, tempo de ponta a ponta, proporção de escolha da ferramenta correta e taxa de acerto dos parâmetros. O recurso ainda está em fase de preview, sem data de lançamento definida, então em produção é bom manter uma chave para voltar ao carregamento estático. Na fase de escolha do modelo, dá para subir primeiro uma linha de base de Function Calling padrão com a interface unificada do APIYI apiyi.com, a baixo custo, e depois migrar para o v1beta oficial para verificar o ganho líquido do Tool Retrieval.

Quanto mais ferramentas você tem, mais cedo precisa pensar em quando cada uma deve ser tirada da caixa. Como dizem os Analectos (Lunyu, Livro 15, Wei Ling Gong): “Para fazer bem o trabalho, é preciso primeiro afiar as ferramentas.”


📚 Materiais de Referência

  1. Introducing Tool Retrieval in the Gemini API: anúncio oficial do Google

    • Link: blog.google/innovation-and-ai/technology/developers-tools/gemini-api-tool-retrieval
    • Descrição: data de publicação, objetivos de design, MCP e os dois modos de recuperação
  2. Documentação oficial do Tool retrieval: configuração, limites, cobrança e exemplos de cálculo

    • Link: aistudio.google.com/docs/tool-retrieval
    • Descrição: principal base para o código deste artigo, regras de erro, replay sem estado e exemplos de cálculo de tokens
  3. Documentação oficial do Function Calling: execução de funções e retorno de resultados

    • Link: aistudio.google.com/docs/function-calling
    • Descrição: uso padrão de function_result e call_id
  4. Documentação oficial da Interactions API: estrutura da interface e etapas de execução

    • Link: aistudio.google.com/docs/interactions-overview
    • Descrição: diferença entre conversas com estado, steps e generateContent
  5. python-genai v3.6.0 / v3.0.0 Release: registro de versões do SDK

    • Link: github.com/googleapis/python-genai/releases
    • Descrição: suporte ao Tool Retrieval Schema e mudança na versão padrão da API

Autor: Equipe técnica da APIYI
Intercâmbio técnico: testes comparativos de Function Calling com múltiplos modelos podem ser acessados em APIYI apiyi.com; mais materiais de integração estão no centro de documentação docs.apiyi.com

Artigos relacionados

Similar Posts