AI એજન્ટ્સ માટે મફત LLM API
AI એજન્ટ એક કાર્ય માટે ઘણી મૉડેલ વિનંતીઓ મોકલે છે. દરેક પગલાને ટૂલ કૉલિંગ અને મોટો context જોઈએ. એક મફત ટિયર એજન્ટને ઝડપથી રોકી દે છે. FreeLLMAPI એક OpenAI-compatible key પાછળ 45 મફત provider ટિયર ભેગા કરે છે. જ્યારે કોઈ મર્યાદા વિનંતીને રોકે છે, ત્યારે તે આગલા provider પર જાય છે, જેથી એજન્ટ ચાલુ રહી શકે. આ માર્ગદર્શિકામાં ટૂલ કૉલિંગ, દરેક પગલા માટે રાઉટિંગ, લાંબાં સત્રો અને રાઉટરના MCP સર્વરને આવરી લેવાયા છે.
કોડ, મૉડેલ નામ અને લાઇવ કૅટલૉગ લેબલ અંગ્રેજીમાં બતાવવામાં આવે છે.
મફત API થી એજન્ટને શું જોઈએ
| જરૂરિયાત | શા માટે | FreeLLMAPI શું કરે છે |
|---|---|---|
| ટૂલ કૉલિંગ | એજન્ટ ટૂલ પસંદ કરે છે અને ચલાવે છે | દરેક providerને OpenAI-style tools પસાર કરે છે. સાદા-લખાણ ટૂલ કૉલને વાસ્તવિક tool_calls માં બદલે છે. |
| ઘણી વિનંતીઓ | એક કાર્યમાં 20 થી 100 પગલાં લાગી શકે | દરેક key નો quota ગણે છે અને 429 પર આગલી key અથવા provider પર જાય છે |
| મોટો context | ટૂલ પરિણામો અને ઇતિહાસ દરેક પગલે વધે છે | તમારી chain ના મૉડેલો પર રૂટ કરે છે. તમે લાંબા-context profile બનાવી શકો છો. |
| સ્થિર વર્તન | કાર્યની વચ્ચે મૉડેલ બદલાય તો એજન્ટ ગૂંચવાઈ શકે | સત્રને 30 મિનિટ સુધી એક મૉડેલ પર રાખે છે. બદલાવ થાય ત્યારે વૈકલ્પિક context handoff. |
| દૃશ્યતા | તમારે જાણવું પડે કે કયું મૉડેલ નિષ્ફળ ગયું | દરેક પ્રતિસાદ પર X-Routed-Via અને X-Fallback-Trail headers |
મફત ટિયરમાં મર્યાદાઓ હોય છે. Failover લોડ તમારી keys પર વહેંચે છે, પરંતુ કુલ મર્યાદા મફત મર્યાદાઓના સરવાળા જેટલી જ રહે છે. એજન્ટ કાર્ય માટે ચાર કે વધુ providers ની keys ઉમેરો.
| મૉડેલ | મફત ઉપલબ્ધ | સંદર્ભ | મફત મર્યાદા (શ્રેષ્ઠ ઑફર) | સાધનો | વિઝન |
|---|---|---|---|---|---|
| GLM 5.3 | UnoRouter | 1M | 1 વિનંતી/મિનિટ 1 req/min per model | હા | ના |
| GLM 5.3 Flash | NVIDIA NIM, UnoRouter | 1M | 40 વિનંતી/મિનિટ 40 RPM | હા | હા |
| Gemini 3.8 Flash | Google AI Studio | 1M | Recurring provider quota | હા | હા |
| Qwen3.8 Flash Next | AMD Radeon Cloud | 262K | Recurring daily account allowance | હા | ના |
| Qwen3.8 Flash | ElectronHub | 1M | $0.25/week shared recurring credit | હા | હા |
| Gemini 3.7 Flash | Google AI Studio | 1M | 10 વિનંતી/મિનિટ 20 વિનંતી/દિવસ 250,000 ટોકન/મિનિટ ~3M | હા | હા |
| GPT-5.6 Luna | ElectronHub | 1M | $0.25/week shared recurring credit | હા | હા |
| Dots3 Note Preview | Kilo Gateway, OpenRouter | 512K | 20 વિનંતી/મિનિટ 50 વિનંતી/દિવસ 50 req/day account-wide (1,000 after a $10 purchase) | હા | હા |
| DeepSeek V4 Flash | AMD Radeon Cloud, BazaarLink, ElectronHub | 1M | 10 વિનંતી/મિનિટ 50 વિનંતી/દિવસ Shared rate limit | હા | ના |
| Qwen3.8 27B | ElectronHub, Groq, OVH AI Endpoints | 262K | 30 વિનંતી/મિનિટ 250 વિનંતી/દિવસ 70,000 ટોકન/મિનિટ ~6M | હા | હા |
| Gemini 3.6 Flash | Google AI Studio | 1M | 10 વિનંતી/મિનિટ 20 વિનંતી/દિવસ 250,000 ટોકન/મિનિટ ~3M | હા | હા |
| Qwen 3.8 27B | Cloudflare Workers AI | 262K | Shared 10k neurons/day | હા | હા |
મેળ ખાતા 109 મફત મૉડેલમાંથી 12 બતાવ્યા. બધા મૉડેલ જુઓ.
FreeLLMAPI કૅટલૉગનો લાઇવ ડેટા (સંસ્કરણ 2026.11.19, તપાસ્યું 2026-11-19). મફત મર્યાદાઓ વારંવાર બદલાય છે. કૅટલૉગ દરરોજ તપાસવામાં આવે છે.
Python માં સંપૂર્ણ એજન્ટ લૂપ
નીચેનો લૂપ સત્તાવાર OpenAI SDK વાપરે છે. તે ટૂલ્સ મોકલે છે, દરેક ટૂલ કૉલ ચલાવે છે, પરિણામ પાછું મોકલે છે અને મૉડેલ અંતિમ જવાબ આપે ત્યારે અટકે છે. તે પગલાંની મહત્તમ સંખ્યા પછી પણ અટકે છે.
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: જ્યાં સુધી મૉડેલ પાસે quota હોય ત્યાં સુધી એક કાર્યના બધા પગલાં એક જ મૉડેલ પર રાખે છે.
- Retry-After: જ્યારે બધી keys તેમની મર્યાદા પર હોય, ત્યારે ગેટવે આ header સાથે 429 પરત કરે છે. લૂપ રાહ જુએ છે અને ફરી પ્રયાસ કરે છે.
- ટૂલ ભૂલો: લૂપ ભૂલોને ટૂલ પરિણામ તરીકે મૉડેલને પાછી મોકલે છે. ત્યારે મૉડેલ પોતાનો કૉલ સુધારી શકે છે.
દરેક પગલું યોગ્ય મૉડેલ પર રૂટ કરો
એજન્ટના બધા પગલાં સરખા નથી. આયોજનના પગલાને મજબૂત મૉડેલ જોઈએ. એક ફીલ્ડ કાઢવાના પગલાને ઝડપી મૉડેલ જોઈએ. દરેક પગલાના પ્રકાર માટે અલગ model string વાપરો. તમારે dashboard બદલવાની જરૂર નથી.
| Model string | ક્રમ કેવી રીતે નક્કી થાય | એજન્ટ ઉપયોગ |
|---|---|---|
auto:smart | બુદ્ધિ | આયોજન, ટૂલ પસંદગી, અંતિમ જવાબ |
auto:fast | માપેલી ગતિ અને પ્રથમ બાઇટનો સમય | નિષ્કર્ષણ, વર્ગીકરણ, ટૂલ આઉટપુટનો ટૂંકો સારાંશ |
auto:reliable | તાજેતરનો સફળતા દર | નિર્ધારિત એજન્ટ જે પૂર્ણ થવા જ જોઈએ |
auto:balanced | પહેલાં વિશ્વસનીયતા, પછી ગતિ અને બુદ્ધિ | સામાન્ય ડિફોલ્ટ |
auto:<profile> | તમારી નામવાળી fallback chain | માત્ર ટૂલ-કૉલિંગ મૉડેલો ધરાવતી chain |
auto:* strategies બધા સક્રિય મૉડેલોને ક્રમ આપે છે અને તમારી chain નો ક્રમ અવગણે છે. ટૂલ્સ સાથેની વિનંતીને હજુ પણ ટૂલ કૉલિંગવાળું મૉડેલ જોઈએ. જો કેટલાક સક્રિય મૉડેલો ટૂલ્સને સારી રીતે સપોર્ટ ન કરે, તો માત્ર ટૂલ-કૉલિંગ મૉડેલો ધરાવતો profile બનાવો. પછી ટૂલ પગલાં માટે auto:<profile> વાપરો. અજાણ્યું profile નામ error 400 પરત કરે છે.
X-FreeLLM-Task-Type: code header એક વિનંતી માટે રાઉટિંગ ભાર ગતિથી બુદ્ધિ તરફ ખસેડે છે. આ નરમ પસંદગી છે. તે capability તપાસ કે fallback chain બદલતી નથી.
લાંબા એજન્ટ સત્રો અને મૉડેલ બદલાવ
લાંબા કાર્ય દરમિયાન મૉડેલ તેની દૈનિક મર્યાદા સુધી પહોંચી શકે છે. ત્યારે રાઉટર બીજા મૉડેલ પર જાય છે. નવા મૉડેલને સંદેશાનો સંપૂર્ણ ઇતિહાસ મળે છે, પરંતુ તે જાણતું નથી કે અગાઉના પગલાં બીજા મૉડેલે કર્યા હતા.
મૉડેલ બદલાય ત્યારે એક ટૂંકો system સંદેશ ઉમેરવા context handoff ચાલુ કરો. સંદેશ નવા મૉડેલને કાર્ય ચાલુ રાખવા અને અગાઉના ટૂલ પરિણામો જાળવવા કહે છે.
FreeLLMAPI .env
FREELLMAPI_CONTEXT_HANDOFF=on_model_switch- handoff સંદેશ ત્યારે જ ઉમેરાય છે જ્યારે સત્ર માટે પસંદ થયેલ મૉડેલ બદલાય.
- સત્રો 3 કલાક સુધી મેમરીમાં રાખવામાં આવે છે. કંઈ પણ ડિસ્ક પર લખાતું નથી.
- સત્ર key
X-Session-Idheader છે. header ન હોય તો, તે પ્રથમ user સંદેશનો hash છે.
રાઉટરને MCP સર્વર તરીકે વાપરો
FreeLLMAPI /mcp પર MCP સર્વર પણ છે. MCP બોલતો એજન્ટ FreeLLMAPI મૉડેલને લખાણ કાર્ય મોકલી શકે છે. તે સત્ર દરમિયાન ગેટવેની સ્થિતિ પણ વાંચી શકે છે: ઉપયોગ યોગ્ય મૉડેલો અને તેમના parameters, provider આરોગ્ય, ઉપયોગ અને cache આંકડા, અને રાઉટિંગ strategy.
નવી installations પર MCP surface બંધ હોય છે. Keys પૃષ્ઠ પર Agent compatibility હેઠળ dashboard માં તેને ચાલુ કરો. તે બંધ હોય ત્યાં સુધી /mcp 403 પરત કરે છે.
Claude Code માં MCP સર્વર ઉમેરો
claude mcp add --transport http freellmapi http://localhost:3001/mcp \
--header "Authorization: Bearer <unified-key>"Streamable HTTP ધરાવતો કોઈ પણ MCP client એ જ રીતે કામ કરે છે. તેને /mcp તરફ નિર્દેશ કરો અને unified key ને Bearer token તરીકે મોકલો. ઉપયોગી ટૂલ્સમાં healthcheck, list_models અને ask_freellmapi છે. ask_freellmapi ટૂલ API ના એ જ chat route દ્વારા કાર્ય ચલાવે છે, જેમાં રાઉટિંગ અને fallback છે.
કોડિંગ એજન્ટ્સ માટે, FreeLLMAPI પાસે setup આદેશો છે જે તમારા માટે client configuration લખે છે. ઉદાહરણો: npx freellmapi setup-claude, setup-codex, setup-cline, setup-openclaw અને setup-hermes. દરેક આદેશ --dry-run ને સપોર્ટ કરે છે અને પહેલાં બેકઅપ બનાવે છે.
સમસ્યાનિવારણ
| સમસ્યા | કારણ | ઉકેલ |
|---|---|---|
| મૉડેલ લખાણમાં જવાબ આપે છે અને કોઈ ટૂલ કૉલ કરતું નથી | મૉડેલમાં ટૂલ કૉલિંગ નબળું છે | માત્ર ટૂલ-કૉલિંગ મૉડેલો સાથે auto:<profile> વાપરો |
| એજન્ટ કાર્યની વચ્ચે ફરી શરૂ કરે છે | મર્યાદાને કારણે મૉડેલ બદલવું પડ્યું | X-Session-Id મોકલો અને context handoff ચાલુ કરો |
| ઘણા પગલાં પછી 429 ભૂલ | chain ની બધી keys તેમની મર્યાદા પર છે | providers ઉમેરો, નાના પગલાં માટે auto:fast વાપરો અને Retry-After ની રાહ જુઓ |
auto:name સાથે 400 ભૂલ | profile અસ્તિત્વમાં નથી | dashboard પર profile નામ તપાસો |
/mcp 403 પરત કરે છે | MCP surface બંધ છે | Keys પૃષ્ઠ પર Agent compatibility હેઠળ તેને ચાલુ કરો |
| કાર્યના અંતમાં context લંબાઈની ભૂલો | ઇતિહાસ મૉડેલની window કરતાં મોટો છે | જૂના ટૂલ પરિણામોનો સારાંશ બનાવો અથવા લાંબા-context profile વાપરો |
વારંવાર પૂછાતા પ્રશ્નો
શું AI એજન્ટ્સ માટે મફત LLM API છે?
હા. ઘણા providers ટૂલ કૉલિંગ સાથે મફત ટિયર આપે છે. FreeLLMAPI તેમને એક OpenAI-compatible key પાછળ ભેગા કરે છે અને મર્યાદા વિનંતીને રોકે ત્યારે આગલા provider પર જાય છે.
ટૂલ કૉલિંગ માટે કયું મફત LLM શ્રેષ્ઠ છે?
ટૂલ કૉલિંગ અને 128K tokens કે તેથી વધુ context window ધરાવતું મૉડેલ વાપરો. આ પૃષ્ઠ પરનું કોષ્ટક આજે આ બંને નિયમો પૂરા કરતા સૌથી મજબૂત મફત મૉડેલો બતાવે છે.
શું હું FreeLLMAPI ને MCP સર્વર તરીકે વાપરી શકું?
હા. Keys પૃષ્ઠ પર Agent compatibility હેઠળ MCP surface ચાલુ કરો. પછી unified key ને Bearer token તરીકે વાપરીને તમારા MCP client ને /mcp સાથે જોડો.
એજન્ટને rate limits પર નિષ્ફળ થતો કેવી રીતે અટકાવું?
વધુ providers ની keys ઉમેરો, નાના પગલાં auto:fast પર મોકલો, Retry-After header સાથે 429 પર ફરી પ્રયાસ કરો અને પગલાંની મહત્તમ સંખ્યા સેટ કરો.
એજન્ટ કાર્યની વચ્ચે મૉડેલ બદલાય ત્યારે શું થાય?
નવા મૉડેલને સંદેશાનો સંપૂર્ણ ઇતિહાસ મળે છે. context handoff ચાલુ હોય તો, તેને એક ટૂંકી નોંધ પણ મળે છે જે તેને કાર્ય ચાલુ રાખવા કહે છે.
સંબંધિત માર્ગદર્શિકાઓ
- function calling સાથે મફત LLM API
- Python માં મફત LLM API
- LangChain માટે મફત LLM API
- n8n માટે મફત LLM API
- Claude Code મફતમાં કેવી રીતે વાપરવું
- મફત LLM API rate limits
સ્રોતો
- FreeLLMAPI docs: REST API (tool calling, routing strategies, response headers) (તપાસ્યું 20 November 2026)
- FreeLLMAPI docs: clients, MCP server and context handoff (તપાસ્યું 20 November 2026)
- OpenAI Python SDK: errors and retries (તપાસ્યું 20 November 2026)
- Claude Code docs: MCP (તપાસ્યું 20 November 2026)