Uncensored Endpoint Telegram Bot: Bouw hem in Python
Om een ongecensureerde endpoint telegram bot te bouwen heb je drie dingen nodig: een bot token van BotFather, een API-sleutel en ongeveer 80 regels Python die elk Telegram bericht naar de chat completions route sturen. Deze walkthrough geeft de volledige code, voegt daarna geheugen, streaming en limietafhandeling toe.
Belangrijkste punten
- De bot gebruikt python-telegram-bot voor Telegram en de standaard OpenAI SDK voor het model.
- Houd een korte geschiedenis per chat bij en knip deze zodat elk verzoek klein en goedkoop blijft.
- Stream door één bericht ongeveer één keer per seconde te bewerken, niet op elke token.
- Beperk gelijktijdige modelverzoeken tot 8 met een semaphore en probeer 429-responses opnieuw.

Wat je bouwt
De bot heeft één taak: een tekstbericht van een Telegramchat opnemen, toevoegen aan de geschiedenis van die chat, de geschiedenis naar het model uncensored sturen en het antwoord terugplaatsen. Elke Telegramchat krijgt zijn eigen geheugen, dus twee mensen die tegen de bot praten zien nooit de context van de ander.
Het complete project is een enkel bestand met deze onderdelen:
- Een client voor de API, met de OpenAI SDK die wijst naar
https://api.uncensoredendpoint.com/v1. - Een woordenboek van chatgeschiedenissen, bijgesneden zodat het niet oneindig groeit.
- Een message handler die het antwoord streamt door één Telegram bericht te bewerken.
- Een semaphore die je onder de 8 gelijktijdige verzoeken houdt die een volledige sleutel toestaat.
Niets hier vereist een database. Wanneer de bot herstart, worden de geschiedenissen gereset, wat prima is voor een eerste versie. Een later deel behandelt waar je persistentie kunt toevoegen.
Vereisten
Je hebt Python 3.10 of nieuwer en twee credentials nodig.
- Een Telegram bot token. Open een chat met BotFather binnen Telegram, stuur het commando om een nieuwe bot te maken, kies een naam en een gebruikersnaam, en kopieer het token dat hij teruggeeft. Behandel het token als een wachtwoord.
- Een API-sleutel. Meld je aan op de sleutelpagina met Google of met e-mail en wachtwoord. Nieuwe gebruikers kunnen $0,50 aan proeftegoed claimen met één klik, wat genoeg is om deze bot vele keren te testen. De trial sleutel staat 2 gelijktijdige verzoeken en 60 verzoeken per minuut toe.
Installeer de twee bibliotheken en exporteer de secrets als omgevingsvariabelen zodat ze nooit in je broncode terechtkomen:
pip install "python-telegram-bot>=20" openai
export TELEGRAM_TOKEN="123456:your-bot-token"
export API_KEY="your-api-key"
Als je later van de trial naar echt verkeer gaat, komt tegoed van een top-up van $20 tot $500, hetzij met crypto (USDT op TRC20 of USDC op Base). De prijspagina vermeldt de bonus tiers.
Een minimale werkende bot
Begin met de kleinste versie die berichten beantwoordt. Deze heeft nog geen streaming en geen trimming, zodat je eerst de bedrading kunt controleren.
import os
from collections import defaultdict
from openai import AsyncOpenAI
from telegram import Update
from telegram.ext import ApplicationBuilder, ContextTypes, MessageHandler, filters
client = AsyncOpenAI(
base_url="https://api.uncensoredendpoint.com/v1",
api_key=os.environ["API_KEY"],
max_retries=3,
)
SYSTEM = "You are a friendly, direct assistant. Keep answers short unless asked for detail."
history = defaultdict(list) # chat_id -> list of messages
async def on_text(update: Update, context: ContextTypes.DEFAULT_TYPE):
chat_id = update.effective_chat.id
history[chat_id].append({"role": "user", "content": update.message.text})
resp = await client.chat.completions.create(
model="uncensored",
messages=[{"role": "system", "content": SYSTEM}] + history[chat_id],
temperature=0.8,
)
answer = resp.choices[0].message.content
history[chat_id].append({"role": "assistant", "content": answer})
await update.message.reply_text(answer[:4000])
app = ApplicationBuilder().token(os.environ["TELEGRAM_TOKEN"]).build()
app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, on_text))
app.run_polling()
Voer het uit, open je bot in Telegram en zeg hallo. De slice answer[:4000] bestaat omdat Telegram een enkel bericht beperkt tot 4096 tekens. Een lang modelantwoord zou anders de aanroep voor het verzenden laten falen. Later kun je lange antwoorden in meerdere berichten splitsen in plaats van ze af te snijden.
De OpenAI SDK probeert sommige fouten automatisch opnieuw, waaronder 429-antwoorden, met een korte wachttijd. Het instellen van max_retries=3 geeft je wat marge zonder dat je een retry-loop hoeft te schrijven.
Geheugen dat niet oneindig groeit
Chat completions zijn stateless. Het model weet alleen wat je in elk verzoek stuurt, dus de bot stuurt de geschiedenis elke beurt opnieuw. Dat is waarom onbeperkte geschiedenis de grootste kosten- en latentieval is. Het contextvenster is 100.000 tokens, wat veel is, maar je betaalt voor elke input token op elke beurt, en de meeste chatbots hebben daar lang niet zoveel voor nodig.
Een eenvoudig beleid werkt goed: bewaar de systeemprompt en bewaar alleen de laatste N berichten. Twintig berichten, tien van de gebruiker en tien van de bot, zijn geschikt voor een casual chat.
MAX_MESSAGES = 20
def remember(chat_id, role, content):
h = history[chat_id]
h.append({"role": role, "content": content})
if len(h) > MAX_MESSAGES:
del h[: len(h) - MAX_MESSAGES]
Knippen op een willekeurig punt kan een geschiedenis achterlaten die begint met een bericht van de assistent. Dat is onschuldig voor dit model, maar als je het netjes wilt houden, verwijder je één bericht extra als het eerste resterende bericht niet van de gebruiker komt.
Voor karakters of lange verhalen waarbij het model feiten van vroeg in de geschiedenis moet onthouden, gaat trimming ze kwijt. Twee veelgebruikte oplossingen zijn een vastgeplakt bericht en een lopende samenvatting. Een vastgeplakt bericht is een kort blok feiten dat je in de system prompt houdt, zoals namen en de huidige scène. Een lopende samenvatting vraagt het model om, ongeveer om de dertig berichten, de oudere helft van de geschiedenis samen te vatten tot een alinea, die je dan opslaat ter vervanging van die berichten.
Voeg een /reset commando toe dat history[chat_id] wist. Mensen houden ervan om een schone lei te hebben, en het kost je niets.
Het antwoord streamen door één bericht te bewerken
Tien seconden wachten op een lang antwoord voelt traag aan in een chat-app. Streaming laat het antwoord op het scherm groeien. Telegram accepteert geen berichten token voor token, dus de truc is een tijdelijke placeholder versturen en deze bewerken naarmate tekst aankomt. Bewerk maximaal één keer per seconde. Telegram past eigen flood-limits toe op bots, en het overbelasten van de bewerk-oproep bij elke token zorgt voor throttling en vertraagt de stream.
import time
async def stream_answer(update, chat_id):
msg = await update.message.reply_text("...")
stream = await client.chat.completions.create(
model="uncensored",
messages=[{"role": "system", "content": SYSTEM}] + history[chat_id],
stream=True,
)
text, last_edit = "", 0.0
async for chunk in stream:
if not chunk.choices:
continue
piece = chunk.choices[0].delta.content or ""
text += piece
if time.monotonic() - last_edit > 1.0 and text.strip():
await msg.edit_text(text[:4000])
last_edit = time.monotonic()
if text.strip():
await msg.edit_text(text[:4000])
return text
Twee details zijn belangrijk. Voer eerst altijd een laatste bewerking uit na de lus, omdat de laatste chunks meestal aankomen tussen de tijdgestuurde bewerkingen. Ten tweede wijst Telegram een bewerking af die de tekst niet wijzigt, dus sla de oproep over als er niets nieuws is. De bibliotheek gooit een fout voor dit geval, en een try/except om de bewerking houdt de stream in leven.
Onthoud dat een gestreamd verzoek zijn concurrentieslot vasthoudt tot de stream eindigt. Een bot met veel chats die tegelijk praten, raakt eerder de limiet met streaming dan zonder, wat leidt tot de volgende sectie.
Binnen de rate limits blijven
Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 verzoeken per minuut toe. Een trial sleutel staat 2 en 60 toe. Een drukke groepschat kan snel meer dan 2 tegelijk overschrijden, dus pas je limiet aan aan de sleutel die je gebruikt.
De schoonste beveiliging is een semaphore rond de modelaanroep. Verzoeken die de limiet overschrijden, wachten in de rij binnen je proces in plaats van tegen de API aan te botsen:
import asyncio
slots = asyncio.Semaphore(8) # use 2 with a trial key
async def on_text(update, context):
chat_id = update.effective_chat.id
remember(chat_id, "user", update.message.text)
async with slots:
text = await stream_answer(update, chat_id)
remember(chat_id, "assistant", text)
Als je nog steeds een HTTP 429 krijgt, lees dan de foutcode. concurrency betekent te veel oproepen tegelijk, rate_limited betekent te veel per minuut, en een 429 met Retry-After: 5 betekent tijdelijke overbelasting; wacht de vijf seconden af. De SDK retry behandelt de meeste van deze gevallen. Mislukte of geweigerde verzoeken worden niet in rekening gebracht, dus retries verhogen de rekening niet.
Een extra beveiligingsmaatregel is per-gebruiker pacing. Als één persoon tien berichten in tien seconden stuurt, serialiseer dan hun verzoeken met een lock per chat, zodat antwoorden in volgorde aankomen en één chat niet alle acht slots gebruikt.
Persona, regels en groepschats
De systeemprompt is waar de bot zijn karakter krijgt. Schrijf het als een kort briefje: wie de bot is, hoe hij spreekt, hoe lang antwoorden moeten zijn en alles wat hij niet moet doen. Voor een rollenspel of metgezelbot voor volwassenen, beschrijf de omgeving en toon in een paar regels en laat de gebruiker daar vanaf sturen. Specifieke prompts zijn beter dan lange; het model volgt een duidelijke vijfregelige persoonlijkheid beter dan een pagina aan regels.
Sommige regels zitten buiten de prompt. Het model antwoordt zonder inhoudelijke weigeringen voor wettelijk volwassen gebruik, maar seksuele inhoud met minderjarigen is nooit toegestaan, en je moet dat ook aan je eigen kant afdwingen. Als je bot open is voor het publiek, zeg dat dan in zijn beschrijving, voeg een leeftijdsmelding toe in het startbericht en onthoud dat Telegram zijn eigen voorwaarden heeft voor bots die je ook moet volgen. De gesprekken van je gebruikers gaan naar de API en prompts worden niet gebruikt voor training; vertel je gebruikers wat je eigen bot opslaat.
In groepschats niet elk bericht beantwoorden. Reageer alleen wanneer de bot wordt vermeld of wanneer iemand antwoordt op een van zijn berichten, en negeer berichten die door andere bots zijn gestuurd. In python-telegram-bot kun je update.message.entities controleren op een vermelding of update.message.reply_to_message.from_user.id vergelijken met de eigen ID van de bot.
Als er iets misgaat, log dan de X-Request-Id antwoordkop voor elke aanroep; je kunt deze lezen via de interface voor ruwe respons van de SDK. De ondersteuningspagina is de plek om te vragen over een specifiek verzoek.
In de praktijk gebruiken
Polling, zoals hierboven gebruikt, is prima voor een kleine bot: het proces vraagt Telegram in een lus naar nieuwe berichten en heeft geen publiek adres nodig. Draai het onder systemd of een container met automatische herstart, en bewaar de twee secrets in de environment van het unit-bestand of een secrets store. Een webhook-setup verlaagt de idle load, maar vereist HTTPS en een publieke URL, dus begin met polling.
Schat de kosten voordat je mensen uitnodigt. De API rekent $0,15 per 1M input tokens en $0,50 per 1M output tokens. Een typische beurt met een bijgesneden geschiedenis van 2.000 input tokens en 500 output tokens kost 2.000 x $0,15 / 1M = $0,0003 voor input plus 500 x $0,50 / 1M = $0,00025 voor output, wat $0,00055 is. Duizend beurten kosten $0,55. Als een chat groeit naar 10.000 input tokens per beurt, wordt het input deel alleen al $0,0015, dus trimming betaalt zichzelf snel terug.
Als je persistentie nodig hebt, sla dan de geschiedenis van elke chat op als JSON in SQLite of Redis, laad deze bij het eerste bericht na een herstart en schrijf hem terug na elk antwoord. Voeg een per-gebruiker dagelijkse berichtlimiet toe als de bot publiek is, zodat één enthousiaste gebruiker het saldo niet kan leegspelen. De API-documentatie vermeldt elke parameter die je kunt aanpassen, en de key-productiechecklist behandelt het draaien van sleutels en het bewaken van de balanskop.
Meer handleidingen
Vragen en antwoorden
Welke bibliotheek moet ik gebruiken voor de Telegram-kant?
Elke bibliotheek werkt omdat de modelkant een gewone HTTP-API is. Deze gids gebruikt python-telegram-bot versie 20 of nieuwer, wat asynchroon is en goed werkt met de async OpenAI-client.
Waarom reageert mijn bot op zichzelf of op iedereen in een groep?
Beperk in groepen de handler tot berichten die de bot noemen of erop antwoorden, en negeer berichten van bots. Anders wordt bij elk bericht in de groep een modelaanroep uitgevoerd.
Hoeveel kost een botgesprek?
Een korte uitwisseling van 2.000 invoertokens en 500 uitvoertokens kost $0,00055, dus duizend daarvan kosten $0,55. Lange gesprekken kosten meer omdat ze elke beurt opnieuw worden verstuurd.
Kan de bot worden gebruikt voor volwassen rollenspel?
Het model is afgestemd op het geven van antwoorden zonder inhoudelijke weigeringen voor wettelijk volwassen gebruik, en bots voor fictie en companion chat zijn een typisch geval. Seksuele inhoud die minderjarigen betrekt is nooit toegestaan, en Telegram heeft eigen regels die je moet volgen.
Je sleutel is nog maar één formulier verwijderd
Maak een account aan, kopieer de sleutel, pas de base URL aan. Dat is de hele setup.