Free LLM API per agenti IA
Un agente IA invia molte richieste al modello per un solo compito. Ogni passo richiede tool calling e un contesto ampio. Un solo piano gratuito blocca presto un agente. FreeLLMAPI raggruppa i piani gratuiti di 45 provider dietro una sola chiave compatibile con OpenAI. Passa al provider successivo quando un limite blocca una richiesta, così l'agente può continuare. Questa guida copre il tool calling, il routing per passo, le sessioni lunghe e il server MCP del router.
Codice, nomi dei modelli ed etichette del catalogo in tempo reale sono mostrati in inglese.
Cosa serve a un agente da un'API gratuita
| Esigenza | Perché | Cosa fa FreeLLMAPI |
|---|---|---|
| Tool calling | L'agente seleziona ed esegue gli strumenti | Passa tools in stile OpenAI a ogni provider. Converte le chiamate a strumenti in testo semplice in tool_calls reali. |
| Molte richieste | Un compito può richiedere da 20 a 100 passi | Conta la quota di ogni chiave e passa alla chiave o al provider successivo su 429 |
| Contesto ampio | I risultati degli strumenti e la cronologia crescono a ogni passo | Instrada verso i modelli della tua catena. Puoi creare un profilo per contesti lunghi. |
| Comportamento stabile | Un cambio di modello a metà di un compito può confondere l'agente | Mantiene una sessione sullo stesso modello per 30 minuti. Passaggio di contesto opzionale quando avviene un cambio. |
| Visibilità | Devi sapere quale modello ha fallito | Intestazioni X-Routed-Via e X-Fallback-Trail in ogni risposta |
I piani gratuiti hanno dei limiti. Il failover distribuisce il carico sulle tue chiavi, ma il totale resta la somma dei limiti gratuiti. Per il lavoro con agenti aggiungi chiavi di quattro o più provider.
| Modello | Gratis su | Contesto | Limiti gratuiti (offerta migliore) | Strumenti | Visione |
|---|---|---|---|---|---|
| GLM 5.3 | UnoRouter | 1M | 1 richieste/min 1 req/min per model | Sì | No |
| GLM 5.3 Flash | NVIDIA NIM, UnoRouter | 1M | 40 richieste/min 40 RPM | Sì | Sì |
| Gemini 3.8 Flash | Google AI Studio | 1M | Recurring provider quota | Sì | Sì |
| Qwen3.8 Flash Next | AMD Radeon Cloud | 262K | Recurring daily account allowance | Sì | No |
| Qwen3.8 Flash | ElectronHub | 1M | $0.25/week shared recurring credit | Sì | Sì |
| Gemini 3.7 Flash | Google AI Studio | 1M | 10 richieste/min 20 richieste/giorno 250,000 token/min ~3M | Sì | Sì |
| GPT-5.6 Luna | ElectronHub | 1M | $0.25/week shared recurring credit | Sì | Sì |
| Dots3 Note Preview | Kilo Gateway, OpenRouter | 512K | 20 richieste/min 50 richieste/giorno 50 req/day account-wide (1,000 after a $10 purchase) | Sì | Sì |
| DeepSeek V4 Flash | AMD Radeon Cloud, BazaarLink, ElectronHub | 1M | 10 richieste/min 50 richieste/giorno Shared rate limit | Sì | No |
| Qwen3.8 27B | ElectronHub, Groq, OVH AI Endpoints | 262K | 30 richieste/min 250 richieste/giorno 70,000 token/min ~6M | Sì | Sì |
| Gemini 3.6 Flash | Google AI Studio | 1M | 10 richieste/min 20 richieste/giorno 250,000 token/min ~3M | Sì | Sì |
| Qwen 3.8 27B | Cloudflare Workers AI | 262K | Shared 10k neurons/day | Sì | Sì |
Mostrati 12 di 109 modelli gratuiti corrispondenti. Vedi tutti i modelli.
Dati in tempo reale dal catalogo FreeLLMAPI (versione 2026.11.19, verificato il 2026-11-19). I limiti gratuiti cambiano spesso. Il catalogo viene verificato ogni giorno.
Un ciclo agente completo in Python
Il ciclo seguente usa l'SDK ufficiale di OpenAI. Invia gli strumenti, esegue ogni chiamata a strumento, rinvia il risultato e si ferma quando il modello dà una risposta finale. Si ferma anche dopo un numero massimo di passi.
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: mantiene tutti i passi di un compito sullo stesso modello, finché quel modello ha quota.
- Retry-After: quando ogni chiave ha raggiunto il limite, il gateway restituisce 429 con questa intestazione. Il ciclo attende e riprova.
- Errori degli strumenti: il ciclo invia gli errori al modello come risultati degli strumenti. Il modello può così correggere la sua chiamata.
Instrada ogni passo verso il modello giusto
I passi di un agente non sono tutti uguali. Un passo di pianificazione richiede un modello forte. Un passo che estrae un solo campo richiede un modello veloce. Usa una stringa di modello diversa per ogni tipo di passo. Non devi cambiare la dashboard.
| Stringa del modello | Classifica i modelli per | Uso con agenti |
|---|---|---|
auto:smart | Intelligenza | Pianificazione, selezione degli strumenti, risposte finali |
auto:fast | Velocità misurata e tempo al primo byte | Estrazione, classificazione, brevi riassunti dell'output degli strumenti |
auto:reliable | Tasso di successo recente | Agenti pianificati che devono completarsi |
auto:balanced | Prima affidabilità, poi velocità e intelligenza | Predefinito generale |
auto:<profile> | La tua catena di fallback con nome | Una catena con solo modelli con tool calling |
Le strategie auto:* classificano ogni modello attivo e ignorano l'ordine della tua catena. Una richiesta con strumenti richiede comunque un modello con tool calling. Se alcuni modelli attivi non supportano bene gli strumenti, crea un profilo con solo modelli con tool calling. Poi usa auto:<profile> per i passi con strumenti. Un nome di profilo sconosciuto restituisce l'errore 400.
L'intestazione X-FreeLLM-Task-Type: code sposta il peso del routing dalla velocità all'intelligenza per una sola richiesta. È una preferenza morbida. Non cambia i controlli delle capacità né la catena di fallback.
Sessioni lunghe con agenti e cambi di modello
Durante un compito lungo, un modello può raggiungere il suo limite giornaliero. Il router passa allora a un altro modello. Il nuovo modello riceve tutta la cronologia dei messaggi, ma non sa che un altro modello ha eseguito i passi precedenti.
Attiva il passaggio di contesto per aggiungere un breve messaggio di sistema quando il modello cambia. Il messaggio dice al nuovo modello di continuare il compito e di mantenere i risultati precedenti degli strumenti.
FreeLLMAPI .env
FREELLMAPI_CONTEXT_HANDOFF=on_model_switch- Il messaggio di passaggio viene aggiunto solo quando il modello selezionato cambia per una sessione.
- Le sessioni restano in memoria per 3 ore. Non viene scritto nulla su disco.
- La chiave di sessione è l'intestazione
X-Session-Id. Senza l'intestazione, è un hash del primo messaggio dell'utente.
Usa il router come server MCP
FreeLLMAPI è anche un server MCP su /mcp. Un agente che parla MCP può inviare un compito di testo a un modello FreeLLMAPI. Può anche leggere lo stato del gateway durante una sessione: i modelli utilizzabili e i loro parametri, lo stato di salute dei provider, le statistiche di utilizzo e cache e la strategia di routing.
La superficie MCP è disattivata nelle nuove installazioni. Attivala nella dashboard, nella pagina Keys, sotto Agent compatibility. Finché è disattivata, /mcp restituisce 403.
Aggiungi il server MCP a Claude Code
claude mcp add --transport http freellmapi http://localhost:3001/mcp \
--header "Authorization: Bearer <unified-key>"Ogni client MCP con Streamable HTTP funziona allo stesso modo. Puntalo a /mcp e invia la chiave unificata come token Bearer. Gli strumenti utili includono healthcheck, list_models e ask_freellmapi. Lo strumento ask_freellmapi esegue un compito con la stessa route di chat dell'API, con routing e fallback.
Per gli agenti di codifica, FreeLLMAPI ha comandi di configurazione che scrivono la configurazione del client al posto tuo. Esempi sono npx freellmapi setup-claude, setup-codex, setup-cline, setup-openclaw e setup-hermes. Ogni comando supporta --dry-run e crea prima un backup.
Risoluzione dei problemi
| Problema | Causa | Soluzione |
|---|---|---|
| Il modello risponde con testo e non chiama alcuno strumento | Il modello ha un tool calling debole | Usa auto:<profile> solo con modelli con tool calling |
| L'agente riavvia il compito a metà | Un limite ha forzato un cambio di modello | Invia X-Session-Id e attiva il passaggio di contesto |
| Errore 429 dopo molti passi | Tutte le chiavi della catena hanno raggiunto il limite | Aggiungi provider, usa auto:fast per i passi piccoli e attendi Retry-After |
Errore 400 con auto:name | Il profilo non esiste | Controlla il nome del profilo nella dashboard |
/mcp restituisce 403 | La superficie MCP è disattivata | Attivala in Agent compatibility nella pagina Keys |
| Errori di lunghezza del contesto a fine compito | La cronologia è più grande della finestra del modello | Riassumi i vecchi risultati degli strumenti o usa un profilo per contesti lunghi |
Domande frequenti
Esiste un'API LLM gratuita per agenti IA?
Sì. Diversi provider hanno piani gratuiti con tool calling. FreeLLMAPI li combina dietro una sola chiave compatibile con OpenAI e passa al provider successivo quando un limite blocca una richiesta.
Quale LLM gratuito è il migliore per il tool calling?
Usa un modello con tool calling e una finestra di contesto di 128K token o più. La tabella di questa pagina mostra i modelli gratuiti più forti che oggi rispettano entrambe le regole.
Posso usare FreeLLMAPI come server MCP?
Sì. Attiva la superficie MCP nella pagina Keys, sotto Agent compatibility. Poi collega il tuo client MCP a /mcp con la chiave unificata come token Bearer.
Come evito che un agente fallisca per i rate limit?
Aggiungi chiavi di più provider, invia i passi piccoli a auto:fast, riprova su 429 con l'intestazione Retry-After e imposta un numero massimo di passi.
Cosa succede se il modello cambia a metà di un compito di un agente?
Il nuovo modello riceve tutta la cronologia dei messaggi. Con il passaggio di contesto attivo, riceve anche una breve nota che gli dice di continuare il compito.
Guide correlate
- API LLM gratuita con function calling
- API LLM gratuita in Python
- API LLM gratuita per LangChain
- API LLM gratuita per n8n
- Come usare Claude Code gratis
- Rate limit delle Free LLM API
Fonti
- FreeLLMAPI docs: REST API (tool calling, routing strategies, response headers) (verificato il 20 November 2026)
- FreeLLMAPI docs: clients, MCP server and context handoff (verificato il 20 November 2026)
- OpenAI Python SDK: errors and retries (verificato il 20 November 2026)
- Claude Code docs: MCP (verificato il 20 November 2026)