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
- 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. - O modelo responde com
tool_callsefinish_reason: "tool_calls". Ele não executa nada por conta própria. - Seu código executa a função e adiciona o resultado como uma mensagem com
role: "tool". - 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.
| Modelo | Gratuito em | Contexto | Limites gratuitos (melhor oferta) | Ferramentas | Visão |
|---|---|---|---|---|---|
| GLM 5.3 | UnoRouter | 1M | 1 req/min 1 req/min per model | Sim | Não |
| Qwen3.8 Max | ACLIDE | - | €20/month shared internal usage credits · no card | Sim | Não |
| GLM 5.3 Flash | NVIDIA NIM, UnoRouter | 1M | 40 req/min 40 RPM | Sim | Sim |
| Gemini 3.8 Flash | Google AI Studio | 1M | Recurring provider quota | Sim | Sim |
| Gemini Flash (latest alias) | Google AI Studio | - | 10 req/min 20 req/dia 250,000 tokens/min ~3M | Sim | Sim |
| Qwen3.8 Flash Next | AMD Radeon Cloud | 262K | Recurring daily account allowance | Sim | Não |
| Qwen3.8 Flash | ElectronHub | 1M | $0.25/week shared recurring credit | Sim | Sim |
| Gemini 3.7 Flash | Google AI Studio | 1M | 10 req/min 20 req/dia 250,000 tokens/min ~3M | Sim | Sim |
| GPT-5.6 Luna | ElectronHub | 1M | $0.25/week shared recurring credit | Sim | Sim |
| Dots3 Note Preview | Kilo Gateway, OpenRouter | 512K | 20 req/min 50 req/dia 50 req/day account-wide (1,000 after a $10 purchase) | Sim | Sim |
| DeepSeek V4 Flash | AMD Radeon Cloud, BazaarLink, ElectronHub | 1M | 10 req/min 50 req/dia Shared rate limit | Sim | Não |
| Qwen3.8 27B | ElectronHub, Groq, OVH AI Endpoints | 262K | 30 req/min 250 req/dia 70,000 tokens/min ~6M | Sim | Sim |
| Gemini 3.6 Flash | Google AI Studio | 1M | 10 req/min 20 req/dia 250,000 tokens/min ~3M | Sim | Sim |
| Qwen 3.8 27B | Cloudflare Workers AI | 262K | Shared 10k neurons/day | Sim | Sim |
| Gemini 3.5 Flash | Google AI Studio | 1M | 10 req/min 20 req/dia 250,000 tokens/min ~3M | Sim | Sim |
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 | bashAbra 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.
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_idda sua chamada. Adicione a mensagem do assistente comtool_callsantes 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.
Solução de problemas
| Problema | Causa | Solução |
|---|---|---|
| O modelo responde em texto e não chama nenhuma ferramenta | O modelo é fraco em ferramentas, ou a descrição não está clara | Fixe um modelo mais forte da tabela, ou melhore a descrição da ferramenta |
json.JSONDecodeError nos argumentos | O modelo enviou um JSON inválido | Trate o erro e envie-o de volta como resultado da ferramenta, para que o modelo tente de novo |
| Erro 400 sobre uma mensagem de ferramenta | O tool_call_id não corresponde, ou a mensagem do assistente está ausente | Adicione primeiro a mensagem do assistente e depois uma mensagem de ferramenta para cada chamada |
| Erro 429 durante uma tarefa de agente | O ciclo envia muitas requisições grandes | Adicione mais chaves de provedores e envie menos ferramentas |
| O ciclo não para | O modelo chama a mesma ferramenta de novo | Defina um limite de rodadas e retorne resultados claros |
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
- API LLM gratuita para agentes de IA
- API gratuita de busca na web para agentes de IA
- Melhores APIs gratuitas de modelos para código
- API LLM gratuita para LangChain
- LLM gratuito em Python
Fontes
- FreeLLMAPI docs: Tool calling (verificado em 20 November 2026)
- FreeLLMAPI README: features (verificado em 20 November 2026)
- OpenAI API reference: Chat Completions tools (verificado em 20 November 2026)