Accueil / Guides / API LLM gratuite avec appel de fonctions

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

  1. Vous envoyez les messages et une liste de tools. Chaque outil a un nom, une description et un JSON Schema pour ses paramètres.
  2. Le modèle répond avec tool_calls et finish_reason: "tool_calls". Il n'exécute rien lui-même.
  3. Votre code exécute la fonction et ajoute le résultat comme message avec role: "tool".
  4. 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èles gratuits avec appel d'outils, les plus performants en premier
ModèleGratuit surContexteLimites gratuites (meilleure offre)OutilsVision
GLM 5.3UnoRouter1M1 req/min
1 req/min per model
OuiNon
Qwen3.8 MaxACLIDE-€20/month shared internal usage credits · no cardOuiNon
GLM 5.3 FlashNVIDIA NIM, UnoRouter1M40 req/min
40 RPM
OuiOui
Gemini 3.8 FlashGoogle AI Studio1MRecurring provider quotaOuiOui
Gemini Flash (latest alias)Google AI Studio-10 req/min
20 req/jour
250,000 jetons/min
~3M
OuiOui
Qwen3.8 Flash NextAMD Radeon Cloud262KRecurring daily account allowanceOuiNon
Qwen3.8 FlashElectronHub1M$0.25/week shared recurring creditOuiOui
Gemini 3.7 FlashGoogle AI Studio1M10 req/min
20 req/jour
250,000 jetons/min
~3M
OuiOui
GPT-5.6 LunaElectronHub1M$0.25/week shared recurring creditOuiOui
Dots3 Note PreviewKilo Gateway, OpenRouter512K20 req/min
50 req/jour
50 req/day account-wide (1,000 after a $10 purchase)
OuiOui
DeepSeek V4 FlashAMD Radeon Cloud, BazaarLink, ElectronHub1M10 req/min
50 req/jour
Shared rate limit
OuiNon
Qwen3.8 27BElectronHub, Groq, OVH AI Endpoints262K30 req/min
250 req/jour
70,000 jetons/min
~6M
OuiOui
Gemini 3.6 FlashGoogle AI Studio1M10 req/min
20 req/jour
250,000 jetons/min
~3M
OuiOui
Qwen 3.8 27BCloudflare Workers AI262KShared 10k neurons/dayOuiOui
Gemini 3.5 FlashGoogle AI Studio1M10 req/min
20 req/jour
250,000 jetons/min
~3M
OuiOui

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 | bash

Ouvrez 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.

Sécurité : n'exécutez pas d'appels d'outils avec des effets de bord, comme des paiements, des e-mails ou la suppression de fichiers, sans vérification. Demandez d'abord à l'utilisateur de confirmer ces actions.

Pièges

  • Les arguments sont une chaîne : function.arguments est 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_id de son appel. Ajoutez le message de l'assistant avec les tool_calls avant 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.
Même modèle pendant une tâche : FreeLLMAPI garde une conversation sur un même modèle pendant 30 minutes. Une boucle d'outils reste en général sur un seul modèle. Si une limite impose un changement, le modèle suivant reçoit l'historique complet des messages, y compris les résultats des outils.

Dépannage

ProblèmeCauseSolution
Le modèle répond en texte et n'appelle aucun outilLe modèle gère mal les outils, ou la description n'est pas claireFixez un modèle plus performant du tableau, ou améliorez la description de l'outil
json.JSONDecodeError sur les argumentsLe modèle a envoyé un JSON non valideInterceptez l'erreur et renvoyez-la comme résultat d'outil, pour que le modèle puisse réessayer
Erreur 400 concernant un message d'outilLe tool_call_id ne correspond pas, ou le message de l'assistant manqueAjoutez d'abord le message de l'assistant, puis un message d'outil pour chaque appel
Erreur 429 pendant une tâche d'agentLa boucle envoie de nombreuses grosses requêtesAjoutez davantage de clés de fournisseurs, et envoyez moins d'outils
La boucle ne s'arrête pasLe modèle appelle à nouveau le même outilDéfinissez une limite de tours, et renvoyez des résultats clairs
Utilisez chacun de ces modèles avec une seule clé. FreeLLMAPI est un routeur open source auto-hébergé. Il place toutes ces offres gratuites derrière un seul point de terminaison compatible OpenAI, et bascule vers une autre offre lorsqu'une limite de débit est atteinte. Parcourir le catalogue ou passer en production.

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

Sources

Tous les guides · Parcourir tous les modèles gratuits