Pythonలో ఉచిత LLM API
అధికారిక openai Python ప్యాకేజీ ఏ OpenAI-compatible APIతోనైనా పనిచేస్తుంది. మీరు base URL మరియు కీని మారుస్తారు. ఈ గైడ్ FreeLLMAPIని ఉపయోగిస్తుంది, ఇది ఒకే కీ వెనుక 45 ఉచిత ప్రొవైడర్ టియర్లను ఉంచుతుంది, మరియు ఒక పరిమితి అభ్యర్థనను ఆపినప్పుడు తదుపరి ప్రొవైడర్కు మారుతుంది. కింద ఉన్న ప్రతి ఉదాహరణ పూర్తిగా ఉంది మరియు ఉన్నట్లుగానే నడుస్తుంది.
కోడ్, మోడల్ పేర్లు మరియు ప్రత్యక్ష కేటలాగ్ లేబుల్లు ఇంగ్లీషులోనే చూపబడతాయి.
సెటప్
FreeLLMAPIని ఇన్స్టాల్ చేయండి. ఇది Docker లో నడుస్తుంది. http://localhost:3001 వద్ద డాష్బోర్డ్ను తెరవండి, Keys పేజీలో రెండు లేదా అంతకంటే ఎక్కువ ప్రొవైడర్ల నుండి ఉచిత కీలను జోడించండి, మరియు unified కీని కాపీ చేయండి. తర్వాత Python ప్యాకేజీని ఇన్స్టాల్ చేయండి.
మీ Python కోడ్ unified కీని మాత్రమే ఉపయోగిస్తుంది. ప్రొవైడర్ కీలు FreeLLMAPIలోనే ఉంటాయి, దాని డేటాబేస్లో ఎన్క్రిప్ట్ చేయబడి. మీరు ప్రొవైడర్ కీని మార్చినా లేదా జోడించినా, మీ కోడ్ను మార్చవలసిన అవసరం లేదు.
ఇన్స్టాల్
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 డాష్బోర్డ్లోని మీ ఫాల్బ్యాక్ చైన్ను అనుసరిస్తుంది. మీరు auto:fast, auto:smart లేదా auto:reliable, auto:coding వంటి ప్రొఫైల్, లేదా స్థిరమైన మోడల్ ID ను కూడా ఉపయోగించవచ్చు.
Streaming మరియు response హెడర్లు
సమాధానాన్ని 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 హెడర్ ఉంటుంది. SDK తో హెడర్లను చదవడానికి, with_raw_response ను ఉపయోగించి సాధారణ ఆబ్జెక్ట్ పొందడానికి parse() ను కాల్ చేయండి.
రూటింగ్ హెడర్లను చదవండి
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 బ్యాచ్లు
AsyncOpenAI ఒకే సమయంలో అనేక అభ్యర్థనలను పంపుతుంది. ఉచిత టియర్లు నిమిషానికి అభ్యర్థనలను పరిమితం చేస్తాయి, కాబట్టి semaphore తో ఏకకాలాన్ని పరిమితం చేయండి. ప్రతి ప్రొవైడర్ తన పరిమితిలో ఉన్నప్పుడు కూడా ఉదాహరణ మళ్ళీ ప్రయత్నిస్తుంది.
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 ను ఇస్తుంది. అప్పుడు response లో Retry-After హెడర్ ఉంటుంది. చిన్న semaphore విలువ మరియు మరిన్ని ప్రొవైడర్ కీలు పెద్ద బ్యాచ్లకు ఉత్తమ ఫలితాలను ఇస్తాయి.
ప్రతి పనికి మోడల్ స్ట్రింగ్ను ఎంచుకోండి
మోడల్ స్ట్రింగ్ రూటర్కు మోడల్ను ఎలా ఎంచుకోవాలో చెబుతుంది. ప్రతి కాల్లో వేరే స్ట్రింగ్ను ఉపయోగించవచ్చు. మీరు డాష్బోర్డ్ను మార్చవలసిన అవసరం లేదు.
| పని | మోడల్ స్ట్రింగ్ | కారణం |
|---|---|---|
| వినియోగదారుల కోసం chat సమాధానాలు | auto | డాష్బోర్డ్లో మీరు సెట్ చేసిన ఫాల్బ్యాక్ చైన్ను అనుసరిస్తుంది |
| వర్గీకరణ, సమాచార సేకరణ, చిన్న సారాంశాలు | auto:fast | ప్రారంభించిన మోడల్లను కొలిచిన వేగం ప్రకారం ర్యాంక్ చేస్తుంది |
| కఠినమైన ప్రశ్నలు, కోడ్ సమీక్ష, ప్రణాళిక | auto:smart | ప్రారంభించిన మోడల్లను తెలివితేటల ప్రకారం ర్యాంక్ చేస్తుంది |
| తప్పనిసరిగా పూర్తి కావలసిన షెడ్యూల్ చేసిన పనులు | auto:reliable | ప్రారంభించిన మోడల్లను ఇటీవలి విజయ రేటు ప్రకారం ర్యాంక్ చేస్తుంది |
| ఒక యాప్ కోసం ప్రత్యేక చైన్ | auto:<profile> | పేరున్న ఫాల్బ్యాక్ చైన్ను ఉపయోగిస్తుంది |
| పునరావృతం కావలసిన పరీక్షలు | స్థిరమైన మోడల్ ID | ప్రతిసారీ అదే మోడల్, కానీ ఆ మోడల్ పరిమితి వద్ద ఆగుతుంది |
మీ కీలు ఇప్పుడు ఏ మోడల్లను కాల్ చేయగలవో చూడటానికి, ఫిల్టర్తో మోడల్ జాబితాను అడగండి. పూర్తి జాబితాలో ఇంకా కీ లేని మోడల్లు కూడా ఉంటాయి.
ఇప్పుడు సమాధానం ఇవ్వగల మోడల్లను జాబితా చేయండి
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 స్థితి ఉన్న మోడల్కు కీలు ఉన్నాయి, కానీ అవన్నీ ఇప్పుడు ఒక పరిమితిలో ఉన్నాయి. cooldowns ముగిసినప్పుడు స్థితి క్లియర్ అవుతుంది. needsKey స్థితి ఉన్న మోడల్కు ప్రారంభించిన కీ లేదు.
ఒక సంభాషణ కోసం, X-Session-Id హెడర్ను extra_headers తో పంపండి. అప్పుడు FreeLLMAPI ఆ సంభాషణను 30 నిమిషాల పాటు ఒకే మోడల్పై ఉంచుతుంది. హెడర్ లేకపోతే, అది session కీగా మొదటి 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 ఫెయిల్ఓవర్ ఎప్పుడూ మోడల్ను మార్చదు. ఒకే family ను అందించే ప్రొవైడర్ల మధ్య మాత్రమే కదులుతుంది, కాబట్టి మీ vectors అనుకూలంగా ఉంటాయి. విలువ auto డాష్బోర్డ్లో మీరు సెట్ చేసిన డిఫాల్ట్ family ను ఉపయోగిస్తుంది.
ఒకే input జాబితాలో అనేక టెక్స్ట్లను పంపండి. 32 టెక్స్ట్లతో ఒక అభ్యర్థన ఉచిత పరిమితి నుండి ఒక అభ్యర్థనను ఉపయోగిస్తుంది, 32 కాదు. ప్రతి టెక్స్ట్ను family గరిష్ట ఇన్పుట్ కంటే తక్కువగా ఉంచండి. family పేరును మీ vectors తో పాటు నిల్వ చేయండి, తద్వారా తర్వాత ప్రశ్నలను అదే family తో embed చేయవచ్చు.
ఎర్రర్లు మరియు పరిష్కారాలు
| మినహాయింపు | కారణం | పరిష్కారం |
|---|---|---|
openai.AuthenticationError | తప్పు unified కీ | Keys పేజీ నుండి కీని మళ్ళీ కాపీ చేయండి |
openai.APIConnectionError | FreeLLMAPI నడవడం లేదు, లేదా తప్పు port | బ్రౌజర్లో http://localhost:3001 తెరవండి |
openai.NotFoundError | base URL లో /v1 లేదు | http://localhost:3001/v1 ను ఉపయోగించండి |
openai.RateLimitError | చైన్లోని అన్ని కీలు వాటి పరిమితిలో ఉన్నాయి | ప్రొవైడర్లను జోడించండి, concurrency ను తగ్గించండి, Retry-After కోసం వేచి ఉండండి |
openai.BadRequestError, auto:name తో | ఆ ప్రొఫైల్ పేరు లేదు | డాష్బోర్డ్లో ప్రొఫైల్ పేరును తనిఖీ చేయండి |
చిత్రాలతో openai.UnprocessableEntityError (422) | మీ చైన్లో vision మోడల్ లేదు | ఫాల్బ్యాక్ చైన్లో vision మోడల్ను ప్రారంభించండి |
ఉచిత టియర్లకు SLA లేదు. రోజులో latency మారుతుంది. అత్యంత శక్తివంతమైన మోడల్లు ముందుగా తమ రోజువారీ పరిమితులను చేరుకుంటాయి, మరియు చాలా పరిమితులు అర్ధరాత్రి UTC కి రీసెట్ అవుతాయి. నిర్ణీత సమయంలో సమాధానం ఇవ్వాల్సిన సేవ కోసం ఉచిత గేట్వేని ఉపయోగించవద్దు.
తరచుగా అడిగే ప్రశ్నలు
Python కోసం ఉచిత LLM API ఉందా?
అవును. అనేక ప్రొవైడర్లకు openai Python ప్యాకేజీతో పనిచేసే ఉచిత టియర్లు ఉన్నాయి. FreeLLMAPI వాటిని ఒకే base URL మరియు ఒకే కీ వెనుక కలుపుతుంది, ప్రొవైడర్ల మధ్య ఫెయిల్ఓవర్తో.
వేరే base URL తో openai Python లైబ్రరీని ఎలా ఉపయోగించాలి?
OpenAI() లేదా AsyncOpenAI() కు base_url ను పంపండి, ఉదాహరణకు base_url="http://localhost:3001/v1". మీ గేట్వే కీని api_key గా పంపండి.
Pythonలో రేట్ పరిమితి ఎర్రర్లను ఎలా నిర్వహించాలి?
క్లయింట్పై max_retries ను సెట్ చేయండి. openai.RateLimitError ను క్యాచ్ చేయండి, Retry-After హెడర్ను చదవండి మరియు వేచి ఉండండి. asyncio semaphore తో concurrency ను పరిమితం చేయండి.
Pythonలో ఉచిత LLM APIలతో streaming పనిచేస్తుందా?
అవును. stream=True ను పంపి, chunk.choices[0].delta.content ను చదవండి. FreeLLMAPI ప్రతి ప్రొవైడర్ కోసం OpenAI ఫార్మాట్లో స్ట్రీమ్ చేస్తుంది.
ఉచిత LLM APIతో async Python ను ఉపయోగించవచ్చా?
అవును. అదే base_url మరియు కీతో AsyncOpenAI ను ఉపయోగించండి. ఉచిత టియర్లు నిమిషానికి అభ్యర్థనలను పరిమితం చేస్తాయి కాబట్టి, సమాంతర అభ్యర్థనల సంఖ్యను చిన్నదిగా ఉంచండి.
సంబంధిత గైడ్లు
- ఉచిత OpenAI-అనుకూల API base URLs
- LangChain కోసం ఉచిత LLM API
- AI ఏజెంట్ల కోసం ఉచిత LLM API
- function calling తో ఉచిత LLM API
- ఉచిత LLM API రేట్ పరిమితులు
మూలాలు
- 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 న తనిఖీ చేయబడింది)