Python માં મફત LLM API
સત્તાવાર openai Python package કોઈપણ OpenAI-compatible API સાથે કામ કરે છે. તમે base URL અને key બદલો છો. આ માર્ગદર્શિકા FreeLLMAPI વાપરે છે, જે એક key પાછળ 45 મફત પ્રદાતા ટિયર એકત્રિત કરે છે અને મર્યાદા વિનંતીને રોકે ત્યારે આગલા પ્રદાતા પર જાય છે. નીચેનું દરેક ઉદાહરણ સંપૂર્ણ છે અને જેમ છે તેમ ચાલે છે.
કોડ, મૉડેલ નામ અને લાઇવ કૅટલૉગ લેબલ અંગ્રેજીમાં બતાવવામાં આવે છે.
સેટઅપ
FreeLLMAPI ઇન્સ્ટોલ કરો. તે Docker માં ચાલે છે. ડેશબોર્ડ http://localhost:3001 પર ખોલો, Keys પેજ પર બે કે વધુ પ્રદાતાઓની મફત keys ઉમેરો અને unified key કૉપી કરો. પછી Python package ઇન્સ્ટોલ કરો.
તમારો Python કોડ ફક્ત unified key વાપરે છે. પ્રદાતા keys FreeLLMAPI માં રહે છે, તેના database માં encrypted. જો તમે પ્રદાતા key બદલો અથવા ઉમેરો, તો તમારો કોડ બદલવાની જરૂર નથી.
ઇન્સ્ટોલ
curl -fsSL https://freellmapi.co/install.sh | bash
python3 -m pip install -U openai
export FREELLMAPI_API_KEY=<unified-key>client.py
import os
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:3001/v1",
api_key=os.environ["FREELLMAPI_API_KEY"],
max_retries=3, # the SDK retries 429, 408, 409 and 5xx errors
timeout=60,
)
resp = client.chat.completions.create(
model="auto",
messages=[{"role": "user", "content": "Name three uses of Python in one line."}],
)
print(resp.choices[0].message.content)મોડેલ auto ડેશબોર્ડની તમારી fallback chain અનુસરે છે. તમે auto:fast, auto:smart અથવા auto:reliable, auto:coding જેવી profile, અથવા નિશ્ચિત model ID પણ વાપરી શકો છો.
Streaming અને response headers
જવાબ stream કરો
from client import client
stream = client.chat.completions.create(
model="auto:fast",
messages=[{"role": "user", "content": "Write a haiku about Python."}],
stream=True,
)
for chunk in stream:
if chunk.choices:
print(chunk.choices[0].delta.content or "", end="", flush=True)
print()દરેક response માં X-Routed-Via header હોય છે, જેમાં જવાબ આપનાર પ્રદાતા અને મોડેલ હોય છે. SDK સાથે headers વાંચવા with_raw_response વાપરો અને સામાન્ય object મેળવવા parse() કૉલ કરો.
routing headers વાંચો
from client import client
raw = client.chat.completions.with_raw_response.create(
model="auto",
messages=[{"role": "user", "content": "hi"}],
)
print("Served by:", raw.headers.get("x-routed-via"))
print("Failed attempts:", raw.headers.get("x-fallback-attempts", "0"))
print(raw.parse().choices[0].message.content)Tool calling
OpenAI શૈલીના tools મોકલો. રાઉટર તેમને OpenAI-compatible પ્રદાતાઓને પસાર કરે છે અને Gemini માટે તેમનું રૂપાંતર કરે છે. દરેક પ્રદાતા માટે જવાબ એક જ ફોર્મેટમાં પાછો આવે છે.
એક tool call અને અંતિમ જવાબ
import json
from client import client
tools = [{
"type": "function",
"function": {
"name": "get_exchange_rate",
"description": "Get the exchange rate between two currencies.",
"parameters": {
"type": "object",
"properties": {
"base": {"type": "string"},
"quote": {"type": "string"},
},
"required": ["base", "quote"],
},
},
}]
messages = [{"role": "user", "content": "How many euros is 250 US dollars?"}]
first = client.chat.completions.create(model="auto", messages=messages, tools=tools)
msg = first.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
result = {"base": args["base"], "quote": args["quote"], "rate": 0.92} # your real lookup
messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
final = client.chat.completions.create(model="auto", messages=messages, tools=tools)
print(final.choices[0].message.content)
else:
print(msg.content)કેટલાક પ્રદાતા tool call સાદા લખાણ તરીકે પાછો આપે છે. FreeLLMAPI આ જવાબોને સાચા tool_calls માં ફેરવે છે, જેથી તમારો કોડ એક જ ફોર્મેટ વાંચે છે. msg.tool_calls ને msg.content વાંચતા પહેલાં હંમેશા તપાસો, કારણ કે મોડેલ tool વગર પણ જવાબ આપી શકે છે.
tool calling વાળું મોડેલ વાપરો. આ મફત મોડેલ tools ને સપોર્ટ કરે છે અને આજે માપેલી સૌથી ઝડપી ગતિ ધરાવે છે:
| મૉડેલ | મફત ઉપલબ્ધ | સંદર્ભ | મફત મર્યાદા (શ્રેષ્ઠ ઑફર) | સાધનો | વિઝન |
|---|---|---|---|---|---|
| Qwen3.8 27B | ElectronHub, Groq, OVH AI Endpoints | 262K | 30 વિનંતી/મિનિટ 250 વિનંતી/દિવસ 70,000 ટોકન/મિનિટ ~6M | હા | હા |
| Nemotron 3.5 Lightning | ElectronHub, Kilo Gateway, OpenRouter | 1M | 20 વિનંતી/મિનિટ 50 વિનંતી/દિવસ 50 req/day account-wide (1,000 after a $10 purchase) | હા | ના |
| GPT-OSS 120B | Cloudflare Workers AI, ElectronHub, Groq +1 વધુ | 131K | 30 વિનંતી/મિનિટ 1,000 વિનંતી/દિવસ 8,000 ટોકન/મિનિટ 200,000 ટોકન/દિવસ ~6M | હા | ના |
| GPT-OSS 20B | Cloudflare Workers AI, Groq, NVIDIA NIM +1 વધુ | 131K | 30 વિનંતી/મિનિટ 1,000 વિનંતી/દિવસ 8,000 ટોકન/મિનિટ 200,000 ટોકન/દિવસ ~6M | હા | ના |
| GPT-OSS Safeguard 20B | Groq | 131K | 30 વિનંતી/મિનિટ 1,000 વિનંતી/દિવસ 8,000 ટોકન/મિનિટ 200,000 ટોકન/દિવસ ~6M | હા | ના |
| Gemini 3.5 Flash Lite | ElectronHub, Google AI Studio | 1M | 15 વિનંતી/મિનિટ 20 વિનંતી/દિવસ 250,000 ટોકન/મિનિટ ~3M | હા | હા |
| Step 3.7 Flash | ElectronHub | 256K | $0.25/week shared recurring credit | હા | હા |
| Gemini 3.1 Flash-Lite | DreamPrompting, Google AI Studio | 1M | 100 વિનંતી/મિનિટ 5,000 વિનંતી/દિવસ 500,000 ટોકન/દિવસ 500K tokens/day · 5,000 req/day | હા | હા |
| Nemotron 3.5 Lightning 30B | Requesty | 1M | 200 વિનંતી/દિવસ 200 rpd | હા | ના |
| Gemini 2.5 Flash-Lite | ElectronHub, Google AI Studio | 1M | 15 વિનંતી/મિનિટ 20 વિનંતી/દિવસ 250,000 ટોકન/મિનિટ ~3M | હા | હા |
મેળ ખાતા 146 મફત મૉડેલમાંથી 10 બતાવ્યા. બધા મૉડેલ જુઓ.
FreeLLMAPI કૅટલૉગનો લાઇવ ડેટા (સંસ્કરણ 2026.11.19, તપાસ્યું 2026-11-19). મફત મર્યાદાઓ વારંવાર બદલાય છે. કૅટલૉગ દરરોજ તપાસવામાં આવે છે.
મફત મર્યાદામાં async batches
AsyncOpenAI ઘણી વિનંતી એક જ સમયે મોકલે છે. મફત ટિયર પ્રતિ મિનિટ વિનંતી મર્યાદિત કરે છે, તેથી semaphore વડે concurrency મર્યાદિત કરો. જ્યારે દરેક પ્રદાતા તેની મર્યાદા પર હોય ત્યારે ઉદાહરણ ફરી પ્રયાસ પણ કરે છે.
batch.py
import asyncio
import os
import openai
from openai import AsyncOpenAI
client = AsyncOpenAI(
base_url="http://localhost:3001/v1",
api_key=os.environ["FREELLMAPI_API_KEY"],
max_retries=2,
)
limit = asyncio.Semaphore(4) # at most 4 requests at a time
async def summarize(text: str) -> str:
async with limit:
for attempt in range(5):
try:
resp = await client.chat.completions.create(
model="auto:fast",
messages=[
{"role": "system", "content": "Summarize in one sentence."},
{"role": "user", "content": text},
],
)
return resp.choices[0].message.content
except openai.RateLimitError as err:
header = err.response.headers.get("retry-after", "")
wait = int(header) if header.isdigit() else 2 ** attempt
await asyncio.sleep(min(wait, 60))
return "ERROR: rate limited"
async def main():
docs = [f"Document {i}: Python is a programming language." for i in range(20)]
results = await asyncio.gather(*(summarize(d) for d in docs))
for r in results:
print(r)
await client.close()
asyncio.run(main())રાઉટર ફક્ત ત્યારે 429 પરત કરે છે જ્યારે chain ની દરેક key તેની મર્યાદા પર હોય. પછી response માં Retry-After header હોય છે. મોટા batch માટે નાનું semaphore મૂલ્ય અને વધુ પ્રદાતા keys શ્રેષ્ઠ પરિણામ આપે છે.
દરેક કાર્ય માટે model string પસંદ કરો
model string રાઉટરને કહે છે કે મોડેલ કેવી રીતે પસંદ કરવું. તમે દરેક call માં જુદી string વાપરી શકો છો. તમારે ડેશબોર્ડ બદલવાની જરૂર નથી.
| કાર્ય | Model string | કારણ |
|---|---|---|
| વપરાશકર્તાઓ માટે chat જવાબ | auto | ડેશબોર્ડ પર તમે સેટ કરેલી fallback chain અનુસરે છે |
| વર્ગીકરણ, extraction, ટૂંકા સારાંશ | auto:fast | સક્ષમ મોડેલને માપેલી ઝડપ પ્રમાણે ક્રમ આપે છે |
| અઘરા સવાલ, code review, આયોજન | auto:smart | સક્ષમ મોડેલને બુદ્ધિ પ્રમાણે ક્રમ આપે છે |
| અવશ્ય પૂરા થવાના શેડ્યૂલ કરેલા jobs | auto:reliable | સક્ષમ મોડેલને તાજેતરની સફળતાના દર પ્રમાણે ક્રમ આપે છે |
| એક app માટે અલગ chain | auto:<profile> | નામવાળી fallback chain વાપરે છે |
| પુનરાવર્તિત થઈ શકે તેવા પરીક્ષણો | નિશ્ચિત model ID | દર વખતે એક જ મોડેલ, પરંતુ તે મોડેલની મર્યાદાએ અટકે છે |
તમારી keys અત્યારે કયા મોડેલ કૉલ કરી શકે છે તે જોવા, ફિલ્ટર સાથે મોડેલની યાદી માંગો. પૂરી યાદીમાં એવા મોડેલ પણ હોય છે જેની હજી key નથી.
અત્યારે જવાબ આપી શકે તેવા મોડેલની યાદી બનાવો
import os
import httpx
r = httpx.get(
"http://localhost:3001/v1/models",
params={"execution_status": "ready"},
headers={"Authorization": f"Bearer {os.environ['FREELLMAPI_API_KEY']}"},
timeout=30,
)
r.raise_for_status()
for m in r.json()["data"]:
print(m["id"])જે મોડેલની સ્થિતિ exhausted છે, તેની keys છે, પરંતુ અત્યારે બધી મર્યાદા પર છે. cooldowns પૂરા થાય ત્યારે સ્થિતિ સાફ થાય છે. જે મોડેલની સ્થિતિ needsKey છે, તેની કોઈ સક્ષમ key નથી.
વાતચીત માટે X-Session-Id header ને extra_headers સાથે મોકલો. પછી FreeLLMAPI તે વાતચીતને 30 મિનિટ સુધી એક જ મોડેલ પર રાખે છે. header વગર, તે session key તરીકે પહેલા user સંદેશના hash નો ઉપયોગ કરે છે.
Embeddings
લખાણ embed કરો
from client import client
resp = client.embeddings.create(
model="bge-m3", # one embedding family
input=["Python is a programming language.", "A snake is a reptile."],
)
print(len(resp.data), "vectors of", len(resp.data[0].embedding), "dimensions")Embedding failover ક્યારેય મોડેલ બદલતું નથી. તે ફક્ત એ જ family આપતા પ્રદાતાઓ વચ્ચે જાય છે, તેથી તમારા vectors સુસંગત રહે છે. મૂલ્ય auto ડેશબોર્ડ પર તમે સેટ કરેલી ડિફોલ્ટ family વાપરે છે.
એક input યાદીમાં ઘણા લખાણ મોકલો. 32 લખાણ સાથેની એક વિનંતી મફત મર્યાદામાંથી એક વિનંતી વાપરે છે, 32 નહીં. દરેક લખાણ family ની મહત્તમ input કરતાં નાનું રાખો. તમારા vectors સાથે family નામ સાચવો, જેથી પછીથી તમે તે જ family વડે queries embed કરી શકો.
Errors અને ઉકેલ
| Exception | કારણ | ઉકેલ |
|---|---|---|
openai.AuthenticationError | ખોટી unified key | Keys પેજ પરથી key ફરી કૉપી કરો |
openai.APIConnectionError | FreeLLMAPI ચાલતું નથી, અથવા port ખોટો છે | બ્રાઉઝરમાં http://localhost:3001 ખોલો |
openai.NotFoundError | base URL માં /v1 નથી | http://localhost:3001/v1 વાપરો |
openai.RateLimitError | chain ની બધી keys તેમની મર્યાદા પર છે | પ્રદાતા ઉમેરો, concurrency ઘટાડો, Retry-After ની રાહ જુઓ |
openai.BadRequestError સાથે auto:name | profile નામ અસ્તિત્વમાં નથી | ડેશબોર્ડ પર profile નામ તપાસો |
છબીઓ સાથે openai.UnprocessableEntityError (422) | તમારી chain માં કોઈ vision મોડેલ નથી | fallback chain માં vision મોડેલ સક્ષમ કરો |
મફત ટિયર પર કોઈ SLA નથી. દિવસ દરમિયાન latency બદલાય છે. સૌથી મજબૂત મોડેલ તેમની દૈનિક મર્યાદા પહેલા પહોંચે છે, અને ઘણી મર્યાદા UTC મધ્યરાત્રિએ reset થાય છે. નિશ્ચિત સમયમાં જવાબ આપવો જ પડે તેવી સેવા માટે મફત gateway વાપરશો નહીં.
વારંવાર પૂછાતા પ્રશ્નો
શું Python માટે મફત LLM API છે?
હા. ઘણા પ્રદાતા પાસે મફત ટિયર છે જે openai Python package સાથે કામ કરે છે. FreeLLMAPI તેમને એક base URL અને એક key પાછળ ભેગા કરે છે, જેમાં પ્રદાતાઓ વચ્ચે failover છે.
જુદા base URL સાથે openai Python library કેવી રીતે વાપરું?
OpenAI() અથવા AsyncOpenAI() ને base_url પાસ કરો, ઉદાહરણ તરીકે base_url="http://localhost:3001/v1". તમારી gateway key ને api_key તરીકે પાસ કરો.
Python માં rate limit errors કેવી રીતે સંભાળું?
client પર max_retries સેટ કરો. openai.RateLimitError પકડો, Retry-After header વાંચો અને રાહ જુઓ. asyncio semaphore વડે concurrency મર્યાદિત કરો.
શું Python માં મફત LLM APIs સાથે streaming કામ કરે છે?
હા. stream=True પાસ કરો અને chunk.choices[0].delta.content વાંચો. FreeLLMAPI દરેક પ્રદાતા માટે OpenAI ફોર્મેટમાં streaming કરે છે.
શું મફત LLM API સાથે async Python વાપરી શકું?
હા. એ જ base_url અને key સાથે AsyncOpenAI વાપરો. સમાંતર વિનંતીઓની સંખ્યા નાની રાખો, કારણ કે મફત ટિયર પ્રતિ મિનિટ વિનંતી મર્યાદિત કરે છે.
સંબંધિત માર્ગદર્શિકાઓ
- મફત OpenAI સાથે સુસંગત API base URL
- LangChain માટે મફત LLM API
- AI એજન્ટ્સ માટે મફત LLM API
- function calling સાથે મફત LLM API
- મફત LLM API rate limits
સ્રોતો
- OpenAI Python SDK README (async, retries, raw responses, errors) (તપાસ્યું 20 November 2026)
- FreeLLMAPI docs: REST API (chat, streaming, tool calling, embeddings, headers) (તપાસ્યું 20 November 2026)
- FreeLLMAPI docs: degraded mode and failover (તપાસ્યું 20 November 2026)