முகப்பு / வழிகாட்டிகள் / Python இல் இலவச LLM API

Python இல் இலவச LLM API

அதிகாரப்பூர்வ openai Python package எந்த OpenAI-compatible API உடனும் வேலை செய்கிறது. நீங்கள் base URL ஐயும் key ஐயும் மாற்றுகிறீர்கள். இந்த வழிகாட்டி FreeLLMAPI ஐப் பயன்படுத்துகிறது. அது 45 இலவச provider நிலைகளை ஒரே key பின்னால் இணைக்கிறது. ஒரு கோரிக்கையை வரம்பு நிறுத்தும்போது அடுத்த provider க்கு மாறுகிறது. கீழே உள்ள ஒவ்வொரு உதாரணமும் முழுமையானது, அப்படியே இயங்கும்.

குறியீடு, மாதிரிப் பெயர்கள் மற்றும் நேரடி பட்டியல் லேபிள்கள் ஆங்கிலத்தில் காட்டப்படுகின்றன.

அமைப்பு

FreeLLMAPI ஐ நிறுவுங்கள். அது Docker இல் இயங்குகிறது. http://localhost:3001 இல் dashboard ஐத் திறந்து, Keys பக்கத்தில் இரண்டு அல்லது அதற்கு மேற்பட்ட providers இலிருந்து இலவச keys ஐச் சேர்த்து unified key ஐ நகலெடுக்கவும். பிறகு Python package ஐ நிறுவவும்.

உங்கள் Python code unified key ஐ மட்டுமே பயன்படுத்துகிறது. Provider keys FreeLLMAPI இல் அதன் database இல் encrypt செய்யப்பட்டு இருக்கும். Provider key ஐ மாற்றினாலோ சேர்த்தாலோ உங்கள் code ஐ மாற்ற வேண்டியதில்லை.

நிறுவு

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 மாடல் dashboard இல் உள்ள உங்கள் fallback சங்கிலியைப் பின்பற்றுகிறது. auto:fast, auto:smart அல்லது auto:reliable, auto:coding போன்ற profile, அல்லது ஒரு நிலையான model ID ஐயும் பயன்படுத்தலாம்.

Streaming மற்றும் response headers

பதிலை streaming மூலம் பெறுங்கள்

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

ஒவ்வொரு பதிலிலும் பதிலளித்த provider மற்றும் மாடலுடன் 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 ஐ அனுப்புங்கள். Router அவற்றை OpenAI-compatible providers க்கு அனுப்புகிறது, Gemini க்கு மொழிபெயர்க்கிறது. பதில் ஒவ்வொரு provider க்கும் ஒரே வடிவத்தில் திரும்ப வருகிறது.

ஒரு 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)

சில providers tool call ஐ சாதாரண உரையாகத் திருப்புகின்றன. FreeLLMAPI இந்தப் பதில்களை உண்மையான tool_calls ஆக மாற்றுகிறது, எனவே உங்கள் code ஒரே வடிவத்தை வாசிக்கிறது. எப்போதும் 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 மூலம் ஒரே நேர எண்ணிக்கையை வரம்பிடுங்கள். ஒவ்வொரு provider ம் அதன் வரம்பில் இருக்கும்போதும் உதாரணம் மீண்டும் முயற்சிக்கிறது.

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

சங்கிலியில் உள்ள ஒவ்வொரு key ம் அதன் வரம்பில் இருந்தால் மட்டுமே router 429 ஐத் திருப்புகிறது. பதிலில் Retry-After header இருக்கும். சிறிய semaphore மதிப்பும் அதிக provider keys ம் பெரிய batches க்கு சிறந்த முடிவுகளைத் தரும்.

ஒவ்வொரு பணிக்கும் model string ஐத் தேர்ந்தெடுங்கள்

Model string router க்கு மாடலை எப்படித் தேர்ந்தெடுப்பது என்பதைச் சொல்கிறது. ஒவ்வொரு அழைப்பிலும் வேறு string ஐப் பயன்படுத்தலாம். Dashboard ஐ மாற்ற வேண்டியதில்லை.

பணிModel stringகாரணம்
பயனர்களுக்கான chat பதில்கள்autoDashboard இல் நீங்கள் அமைத்த fallback சங்கிலியைப் பின்பற்றுகிறது
வகைப்படுத்தல், பிரித்தெடுத்தல், குறுகிய சுருக்கங்கள்auto:fastஇயக்கப்பட்ட மாடல்களை அளவிடப்பட்ட வேகத்தின்படி வரிசைப்படுத்துகிறது
கடினமான கேள்விகள், code review, திட்டமிடல்auto:smartஇயக்கப்பட்ட மாடல்களை நுண்ணறிவின்படி வரிசைப்படுத்துகிறது
முடிய வேண்டிய திட்டமிடப்பட்ட பணிகள்auto:reliableஇயக்கப்பட்ட மாடல்களை சமீபத்திய வெற்றி விகிதத்தின்படி வரிசைப்படுத்துகிறது
ஒரு செயலிக்கான தனி சங்கிலிauto:<profile>பெயரிடப்பட்ட fallback சங்கிலியைப் பயன்படுத்துகிறது
மீண்டும் செய்யக்கூடிய சோதனைகள்ஒரு நிலையான 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 இல்லையென்றால், முதல் user செய்தியின் hash ஐ session key ஆகப் பயன்படுத்துகிறது.

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 ஐ வழங்கும் providers க்கு இடையே மட்டுமே நகர்கிறது, எனவே உங்கள் vectors ஒத்துப்போகின்றன. auto மதிப்பு dashboard இல் நீங்கள் அமைத்த இயல்புநிலை family ஐப் பயன்படுத்துகிறது.

ஒரே input பட்டியலில் பல உரைகளை அனுப்புங்கள். 32 உரைகள் உள்ள ஒரு கோரிக்கை இலவச வரம்பிலிருந்து 32 அல்ல, ஒரு கோரிக்கையைப் பயன்படுத்துகிறது. ஒவ்வொரு உரையையும் family இன் அதிகபட்ச input க்குக் கீழ் வையுங்கள். Family பெயரை உங்கள் vectors உடன் சேமியுங்கள், அதனால் பின்னர் queries ஐ அதே family உடன் embed செய்யலாம்.

பிழைகளும் தீர்வுகளும்

விதிவிலக்குகாரணம்தீர்வு
openai.AuthenticationErrorதவறான unified keyKeys பக்கத்திலிருந்து key ஐ மீண்டும் நகலெடுங்கள்
openai.APIConnectionErrorFreeLLMAPI இயங்கவில்லை, அல்லது தவறான portஉலாவியில் http://localhost:3001 ஐத் திறக்கவும்
openai.NotFoundErrorBase URL இல் /v1 இல்லைhttp://localhost:3001/v1 ஐப் பயன்படுத்துங்கள்
openai.RateLimitErrorசங்கிலியில் உள்ள எல்லா keys ம் அவற்றின் வரம்பில் உள்ளனProviders ஐச் சேர்க்கவும், ஒரே நேர எண்ணிக்கையைக் குறைக்கவும், Retry-After க்குக் காத்திருக்கவும்
openai.BadRequestError, auto:name உடன்Profile பெயர் இல்லைDashboard இல் profile பெயரைச் சரிபார்க்கவும்
படங்களுடன் openai.UnprocessableEntityError (422)உங்கள் சங்கிலியில் vision மாடல் இல்லைFallback சங்கிலியில் ஒரு vision மாடலை இயக்குங்கள்

இலவச நிலைகளுக்கு SLA இல்லை. நாளின் போது latency மாறுகிறது. வலிமையான மாடல்கள் முதலில் அவற்றின் நாள் வரம்புகளை அடைகின்றன, பல வரம்புகள் UTC நள்ளிரவில் மீட்டமைக்கப்படுகின்றன. ஒரு குறிப்பிட்ட நேரத்தில் பதிலளிக்க வேண்டிய சேவைக்கு இலவச gateway ஐப் பயன்படுத்த வேண்டாம்.

இவை அனைத்தையும் ஒரே விசை மூலம் பயன்படுத்துங்கள். FreeLLMAPI என்பது திறந்த மூலமான, நீங்களே நிறுவும் ரூட்டர். இந்த இலவச அடுக்குகள் அனைத்தையும் ஒரே OpenAI-இணக்கமான இறுதிப்புள்ளிக்குப் பின்னால் வைக்கிறது. ஒரு வழங்குநர் வரம்பை எட்டும்போது தானாக அடுத்ததற்கு மாறுகிறது. பட்டியலைப் பார்க்கவும் அல்லது நேரலைக்குச் செல்லவும்.

அடிக்கடி கேட்கப்படும் கேள்விகள்

Python க்கு இலவச LLM API உள்ளதா?

ஆம். பல providers, openai Python package உடன் வேலை செய்யும் இலவச நிலைகளை வைத்துள்ளனர். FreeLLMAPI அவற்றை ஒரே base URL மற்றும் ஒரே key பின்னால் இணைக்கிறது, providers க்கு இடையே failover உடன்.

வேறு base URL உடன் openai Python library ஐ எப்படிப் பயன்படுத்துவது?

OpenAI() அல்லது AsyncOpenAI() க்கு base_url ஐ அனுப்புங்கள், எடுத்துக்காட்டாக base_url="http://localhost:3001/v1". உங்கள் gateway key ஐ api_key ஆக அனுப்புங்கள்.

Python இல் rate limit பிழைகளை எப்படிக் கையாள்வது?

Client இல் max_retries ஐ அமையுங்கள். openai.RateLimitError ஐப் பிடித்து, Retry-After header ஐ வாசித்து காத்திருங்கள். asyncio semaphore மூலம் ஒரே நேர எண்ணிக்கையை வரம்பிடுங்கள்.

Python இல் இலவச LLM APIs உடன் streaming வேலை செய்யுமா?

ஆம். stream=True ஐ அனுப்பி, chunk.choices[0].delta.content ஐ வாசியுங்கள். FreeLLMAPI ஒவ்வொரு provider க்கும் OpenAI வடிவத்தில் streaming செய்கிறது.

இலவச LLM API உடன் async Python ஐப் பயன்படுத்த முடியுமா?

ஆம். அதே base_url மற்றும் key உடன் AsyncOpenAI ஐப் பயன்படுத்துங்கள். இலவச நிலைகள் நிமிடத்திற்கான கோரிக்கைகளை வரம்பிடுவதால், ஒரே நேர கோரிக்கைகளை குறைவாக வையுங்கள்.

தொடர்புடைய வழிகாட்டிகள்

ஆதாரங்கள்

அனைத்து வழிகாட்டிகள் · அனைத்து இலவச மாதிரிகளையும் பார்க்கவும்