హోమ్ / గైడ్‌లు / Pythonలో ఉచిత LLM API

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 కు మద్దతు ఇస్తాయి మరియు ఈరోజు అత్యంత వేగవంతమైన కొలిచిన వేగాన్ని కలిగి ఉన్నాయి:

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 బ్యాచ్‌లు

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.APIConnectionErrorFreeLLMAPI నడవడం లేదు, లేదా తప్పు portబ్రౌజర్‌లో http://localhost:3001 తెరవండి
openai.NotFoundErrorbase URL లో /v1 లేదుhttp://localhost:3001/v1 ను ఉపయోగించండి
openai.RateLimitErrorచైన్‌లోని అన్ని కీలు వాటి పరిమితిలో ఉన్నాయిప్రొవైడర్లను జోడించండి, concurrency ను తగ్గించండి, Retry-After కోసం వేచి ఉండండి
openai.BadRequestError, auto:name తోఆ ప్రొఫైల్ పేరు లేదుడాష్‌బోర్డ్‌లో ప్రొఫైల్ పేరును తనిఖీ చేయండి
చిత్రాలతో openai.UnprocessableEntityError (422)మీ చైన్‌లో vision మోడల్ లేదుఫాల్‌బ్యాక్ చైన్‌లో vision మోడల్‌ను ప్రారంభించండి

ఉచిత టియర్‌లకు SLA లేదు. రోజులో latency మారుతుంది. అత్యంత శక్తివంతమైన మోడల్‌లు ముందుగా తమ రోజువారీ పరిమితులను చేరుకుంటాయి, మరియు చాలా పరిమితులు అర్ధరాత్రి UTC కి రీసెట్ అవుతాయి. నిర్ణీత సమయంలో సమాధానం ఇవ్వాల్సిన సేవ కోసం ఉచిత గేట్‌వేని ఉపయోగించవద్దు.

ఇవన్నీ ఒకే కీ ద్వారా ఉపయోగించండి. FreeLLMAPI ఒక ఓపెన్-సోర్స్, సెల్ఫ్-హోస్ట్ రూటర్. ఇది ఈ ఉచిత టియర్‌లన్నింటినీ ఒకే OpenAI-అనుకూల ఎండ్‌పాయింట్ వెనుక ఉంచుతుంది. ఒకటి రేట్ లిమిట్ అయినప్పుడు, అది మరొక దానికి మారుతుంది. కేటలాగ్‌ను బ్రౌజ్ చేయండి లేదా ప్రత్యక్షంగా.

తరచుగా అడిగే ప్రశ్నలు

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 ను ఉపయోగించండి. ఉచిత టియర్‌లు నిమిషానికి అభ్యర్థనలను పరిమితం చేస్తాయి కాబట్టి, సమాంతర అభ్యర్థనల సంఖ్యను చిన్నదిగా ఉంచండి.

సంబంధిత గైడ్‌లు

మూలాలు

అన్ని గైడ్‌లు · అన్ని ఉచిత మోడల్‌లను చూడండి