హోమ్ / గైడ్‌లు / AI ఏజెంట్ల కోసం ఉచిత LLM API

AI ఏజెంట్ల కోసం ఉచిత LLM API

ఒక AI ఏజెంట్ ఒక పని కోసం అనేక మోడల్ అభ్యర్థనలు పంపుతుంది. ప్రతి దశకు టూల్ కాలింగ్ మరియు పెద్ద కాంటెక్స్ట్ అవసరం. ఒకే ఉచిత టియర్ ఏజెంట్‌ను త్వరగా ఆపివేస్తుంది. FreeLLMAPI 45 ఉచిత ప్రొవైడర్ టియర్‌లను ఒకే OpenAI-compatible కీ వెనుక కలుపుతుంది. ఒక పరిమితి అభ్యర్థనను ఆపినప్పుడు అది తదుపరి ప్రొవైడర్‌కు మారుతుంది, కాబట్టి ఏజెంట్ కొనసాగగలదు. ఈ గైడ్ టూల్ కాలింగ్, ప్రతి దశకు రూటింగ్, దీర్ఘ సెషన్‌లు మరియు రౌటర్ యొక్క MCP సర్వర్‌ను వివరిస్తుంది.

కోడ్, మోడల్ పేర్లు మరియు ప్రత్యక్ష కేటలాగ్ లేబుల్‌లు ఇంగ్లీషులోనే చూపబడతాయి.

ఉచిత API నుండి ఏజెంట్‌కు ఏమి కావాలి

అవసరంఎందుకుFreeLLMAPI ఏమి చేస్తుంది
టూల్ కాలింగ్ఏజెంట్ టూల్‌లను ఎంచుకుని నడుపుతుందిప్రతి ప్రొవైడర్‌కు OpenAI-శైలి tools పంపుతుంది. సాధారణ టెక్స్ట్ టూల్ కాల్‌లను నిజమైన tool_callsగా మారుస్తుంది.
అనేక అభ్యర్థనలుఒక పనికి 20 నుండి 100 దశలు పట్టవచ్చుప్రతి కీ కోటాను లెక్కిస్తుంది, 429 వస్తే తదుపరి కీ లేదా ప్రొవైడర్‌కు మారుతుంది
పెద్ద కాంటెక్స్ట్టూల్ ఫలితాలు మరియు చరిత్ర ప్రతి దశలో పెరుగుతాయిమీ చైన్‌లోని మోడళ్లకు రూట్ చేస్తుంది. దీర్ఘ-కాంటెక్స్ట్ ప్రొఫైల్‌ను సృష్టించవచ్చు.
స్థిరమైన ప్రవర్తనపని మధ్యలో మోడల్ మారితే ఏజెంట్ గందరగోళానికి గురికావచ్చుఒక సెషన్‌ను 30 నిమిషాల పాటు ఒకే మోడల్‌పై ఉంచుతుంది. మార్పు జరిగినప్పుడు ఐచ్ఛిక కాంటెక్స్ట్ హ్యాండాఫ్.
దృశ్యమానతఏ మోడల్ విఫలమైందో మీరు తెలుసుకోవాలిప్రతి ప్రతిస్పందనపై X-Routed-Via మరియు X-Fallback-Trail హెడర్‌లు

ఉచిత టియర్‌లకు పరిమితులు ఉంటాయి. ఫెయిలోవర్ లోడ్‌ను మీ కీల మీద విభజిస్తుంది, కానీ మొత్తం ఇప్పటికీ ఉచిత పరిమితుల మొత్తమే. ఏజెంట్ పని కోసం నాలుగు లేదా అంతకంటే ఎక్కువ ప్రొవైడర్ల కీలను జోడించండి.

టూల్ కాలింగ్ మరియు 128K+ కాంటెక్స్ట్ ఉన్న ఉచిత మోడళ్లు
మోడల్ఉచితంగా లభ్యంకాంటెక్స్ట్ఉచిత పరిమితులు (ఉత్తమ ఆఫర్)సాధనాలువిజన్
GLM 5.3UnoRouter1M1 అభ్యర్థనలు/నిమిషం
1 req/min per model
అవునులేదు
GLM 5.3 FlashNVIDIA NIM, UnoRouter1M40 అభ్యర్థనలు/నిమిషం
40 RPM
అవునుఅవును
Gemini 3.8 FlashGoogle AI Studio1MRecurring provider quotaఅవునుఅవును
Qwen3.8 Flash NextAMD Radeon Cloud262KRecurring daily account allowanceఅవునులేదు
Qwen3.8 FlashElectronHub1M$0.25/week shared recurring creditఅవునుఅవును
Gemini 3.7 FlashGoogle AI Studio1M10 అభ్యర్థనలు/నిమిషం
20 అభ్యర్థనలు/రోజు
250,000 టోకెన్‌లు/నిమిషం
~3M
అవునుఅవును
GPT-5.6 LunaElectronHub1M$0.25/week shared recurring creditఅవునుఅవును
Dots3 Note PreviewKilo Gateway, OpenRouter512K20 అభ్యర్థనలు/నిమిషం
50 అభ్యర్థనలు/రోజు
50 req/day account-wide (1,000 after a $10 purchase)
అవునుఅవును
DeepSeek V4 FlashAMD Radeon Cloud, BazaarLink, ElectronHub1M10 అభ్యర్థనలు/నిమిషం
50 అభ్యర్థనలు/రోజు
Shared rate limit
అవునులేదు
Qwen3.8 27BElectronHub, Groq, OVH AI Endpoints262K30 అభ్యర్థనలు/నిమిషం
250 అభ్యర్థనలు/రోజు
70,000 టోకెన్‌లు/నిమిషం
~6M
అవునుఅవును
Gemini 3.6 FlashGoogle AI Studio1M10 అభ్యర్థనలు/నిమిషం
20 అభ్యర్థనలు/రోజు
250,000 టోకెన్‌లు/నిమిషం
~3M
అవునుఅవును
Qwen 3.8 27BCloudflare Workers AI262KShared 10k neurons/dayఅవునుఅవును

సరిపోలే 109 ఉచిత మోడల్‌లలో 12 చూపబడుతున్నాయి. అన్ని మోడల్‌లను చూడండి.

FreeLLMAPI కేటలాగ్ నుండి ప్రత్యక్ష డేటా (వెర్షన్ 2026.11.19, 2026-11-19 న తనిఖీ చేయబడింది). ఉచిత పరిమితులు తరచుగా మారుతాయి. కేటలాగ్ ప్రతి రోజు తనిఖీ చేయబడుతుంది.

Python లో పూర్తి ఏజెంట్ లూప్

క్రింది లూప్ అధికారిక OpenAI SDKని ఉపయోగిస్తుంది. ఇది టూల్‌లను పంపుతుంది, ప్రతి టూల్ కాల్‌ను నడుపుతుంది, ఫలితాన్ని తిరిగి పంపుతుంది, మరియు మోడల్ తుది సమాధానం ఇచ్చినప్పుడు ఆగుతుంది. గరిష్ట దశల సంఖ్య తర్వాత కూడా ఆగుతుంది.

agent.py

import json
import os
import time

import openai
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:3001/v1",
    api_key=os.environ["FREELLMAPI_API_KEY"],  # <unified-key>
    max_retries=3,
)

def get_weather(city: str) -> dict:
    return {"city": city, "temp_c": 18, "sky": "cloudy"}

TOOLS = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get the current weather for a city.",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]
FUNCTIONS = {"get_weather": get_weather}

def call_model(messages, session_id):
    for attempt in range(5):
        try:
            return client.chat.completions.create(
                model="auto:smart",
                messages=messages,
                tools=TOOLS,
                extra_headers={"X-Session-Id": session_id},
            )
        except openai.RateLimitError as err:
            header = err.response.headers.get("retry-after", "")
            wait = int(header) if header.isdigit() else 2 ** attempt
            time.sleep(min(wait, 60))
    raise RuntimeError("All free providers are at their limit")

def run(task: str, session_id: str, max_steps: int = 10) -> str:
    messages = [
        {"role": "system", "content": "Use the tools when they help. Be brief."},
        {"role": "user", "content": task},
    ]
    for _ in range(max_steps):
        msg = call_model(messages, session_id).choices[0].message
        messages.append(msg)
        if not msg.tool_calls:
            return msg.content
        for call in msg.tool_calls:
            fn = FUNCTIONS.get(call.function.name)
            try:
                args = json.loads(call.function.arguments or "{}")
                result = fn(**args) if fn else {"error": "unknown tool"}
            except Exception as exc:  # return tool errors to the model
                result = {"error": str(exc)}
            messages.append({
                "role": "tool",
                "tool_call_id": call.id,
                "content": json.dumps(result),
            })
    return "Stopped: too many steps."

print(run("Should I take an umbrella in Dublin today?", session_id="task-001"))
  • X-Session-Id: ఒక పని యొక్క అన్ని దశలను, ఆ మోడల్‌కు కోటా ఉన్నంత వరకు, ఒకే మోడల్‌పై ఉంచుతుంది.
  • Retry-After: ప్రతి కీ దాని పరిమితిలో ఉన్నప్పుడు, గేట్‌వే ఈ హెడర్‌తో 429ని తిరిగి ఇస్తుంది. లూప్ వేచి ఉండి మళ్లీ ప్రయత్నిస్తుంది.
  • టూల్ ఎర్రర్‌లు: లూప్ ఎర్రర్‌లను టూల్ ఫలితాలుగా మోడల్‌కు తిరిగి పంపుతుంది. అప్పుడు మోడల్ తన కాల్‌ను సరిచేయగలదు.

ప్రతి దశను సరైన మోడల్‌కు రూట్ చేయండి

ఏజెంట్ దశలు సమానం కావు. ప్రణాళిక దశకు బలమైన మోడల్ కావాలి. ఒక ఫీల్డ్‌ను మాత్రమే సంగ్రహించే దశకు వేగవంతమైన మోడల్ కావాలి. ప్రతి దశ రకానికి వేరే మోడల్ స్ట్రింగ్ ఉపయోగించండి. డ్యాష్‌బోర్డ్‌ను మార్చాల్సిన అవసరం లేదు.

మోడల్ స్ట్రింగ్ర్యాంక్ చేసే ఆధారంఏజెంట్ ఉపయోగం
auto:smartతెలివితేటలుప్రణాళిక, టూల్ ఎంపిక, తుది సమాధానాలు
auto:fastకొలిచిన వేగం మరియు మొదటి బైట్ సమయంవర్గీకరణ, సంగ్రహించడం, టూల్ అవుట్‌పుట్ యొక్క చిన్న సారాంశాలు
auto:reliableఇటీవలి విజయ రేటుపూర్తి కావాల్సిన షెడ్యూల్ చేసిన ఏజెంట్లు
auto:balancedమొదట విశ్వసనీయత, తర్వాత వేగం మరియు తెలివితేటలుసాధారణ డిఫాల్ట్
auto:<profile>మీరు పేర్కొన్న ఫాల్‌బ్యాక్ చైన్టూల్ కాలింగ్ ఉన్న మోడళ్లు మాత్రమే ఉన్న చైన్

auto:* వ్యూహాలు ప్రారంభించబడిన ప్రతి మోడల్‌ను ర్యాంక్ చేస్తాయి మరియు మీ చైన్ క్రమాన్ని పట్టించుకోవు. టూల్‌లతో ఉన్న అభ్యర్థనకు ఇప్పటికీ టూల్ కాలింగ్ ఉన్న మోడల్ అవసరం. కొన్ని ప్రారంభించబడిన మోడళ్లు టూల్‌లను బాగా సపోర్ట్ చేయకపోతే, టూల్ కాలింగ్ ఉన్న మోడళ్లతో మాత్రమే ప్రొఫైల్ సృష్టించండి. అప్పుడు టూల్ దశల కోసం auto:<profile> ఉపయోగించండి. తెలియని ప్రొఫైల్ పేరు ఎర్రర్ 400ని ఇస్తుంది.

హెడర్ X-FreeLLM-Task-Type: code ఒక అభ్యర్థనకు రూటింగ్ బరువును వేగం నుండి తెలివితేటలకు మారుస్తుంది. ఇది మృదువైన ప్రాధాన్యత. ఇది సామర్థ్య తనిఖీలను లేదా ఫాల్‌బ్యాక్ చైన్‌ను మార్చదు.

దీర్ఘ ఏజెంట్ సెషన్‌లు మరియు మోడల్ మార్పులు

దీర్ఘ పని సమయంలో, ఒక మోడల్ తన రోజువారీ పరిమితికి చేరుకోవచ్చు. అప్పుడు రౌటర్ మరొక మోడల్‌కు మారుతుంది. కొత్త మోడల్‌కు పూర్తి సందేశ చరిత్ర లభిస్తుంది, కానీ మునుపటి దశలను మరో మోడల్ చేసిందని దానికి తెలియదు.

మోడల్ మారినప్పుడు ఒక చిన్న సిస్టమ్ సందేశాన్ని జోడించడానికి కాంటెక్స్ట్ హ్యాండాఫ్‌ను ఆన్ చేయండి. ఆ సందేశం కొత్త మోడల్‌కు పనిని కొనసాగించమని మరియు మునుపటి టూల్ ఫలితాలను ఉంచమని చెబుతుంది.

FreeLLMAPI .env

FREELLMAPI_CONTEXT_HANDOFF=on_model_switch
  • సెషన్ కోసం ఎంచుకున్న మోడల్ మారినప్పుడు మాత్రమే హ్యాండాఫ్ సందేశం జోడించబడుతుంది.
  • సెషన్‌లు 3 గంటల పాటు మెమరీలో ఉంచబడతాయి. ఏదీ డిస్క్‌పై రాయబడదు.
  • సెషన్ కీ X-Session-Id హెడర్. హెడర్ లేకపోతే, ఇది మొదటి యూజర్ సందేశం యొక్క హ్యాష్.

రౌటర్‌ను MCP సర్వర్‌గా ఉపయోగించండి

FreeLLMAPI /mcp వద్ద MCP సర్వర్ కూడా. MCP మాట్లాడే ఏజెంట్ ఒక టెక్స్ట్ పనిని FreeLLMAPI మోడల్‌కు పంపగలదు. ఒక సెషన్ సమయంలో గేట్‌వే స్థితిని కూడా చదవగలదు: ఉపయోగించగల మోడళ్లు మరియు వాటి పారామీటర్‌లు, ప్రొవైడర్ ఆరోగ్యం, వినియోగం మరియు క్యాష్ గణాంకాలు, మరియు రూటింగ్ వ్యూహం.

ఫ్రెష్ ఇన్‌స్టాల్‌లపై MCP ఉపరితలం ఆఫ్‌లో ఉంటుంది. డ్యాష్‌బోర్డ్‌లో Keys పేజీలో, Agent compatibility కింద దాన్ని ఆన్ చేయండి. అది ఆఫ్‌లో ఉన్నప్పుడు, /mcp 403ని ఇస్తుంది.

Claude Codeకు MCP సర్వర్‌ను జోడించండి

claude mcp add --transport http freellmapi http://localhost:3001/mcp \
  --header "Authorization: Bearer <unified-key>"

Streamable HTTP ఉన్న ఏ MCP క్లయింట్ అయినా అదే విధంగా పనిచేస్తుంది. దాన్ని /mcpకు సూచించండి మరియు ఏకీకృత కీని Bearer టోకెన్‌గా పంపండి. ఉపయోగకరమైన టూల్‌లు healthcheck, list_models మరియు ask_freellmapi. ask_freellmapi టూల్ API వలె అదే చాట్ రూట్ ద్వారా, రూటింగ్ మరియు ఫాల్‌బ్యాక్‌తో ఒక పనిని నడుపుతుంది.

కోడింగ్ ఏజెంట్ల కోసం, FreeLLMAPIకి క్లయింట్ కాన్ఫిగరేషన్‌ను మీ కోసం రాసే సెటప్ కమాండ్‌లు ఉన్నాయి. ఉదాహరణలు npx freellmapi setup-claude, setup-codex, setup-cline, setup-openclaw మరియు setup-hermes. ప్రతి కమాండ్ --dry-runకు మద్దతు ఇస్తుంది మరియు ముందు బ్యాకప్ చేస్తుంది.

సమస్య పరిష్కారం

సమస్యకారణంపరిష్కారం
మోడల్ టెక్స్ట్‌లో సమాధానం ఇస్తుంది మరియు టూల్‌ను కాల్ చేయదుమోడల్‌కు టూల్ కాలింగ్ బలహీనంగా ఉందిటూల్ కాలింగ్ ఉన్న మోడళ్లతో మాత్రమే auto:<profile> ఉపయోగించండి
ఏజెంట్ పని మధ్యలో మళ్లీ ప్రారంభిస్తుందిఒక పరిమితి మోడల్ మార్పును బలవంతం చేసిందిX-Session-Id పంపండి మరియు కాంటెక్స్ట్ హ్యాండాఫ్‌ను ఆన్ చేయండి
అనేక దశల తర్వాత ఎర్రర్ 429చైన్‌లోని అన్ని కీలు తమ పరిమితిలో ఉన్నాయిప్రొవైడర్లను జోడించండి, చిన్న దశలకు auto:fast ఉపయోగించండి మరియు Retry-After కోసం వేచి ఉండండి
auto:nameతో ఎర్రర్ 400ప్రొఫైల్ ఉనికిలో లేదుడ్యాష్‌బోర్డ్‌లో ప్రొఫైల్ పేరును తనిఖీ చేయండి
/mcp 403ని ఇస్తుందిMCP ఉపరితలం ఆఫ్‌లో ఉందిKeys పేజీలో Agent compatibility కింద దాన్ని ఆన్ చేయండి
పని చివరిలో కాంటెక్స్ట్ పొడవు ఎర్రర్‌లుచరిత్ర మోడల్ విండో కంటే పెద్దదిపాత టూల్ ఫలితాలను సంగ్రహించండి లేదా దీర్ఘ-కాంటెక్స్ట్ ప్రొఫైల్ ఉపయోగించండి
ఇవన్నీ ఒకే కీ ద్వారా ఉపయోగించండి. FreeLLMAPI ఒక ఓపెన్-సోర్స్, సెల్ఫ్-హోస్ట్ రూటర్. ఇది ఈ ఉచిత టియర్‌లన్నింటినీ ఒకే OpenAI-అనుకూల ఎండ్‌పాయింట్ వెనుక ఉంచుతుంది. ఒకటి రేట్ లిమిట్ అయినప్పుడు, అది మరొక దానికి మారుతుంది. కేటలాగ్‌ను బ్రౌజ్ చేయండి లేదా ప్రత్యక్షంగా.

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

AI ఏజెంట్ల కోసం ఉచిత LLM API ఉందా?

అవును. అనేక ప్రొవైడర్లు టూల్ కాలింగ్‌తో ఉచిత టియర్‌లను అందిస్తాయి. FreeLLMAPI వాటిని ఒకే OpenAI-compatible కీ వెనుక కలుపుతుంది మరియు ఒక పరిమితి అభ్యర్థనను ఆపినప్పుడు తదుపరి ప్రొవైడర్‌కు మారుతుంది.

టూల్ కాలింగ్ కోసం ఏ ఉచిత LLM ఉత్తమం?

టూల్ కాలింగ్ ఉన్న మరియు 128K టోకెన్‌ల లేదా అంతకంటే ఎక్కువ కాంటెక్స్ట్ విండో ఉన్న మోడల్‌ను ఉపయోగించండి. ఈ పేజీలోని పట్టిక ఈ రెండు నియమాలను ఈ రోజు తీర్చే బలమైన ఉచిత మోడళ్లను చూపుతుంది.

నేను FreeLLMAPIని MCP సర్వర్‌గా ఉపయోగించవచ్చా?

అవును. Keys పేజీలో Agent compatibility కింద MCP ఉపరితలాన్ని ఆన్ చేయండి. తర్వాత మీ MCP క్లయింట్‌ను ఏకీకృత కీతో Bearer టోకెన్‌గా /mcpకు కనెక్ట్ చేయండి.

రేట్ పరిమితులపై ఏజెంట్ విఫలం కాకుండా ఎలా ఆపాలి?

మరిన్ని ప్రొవైడర్ల కీలను జోడించండి, చిన్న దశలను auto:fastకు పంపండి, 429పై Retry-After హెడర్‌తో మళ్లీ ప్రయత్నించండి మరియు దశల గరిష్ట సంఖ్యను సెట్ చేయండి.

ఏజెంట్ పని మధ్యలో మోడల్ మారినప్పుడు ఏమి జరుగుతుంది?

కొత్త మోడల్‌కు పూర్తి సందేశ చరిత్ర లభిస్తుంది. కాంటెక్స్ట్ హ్యాండాఫ్ ఆన్‌లో ఉంటే, పనిని కొనసాగించమని చెప్పే చిన్న నోట్ కూడా లభిస్తుంది.

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

మూలాలు

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