Acasă / Ghiduri / API LLM gratuit cu apeluri de funcții

API LLM gratuit cu apeluri de funcții

Apelul de funcții, sau tool calling, permite unui LLM să ceară rularea unei funcții din cod. Agenții, boturile de chat cu date live și extragerea structurată le folosesc pe toate. Catalogul FreeLLMAPI conține 190 oferte de modele gratuite cu apeluri de unelte. Trimiteți tools în stil OpenAI, iar gateway-ul le traduce pentru fiecare furnizor.

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

Cum funcționează apelurile de unelte prin FreeLLMAPI

  1. Trimiteți mesajele și o listă de tools. Fiecare unealtă are un nume, o descriere și un JSON Schema pentru parametrii săi.
  2. Modelul răspunde cu tool_calls și finish_reason: "tool_calls". El nu rulează nimic singur.
  3. Codul rulează funcția și adaugă rezultatul ca mesaj cu role: "tool".
  4. Trimiteți din nou conversația. Modelul folosește rezultatul ca să scrie răspunsul final.

Furnizorii compatibili OpenAI, precum Groq, Cerebras, Mistral, OpenRouter și Cloudflare, primesc cererea așa cum este. Pentru Gemini, FreeLLMAPI traduce unealtele în formatul functionDeclarations de la Google și traduce răspunsul înapoi. Codul este același pentru fiecare furnizor.

Unele modele scriu un apel de unealtă ca text simplu, nu ca apel real de unealtă. FreeLLMAPI le detectează și le transformă în tool_calls reale.

Modele gratuite cu apeluri de unelte, astăzi

Tabelul arată cele mai puternice modele gratuite cu apeluri de unelte. Datele vin din catalogul activ. Pentru agenți, verificați și dimensiunea contextului, deoarece definițiile de unelte și rezultatele folosesc multe tokenuri.

Modele gratuite cu apeluri de unelte, cele mai puternice primele
ModelGratuit peContextLimite gratuite (cea mai bună ofertă)InstrumenteViziune
GLM 5.3UnoRouter1M1 cereri/min
1 req/min per model
DaNu
Qwen3.8 MaxACLIDE-€20/month shared internal usage credits · no cardDaNu
GLM 5.3 FlashNVIDIA NIM, UnoRouter1M40 cereri/min
40 RPM
DaDa
Gemini 3.8 FlashGoogle AI Studio1MRecurring provider quotaDaDa
Gemini Flash (latest alias)Google AI Studio-10 cereri/min
20 cereri/zi
250,000 tokeni/min
~3M
DaDa
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
Gemini 3.5 FlashGoogle AI Studio1M10 cereri/min
20 cereri/zi
250,000 tokeni/min
~3M
DaDa

Se afișează 15 din 146 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.

Pasul 1: Instalați FreeLLMAPI și adăugați chei

FreeLLMAPI este open source. Rulează pe computer, în Docker. Cheile furnizorilor rămân pe computer.

Instalare (macOS sau Linux)

curl -fsSL https://freellmapi.co/install.sh | bash

Deschideți panoul la http://localhost:3001. Adăugați chei de la trei sau mai mulți furnizori pe pagina Keys. O buclă de unelte trimite mai multe cereri pentru o sarcină, deci mai multe chei dau mai mult spațiu. Copiați cheia unificată de pe aceeași pagină.

Pasul 2: Rulați o buclă completă de unelte

curl: prima cerere

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: buclă până când modelul dă un răspuns final

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)})

Apelurile de unelte funcționează și cu stream=True. Primiți fragmente delta.tool_calls, apoi un fragment final cu finish_reason: "tool_calls". Uniți fragmentele de argumente înainte să parsați JSON-ul.

Folosiți o unealtă pentru date structurate

Apelurile de unelte sunt și o metodă bună de a obține date într-o formă fixă. Definiți o unealtă al cărei parametri sunt câmpurile pe care le doriți. Setați tool_choice la "required", astfel încât modelul trebuie să apeleze o unealtă. Apoi citiți argumentele. Nu trebuie să rulați nicio funcție.

Python: extrageți câmpuri cu un apel de unealtă obligatoriu

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

Validați argumentele cu propriul cod. Un model poate lăsa un câmp obligatoriu sau poate trimite un tip greșit. Dacă verificarea eșuează, trimiteți eroarea înapoi și cereți din nou.

Siguranță: nu rulați apeluri de unelte cu efecte secundare, precum plăți, e-mailuri sau ștergerea de fișiere, fără o verificare. Cereți utilizatorului să confirme mai întâi aceste acțiuni.

Capcane

  • Argumentele sunt un șir: function.arguments este un șir JSON. Parsați-l și prindeți erorile. Modelele mici trimit uneori JSON care nu este valid.
  • Potriviți ID-urile: fiecare mesaj de unealtă are nevoie de tool_call_id al apelului său. Adăugați mesajul asistentului cu tool_calls înainte de mesajele de unealtă.
  • Mai multe apeluri deodată: un model poate returna mai multe apeluri de unelte într-un singur răspuns. Rulați-le pe toate, apoi trimiteți toate rezultatele.
  • Costul în tokenuri: fiecare definiție de unealtă se trimite cu fiecare cerere. Douăzeci de unelte mari pot folosi mii de tokenuri și pot atinge repede o limită scăzută de tokenuri pe minut. Trimiteți doar uneltele de care are nevoie sarcina.
  • Descrieri clare: modelul alege o unealtă după nume și descriere. Scrieți o propoziție scurtă care spune ce face unealta și când se folosește.
  • Opriți bucla: stabiliți un număr maxim de runde. Un model slab poate apela aceeași unealtă din nou și din nou.
  • Modele fără unelte: unii furnizori gratuiți nu acceptă unelte. De exemplu, AI Horde elimină uneltele și răspunde ca un chat simplu.
Același model în timpul unei sarcini: FreeLLMAPI păstrează o conversație pe un model timp de 30 de minute. O buclă de unelte rămâne de obicei pe un singur model. Dacă o limită forțează o schimbare, următorul model primește istoricul complet al mesajelor, inclusiv rezultatele uneltelor.

Depanare

ProblemăCauzăRemediere
Modelul răspunde în text și nu apelează nicio unealtăModelul este slab la unelte, sau descrierea nu este clarăFixați un model mai puternic din tabel sau îmbunătățiți descrierea uneltei
json.JSONDecodeError la argumenteModelul a trimis JSON nevalidPrindeți eroarea și trimiteți-o înapoi ca rezultat al uneltei, ca modelul să poată încerca din nou
Eroare 400 despre un mesaj de unealtătool_call_id nu se potrivește, sau lipsește mesajul asistentuluiAdăugați mai întâi mesajul asistentului, apoi câte un mesaj de unealtă pentru fiecare apel
Eroare 429 în timpul unei sarcini de agentBucla trimite multe cereri mariAdăugați mai multe chei de furnizori și trimiteți mai puține unelte
Bucla nu se opreșteModelul apelează din nou aceeași unealtăStabiliți o limită de runde și returnați rezultate clare
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

Ce API-uri LLM gratuite acceptă apeluri de funcții?

Gemini, Groq, Cerebras, Mistral, OpenRouter, Cloudflare și alți furnizori au modele gratuite cu apeluri de unelte. Catalogul FreeLLMAPI conține 190 oferte de modele gratuite cu unelte, astăzi.

Este tool calling același lucru cu function calling?

Da. OpenAI a folosit primul numele function calling. API-ul actual folosește tools și tool_calls. Ambele nume înseamnă că modelul cere codului să ruleze o funcție.

Funcționează apelurile de unelte Gemini cu formatul OpenAI?

Da, prin FreeLLMAPI. Gateway-ul traduce uneltele OpenAI în functionDeclarations Gemini și traduce răspunsul înapoi în tool_calls OpenAI.

Pot transmite apelurile de unelte în streaming?

Da. Cu stream=True primiți fragmente delta.tool_calls și un finish_reason final de tool_calls. Uniți fragmentele de argumente înainte să le parsați.

Ghiduri înrudite

Surse

Toate ghidurile · Vezi toate modelele gratuite