Acasă / Ghiduri / Free LLM API pentru agenți AI

Free LLM API pentru agenți AI

Un agent AI trimite multe cereri către model pentru o singură sarcină. Fiecare pas are nevoie de apelare de instrumente și de un context mare. Un singur nivel gratuit oprește repede un agent. FreeLLMAPI reunește 45 niveluri gratuite de furnizori în spatele unei singure chei compatibile cu OpenAI. Când o limită oprește o cerere, trece la următorul furnizor, iar agentul poate continua. Acest ghid acoperă apelarea de instrumente, rutarea pe pas, sesiunile lungi și serverul MCP al routerului.

Codul, numele modelelor și etichetele live din catalog sunt afișate în engleză.

Ce are nevoie un agent de la un API gratuit

NecesitateMotivCe face FreeLLMAPI
Apelare de instrumenteAgentul alege și rulează instrumenteTrimite tools în stil OpenAI către fiecare furnizor. Convertește apelurile de instrumente din text simplu în tool_calls reale.
Multe cereriO sarcină poate avea de la 20 până la 100 de pașiNumără cota fiecărei chei și trece la următoarea cheie sau următorul furnizor la 429
Context mareRezultatele instrumentelor și istoricul cresc la fiecare pasRutează către modele din lanțul dumneavoastră. Puteți crea un profil pentru context lung.
Comportament stabilO schimbare de model în mijlocul unei sarcini poate deruta agentulPăstrează o sesiune pe același model timp de 30 de minute. Transmiterea opțională a contextului la o schimbare.
VizibilitateTrebuie să știți ce model a eșuatAntetele X-Routed-Via și X-Fallback-Trail la fiecare răspuns

Nivelurile gratuite au limite. Trecerea automată la alt furnizor distribuie sarcina pe cheile dumneavoastră, dar totalul rămâne suma limitelor gratuite. Adăugați chei de la patru sau mai mulți furnizori pentru lucrul cu agenți.

Modele gratuite cu apelare de instrumente și context de 128K+
ModelGratuit peContextLimite gratuite (cea mai bună ofertă)InstrumenteViziune
GLM 5.3UnoRouter1M1 cereri/min
1 req/min per model
DaNu
GLM 5.3 FlashNVIDIA NIM, UnoRouter1M40 cereri/min
40 RPM
DaDa
Gemini 3.8 FlashGoogle AI Studio1MRecurring provider quotaDaDa
Qwen3.8 Flash NextAMD Radeon Cloud262KRecurring daily account allowanceDaNu
Qwen3.8 FlashElectronHub1M$0.25/week shared recurring creditDaDa
Gemini 3.7 FlashGoogle AI Studio1M10 cereri/min
20 cereri/zi
250,000 tokeni/min
~3M
DaDa
GPT-5.6 LunaElectronHub1M$0.25/week shared recurring creditDaDa
Dots3 Note PreviewKilo Gateway, OpenRouter512K20 cereri/min
50 cereri/zi
50 req/day account-wide (1,000 after a $10 purchase)
DaDa
DeepSeek V4 FlashAMD Radeon Cloud, BazaarLink, ElectronHub1M10 cereri/min
50 cereri/zi
Shared rate limit
DaNu
Qwen3.8 27BElectronHub, Groq, OVH AI Endpoints262K30 cereri/min
250 cereri/zi
70,000 tokeni/min
~6M
DaDa
Gemini 3.6 FlashGoogle AI Studio1M10 cereri/min
20 cereri/zi
250,000 tokeni/min
~3M
DaDa
Qwen 3.8 27BCloudflare Workers AI262KShared 10k neurons/dayDaDa

Se afișează 12 din 109 modele gratuite care se potrivesc. Vezi toate modelele.

Date live din catalogul FreeLLMAPI (versiunea 2026.11.19, verificat 2026-11-19). Limitele gratuite se schimbă des. Catalogul este verificat în fiecare zi.

O buclă completă de agent în Python

Bucla de mai jos folosește SDK-ul oficial OpenAI. Trimite instrumentele, rulează fiecare apel de instrument, trimite rezultatul înapoi și se oprește când modelul dă un răspuns final. Se oprește și după un număr maxim de pași.

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: păstrează toți pașii unei sarcini pe același model, cât timp modelul are cotă.
  • Retry-After: când fiecare cheie este la limită, gateway-ul returnează 429 cu acest antet. Bucla așteaptă și încearcă din nou.
  • Erori de instrument: bucla trimite erorile înapoi către model ca rezultate ale instrumentelor. Modelul poate apoi să corecteze apelul.

Rutați fiecare pas către modelul potrivit

Pașii unui agent nu sunt egali. Un pas de planificare are nevoie de un model puternic. Un pas care extrage un singur câmp are nevoie de un model rapid. Folosiți un șir de model diferit pentru fiecare tip de pas. Nu trebuie să modificați panoul.

Șir de modelClasează modelele dupăUtilizare în agent
auto:smartInteligențăPlanificare, selectarea instrumentelor, răspunsuri finale
auto:fastViteză măsurată și timp până la primul octetExtragere, clasificare, rezumate scurte ale rezultatului unui instrument
auto:reliableRata recentă de succesAgenți programați care trebuie să termine
auto:balancedMai întâi fiabilitatea, apoi viteza și inteligențaImplicit general
auto:<profile>Lanțul dumneavoastră de rezervă denumitUn lanț cu doar modele cu apelare de instrumente

Strategiile auto:* clasează fiecare model activat și ignoră ordinea din lanțul dumneavoastră. O cerere cu instrumente are nevoie totuși de un model cu apelare de instrumente. Dacă unele modele activate nu acceptă bine instrumentele, creați un profil doar cu modele care apelează instrumente. Apoi folosiți auto:<profile> pentru pașii cu instrumente. Un nume de profil necunoscut returnează eroarea 400.

Antetul X-FreeLLM-Task-Type: code mută ponderea rutării de la viteză la inteligență pentru o singură cerere. Este o preferință orientativă. Nu schimbă verificările de capacitate sau lanțul de rezervă.

Sesiuni lungi de agent și schimbări de model

În timpul unei sarcini lungi, un model poate ajunge la limita zilnică. Routerul trece atunci la alt model. Noul model primește tot istoricul mesajelor, dar nu știe că alt model a făcut pașii anteriori.

Activați transmiterea contextului ca să adăugați un mesaj de sistem scurt când se schimbă modelul. Mesajul îi spune noului model să continue sarcina și să păstreze rezultatele anterioare ale instrumentelor.

FreeLLMAPI .env

FREELLMAPI_CONTEXT_HANDOFF=on_model_switch
  • Mesajul de transmitere se adaugă doar când modelul selectat se schimbă pentru o sesiune.
  • Sesiunile se țin în memorie timp de 3 ore. Nimic nu se scrie pe disc.
  • Cheia sesiunii este antetul X-Session-Id. Fără acest antet, cheia este un hash al primului mesaj al utilizatorului.

Folosiți routerul ca server MCP

FreeLLMAPI este și un server MCP pe /mcp. Un agent care vorbește MCP poate trimite o sarcină text către un model FreeLLMAPI. Poate citi și starea gateway-ului în timpul unei sesiuni: modelele utilizabile și parametrii lor, starea furnizorilor, statisticile de utilizare și de cache și strategia de rutare.

Suprafața MCP este dezactivată la instalările noi. Activați-o în panou, pe pagina Keys, sub Agent compatibility. Cât timp este dezactivată, /mcp returnează 403.

Adăugați serverul MCP în Claude Code

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

Orice client MCP cu Streamable HTTP funcționează la fel. Indicați-l către /mcp și trimiteți cheia unificată ca Bearer token. Instrumentele utile sunt healthcheck, list_models și ask_freellmapi. Instrumentul ask_freellmapi rulează o sarcină prin aceeași rută de chat ca API-ul, cu rutare și rezervă.

Pentru agenții de programare, FreeLLMAPI are comenzi de configurare care scriu configurația clientului în locul dumneavoastră. Exemple sunt npx freellmapi setup-claude, setup-codex, setup-cline, setup-openclaw și setup-hermes. Fiecare comandă acceptă --dry-run și face mai întâi o copie de rezervă.

Depanare

ProblemăCauzăRemediere
Modelul răspunde în text și nu apelează niciun instrumentModelul are apelare de instrumente slabăFolosiți auto:<profile> doar cu modele care apelează instrumente
Agentul reia sarcina de la început, în mijlocO limită a forțat schimbarea modeluluiTrimiteți X-Session-Id și activați transmiterea contextului
Eroarea 429 după mulți pașiToate cheile din lanț sunt la limităAdăugați furnizori, folosiți auto:fast pentru pașii mici și așteptați Retry-After
Eroarea 400 cu auto:nameProfilul nu existăVerificați numele profilului în panou
/mcp returnează 403Suprafața MCP este dezactivatăActivați-o sub Agent compatibility pe pagina Keys
Erori de lungime a contextului târziu într-o sarcinăIstoricul este mai mare decât fereastra modeluluiRezumați rezultatele vechi ale instrumentelor sau folosiți un profil cu context lung
Folosiți fiecare dintre aceste modele printr-o singură cheie. FreeLLMAPI este un router open-source, găzduit de dumneavoastră, care pune toate aceste niveluri gratuite în spatele unui singur endpoint compatibil cu OpenAI și trece la alt furnizor când un furnizor este limitat la rată. Vezi catalogul sau trece live.

Întrebări frecvente

Există un API LLM gratuit pentru agenți AI?

Da. Mai mulți furnizori au niveluri gratuite cu apelare de instrumente. FreeLLMAPI le reunește în spatele unei singure chei compatibile cu OpenAI și trece la următorul furnizor când o limită oprește o cerere.

Care LLM gratuit este cel mai bun pentru apelarea de instrumente?

Folosiți un model cu apelare de instrumente și o fereastră de context de 128K tokeni sau mai mult. Tabelul de pe această pagină arată cele mai puternice modele gratuite care respectă astăzi ambele reguli.

Pot folosi FreeLLMAPI ca server MCP?

Da. Activați suprafața MCP pe pagina Keys, sub Agent compatibility. Apoi conectați clientul MCP la /mcp cu cheia unificată ca Bearer token.

Cum opresc un agent să eșueze la limitele de rată?

Adăugați chei de la mai mulți furnizori, trimiteți pașii mici către auto:fast, reîncercați la 429 cu antetul Retry-After și stabiliți un număr maxim de pași.

Ce se întâmplă când modelul se schimbă în mijlocul unei sarcini de agent?

Noul model primește tot istoricul mesajelor. Cu transmiterea contextului activată, primește și o notă scurtă care îi spune să continue sarcina.

Ghiduri înrudite

Surse

Toate ghidurile · Vezi toate modelele gratuite