Início / Guias / API LLM gratuita com function calling

API LLM gratuita com function calling

Function calling, ou chamada de ferramentas, permite que um LLM peça ao seu código para executar uma função. Agentes, chatbots com dados em tempo real e extração estruturada usam esse recurso. O catálogo do FreeLLMAPI tem 190 ofertas de modelos gratuitos com chamada de ferramentas. Você envia tools no estilo OpenAI, e o gateway as converte para cada provedor.

O código, os nomes dos modelos e os rótulos do catálogo ao vivo são exibidos em inglês.

Como a chamada de ferramentas funciona pelo FreeLLMAPI

  1. Você envia as mensagens e uma lista de tools. Cada ferramenta tem um nome, uma descrição e um JSON Schema para os seus parâmetros.
  2. O modelo responde com tool_calls e finish_reason: "tool_calls". Ele não executa nada por conta própria.
  3. Seu código executa a função e adiciona o resultado como uma mensagem com role: "tool".
  4. Você envia a conversa de novo. O modelo usa o resultado para escrever a resposta final.

Provedores compatíveis com OpenAI, como Groq, Cerebras, Mistral, OpenRouter e Cloudflare, recebem a requisição como ela é. Para o Gemini, o FreeLLMAPI converte as ferramentas para o formato functionDeclarations do Google e converte a resposta de volta. Seu código é o mesmo para todos os provedores.

Alguns modelos escrevem uma chamada de ferramenta como texto simples, e não como uma chamada de ferramenta real. O FreeLLMAPI detecta esses casos e os transforma em tool_calls reais.

Modelos gratuitos com chamada de ferramentas hoje

A tabela mostra os modelos gratuitos mais fortes com chamada de ferramentas. Os dados vêm do catálogo atualizado. Para agentes, verifique também o tamanho do contexto, porque as definições e os resultados de ferramentas usam muitos tokens.

Modelos gratuitos com chamada de ferramentas, do mais forte para o mais fraco
ModeloGratuito emContextoLimites gratuitos (melhor oferta)FerramentasVisão
GLM 5.3UnoRouter1M1 req/min
1 req/min per model
SimNão
Qwen3.8 MaxACLIDE-€20/month shared internal usage credits · no cardSimNão
GLM 5.3 FlashNVIDIA NIM, UnoRouter1M40 req/min
40 RPM
SimSim
Gemini 3.8 FlashGoogle AI Studio1MRecurring provider quotaSimSim
Gemini Flash (latest alias)Google AI Studio-10 req/min
20 req/dia
250,000 tokens/min
~3M
SimSim
Qwen3.8 Flash NextAMD Radeon Cloud262KRecurring daily account allowanceSimNão
Qwen3.8 FlashElectronHub1M$0.25/week shared recurring creditSimSim
Gemini 3.7 FlashGoogle AI Studio1M10 req/min
20 req/dia
250,000 tokens/min
~3M
SimSim
GPT-5.6 LunaElectronHub1M$0.25/week shared recurring creditSimSim
Dots3 Note PreviewKilo Gateway, OpenRouter512K20 req/min
50 req/dia
50 req/day account-wide (1,000 after a $10 purchase)
SimSim
DeepSeek V4 FlashAMD Radeon Cloud, BazaarLink, ElectronHub1M10 req/min
50 req/dia
Shared rate limit
SimNão
Qwen3.8 27BElectronHub, Groq, OVH AI Endpoints262K30 req/min
250 req/dia
70,000 tokens/min
~6M
SimSim
Gemini 3.6 FlashGoogle AI Studio1M10 req/min
20 req/dia
250,000 tokens/min
~3M
SimSim
Qwen 3.8 27BCloudflare Workers AI262KShared 10k neurons/daySimSim
Gemini 3.5 FlashGoogle AI Studio1M10 req/min
20 req/dia
250,000 tokens/min
~3M
SimSim

Mostrando 15 de 146 modelos gratuitos correspondentes. Ver todos os modelos.

Dados ao vivo do catálogo FreeLLMAPI (versão 2026.11.19, verificado em 2026-11-19). Os limites gratuitos mudam com frequência. O catálogo é verificado todos os dias.

Etapa 1: instale o FreeLLMAPI e adicione as chaves

O FreeLLMAPI é de código aberto. Ele roda no seu computador, em Docker. Suas chaves de provedores ficam no seu computador.

Instale (macOS ou Linux)

curl -fsSL https://freellmapi.co/install.sh | bash

Abra o painel em http://localhost:3001. Adicione chaves de três ou mais provedores na página Keys. Um ciclo de ferramentas envia várias requisições para uma tarefa, então mais chaves dão mais margem. Copie sua chave unificada da mesma página.

Etapa 2: execute um ciclo completo de ferramentas

curl: a primeira requisição

curl http://localhost:3001/v1/chat/completions \
  -H "Authorization: Bearer <unified-key>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "auto",
    "messages": [{"role": "user", "content": "What is the weather in Karachi?"}],
    "tools": [{
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Get the current weather for a city.",
        "parameters": {
          "type": "object",
          "properties": {"city": {"type": "string"}},
          "required": ["city"]
        }
      }
    }]
  }'

Python: repita até o modelo dar uma resposta final

import json
from openai import OpenAI

client = OpenAI(base_url="http://localhost:3001/v1", api_key="<unified-key>")

def get_weather(city: str) -> dict:
    return {"city": city, "temp_c": 32, "condition": "sunny"}  # call a real API here

FUNCS = {"get_weather": get_weather}
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get the current weather for a city.",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]
messages = [{"role": "user", "content": "What is the weather in Karachi and Lahore?"}]

for _ in range(5):  # stop after 5 rounds
    msg = client.chat.completions.create(model="auto", messages=messages, tools=tools).choices[0].message
    if not msg.tool_calls:
        print(msg.content)
        break
    messages.append(msg)
    for call in msg.tool_calls:
        try:
            args = json.loads(call.function.arguments or "{}")
            result = FUNCS[call.function.name](**args)
        except Exception as exc:  # bad JSON, unknown tool or wrong arguments
            result = {"error": str(exc)}
        messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})

A chamada de ferramentas também funciona com stream=True. Você recebe blocos delta.tool_calls, depois um bloco final com finish_reason: "tool_calls". Una os blocos de argumentos antes de interpretar o JSON.

Use uma ferramenta para obter dados estruturados

A chamada de ferramentas também é um bom modo de obter dados em um formato fixo. Defina uma ferramenta cujos parâmetros sejam os campos que você quer. Defina tool_choice como "required", para que o modelo precise chamar uma ferramenta. Depois, leia os argumentos. Você não precisa executar nenhuma função.

Python: extraia campos com uma chamada de ferramenta obrigatória

import json
from openai import OpenAI

client = OpenAI(base_url="http://localhost:3001/v1", api_key="<unified-key>")
schema = {
    "type": "function",
    "function": {
        "name": "save_contact",
        "description": "Save one contact found in the text.",
        "parameters": {
            "type": "object",
            "properties": {"name": {"type": "string"}, "email": {"type": "string"}},
            "required": ["name", "email"],
        },
    },
}
resp = client.chat.completions.create(
    model="auto",
    messages=[{"role": "user", "content": "Reach Sara Khan at [email protected]."}],
    tools=[schema],
    tool_choice="required",
)
print(json.loads(resp.choices[0].message.tool_calls[0].function.arguments))

Valide os argumentos com o seu próprio código. Um modelo pode omitir um campo obrigatório ou enviar um tipo errado. Se a verificação falhar, envie o erro de volta e peça de novo.

Segurança: não execute chamadas de ferramenta com efeitos colaterais, como pagamentos, e-mails ou exclusão de arquivos, sem uma verificação. Peça ao usuário para confirmar essas ações antes.

Armadilhas

  • Os argumentos são uma string: function.arguments é uma string JSON. Interprete-a e trate os erros. Modelos pequenos às vezes enviam um JSON que não é válido.
  • Combine os IDs: cada mensagem de ferramenta precisa do tool_call_id da sua chamada. Adicione a mensagem do assistente com tool_calls antes das mensagens de ferramenta.
  • Várias chamadas de uma vez: um modelo pode retornar mais de uma chamada de ferramenta em uma resposta. Execute todas e depois envie todos os resultados.
  • Custo em tokens: cada definição de ferramenta é enviada em todas as requisições. Vinte ferramentas grandes podem usar milhares de tokens e atingir rapidamente um limite baixo de tokens por minuto. Envie somente as ferramentas que a tarefa precisa.
  • Descrições claras: o modelo escolhe uma ferramenta pelo nome e pela descrição. Escreva uma frase curta que diga o que a ferramenta faz e quando usá-la.
  • Interrompa o ciclo: defina um número máximo de rodadas. Um modelo fraco pode chamar a mesma ferramenta várias vezes.
  • Modelos sem ferramentas: alguns provedores gratuitos não oferecem suporte a ferramentas. Por exemplo, o AI Horde remove as ferramentas e responde como chat simples.
Mesmo modelo durante uma tarefa: o FreeLLMAPI mantém uma conversa no mesmo modelo por 30 minutos. Um ciclo de ferramentas normalmente fica em um único modelo. Se um limite forçar a troca, o próximo modelo recebe o histórico completo de mensagens, incluindo os resultados das ferramentas.

Solução de problemas

ProblemaCausaSolução
O modelo responde em texto e não chama nenhuma ferramentaO modelo é fraco em ferramentas, ou a descrição não está claraFixe um modelo mais forte da tabela, ou melhore a descrição da ferramenta
json.JSONDecodeError nos argumentosO modelo enviou um JSON inválidoTrate o erro e envie-o de volta como resultado da ferramenta, para que o modelo tente de novo
Erro 400 sobre uma mensagem de ferramentaO tool_call_id não corresponde, ou a mensagem do assistente está ausenteAdicione primeiro a mensagem do assistente e depois uma mensagem de ferramenta para cada chamada
Erro 429 durante uma tarefa de agenteO ciclo envia muitas requisições grandesAdicione mais chaves de provedores e envie menos ferramentas
O ciclo não paraO modelo chama a mesma ferramenta de novoDefina um limite de rodadas e retorne resultados claros
Use todos estes modelos com uma única chave. FreeLLMAPI é um roteador de código aberto e de hospedagem própria. Ele coloca todas estas camadas gratuitas atrás de um único endpoint compatível com OpenAI e passa para o próximo provedor quando um deles está com limite de requisições. Ver o catálogo ou colocar em produção.

Perguntas frequentes

Quais APIs LLM gratuitas oferecem suporte a function calling?

Gemini, Groq, Cerebras, Mistral, OpenRouter, Cloudflare e outros provedores têm modelos gratuitos com chamada de ferramentas. O catálogo do FreeLLMAPI tem 190 ofertas de modelos gratuitos com ferramentas hoje.

Chamada de ferramentas é o mesmo que function calling?

Sim. A OpenAI usou primeiro o nome function calling. A API atual usa tools e tool_calls. Os dois nomes significam que o modelo pede ao seu código para executar uma função.

A chamada de ferramentas do Gemini funciona com o formato da OpenAI?

Sim, pelo FreeLLMAPI. O gateway converte as ferramentas da OpenAI em functionDeclarations do Gemini e converte a resposta de volta em tool_calls da OpenAI.

Posso transmitir chamadas de ferramenta em streaming?

Sim. Com stream=True, você recebe blocos delta.tool_calls e um finish_reason final de tool_calls. Una os blocos de argumentos antes de interpretá-los.

Guias relacionados

Fontes

Todos os guias · Ver todos os modelos gratuitos