Discord లేదా Telegram బాట్ కోసం ఉచిత AI API
చాట్ బాట్ ప్రతి సందేశానికి ఒక మోడల్ అభ్యర్థనను పంపుతుంది. రద్దీగా ఉండే సర్వర్లో, ఒక ఉచిత టియర్ నిమిషాల్లోనే తన పరిమితికి చేరుతుంది. ఈ గైడ్ Discord బాట్ మరియు Telegram బాట్ను FreeLLMAPIకి కనెక్ట్ చేస్తుంది. FreeLLMAPI ఒకే OpenAI-compatible కీ వెనుక 45 ఉచిత ప్రొవైడర్ టియర్లను ఉంచుతుంది, మరియు ఒక పరిమితి అభ్యర్థనను ఆపినప్పుడు తదుపరి ప్రొవైడర్కు మారుతుంది. కోడ్ Python లో ఉంది మరియు పూర్తిగా ఉంది.
కోడ్, మోడల్ పేర్లు మరియు ప్రత్యక్ష కేటలాగ్ లేబుల్లు ఇంగ్లీషులోనే చూపబడతాయి.
ముందుగా పరిమితుల కోసం ప్లాన్ చేయండి
ఉచిత టియర్లు నిమిషానికి మరియు రోజుకు అభ్యర్థనలను పరిమితం చేస్తాయి. 200 చురుకైన వినియోగదారులున్న సర్వర్లోని బాట్ రోజుకు వేల అభ్యర్థనలను పంపగలదు. ఫెయిల్ఓవర్ ఈ అభ్యర్థనలను మీ అన్ని కీలపై పంచుతుంది, కానీ మొత్తం ఇప్పటికీ ఉచిత పరిమితుల మొత్తమే.
- అడిగినప్పుడు మాత్రమే సమాధానం ఇవ్వండి. Discord లో, mentions కు మాత్రమే సమాధానం ఇవ్వండి. Telegram గ్రూప్లలో, commands లేదా replies కు మాత్రమే సమాధానం ఇవ్వండి.
- ప్రతి వినియోగదారునికి పరిమితి పెట్టండి. ప్రతి కొన్ని సెకన్లకు ఒక వినియోగదారుకు ఒక అభ్యర్థనను అనుమతించండి.
- చరిత్రను చిన్నదిగా ఉంచండి. పూర్తి ఛానల్ చరిత్రను కాదు, చివరి 10 సందేశాలను పంపండి.
- వేగవంతమైన రూట్ను ఉపయోగించండి.
auto:fastమోడల్లను వేగం ప్రకారం ర్యాంక్ చేస్తుంది. చాట్ వినియోగదారులు తక్కువ సమయం వేచి ఉంటారు. - మర్యాదగా విఫలమవ్వండి. అన్ని కీలు వాటి పరిమితిలో ఉన్నప్పుడు, వినియోగదారుకు తర్వాత మళ్ళీ ప్రయత్నించమని చెప్పండి.
ఈ ఉచిత మోడల్లు ఈరోజు అత్యంత వేగవంతమైన కొలిచిన వేగాన్ని కలిగి ఉన్నాయి. వీటిలో చాలా మోడల్లకు అధిక అభ్యర్థన పరిమితులు ఉన్నాయి:
| మోడల్ | ఉచితంగా లభ్యం | కాంటెక్స్ట్ | ఉచిత పరిమితులు (ఉత్తమ ఆఫర్) | సాధనాలు | విజన్ |
|---|---|---|---|---|---|
| Qwen3.8 27B | BlazeAPI, ElectronHub, Gizmo +3 మరిన్ని | 262K | 30 అభ్యర్థనలు/నిమిషం 250 అభ్యర్థనలు/రోజు 70,000 టోకెన్లు/నిమిషం ~6M | అవును | అవును |
| GPT-OSS 20B | Api.Airforce, Cloudflare Workers AI, Groq +4 మరిన్ని | 131K | 30 అభ్యర్థనలు/నిమిషం 1,000 అభ్యర్థనలు/రోజు 8,000 టోకెన్లు/నిమిషం 200,000 టోకెన్లు/రోజు ~6M | అవును | లేదు |
| Nemotron 3.5 Lightning | ElectronHub, Gizmo, Kilo Gateway +2 మరిన్ని | 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 (via Groq) | DreamPrompting | 131K | 100 అభ్యర్థనలు/నిమిషం 5,000 అభ్యర్థనలు/రోజు 500,000 టోకెన్లు/రోజు 500K tokens/day · 5,000 req/day | లేదు | లేదు |
| GPT-OSS Safeguard 20B | Groq | 131K | 30 అభ్యర్థనలు/నిమిషం 1,000 అభ్యర్థనలు/రోజు 8,000 టోకెన్లు/నిమిషం 200,000 టోకెన్లు/రోజు ~6M | అవును | లేదు |
| Groq Compound Mini | DreamPrompting | 131K | 100 అభ్యర్థనలు/నిమిషం 5,000 అభ్యర్థనలు/రోజు 500,000 టోకెన్లు/రోజు 500K tokens/day · 5,000 req/day | లేదు | లేదు |
| 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 | అవును | అవును |
సరిపోలే 215 ఉచిత మోడల్లలో 10 చూపబడుతున్నాయి. అన్ని మోడల్లను చూడండి.
FreeLLMAPI కేటలాగ్ నుండి ప్రత్యక్ష డేటా (వెర్షన్ 2026.11.19, 2026-11-19 న తనిఖీ చేయబడింది). ఉచిత పరిమితులు తరచుగా మారుతాయి. కేటలాగ్ ప్రతి రోజు తనిఖీ చేయబడుతుంది.
భాగస్వామ్య కోడ్: మోడల్ కాల్
రెండు బాట్లు ఒకే module ను ఉపయోగిస్తాయి. ఇది ప్రతి చాట్కు చిన్న చరిత్రను ఉంచుతుంది, ప్రతి చాట్కు ఒక session ID ను పంపుతుంది మరియు రేట్ పరిమితులను నిర్వహిస్తుంది. ముందుగా FreeLLMAPIని ఇన్స్టాల్ చేసి, డాష్బోర్డ్ Keys పేజీ నుండి unified కీని కాపీ చేయండి.
ఇన్స్టాల్
curl -fsSL https://freellmapi.co/install.sh | bash
python3 -m pip install -U openai discord.py python-telegram-bot
export FREELLMAPI_API_KEY=<unified-key>brain.py
import asyncio
import os
import time
from collections import defaultdict, deque
import openai
from openai import AsyncOpenAI
llm = AsyncOpenAI(
base_url="http://localhost:3001/v1",
api_key=os.environ["FREELLMAPI_API_KEY"],
max_retries=2,
timeout=60,
)
SYSTEM = "You are a helpful chat bot. Answer in short paragraphs."
history = defaultdict(lambda: deque(maxlen=10)) # chat id -> last 10 messages
last_call = {} # user id -> time of the last request
COOLDOWN_S = 5
async def ask(chat_id: str, user_id: str, text: str) -> str:
now = time.monotonic()
if now - last_call.get(user_id, 0) < COOLDOWN_S:
return "Please wait a few seconds before the next question."
last_call[user_id] = now
turns = history[chat_id]
turns.append({"role": "user", "content": text[:4000]})
messages = [{"role": "system", "content": SYSTEM}, *turns]
for attempt in range(3):
try:
resp = await llm.chat.completions.create(
model="auto:fast",
messages=messages,
max_tokens=800,
extra_headers={"X-Session-Id": f"chat-{chat_id}"},
)
answer = resp.choices[0].message.content or "(no answer)"
turns.append({"role": "assistant", "content": answer})
return answer
except openai.RateLimitError as err:
header = err.response.headers.get("retry-after", "")
wait = int(header) if header.isdigit() else 2 ** attempt
if wait > 30:
break
await asyncio.sleep(wait)
except openai.APIError:
break
turns.pop() # forget the unanswered question
return "All free models are busy now. Please try again later."
def split(text: str, size: int) -> list[str]:
return [text[i:i + size] for i in range(0, len(text), size)] or [""]X-Session-Id హెడర్ ఒక చాట్ను 30 నిమిషాల పాటు ఒకే మోడల్పై ఉంచుతుంది. దీనివల్ల బాట్ సంభాషణలో అదే శైలిని ఉంచుతుంది. ఆ మోడల్ తన పరిమితికి చేరితే, రూటర్ మరో మోడల్కు మారుతుంది, అది అదే చరిత్రను పొందుతుంది.
చరిత్ర మరియు cooldowns మెమరీలో ఉంచబడతాయి. బాట్ రీస్టార్ట్ అయితే అవి పోతాయి. పొడవైన సంభాషణలను గుర్తుంచుకోవాల్సిన బాట్ కోసం, చరిత్రను SQLite లేదా Redis వంటి డేటాబేస్లో నిల్వ చేయండి.
discord.py తో Discord బాట్
- Discord Developer Portal ను తెరిచి ఒక application ను సృష్టించండి. ఒక బాట్ను జోడించి దాని token ను కాపీ చేయండి.
- bot ట్యాబ్లో, Privileged Gateway Intents కు వెళ్ళండి. Message Content ను ఆన్ చేయండి.
botscope మరియు Send Messages permission తో బాట్ను మీ సర్వర్కు ఆహ్వానించండి.DISCORD_TOKENenvironment variable లో token ను సెట్ చేసి script ను నడపండి.
discord_bot.py
import os
import discord
from brain import ask, split
intents = discord.Intents.default()
intents.message_content = True
client = discord.Client(intents=intents)
@client.event
async def on_ready():
print(f"Logged in as {client.user}")
@client.event
async def on_message(message: discord.Message):
if message.author.bot or client.user not in message.mentions:
return
text = message.content
for tag in (f"<@{client.user.id}>", f"<@!{client.user.id}>"):
text = text.replace(tag, "")
text = text.strip()
if not text:
return
async with message.channel.typing():
answer = await ask(str(message.channel.id), str(message.author.id), text)
parts = split(answer, 2000) # Discord limit: 2000 characters
await message.reply(parts[0])
for part in parts[1:]:
await message.channel.send(part)
client.run(os.environ["DISCORD_TOKEN"])python-telegram-bot తో Telegram బాట్
- Telegram లో @BotFather ను తెరిచి
/newbotను పంపండి. token ను కాపీ చేయండి. TELEGRAM_TOKENenvironment variable లో token ను సెట్ చేయండి.- script ను నడపండి. మీ బాట్కు ఒక సందేశం పంపండి.
telegram_bot.py
import os
from telegram import Update
from telegram.constants import ChatAction
from telegram.ext import Application, ContextTypes, MessageHandler, filters
from brain import ask, split
async def on_text(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
chat_id = update.effective_chat.id
await context.bot.send_chat_action(chat_id=chat_id, action=ChatAction.TYPING)
answer = await ask(str(chat_id), str(update.effective_user.id), update.message.text)
for part in split(answer, 4096): # Telegram limit: 4096 characters
await update.message.reply_text(part)
def main() -> None:
app = Application.builder().token(os.environ["TELEGRAM_TOKEN"]).build()
app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, on_text))
app.run_polling(allowed_updates=Update.ALL_TYPES)
if __name__ == "__main__":
main()Telegram లో typing స్థితి 5 సెకన్లు లేదా అంతకంటే తక్కువ ఉంటుంది. నెమ్మది మోడల్ల కోసం, పొడవైన అభ్యర్థనల సమయంలో chat action ను మళ్ళీ పంపండి. కోడ్ python-telegram-bot వెర్షన్ 22 ను ఉపయోగిస్తుంది, ఇది పూర్తిగా async.
సిద్ధంగా ఉన్న బాట్ agents
మీరు బాట్ రాయకూడదనుకుంటే, రెండు agents Discord మరియు Telegram లో సమాధానం ఇవ్వగలవు, మరియు FreeLLMAPIని తమ మోడల్గా ఉపయోగించగలవు. FreeLLMAPI ప్రతి దానికి ఒక సెటప్ కమాండ్ కలిగి ఉంది. ప్రతి కమాండ్ --dry-run కు మద్దతు ఇస్తుంది మరియు ముందుగా configuration కు బ్యాకప్ తీసుకుంటుంది.
| Agent | సెటప్ కమాండ్ | ఇది ఏమి వ్రాస్తుంది |
|---|---|---|
| OpenClaw | npx freellmapi setup-openclaw --url http://localhost:3001 --api-key <unified-key> | freellmapi ప్రొవైడర్ ~/.openclaw/openclaw.json లో, డిఫాల్ట్ మోడల్ freellmapi/auto |
| Hermes Agent | npx freellmapi setup-hermes --url http://localhost:3001 --api-key <unified-key> | ~/.hermes/config.yaml లో ఒక custom model బ్లాక్ |
నడుస్తున్న OpenClaw లేదా Hermes గేట్వేకు సెటప్ కమాండ్ తర్వాత రీస్టార్ట్ అవసరం.
బాట్ మరియు FreeLLMAPIని ఒకే కంప్యూటర్ లేదా సర్వర్లో నడపండి. అప్పుడు బాట్ localhost వద్ద గేట్వేని చేరుకుంటుంది, మరియు గేట్వే పోర్ట్ ఇంటర్నెట్కు మూసి ఉంటుంది. చిన్న సర్వర్ లేదా Raspberry Pi రెండింటికీ సరిపోతుంది.
ట్రబుల్షూటింగ్
| సమస్య | కారణం | పరిష్కారం |
|---|---|---|
| Discord బాట్ ఖాళీ సందేశాలను చదువుతుంది | Message Content intent ఆఫ్లో ఉంది | పోర్టల్లో మరియు intents.message_content లో దాన్ని ఆన్ చేయండి |
| బాట్ తన స్వంత సందేశాలకు సమాధానం ఇస్తుంది | బాట్ రచయితల కోసం తనిఖీ లేదు | message.author.bot నిజమైనప్పుడు తిరిగి వెళ్ళండి |
| పొడవైన సమాధానాలపై Discord ఎర్రర్ 50035 | సందేశం 2000 అక్షరాల కంటే పొడవుగా ఉంది | పైన ఉన్న కోడ్లో ఉన్నట్లుగా సమాధానాన్ని విభజించండి |
| సాయంత్రం "అన్ని ఉచిత మోడల్లు బిజీగా ఉన్నాయి" | చైన్లోని అన్ని కీలు వాటి రోజువారీ పరిమితిలో ఉన్నాయి | మరిన్ని ప్రొవైడర్ల నుండి కీలను జోడించండి. చాలా రోజువారీ పరిమితులు అర్ధరాత్రి UTC కి రీసెట్ అవుతాయి. |
| నెమ్మది సమాధానాలు | నెమ్మది మోడల్ లేదా పొడవైన చరిత్ర | auto:fast ను ఉపయోగించి 10 లేదా అంతకంటే తక్కువ సందేశాలను ఉంచండి |
బాట్ నుండి Connection refused | బాట్ Docker లో నడుస్తోంది మరియు localhost ను ఉపయోగిస్తోంది | host.docker.internal ను లేదా ఉమ్మడి Docker నెట్వర్క్ను ఉపయోగించండి |
తరచుగా అడిగే ప్రశ్నలు
Discord బాట్ కోసం ఉచిత AI API ఉందా?
అవును. అనేక ప్రొవైడర్లకు openai Python ప్యాకేజీతో పనిచేసే ఉచిత టియర్లు ఉన్నాయి. FreeLLMAPI వాటిని ఒకే కీ వెనుక కలుపుతుంది, కాబట్టి రద్దీగా ఉండే బాట్ అనేక ప్రొవైడర్ల పరిమితులను ఉపయోగించగలదు.
ఉచిత AI Telegram బాట్ను తయారు చేయవచ్చా?
అవును. బాట్ కోసం python-telegram-bot ను, సమాధానాల కోసం OpenAI-compatible ఉచిత APIని ఉపయోగించండి. ఈ పేజీలోని కోడ్ పూర్తిగా ఉంది.
నా AI బాట్ రేట్ పరిమితులను చేరకుండా ఎలా ఆపాలి?
mentions లేదా commands కు మాత్రమే సమాధానం ఇవ్వండి, ప్రతి వినియోగదారుని ప్రతి కొన్ని సెకన్లకు ఒక అభ్యర్థనకు పరిమితం చేయండి, చరిత్రను చిన్నదిగా ఉంచండి మరియు మరిన్ని ప్రొవైడర్ల నుండి కీలను జోడించండి.
నా Discord బాట్కు సందేశ కంటెంట్ ఎందుకు ఖాళీగా వస్తుంది?
Message Content intent ఆఫ్లో ఉంది. bot ట్యాబ్లో Developer Portal లో దాన్ని ఆన్ చేయండి, మరియు కోడ్లో intents.message_content = True ను సెట్ చేయండి.
అన్ని ఉచిత మోడల్లు వాటి పరిమితిలో ఉన్నప్పుడు ఏమి జరుగుతుంది?
FreeLLMAPI Retry-After హెడర్తో ఎర్రర్ 429 ను ఇస్తుంది. బాట్ కోడ్ దాన్ని క్యాచ్ చేసి, వినియోగదారుకు తర్వాత మళ్ళీ ప్రయత్నించమని చెబుతుంది.
సంబంధిత గైడ్లు
- Pythonలో ఉచిత LLM API
- ఉచిత LLM API రేట్ పరిమితులు
- ఉచిత OpenAI-అనుకూల API base URLs
- AI ఏజెంట్ల కోసం ఉచిత LLM API
- క్రెడిట్ కార్డ్ లేకుండా ఉచిత LLM API
మూలాలు
- discord.py docs: quickstart (20 November 2026 న తనిఖీ చేయబడింది)
- discord.py docs: privileged intents (20 November 2026 న తనిఖీ చేయబడింది)
- Discord developer docs: message resource (2000 character content limit) (20 November 2026 న తనిఖీ చేయబడింది)
- python-telegram-bot v22 docs: echobot example (20 November 2026 న తనిఖీ చేయబడింది)
- Telegram Bot API: sendMessage and sendChatAction (20 November 2026 న తనిఖీ చేయబడింది)
- FreeLLMAPI docs: clients (OpenClaw, Hermes Agent, context handoff) (20 November 2026 న తనిఖీ చేయబడింది)