API LLM gratuite avec appel de fonctions
L'appel de fonctions, ou appel d'outils, permet à un LLM de demander à votre code d'exécuter une fonction. Les agents, les chatbots avec des données en direct et l'extraction structurée utilisent tous cette méthode. Le catalogue FreeLLMAPI compte 190 offres de modèles gratuits avec appel d'outils. Vous envoyez des tools au format OpenAI, et la passerelle les traduit pour chaque fournisseur.
Le code, les noms de modèles et les libellés du catalogue en direct sont affichés en anglais.
Fonctionnement de l'appel d'outils avec FreeLLMAPI
- Vous envoyez les messages et une liste de
tools. Chaque outil a un nom, une description et un JSON Schema pour ses paramètres. - Le modèle répond avec
tool_callsetfinish_reason: "tool_calls". Il n'exécute rien lui-même. - Votre code exécute la fonction et ajoute le résultat comme message avec
role: "tool". - Vous renvoyez la conversation. Le modèle utilise le résultat pour rédiger la réponse finale.
Les fournisseurs compatibles OpenAI, comme Groq, Cerebras, Mistral, OpenRouter et Cloudflare, reçoivent la requête telle quelle. Pour Gemini, FreeLLMAPI traduit les outils au format functionDeclarations de Google, puis traduit la réponse en retour. Votre code est le même pour chaque fournisseur.
Certains modèles écrivent un appel d'outil sous forme de texte brut, et non comme un vrai appel d'outil. FreeLLMAPI les détecte et les transforme en vrais tool_calls.
Modèles gratuits avec appel d'outils aujourd'hui
Le tableau présente les modèles gratuits les plus performants avec appel d'outils. Les données viennent du catalogue en direct. Pour les agents, vérifiez aussi la taille du contexte, car les définitions d'outils et les résultats utilisent beaucoup de tokens.
| Modèle | Gratuit sur | Contexte | Limites gratuites (meilleure offre) | Outils | Vision |
|---|---|---|---|---|---|
| GLM 5.3 | UnoRouter | 1M | 1 req/min 1 req/min per model | Oui | Non |
| Qwen3.8 Max | ACLIDE | - | €20/month shared internal usage credits · no card | Oui | Non |
| GLM 5.3 Flash | NVIDIA NIM, UnoRouter | 1M | 40 req/min 40 RPM | Oui | Oui |
| Gemini 3.8 Flash | Google AI Studio | 1M | Recurring provider quota | Oui | Oui |
| Gemini Flash (latest alias) | Google AI Studio | - | 10 req/min 20 req/jour 250,000 jetons/min ~3M | Oui | Oui |
| Qwen3.8 Flash Next | AMD Radeon Cloud | 262K | Recurring daily account allowance | Oui | Non |
| Qwen3.8 Flash | ElectronHub | 1M | $0.25/week shared recurring credit | Oui | Oui |
| Gemini 3.7 Flash | Google AI Studio | 1M | 10 req/min 20 req/jour 250,000 jetons/min ~3M | Oui | Oui |
| GPT-5.6 Luna | ElectronHub | 1M | $0.25/week shared recurring credit | Oui | Oui |
| Dots3 Note Preview | Kilo Gateway, OpenRouter | 512K | 20 req/min 50 req/jour 50 req/day account-wide (1,000 after a $10 purchase) | Oui | Oui |
| DeepSeek V4 Flash | AMD Radeon Cloud, BazaarLink, ElectronHub | 1M | 10 req/min 50 req/jour Shared rate limit | Oui | Non |
| Qwen3.8 27B | ElectronHub, Groq, OVH AI Endpoints | 262K | 30 req/min 250 req/jour 70,000 jetons/min ~6M | Oui | Oui |
| Gemini 3.6 Flash | Google AI Studio | 1M | 10 req/min 20 req/jour 250,000 jetons/min ~3M | Oui | Oui |
| Qwen 3.8 27B | Cloudflare Workers AI | 262K | Shared 10k neurons/day | Oui | Oui |
| Gemini 3.5 Flash | Google AI Studio | 1M | 10 req/min 20 req/jour 250,000 jetons/min ~3M | Oui | Oui |
Affichage de 15 modèles gratuits sur 146 correspondants. Voir tous les modèles.
Données en direct du catalogue FreeLLMAPI (version 2026.11.19, vérifié le 2026-11-19). Les limites gratuites changent souvent. Le catalogue est vérifié chaque jour.
Étape 1 : installer FreeLLMAPI et ajouter les clés
FreeLLMAPI est open source. Il s'exécute sur votre ordinateur dans Docker. Vos clés de fournisseurs restent sur votre ordinateur.
Installer (macOS ou Linux)
curl -fsSL https://freellmapi.co/install.sh | bashOuvrez le tableau de bord à l'adresse http://localhost:3001. Ajoutez des clés d'au moins trois fournisseurs sur la page Keys. Une boucle d'outils envoie plusieurs requêtes pour une seule tâche, donc davantage de clés donnent plus de marge. Copiez votre clé unifiée depuis la même page.
Étape 2 : exécuter une boucle d'outils complète
curl : la première requête
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 : boucler jusqu'à la réponse finale du modèle
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)})L'appel d'outils fonctionne aussi avec stream=True. Vous recevez des fragments delta.tool_calls, puis un fragment final avec finish_reason: "tool_calls". Assemblez les fragments d'arguments avant d'analyser le JSON.
Utiliser un outil pour obtenir des données structurées
L'appel d'outils est aussi une bonne méthode pour obtenir des données dans une forme fixe. Définissez un outil dont les paramètres sont les champs souhaités. Réglez tool_choice sur "required", afin que le modèle doive appeler un outil. Lisez ensuite les arguments. Vous n'avez pas besoin d'exécuter de fonction.
Python : extraire des champs avec un appel d'outil obligatoire
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))Validez les arguments avec votre propre code. Un modèle peut omettre un champ obligatoire ou envoyer un mauvais type. Si la vérification échoue, renvoyez l'erreur et demandez de nouveau.
Pièges
- Les arguments sont une chaîne :
function.argumentsest une chaîne JSON. Analysez-la, et gérez les erreurs. Les petits modèles envoient parfois un JSON non valide. - Faites correspondre les ID : chaque message d'outil a besoin du
tool_call_idde son appel. Ajoutez le message de l'assistant avec lestool_callsavant les messages d'outil. - Plusieurs appels à la fois : un modèle peut renvoyer plusieurs appels d'outils dans une seule réponse. Exécutez-les tous, puis envoyez tous les résultats.
- Coût en tokens : chaque définition d'outil est envoyée avec chaque requête. Vingt gros outils peuvent utiliser des milliers de tokens et atteindre rapidement une faible limite de tokens par minute. N'envoyez que les outils dont la tâche a besoin.
- Descriptions claires : le modèle choisit un outil d'après son nom et sa description. Rédigez une phrase courte qui indique ce que fait l'outil et quand l'utiliser.
- Arrêtez la boucle : définissez un nombre maximal de tours. Un modèle faible peut appeler le même outil encore et encore.
- Modèles sans outils : certains fournisseurs gratuits ne prennent pas en charge les outils. Par exemple, AI Horde supprime les outils et répond comme un simple chat.
Dépannage
| Problème | Cause | Solution |
|---|---|---|
| Le modèle répond en texte et n'appelle aucun outil | Le modèle gère mal les outils, ou la description n'est pas claire | Fixez un modèle plus performant du tableau, ou améliorez la description de l'outil |
json.JSONDecodeError sur les arguments | Le modèle a envoyé un JSON non valide | Interceptez l'erreur et renvoyez-la comme résultat d'outil, pour que le modèle puisse réessayer |
| Erreur 400 concernant un message d'outil | Le tool_call_id ne correspond pas, ou le message de l'assistant manque | Ajoutez d'abord le message de l'assistant, puis un message d'outil pour chaque appel |
| Erreur 429 pendant une tâche d'agent | La boucle envoie de nombreuses grosses requêtes | Ajoutez davantage de clés de fournisseurs, et envoyez moins d'outils |
| La boucle ne s'arrête pas | Le modèle appelle à nouveau le même outil | Définissez une limite de tours, et renvoyez des résultats clairs |
Questions fréquentes
Quelles API LLM gratuites prennent en charge l'appel de fonctions ?
Gemini, Groq, Cerebras, Mistral, OpenRouter, Cloudflare et d'autres fournisseurs ont des modèles gratuits avec appel d'outils. Le catalogue FreeLLMAPI compte aujourd'hui 190 offres de modèles gratuits avec outils.
L'appel d'outils est-il identique à l'appel de fonctions ?
Oui. OpenAI a d'abord utilisé le terme function calling. L'API actuelle utilise tools et tool_calls. Les deux termes signifient que le modèle demande à votre code d'exécuter une fonction.
L'appel d'outils de Gemini fonctionne-t-il avec le format OpenAI ?
Oui, grâce à FreeLLMAPI. La passerelle traduit les outils OpenAI en functionDeclarations Gemini et traduit la réponse en tool_calls OpenAI.
Puis-je diffuser les appels d'outils en streaming ?
Oui. Avec stream=True, vous recevez des fragments delta.tool_calls et un finish_reason final égal à tool_calls. Assemblez les fragments d'arguments avant de les analyser.
Guides associés
- API LLM gratuite pour agents IA
- API de recherche web gratuite pour agents IA
- Meilleures API gratuites de modèles de code
- API LLM gratuite pour LangChain
- API LLM gratuite en Python
Sources
- FreeLLMAPI docs: Tool calling (vérifié le 20 November 2026)
- FreeLLMAPI README: features (vérifié le 20 November 2026)
- OpenAI API reference: Chat Completions tools (vérifié le 20 November 2026)