ಮುಖಪುಟ / ಮಾರ್ಗದರ್ಶಿಗಳು / ಡಿಸ್ಕಾರ್ಡ್ ಅಥವಾ ಟೆಲಿಗ್ರಾಮ್ ಬಾಟ್‌ಗಾಗಿ ಉಚಿತ AI API

ಡಿಸ್ಕಾರ್ಡ್ ಅಥವಾ ಟೆಲಿಗ್ರಾಮ್ ಬಾಟ್‌ಗಾಗಿ ಉಚಿತ AI API

ಚಾಟ್ ಬಾಟ್ ಪ್ರತಿ ಸಂದೇಶಕ್ಕೆ ಒಂದು ಮಾಡೆಲ್ ವಿನಂತಿ ಕಳುಹಿಸುತ್ತದೆ. ಬಿಜಿ ಸರ್ವರ್‌ನಲ್ಲಿ, ಒಂದು ಉಚಿತ ಶ್ರೇಣಿ ನಿಮಿಷಗಳಲ್ಲಿ ತನ್ನ ಮಿತಿ ತಲುಪುತ್ತದೆ. ಈ ಮಾರ್ಗದರ್ಶಿ Discord ಬಾಟ್ ಮತ್ತು Telegram ಬಾಟ್ ಅನ್ನು FreeLLMAPI ಗೆ ಸಂಪರ್ಕಿಸುತ್ತದೆ. FreeLLMAPI ಒಂದು OpenAI-ಹೊಂದಾಣಿಕೆಯ ಕೀ ಹಿಂದೆ 45 ಉಚಿತ ಪ್ರೊವೈಡರ್ ಶ್ರೇಣಿಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ ಮತ್ತು ಮಿತಿ ವಿನಂತಿಯನ್ನು ನಿಲ್ಲಿಸಿದಾಗ ಮುಂದಿನ ಪ್ರೊವೈಡರ್‌ಗೆ ಹೋಗುತ್ತದೆ. ಕೋಡ್ Python ನಲ್ಲಿದ್ದು ಸಂಪೂರ್ಣವಾಗಿದೆ.

ಕೋಡ್, ಮಾದರಿ ಹೆಸರುಗಳು ಮತ್ತು ನೇರ ಕ್ಯಾಟಲಾಗ್ ಲೇಬಲ್‌ಗಳನ್ನು ಇಂಗ್ಲಿಷ್‌ನಲ್ಲಿ ತೋರಿಸಲಾಗಿದೆ.

ಮೊದಲು ಮಿತಿಗಳಿಗೆ ಯೋಜಿಸಿ

ಉಚಿತ ಶ್ರೇಣಿಗಳು ನಿಮಿಷ ಮತ್ತು ದಿನಕ್ಕೆ ವಿನಂತಿಗಳನ್ನು ಮಿತಿಗೊಳಿಸುತ್ತವೆ. 200 ಸಕ್ರಿಯ ಬಳಕೆದಾರರಿರುವ ಸರ್ವರ್‌ನಲ್ಲಿರುವ ಬಾಟ್ ದಿನಕ್ಕೆ ಸಾವಿರಾರು ವಿನಂತಿಗಳನ್ನು ಕಳುಹಿಸಬಹುದು. ಫೇಲ್‌ಓವರ್ ಈ ವಿನಂತಿಗಳನ್ನು ನಿಮ್ಮ ಎಲ್ಲಾ ಕೀಗಳ ನಡುವೆ ಹಂಚುತ್ತದೆ, ಆದರೆ ಒಟ್ಟು ಇನ್ನೂ ಉಚಿತ ಮಿತಿಗಳ ಮೊತ್ತವೇ.

  • ಕೇಳಿದಾಗ ಮಾತ್ರ ಉತ್ತರಿಸಿ. Discord ನಲ್ಲಿ ಕೇವಲ ಉಲ್ಲೇಖಗಳಿಗೆ ಉತ್ತರಿಸಿ. Telegram ಗುಂಪುಗಳಲ್ಲಿ ಕೇವಲ ಆಜ್ಞೆಗಳು ಅಥವಾ ಉತ್ತರಗಳಿಗೆ ಉತ್ತರಿಸಿ.
  • ಪ್ರತಿ ಬಳಕೆದಾರರನ್ನು ಮಿತಿಗೊಳಿಸಿ. ಪ್ರತಿ ಕೆಲವು ಸೆಕೆಂಡ್‌ಗಳಿಗೆ ಪ್ರತಿ ಬಳಕೆದಾರರಿಗೆ ಒಂದು ವಿನಂತಿಗೆ ಅವಕಾಶ ನೀಡಿ.
  • ಇತಿಹಾಸವನ್ನು ಚಿಕ್ಕದಾಗಿ ಇರಿಸಿ. ಕೊನೆಯ 10 ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸಿ, ಪೂರ್ಣ ಚಾನೆಲ್ ಇತಿಹಾಸವನ್ನು ಅಲ್ಲ.
  • ವೇಗದ ಮಾರ್ಗ ಬಳಸಿ. auto:fast ಮಾಡೆಲ್‌ಗಳನ್ನು ವೇಗದ ಪ್ರಕಾರ ಶ್ರೇಣೀಕರಿಸುತ್ತದೆ. ಚಾಟ್ ಬಳಕೆದಾರರು ಕಡಿಮೆ ಕಾಯುತ್ತಾರೆ.
  • ಸಭ್ಯವಾಗಿ ವಿಫಲವಾಗಿ. ಎಲ್ಲಾ ಕೀಗಳು ಮಿತಿಯಲ್ಲಿದ್ದಾಗ, ಬಳಕೆದಾರರಿಗೆ ನಂತರ ಮತ್ತೆ ಪ್ರಯತ್ನಿಸಲು ಹೇಳಿ.
ಗೌಪ್ಯತೆ: ಬಾಟ್ ಬಳಕೆದಾರರ ಸಂದೇಶಗಳನ್ನು ಉತ್ತರಿಸುವ ಪ್ರೊವೈಡರ್‌ಗೆ ಕಳುಹಿಸುತ್ತದೆ. ಕೆಲವು ಉಚಿತ ಶ್ರೇಣಿಗಳು ತಮ್ಮ ಮಾಡೆಲ್‌ಗಳನ್ನು ಸುಧಾರಿಸಲು ಪ್ರಾಂಪ್ಟ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. AI ಸೇವೆ ತಮ್ಮ ಸಂದೇಶಗಳನ್ನು ಓದುತ್ತದೆ ಎಂದು ನಿಮ್ಮ ಬಳಕೆದಾರರಿಗೆ ತಿಳಿಸಿ. ಯಾವ ಉಚಿತ LLM API ಗಳು ನಿಮ್ಮ ಡೇಟಾದ ಮೇಲೆ ತರಬೇತಿ ನೀಡುತ್ತವೆ ಓದಿ ಮತ್ತು ನೀವು ಒಪ್ಪದ ಪ್ರೊವೈಡರ್‌ಗಳನ್ನು ನಿಮ್ಮ ಸರಣಿಯಿಂದ ತೆಗೆದುಹಾಕಿ.

ಈ ಉಚಿತ ಮಾಡೆಲ್‌ಗಳು ಇಂದು ಅತ್ಯಂತ ವೇಗದ ಅಳೆಯಲಾದ ವೇಗವನ್ನು ಹೊಂದಿವೆ. ಇವುಗಳಲ್ಲಿ ಅನೇಕವು ಹೆಚ್ಚಿನ ವಿನಂತಿ ಮಿತಿಗಳನ್ನು ಹೊಂದಿವೆ:

ವೇಗದ ಉಚಿತ ಚಾಟ್ ಮಾಡೆಲ್‌ಗಳು
ಮಾದರಿಉಚಿತಸಂದರ್ಭಉಚಿತ ಮಿತಿಗಳು (ಅತ್ಯುತ್ತಮ ಕೊಡುಗೆ)ಉಪಕರಣಗಳುದೃಷ್ಟಿ
Qwen3.8 27BBlazeAPI, ElectronHub, Gizmo +3 ಇನ್ನೂ262K30 ವಿನಂತಿ/ನಿಮಿಷ
250 ವಿನಂತಿ/ದಿನ
70,000 ಟೋಕನ್/ನಿಮಿಷ
~6M
ಹೌದುಹೌದು
GPT-OSS 20BApi.Airforce, Cloudflare Workers AI, Groq +4 ಇನ್ನೂ131K30 ವಿನಂತಿ/ನಿಮಿಷ
1,000 ವಿನಂತಿ/ದಿನ
8,000 ಟೋಕನ್/ನಿಮಿಷ
200,000 ಟೋಕನ್/ದಿನ
~6M
ಹೌದುಇಲ್ಲ
Nemotron 3.5 LightningElectronHub, Gizmo, Kilo Gateway +2 ಇನ್ನೂ1M20 ವಿನಂತಿ/ನಿಮಿಷ
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 20B (via Groq)DreamPrompting131K100 ವಿನಂತಿ/ನಿಮಿಷ
5,000 ವಿನಂತಿ/ದಿನ
500,000 ಟೋಕನ್/ದಿನ
500K tokens/day · 5,000 req/day
ಇಲ್ಲಇಲ್ಲ
GPT-OSS Safeguard 20BGroq131K30 ವಿನಂತಿ/ನಿಮಿಷ
1,000 ವಿನಂತಿ/ದಿನ
8,000 ಟೋಕನ್/ನಿಮಿಷ
200,000 ಟೋಕನ್/ದಿನ
~6M
ಹೌದುಇಲ್ಲ
Groq Compound MiniDreamPrompting131K100 ವಿನಂತಿ/ನಿಮಿಷ
5,000 ವಿನಂತಿ/ದಿನ
500,000 ಟೋಕನ್/ದಿನ
500K tokens/day · 5,000 req/day
ಇಲ್ಲಇಲ್ಲ
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
ಹೌದುಹೌದು

ಹೊಂದಾಣಿಕೆಯಾಗುವ 215 ಉಚಿತ ಮಾದರಿಗಳಲ್ಲಿ 10 ಅನ್ನು ತೋರಿಸಲಾಗುತ್ತಿದೆ. ಎಲ್ಲಾ ಮಾದರಿಗಳನ್ನು ನೋಡಿ.

FreeLLMAPI ಕ್ಯಾಟಲಾಗ್‌ನಿಂದ ನೇರ ಡೇಟಾ (ಆವೃತ್ತಿ 2026.11.19, 2026-11-19 ರಂದು ಪರಿಶೀಲಿಸಲಾಗಿದೆ). ಉಚಿತ ಮಿತಿಗಳು ಆಗಾಗ್ಗೆ ಬದಲಾಗುತ್ತವೆ. ಕ್ಯಾಟಲಾಗ್ ಪ್ರತಿದಿನ ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ.

ಹಂಚಿದ ಕೋಡ್: ಮಾಡೆಲ್ ಕರೆ

ಎರಡೂ ಬಾಟ್‌ಗಳು ಒಂದೇ ಮಾಡ್ಯೂಲ್ ಬಳಸುತ್ತವೆ. ಇದು ಪ್ರತಿ ಚಾಟ್‌ಗೆ ಚಿಕ್ಕ ಇತಿಹಾಸವನ್ನು ಇಡುತ್ತದೆ, ಪ್ರತಿ ಚಾಟ್‌ಗೆ ಒಂದು ಸೆಷನ್ ID ಕಳುಹಿಸುತ್ತದೆ ಮತ್ತು ರೇಟ್ ಮಿತಿಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. ಮೊದಲು FreeLLMAPI ಸ್ಥಾಪಿಸಿ ಮತ್ತು ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನ Keys ಪುಟದಿಂದ ಏಕೀಕೃತ ಕೀಯನ್ನು ನಕಲಿಸಿ.

ಸ್ಥಾಪಿಸಿ

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 ನಿಮಿಷಗಳ ಕಾಲ ಒಂದೇ ಮಾಡೆಲ್‌ನಲ್ಲಿ ಇಡುತ್ತದೆ. ಆಗ ಬಾಟ್ ಒಂದು ಸಂಭಾಷಣೆಯಲ್ಲಿ ಅದೇ ಶೈಲಿಯನ್ನು ಉಳಿಸುತ್ತದೆ. ಆ ಮಾಡೆಲ್ ತನ್ನ ಮಿತಿ ತಲುಪಿದರೆ, ರೂಟರ್ ಬೇರೆ ಮಾಡೆಲ್‌ಗೆ ಹೋಗುತ್ತದೆ, ಅದು ಅದೇ ಇತಿಹಾಸವನ್ನು ಪಡೆಯುತ್ತದೆ.

ಇತಿಹಾಸ ಮತ್ತು ಕೂಲ್‌ಡೌನ್‌ಗಳು ಮೆಮೊರಿಯಲ್ಲಿ ಇರುತ್ತವೆ. ಬಾಟ್ ಮರುಪ್ರಾರಂಭಗೊಂಡಾಗ ಅವು ಕಳೆದುಹೋಗುತ್ತವೆ. ದೀರ್ಘ ಸಂಭಾಷಣೆಗಳನ್ನು ನೆನಪಿಡಬೇಕಾದ ಬಾಟ್‌ಗೆ, SQLite ಅಥವಾ Redis ನಂತಹ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಇತಿಹಾಸವನ್ನು ಸಂಗ್ರಹಿಸಿ.

discord.py ಜೊತೆ Discord ಬಾಟ್

  1. Discord Developer Portal ತೆರೆದು ಒಂದು ಅಪ್ಲಿಕೇಶನ್ ರಚಿಸಿ. ಬಾಟ್ ಸೇರಿಸಿ ಮತ್ತು ಅದರ ಟೋಕನ್ ನಕಲಿಸಿ.
  2. ಬಾಟ್ ಟ್ಯಾಬ್‌ನಲ್ಲಿ, Privileged Gateway Intents ಗೆ ಹೋಗಿ. Message Content ಆನ್ ಮಾಡಿ.
  3. bot ಸ್ಕೋಪ್ ಮತ್ತು Send Messages ಅನುಮತಿಯೊಂದಿಗೆ ಬಾಟ್ ಅನ್ನು ನಿಮ್ಮ ಸರ್ವರ್‌ಗೆ ಆಹ್ವಾನಿಸಿ.
  4. DISCORD_TOKEN ಪರಿಸರ ವೇರಿಯೇಬಲ್‌ನಲ್ಲಿ ಟೋಕನ್ ಹೊಂದಿಸಿ ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್ ಚಲಾಯಿಸಿ.

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 ಬಾಟ್

  1. Telegram ನಲ್ಲಿ @BotFather ತೆರೆದು /newbot ಕಳುಹಿಸಿ. ಟೋಕನ್ ನಕಲಿಸಿ.
  2. TELEGRAM_TOKEN ಪರಿಸರ ವೇರಿಯೇಬಲ್‌ನಲ್ಲಿ ಟೋಕನ್ ಹೊಂದಿಸಿ.
  3. ಸ್ಕ್ರಿಪ್ಟ್ ಚಲಾಯಿಸಿ. ನಿಮ್ಮ ಬಾಟ್‌ಗೆ ಸಂದೇಶ ಕಳುಹಿಸಿ.

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 ನಲ್ಲಿ ಟೈಪಿಂಗ್ ಸ್ಥಿತಿ 5 ಸೆಕೆಂಡ್ ಅಥವಾ ಕಡಿಮೆ ಇರುತ್ತದೆ. ನಿಧಾನ ಮಾಡೆಲ್‌ಗಳಿಗೆ, ದೀರ್ಘ ವಿನಂತಿಗಳ ಸಮಯದಲ್ಲಿ ಚಾಟ್ ಕ್ರಿಯೆಯನ್ನು ಮತ್ತೆ ಕಳುಹಿಸಿ. ಕೋಡ್ python-telegram-bot ಆವೃತ್ತಿ 22 ಬಳಸುತ್ತದೆ, ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಅಸಿಂಕ್ ಆಗಿದೆ.

ಸಿದ್ಧ ಬಾಟ್ ಏಜೆಂಟ್‌ಗಳು

ನೀವು ಬಾಟ್ ಬರೆಯಲು ಬಯಸದಿದ್ದರೆ, ಎರಡು ಏಜೆಂಟ್‌ಗಳು Discord ಮತ್ತು Telegram ನಲ್ಲಿ ಉತ್ತರಿಸಬಹುದು ಮತ್ತು FreeLLMAPI ಅನ್ನು ತಮ್ಮ ಮಾಡೆಲ್ ಆಗಿ ಬಳಸಬಹುದು. ಪ್ರತಿಯೊಂದಕ್ಕೂ FreeLLMAPI ಸೆಟಪ್ ಆಜ್ಞೆ ಇದೆ. ಪ್ರತಿ ಆಜ್ಞೆ --dry-run ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ ಮತ್ತು ಮೊದಲು ಕಾನ್ಫಿಗರೇಶನ್‌ನ ಬ್ಯಾಕಪ್ ಮಾಡುತ್ತದೆ.

ಏಜೆಂಟ್ಸೆಟಪ್ ಆಜ್ಞೆಅದು ಏನು ಬರೆಯುತ್ತದೆ
OpenClawnpx freellmapi setup-openclaw --url http://localhost:3001 --api-key <unified-key>freellmapi ಪ್ರೊವೈಡರ್ ~/.openclaw/openclaw.json ನಲ್ಲಿ, ಡೀಫಾಲ್ಟ್ ಮಾಡೆಲ್ freellmapi/auto
Hermes Agentnpx freellmapi setup-hermes --url http://localhost:3001 --api-key <unified-key>~/.hermes/config.yaml ನಲ್ಲಿ ಕಸ್ಟಮ್ ಮಾಡೆಲ್ ಬ್ಲಾಕ್

ಚಾಲನೆಯಲ್ಲಿರುವ OpenClaw ಅಥವಾ Hermes ಗೇಟ್‌ವೇಗೆ ಸೆಟಪ್ ಆಜ್ಞೆಯ ನಂತರ ಮರುಪ್ರಾರಂಭ ಬೇಕು.

ಬಾಟ್ ಮತ್ತು FreeLLMAPI ಅನ್ನು ಒಂದೇ ಕಂಪ್ಯೂಟರ್ ಅಥವಾ ಸರ್ವರ್‌ನಲ್ಲಿ ಚಲಾಯಿಸಿ. ಆಗ ಬಾಟ್ localhost ನಲ್ಲಿ ಗೇಟ್‌ವೇ ತಲುಪುತ್ತದೆ, ಮತ್ತು ಗೇಟ್‌ವೇ ಪೋರ್ಟ್ ಇಂಟರ್ನೆಟ್‌ಗೆ ಮುಚ್ಚಿರುತ್ತದೆ. ಚಿಕ್ಕ ಸರ್ವರ್ ಅಥವಾ Raspberry Pi ಎರಡಕ್ಕೂ ಸಾಕು.

ದೋಷ ನಿವಾರಣೆ

ಸಮಸ್ಯೆಕಾರಣಪರಿಹಾರ
Discord ಬಾಟ್ ಖಾಲಿ ಸಂದೇಶಗಳನ್ನು ಓದುತ್ತದೆMessage Content ಉದ್ದೇಶ ಆಫ್ ಆಗಿದೆಪೋರ್ಟಲ್‌ನಲ್ಲಿ ಮತ್ತು intents.message_content ನಲ್ಲಿ ಅದನ್ನು ಆನ್ ಮಾಡಿ
ಬಾಟ್ ತನ್ನದೇ ಸಂದೇಶಗಳಿಗೆ ಉತ್ತರಿಸುತ್ತದೆಬಾಟ್ ಲೇಖಕರಿಗಾಗಿ ಯಾವುದೇ ಪರಿಶೀಲನೆ ಇಲ್ಲmessage.author.bot ಸತ್ಯವಾದಾಗ ಹಿಂತಿರುಗಿ
ದೀರ್ಘ ಉತ್ತರಗಳಲ್ಲಿ Discord ದೋಷ 50035ಸಂದೇಶ 2000 ಅಕ್ಷರಗಳಿಗಿಂತ ಉದ್ದವಾಗಿದೆಮೇಲಿನ ಕೋಡ್‌ನಲ್ಲಿರುವಂತೆ ಉತ್ತರವನ್ನು ವಿಭಜಿಸಿ
ಸಂಜೆ "All free models are busy"ಸರಣಿಯ ಎಲ್ಲಾ ಕೀಗಳು ತಮ್ಮ ದೈನಂದಿನ ಮಿತಿಯಲ್ಲಿವೆಇನ್ನಷ್ಟು ಪ್ರೊವೈಡರ್‌ಗಳ ಕೀಗಳನ್ನು ಸೇರಿಸಿ. ಅನೇಕ ದೈನಂದಿನ ಮಿತಿಗಳು UTC ಮಧ್ಯರಾತ್ರಿಗೆ ಮರುಹೊಂದುತ್ತವೆ.
ನಿಧಾನ ಉತ್ತರಗಳುನಿಧಾನ ಮಾಡೆಲ್ ಅಥವಾ ದೀರ್ಘ ಇತಿಹಾಸauto:fast ಬಳಸಿ ಮತ್ತು 10 ಅಥವಾ ಕಡಿಮೆ ಸಂದೇಶಗಳನ್ನು ಇರಿಸಿ
ಬಾಟ್‌ನಿಂದ Connection refusedಬಾಟ್ Docker ನಲ್ಲಿ ಚಲಿಸುತ್ತದೆ ಮತ್ತು localhost ಬಳಸುತ್ತದೆhost.docker.internal ಬಳಸಿ, ಅಥವಾ ಹಂಚಿದ Docker ನೆಟ್‌ವರ್ಕ್ ಬಳಸಿ
ಇವೆಲ್ಲವನ್ನೂ ಒಂದೇ ಕೀ ಮೂಲಕ ಬಳಸಿ. FreeLLMAPI ಒಂದು ಮುಕ್ತ ಮೂಲದ, ಸ್ವಯಂ-ಹೋಸ್ಟ್ ಮಾಡಿದ ರೂಟರ್ ಆಗಿದೆ. ಇದು ಈ ಎಲ್ಲಾ ಉಚಿತ ಶ್ರೇಣಿಗಳನ್ನು ಒಂದೇ OpenAI-ಹೊಂದಾಣಿಕೆಯ ಎಂಡ್‌ಪಾಯಿಂಟ್ ಹಿಂದೆ ಇಡುತ್ತದೆ ಮತ್ತು ಒಂದು ಮಿತಿಗೆ ಒಳಪಟ್ಟಾಗ ಬದಲಾಯಿಸುತ್ತದೆ. ಕ್ಯಾಟಲಾಗ್ ನೋಡಿ ಅಥವಾ ಲೈವ್ ಆಗಿ.

ಪದೇ ಪದೇ ಕೇಳುವ ಪ್ರಶ್ನೆಗಳು

ಡಿಸ್ಕಾರ್ಡ್ ಬಾಟ್‌ಗೆ ಉಚಿತ AI API ಇದೆಯೇ?

ಹೌದು. ಹಲವು ಪ್ರೊವೈಡರ್‌ಗಳು openai Python ಪ್ಯಾಕೇಜ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಉಚಿತ ಶ್ರೇಣಿಗಳನ್ನು ಹೊಂದಿವೆ. FreeLLMAPI ಅವುಗಳನ್ನು ಒಂದೇ ಕೀ ಹಿಂದೆ ಸೇರಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಬಿಜಿ ಬಾಟ್ ಅನೇಕ ಪ್ರೊವೈಡರ್‌ಗಳ ಮಿತಿಗಳನ್ನು ಬಳಸಬಹುದು.

ಉಚಿತ AI Telegram ಬಾಟ್ ಮಾಡಬಹುದೇ?

ಹೌದು. ಬಾಟ್‌ಗೆ python-telegram-bot ಮತ್ತು ಉತ್ತರಗಳಿಗೆ OpenAI-ಹೊಂದಾಣಿಕೆಯ ಉಚಿತ API ಬಳಸಿ. ಈ ಪುಟದ ಕೋಡ್ ಸಂಪೂರ್ಣವಾಗಿದೆ.

ನನ್ನ AI ಬಾಟ್ ರೇಟ್ ಮಿತಿಗಳನ್ನು ತಲುಪುವುದನ್ನು ಹೇಗೆ ತಡೆಯುವುದು?

ಕೇವಲ ಉಲ್ಲೇಖಗಳು ಅಥವಾ ಆಜ್ಞೆಗಳಿಗೆ ಉತ್ತರಿಸಿ, ಪ್ರತಿ ಕೆಲವು ಸೆಕೆಂಡ್‌ಗಳಿಗೆ ಪ್ರತಿ ಬಳಕೆದಾರರಿಗೆ ಒಂದು ವಿನಂತಿಗೆ ಮಿತಿಗೊಳಿಸಿ, ಇತಿಹಾಸವನ್ನು ಚಿಕ್ಕದಾಗಿ ಇರಿಸಿ ಮತ್ತು ಇನ್ನಷ್ಟು ಪ್ರೊವೈಡರ್‌ಗಳ ಕೀಗಳನ್ನು ಸೇರಿಸಿ.

ನನ್ನ Discord ಬಾಟ್‌ಗೆ ಖಾಲಿ ಸಂದೇಶ ವಿಷಯ ಏಕೆ ಸಿಗುತ್ತದೆ?

Message Content ಉದ್ದೇಶ ಆಫ್ ಆಗಿದೆ. ಬಾಟ್ ಟ್ಯಾಬ್‌ನಲ್ಲಿ Developer Portal ನಲ್ಲಿ ಅದನ್ನು ಆನ್ ಮಾಡಿ, ಮತ್ತು ಕೋಡ್‌ನಲ್ಲಿ intents.message_content = True ಹೊಂದಿಸಿ.

ಎಲ್ಲಾ ಉಚಿತ ಮಾಡೆಲ್‌ಗಳು ತಮ್ಮ ಮಿತಿಯಲ್ಲಿದ್ದಾಗ ಏನಾಗುತ್ತದೆ?

FreeLLMAPI Retry-After ಹೆಡರ್‌ನೊಂದಿಗೆ ದೋಷ 429 ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಬಾಟ್ ಕೋಡ್ ಅದನ್ನು ಹಿಡಿಯುತ್ತದೆ ಮತ್ತು ಬಳಕೆದಾರರಿಗೆ ನಂತರ ಮತ್ತೆ ಪ್ರಯತ್ನಿಸಲು ಹೇಳುತ್ತದೆ.

ಸಂಬಂಧಿತ ಮಾರ್ಗದರ್ಶಿಗಳು

ಮೂಲಗಳು

ಎಲ್ಲಾ ಮಾರ್ಗದರ್ಶಿಗಳು · ಎಲ್ಲಾ ಉಚಿತ ಮಾದರಿಗಳನ್ನು ನೋಡಿ