Home / Guide / Free LLM API per agenti IA

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

EsigenzaPerchéCosa fa FreeLLMAPI
Tool callingL'agente seleziona ed esegue gli strumentiPassa tools in stile OpenAI a ogni provider. Converte le chiamate a strumenti in testo semplice in tool_calls reali.
Molte richiesteUn compito può richiedere da 20 a 100 passiConta la quota di ogni chiave e passa alla chiave o al provider successivo su 429
Contesto ampioI risultati degli strumenti e la cronologia crescono a ogni passoInstrada verso i modelli della tua catena. Puoi creare un profilo per contesti lunghi.
Comportamento stabileUn cambio di modello a metà di un compito può confondere l'agenteMantiene una sessione sullo stesso modello per 30 minuti. Passaggio di contesto opzionale quando avviene un cambio.
VisibilitàDevi sapere quale modello ha fallitoIntestazioni 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.

Modelli gratuiti con tool calling e contesto di 128K+
ModelloGratis suContestoLimiti gratuiti (offerta migliore)StrumentiVisione
GLM 5.3UnoRouter1M1 richieste/min
1 req/min per model
SìNo
GLM 5.3 FlashNVIDIA NIM, UnoRouter1M40 richieste/min
40 RPM
SìSì
Gemini 3.8 FlashGoogle AI Studio1MRecurring provider quotaSìSì
Qwen3.8 Flash NextAMD Radeon Cloud262KRecurring daily account allowanceSìNo
Qwen3.8 FlashElectronHub1M$0.25/week shared recurring creditSìSì
Gemini 3.7 FlashGoogle AI Studio1M10 richieste/min
20 richieste/giorno
250,000 token/min
~3M
SìSì
GPT-5.6 LunaElectronHub1M$0.25/week shared recurring creditSìSì
Dots3 Note PreviewKilo Gateway, OpenRouter512K20 richieste/min
50 richieste/giorno
50 req/day account-wide (1,000 after a $10 purchase)
SìSì
DeepSeek V4 FlashAMD Radeon Cloud, BazaarLink, ElectronHub1M10 richieste/min
50 richieste/giorno
Shared rate limit
SìNo
Qwen3.8 27BElectronHub, Groq, OVH AI Endpoints262K30 richieste/min
250 richieste/giorno
70,000 token/min
~6M
SìSì
Gemini 3.6 FlashGoogle AI Studio1M10 richieste/min
20 richieste/giorno
250,000 token/min
~3M
SìSì
Qwen 3.8 27BCloudflare Workers AI262KShared 10k neurons/daySì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 modelloClassifica i modelli perUso con agenti
auto:smartIntelligenzaPianificazione, selezione degli strumenti, risposte finali
auto:fastVelocità misurata e tempo al primo byteEstrazione, classificazione, brevi riassunti dell'output degli strumenti
auto:reliableTasso di successo recenteAgenti pianificati che devono completarsi
auto:balancedPrima affidabilità, poi velocità e intelligenzaPredefinito generale
auto:<profile>La tua catena di fallback con nomeUna 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

ProblemaCausaSoluzione
Il modello risponde con testo e non chiama alcuno strumentoIl modello ha un tool calling deboleUsa auto:<profile> solo con modelli con tool calling
L'agente riavvia il compito a metàUn limite ha forzato un cambio di modelloInvia X-Session-Id e attiva il passaggio di contesto
Errore 429 dopo molti passiTutte le chiavi della catena hanno raggiunto il limiteAggiungi provider, usa auto:fast per i passi piccoli e attendi Retry-After
Errore 400 con auto:nameIl profilo non esisteControlla il nome del profilo nella dashboard
/mcp restituisce 403La superficie MCP è disattivataAttivala in Agent compatibility nella pagina Keys
Errori di lunghezza del contesto a fine compitoLa cronologia è più grande della finestra del modelloRiassumi i vecchi risultati degli strumenti o usa un profilo per contesti lunghi
Usa ognuno di questi modelli con una sola chiave. FreeLLMAPI è un router open source self-hosted che mette tutti questi piani gratuiti dietro un unico endpoint compatibile con OpenAI e passa al successivo quando uno raggiunge il limite di frequenza. Sfoglia il catalogo oppure inizia.

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

Fonti

Tutte le guide · Sfoglia tutti i modelli gratuiti