Accueil / Guides / API LLM gratuite pour agents IA

API LLM gratuite pour agents IA

Un agent IA envoie de nombreuses requêtes au modèle pour une seule tâche. Chaque étape demande des appels d'outils et un grand contexte. Une seule offre gratuite s'épuise vite pour un agent. FreeLLMAPI regroupe 45 offres gratuites de fournisseurs derrière une seule clé compatible OpenAI. Quand une limite bloque une requête, il passe au fournisseur suivant, et l'agent peut continuer. Ce guide traite des appels d'outils, du routage par étape, des longues sessions et du serveur MCP du routeur.

Le code, les noms de modèles et les libellés du catalogue en direct sont affichés en anglais.

Ce dont un agent a besoin d'une API gratuite

BesoinPourquoiCe que fait FreeLLMAPI
Appels d'outilsL'agent choisit et exécute des outilsTransmet tools au format OpenAI à chaque fournisseur. Convertit les appels d'outils en texte brut en vrais tool_calls.
Nombreuses requêtesUne tâche peut comporter de 20 à 100 étapesCompte le quota de chaque clé et passe à la clé ou au fournisseur suivant en cas de 429
Grand contexteLes résultats d'outils et l'historique grossissent à chaque étapeRoute vers les modèles de votre chaîne. Vous pouvez créer un profil à long contexte.
Comportement stableUn changement de modèle au milieu d'une tâche peut dérouter l'agentGarde une session sur un même modèle pendant 30 minutes. Transfert de contexte facultatif quand un changement se produit.
VisibilitéVous devez savoir quel modèle a échouéLes en-têtes X-Routed-Via et X-Fallback-Trail sur chaque réponse

Les offres gratuites ont des limites. Le basculement répartit la charge sur vos clés, mais le total reste la somme des limites gratuites. Pour un travail d'agent, ajoutez des clés d'au moins quatre fournisseurs.

Modèles gratuits avec appels d'outils et contexte de 128K+
ModèleGratuit surContexteLimites gratuites (meilleure offre)OutilsVision
GLM 5.3UnoRouter1M1 req/min
1 req/min per model
OuiNon
GLM 5.3 FlashNVIDIA NIM, UnoRouter1M40 req/min
40 RPM
OuiOui
Gemini 3.8 FlashGoogle AI Studio1MRecurring provider quotaOuiOui
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

Affichage de 12 modèles gratuits sur 109 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.

Une boucle d'agent complète en Python

La boucle ci-dessous utilise le SDK OpenAI officiel. Elle envoie les outils, exécute chaque appel d'outil, renvoie le résultat au modèle et s'arrête quand le modèle donne une réponse finale. Elle s'arrête aussi après un nombre maximal d'étapes.

agent.py

import json
import os
import time

import openai
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:3001/v1",
    api_key=os.environ["FREELLMAPI_API_KEY"],  # <unified-key>
    max_retries=3,
)

def get_weather(city: str) -> dict:
    return {"city": city, "temp_c": 18, "sky": "cloudy"}

TOOLS = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get the current weather for a city.",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]
FUNCTIONS = {"get_weather": get_weather}

def call_model(messages, session_id):
    for attempt in range(5):
        try:
            return client.chat.completions.create(
                model="auto:smart",
                messages=messages,
                tools=TOOLS,
                extra_headers={"X-Session-Id": session_id},
            )
        except openai.RateLimitError as err:
            header = err.response.headers.get("retry-after", "")
            wait = int(header) if header.isdigit() else 2 ** attempt
            time.sleep(min(wait, 60))
    raise RuntimeError("All free providers are at their limit")

def run(task: str, session_id: str, max_steps: int = 10) -> str:
    messages = [
        {"role": "system", "content": "Use the tools when they help. Be brief."},
        {"role": "user", "content": task},
    ]
    for _ in range(max_steps):
        msg = call_model(messages, session_id).choices[0].message
        messages.append(msg)
        if not msg.tool_calls:
            return msg.content
        for call in msg.tool_calls:
            fn = FUNCTIONS.get(call.function.name)
            try:
                args = json.loads(call.function.arguments or "{}")
                result = fn(**args) if fn else {"error": "unknown tool"}
            except Exception as exc:  # return tool errors to the model
                result = {"error": str(exc)}
            messages.append({
                "role": "tool",
                "tool_call_id": call.id,
                "content": json.dumps(result),
            })
    return "Stopped: too many steps."

print(run("Should I take an umbrella in Dublin today?", session_id="task-001"))
  • X-Session-Id : garde toutes les étapes d'une tâche sur le même modèle tant que ce modèle a du quota.
  • Retry-After : quand toutes les clés ont atteint leur limite, la passerelle renvoie 429 avec cet en-tête. La boucle attend, puis réessaie.
  • Erreurs d'outils : la boucle renvoie les erreurs au modèle sous forme de résultats d'outils. Le modèle peut alors corriger son appel.

Router chaque étape vers le bon modèle

Les étapes d'un agent ne demandent pas toutes la même chose. Une étape de planification demande un modèle puissant. Une étape qui extrait un seul champ demande un modèle rapide. Utilisez une chaîne de modèle différente pour chaque type d'étape. Vous n'avez pas besoin de modifier le tableau de bord.

Chaîne de modèleClasse les modèles parUsage avec un agent
auto:smartIntelligencePlanification, choix des outils, réponses finales
auto:fastVitesse mesurée et délai avant le premier octetExtraction, classification, résumés courts des résultats d'outils
auto:reliableTaux de réussite récentAgents planifiés qui doivent aboutir
auto:balancedFiabilité d'abord, puis vitesse et intelligenceValeur par défaut générale
auto:<profile>Votre chaîne de repli nomméeUne chaîne avec des modèles à appels d'outils uniquement

Les stratégies auto:* classent tous les modèles activés et ignorent l'ordre de votre chaîne. Une requête avec outils demande toujours un modèle capable d'appeler des outils. Si certains modèles activés ne gèrent pas bien les outils, créez un profil avec les seuls modèles à appels d'outils. Utilisez ensuite auto:<profile> pour les étapes avec outils. Un nom de profil inconnu renvoie l'erreur 400.

L'en-tête X-FreeLLM-Task-Type: code fait passer le poids du routage de la vitesse à l'intelligence pour une seule requête. C'est une préférence souple. Elle ne modifie ni les vérifications de capacité ni la chaîne de repli.

Longues sessions d'agent et changements de modèle

Pendant une longue tâche, un modèle peut atteindre sa limite quotidienne. Le routeur passe alors à un autre modèle. Le nouveau modèle reçoit tout l'historique des messages, mais il ne sait pas qu'un autre modèle a effectué les étapes précédentes.

Activez le transfert de contexte pour ajouter un court message système quand le modèle change. Ce message demande au nouveau modèle de poursuivre la tâche et de conserver les résultats d'outils précédents.

FreeLLMAPI .env

FREELLMAPI_CONTEXT_HANDOFF=on_model_switch
  • Le message de transfert n'est ajouté que lorsque le modèle sélectionné change pour une session.
  • Les sessions sont conservées en mémoire pendant 3 heures. Rien n'est écrit sur le disque.
  • La clé de session est l'en-tête X-Session-Id. Sans cet en-tête, c'est un hachage du premier message de l'utilisateur.

Utiliser le routeur comme serveur MCP

FreeLLMAPI est aussi un serveur MCP sur /mcp. Un agent qui parle MCP peut envoyer une tâche textuelle à un modèle FreeLLMAPI. Il peut aussi lire l'état de la passerelle pendant une session : modèles utilisables et leurs paramètres, santé des fournisseurs, statistiques d'usage et de cache, et stratégie de routage.

La surface MCP est désactivée sur les installations neuves. Activez-la dans le tableau de bord, sur la page Keys, sous Agent compatibility. Tant qu'elle est désactivée, /mcp renvoie 403.

Ajouter le serveur MCP à Claude Code

claude mcp add --transport http freellmapi http://localhost:3001/mcp \
  --header "Authorization: Bearer <unified-key>"

Tout client MCP compatible avec Streamable HTTP fonctionne de la même façon. Pointez-le vers /mcp et envoyez la clé unifiée comme jeton Bearer. Les outils utiles sont healthcheck, list_models et ask_freellmapi. L'outil ask_freellmapi exécute une tâche par la même route de chat que l'API, avec routage et repli.

Pour les agents de code, FreeLLMAPI propose des commandes de configuration qui écrivent la configuration du client à votre place. Exemples : npx freellmapi setup-claude, setup-codex, setup-cline, setup-openclaw et setup-hermes. Chaque commande accepte --dry-run et crée d'abord une sauvegarde.

Dépannage

ProblèmeCauseSolution
Le modèle répond en texte et n'appelle aucun outilLe modèle gère mal les appels d'outilsUtilisez auto:<profile> avec des modèles à appels d'outils uniquement
L'agent recommence la tâche au milieuUne limite a forcé un changement de modèleEnvoyez X-Session-Id et activez le transfert de contexte
Erreur 429 après de nombreuses étapesToutes les clés de la chaîne ont atteint leur limiteAjoutez des fournisseurs, utilisez auto:fast pour les petites étapes et attendez Retry-After
Erreur 400 avec auto:nameLe profil n'existe pasVérifiez le nom du profil sur le tableau de bord
/mcp renvoie 403La surface MCP est désactivéeActivez-la sous Agent compatibility, sur la page Keys
Erreurs de longueur de contexte en fin de tâcheL'historique dépasse la fenêtre du modèleRésumez les anciens résultats d'outils ou utilisez un profil à long contexte
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

Existe-t-il une API LLM gratuite pour les agents IA ?

Oui. Plusieurs fournisseurs proposent des offres gratuites avec appels d'outils. FreeLLMAPI les regroupe derrière une seule clé compatible OpenAI et passe au fournisseur suivant quand une limite bloque une requête.

Quel LLM gratuit est le meilleur pour les appels d'outils ?

Utilisez un modèle à appels d'outils dont la fenêtre de contexte atteint 128K tokens ou plus. Le tableau de cette page montre les modèles gratuits les plus performants qui respectent ces deux règles aujourd'hui.

Puis-je utiliser FreeLLMAPI comme serveur MCP ?

Oui. Activez la surface MCP sur la page Keys, sous Agent compatibility. Connectez ensuite votre client MCP à /mcp avec la clé unifiée comme jeton Bearer.

Comment éviter qu'un agent échoue à cause des limites de débit ?

Ajoutez des clés de plusieurs fournisseurs, envoyez les petites étapes à auto:fast, relancez en cas de 429 avec l'en-tête Retry-After et définissez un nombre maximal d'étapes.

Que se passe-t-il quand le modèle change au milieu d'une tâche d'agent ?

Le nouveau modèle reçoit tout l'historique des messages. Avec le transfert de contexte activé, il reçoit aussi une courte note lui demandant de poursuivre la tâche.

Guides associés

Sources

Tous les guides · Parcourir tous les modèles gratuits