હોમ / માર્ગદર્શિકાઓ / Python માં મફત LLM API

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 ને સપોર્ટ કરે છે અને આજે માપેલી સૌથી ઝડપી ગતિ ધરાવે છે:

tool calling સાથે ઝડપી મફત મોડેલ
મૉડેલમફત ઉપલબ્ધસંદર્ભમફત મર્યાદા (શ્રેષ્ઠ ઑફર)સાધનોવિઝન
Qwen3.8 27BElectronHub, Groq, OVH AI Endpoints262K30 વિનંતી/મિનિટ
250 વિનંતી/દિવસ
70,000 ટોકન/મિનિટ
~6M
હાહા
Nemotron 3.5 LightningElectronHub, Kilo Gateway, OpenRouter1M20 વિનંતી/મિનિટ
50 વિનંતી/દિવસ
50 req/day account-wide (1,000 after a $10 purchase)
હાના
GPT-OSS 120BCloudflare Workers AI, ElectronHub, Groq +1 વધુ131K30 વિનંતી/મિનિટ
1,000 વિનંતી/દિવસ
8,000 ટોકન/મિનિટ
200,000 ટોકન/દિવસ
~6M
હાના
GPT-OSS 20BCloudflare Workers AI, Groq, NVIDIA NIM +1 વધુ131K30 વિનંતી/મિનિટ
1,000 વિનંતી/દિવસ
8,000 ટોકન/મિનિટ
200,000 ટોકન/દિવસ
~6M
હાના
GPT-OSS Safeguard 20BGroq131K30 વિનંતી/મિનિટ
1,000 વિનંતી/દિવસ
8,000 ટોકન/મિનિટ
200,000 ટોકન/દિવસ
~6M
હાના
Gemini 3.5 Flash LiteElectronHub, Google AI Studio1M15 વિનંતી/મિનિટ
20 વિનંતી/દિવસ
250,000 ટોકન/મિનિટ
~3M
હાહા
Step 3.7 FlashElectronHub256K$0.25/week shared recurring creditહાહા
Gemini 3.1 Flash-LiteDreamPrompting, Google AI Studio1M100 વિનંતી/મિનિટ
5,000 વિનંતી/દિવસ
500,000 ટોકન/દિવસ
500K tokens/day · 5,000 req/day
હાહા
Nemotron 3.5 Lightning 30BRequesty1M200 વિનંતી/દિવસ
200 rpd
હાના
Gemini 2.5 Flash-LiteElectronHub, Google AI Studio1M15 વિનંતી/મિનિટ
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સક્ષમ મોડેલને બુદ્ધિ પ્રમાણે ક્રમ આપે છે
અવશ્ય પૂરા થવાના શેડ્યૂલ કરેલા jobsauto:reliableસક્ષમ મોડેલને તાજેતરની સફળતાના દર પ્રમાણે ક્રમ આપે છે
એક app માટે અલગ chainauto:<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 keyKeys પેજ પરથી key ફરી કૉપી કરો
openai.APIConnectionErrorFreeLLMAPI ચાલતું નથી, અથવા port ખોટો છેબ્રાઉઝરમાં http://localhost:3001 ખોલો
openai.NotFoundErrorbase URL માં /v1 નથીhttp://localhost:3001/v1 વાપરો
openai.RateLimitErrorchain ની બધી keys તેમની મર્યાદા પર છેપ્રદાતા ઉમેરો, concurrency ઘટાડો, Retry-After ની રાહ જુઓ
openai.BadRequestError સાથે auto:nameprofile નામ અસ્તિત્વમાં નથીડેશબોર્ડ પર profile નામ તપાસો
છબીઓ સાથે openai.UnprocessableEntityError (422)તમારી chain માં કોઈ vision મોડેલ નથીfallback chain માં vision મોડેલ સક્ષમ કરો

મફત ટિયર પર કોઈ SLA નથી. દિવસ દરમિયાન latency બદલાય છે. સૌથી મજબૂત મોડેલ તેમની દૈનિક મર્યાદા પહેલા પહોંચે છે, અને ઘણી મર્યાદા UTC મધ્યરાત્રિએ reset થાય છે. નિશ્ચિત સમયમાં જવાબ આપવો જ પડે તેવી સેવા માટે મફત gateway વાપરશો નહીં.

આ બધાનો ઉપયોગ એક જ કી દ્વારા કરો. FreeLLMAPI એક ઓપન-સોર્સ, સ્વ-હોસ્ટેડ રાઉટર છે. તે આ બધા મફત ટાયરને એક OpenAI સાથે સુસંગત એન્ડપોઇન્ટ પાછળ મૂકે છે અને જ્યારે એક મૉડેલની રેટ મર્યાદા આવે ત્યારે બીજા પર આપમેળે સ્વિચ કરે છે. કૅટલૉગ બ્રાઉઝ કરો અથવા લાઇવ જાઓ.

વારંવાર પૂછાતા પ્રશ્નો

શું 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 વાપરો. સમાંતર વિનંતીઓની સંખ્યા નાની રાખો, કારણ કે મફત ટિયર પ્રતિ મિનિટ વિનંતી મર્યાદિત કરે છે.

સંબંધિત માર્ગદર્શિકાઓ

સ્રોતો

બધી માર્ગદર્શિકાઓ · બધા મફત મૉડેલ જુઓ