บอท Telegram ของ Uncensored Endpoint: สร้างด้วย Python
การสร้างบอท Telegram สำหรับเอนด์พอยต์ที่ไม่เซ็นเซอร์ต้องมีสามส่วน: โทเคนบอทจาก BotFather คีย์ API และโค้ด Python ยาวประมาณ 80 บรรทัดที่ส่งข้อความ Telegram แต่ละข้อความไปยังเส้นทาง chat completions การแนะนำขั้นตอนนี้ให้โค้ดเต็มรูปแบบ จากนั้นเพิ่มหน่วยความจำ การสตรีมมิง และการจัดการขีดจำกัด
ประเด็นสำคัญ
- บอทใช้ python-telegram-bot สำหรับ Telegram และ OpenAI SDK มาตรฐานสำหรับโมเดล
- เก็บประวัติสั้นๆ ต่อแชทและตัดส่วนเกินออกเพื่อให้ทุกคำขอมีขนาดเล็กและประหยัด
- สตรีมมิงโดยการแก้ไขข้อความหนึ่งข้อความประมาณครั้งละหนึ่งวินาที ไม่ใช่ทุกโทเคน
- จำกัดการเรียกโมเดลแบบขนานไว้ที่ 8 ด้วย semaphore และลองใหม่เมื่อได้รับสถานะ 429

สิ่งที่คุณกำลังสร้าง
บอทมีหน้าที่เดียว: รับข้อความจากแชท Telegram เพิ่มลงในประวัติแชทนั้น ส่งประวัติไปยังโมเดล uncensored และโพสต์คำตอบกลับ แต่ละแชท Telegram มีหน่วยความจำของตัวเอง ดังนั้นผู้ใช้สองคนที่คุยกับบอทจะไม่เห็นบริบทของกันและกัน
โปรเจกต์ที่เสร็จสมบูรณ์คือไฟล์เดียวที่มีส่วนประกอบเหล่านี้:
- ไคลเอนต์สำหรับ API โดยใช้ OpenAI SDK ที่ชี้ไปที่
https://api.uncensoredendpoint.com/v1 - พจนานุกรมของประวัติแชท ซึ่งตัดส่วนเกินออกเพื่อไม่ให้ขยายเกินขีดจำกัด
- ตัวจัดการข้อความที่สตรีมคำตอบโดยการแก้ไขข้อความ Telegram ข้อความเดียว
- เซมาโฟร์ที่ควบคุมคุณให้อยู่ภายใต้คำขอพร้อมกัน 8 คำขอที่คีย์แบบเต็มอนุญาตให้ทำได้
ไม่มีส่วนใดที่นี่ที่ต้องใช้ฐานข้อมูล เมื่อบอทรีสตาร์ท ประวัติจะรีเซ็ต ซึ่งเพียงพอสำหรับเวอร์ชันแรก ส่วนถัดไปจะครอบคลุมวิธีการเพิ่มการบันทึกข้อมูลถาวร
ข้อกำหนดเบื้องต้น
คุณต้องการ Python 3.10 ขึ้นไปและข้อมูลรับรองสองรายการ
- โทเคนบอท Telegram เปิดแชทกับ BotFather ภายใน Telegram ส่งคำสั่งเพื่อสร้างบอทใหม่ เลือกชื่อและชื่อผู้ใช้ แล้วคัดลอกโทเคนที่มันส่งกลับมา ถือว่าโทเคนนี้เหมือนรหัสผ่าน
- คีย์ API ลงทะเบียนใน หน้าคีย์ ด้วย Google หรือด้วยอีเมลและรหัสผ่าน ผู้ใช้ใหม่สามารถขอเครดิตทดลองใช้ $0.50 ได้ด้วยการคลิกหนึ่งครั้ง ซึ่งเพียงพอสำหรับการทดสอบบอทนี้หลายครั้ง คีย์ทดลองอนุญาตให้ทำคำขอพร้อมกัน 2 คำขอและ 60 คำขอต่อนาที
ติดตั้งไลบรารีทั้งสองและส่งออกตัวแปรสภาพแวดล้อมเพื่อให้ข้อมูลลับไม่ตกอยู่ในโค้ดแหล่งที่มาของคุณ:
pip install "python-telegram-bot>=20" openai
export TELEGRAM_TOKEN="123456:your-bot-token"
export API_KEY="your-api-key"
หากคุณเปลี่ยนจากการทดลองเป็นการใช้งานจริง เครดิตมาจากการเติมเงินมูลค่า $20 ถึง $500 โดยชำระด้วยUSDT บน TRC20 หรือ USDC บน Base หน้าราคา แสดงระดับโบนัส
บอทที่ทำงานได้อย่างน้อยที่สุด
เริ่มจากเวอร์ชันที่เล็กที่สุดที่ตอบข้อความได้ ยังไม่มีสตรีมมิงและการตัดข้อความ ดังนั้นคุณจึงสามารถตรวจสอบการเชื่อมต่อพื้นฐานก่อน
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()
รันมัน เปิดบอทของคุณใน Telegram แล้วทักทาย ชิ้นส่วน answer[:4000] มีอยู่เพราะ Telegram จำกัดข้อความเดียวไว้ที่ 4096 ตัวอักษร คำตอบยาวจากโมเดลจะทำให้การเรียกใช้ล้มเหลว ในภายหลังคุณสามารถแบ่งคำตอบยาวออกเป็นหลายข้อความแทนที่จะตัดทิ้ง
OpenAI SDK จะลองเรียกใหม่สำหรับข้อผิดพลาดบางรายการโดยอัตโนมัติ รวมถึงการตอบกลับ 429 พร้อมการหน่วงเวลาสั้นๆ การตั้งค่า max_retries=3 ให้พื้นที่ปลอดภัยเล็กน้อยโดยไม่ต้องเขียนลูปเรียกซ้ำในตอนนี้
หน่วยความจำที่ไม่ขยายตลอดไป
การเติมเต็มแชทเป็นแบบไม่มีสถานะ โมเดลจะรู้เฉพาะสิ่งที่คุณส่งในคำขอแต่ละครั้ง ดังนั้นบอทจึงส่งประวัติใหม่ในทุกเทิร์น นั่นเป็นสาเหตุที่ประวัติแบบไม่มีขอบเขตเป็นกับดักด้านต้นทุนและความล่าช้าหลัก หน้าต่างบริบทมีขนาด 100,000 โทเคน ซึ่งมาก แต่คุณต้องจ่ายสำหรับทุกโทเคนอินพุตในทุกเทิร์น และบอทแชทส่วนใหญ่ไม่ต้องการมากขนาดนั้นเลย
นโยบายแบบง่ายทำงานได้ดี: เก็บพรอมต์ระบบ และเก็บเฉพาะข้อความ N ล่าสุด ข้อความยี่สิบข้อความ สิบข้อความจากผู้ใช้และสิบข้อความจากบอท เหมาะสำหรับการแชททั่วไป
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]
การตัดที่จุดสุ่มอาจทำให้ประวัติเริ่มต้นด้วยข้อความของผู้ช่วย ซึ่งไม่เป็นอันตรายสำหรับโมเดลนี้ แต่หากคุณต้องการให้เรียบร้อย ให้ลบข้อความอีกหนึ่งข้อความเมื่อข้อความที่เหลืออยู่แรกสุดไม่ได้มาจากผู้ใช้
สำหรับตัวละครหรือเรื่องยาวที่โมเดลต้องจำข้อเท็จจริงจากช่วงต้น การตัดข้อความจะทำให้สูญเสียสิ่งเหล่านั้น วิธีแก้ไขทั่วไปสองอย่างคือบันทึกที่ตรึงไว้และสรุปแบบหมุนเวียน บันทึกที่ตรึงไว้คือบล็อกข้อเท็จจริงสั้นๆ ที่คุณเก็บไว้ในพรอมต์ระบบ เช่น ชื่อและฉากปัจจุบัน การสรุปแบบหมุนเวียนจะถามโมเดลทุกสามสิบข้อความหรือประมาณนั้น ให้บีบอัดครึ่งหนึ่งของประวัติที่เก่ากว่าลงในย่อหน้า ซึ่งคุณจะเก็บไว้ในที่แทนข้อความเหล่านั้น
เพิ่มคำสั่ง /reset ที่ล้าง history[chat_id] คนชอบมีพื้นที่เริ่มต้นที่สะอาด และมันไม่เสียค่าใช้จ่ายสำหรับคุณ
สตรีมมิงการตอบกลับโดยการแก้ไขข้อความเดียว
การรอสิบวินาทีสำหรับคำตอบที่ยาวรู้สึกช้าในแอปแชท การสตรีมมิงทำให้การตอบกลับเติบโตบนหน้าจอ Telegram ไม่ยอมรับโทเคนข้อความทีละโทเคน ดังนั้นเคล็ดลับคือการส่งข้อความชั่วคราว จากนั้นแก้ไขเมื่อข้อความมาถึง แก้ไขประมาณหนึ่งครั้งต่อวินาทีมากที่สุด Telegram ใช้ขีดจำกัดการไหลของตัวเองกับบอท และการเรียกแก้ไขทุกโทเคนจะทำให้คุณถูกจำกัดความเร็วและทำให้สตรีมช้าลง
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
มีสองรายละเอียดที่สำคัญ ประการแรก ควรแก้ไขข้อความสุดท้ายหลังจากจบลูปเสมอ เนื่องจากส่วนสุดท้ายมักมาถึงระหว่างการแก้ไขตามเวลา ประการที่สอง Telegram ปฏิเสธการแก้ไขที่ไม่มีการเปลี่ยนแปลงข้อความ ดังนั้นให้ข้ามการเรียกเมื่อยังไม่มีข้อมูลใหม่ ไลบรารีจะแสดงข้อผิดพลาดสำหรับกรณีนี้ และการใช้ try/except ครอบการแก้ไขจะช่วยรักษาการสตรีมให้ทำงานต่อได้
โปรดจำไว้ว่าการร้องขอแบบสตรีมจะครอบครองช่องคำขอพร้อมกัน (concurrency slot) ไว้จนกว่าการสตรีมจะสิ้นสุด บอทที่มีหลายแชทพูดคุยพร้อมกันจะชนขีดจำกัดได้เร็วกว่าเมื่อใช้สตรีมเมื่อเทียบกับแบบไม่สตรีม ซึ่งนำไปสู่หัวข้อถัดไป
การอยู่ภายในขีดจำกัดอัตรา
คีย์แบบเต็มอนุญาตให้ทำคำขอพร้อมกัน 8 คำขอ และ 300 คำขอต่อนาที ส่วนคีย์แบบทดลองอนุญาตให้ทำคำขอพร้อมกัน 2 คำขอ และ 60 คำขอต่อนาที กลุ่มแชทที่ใช้งานหนักสามารถเกิน 2 คำขอพร้อมกันได้ง่าย ดังนั้นควรปรับขนาดขีดจำกัดให้ตรงกับคีย์ที่คุณใช้งานอยู่
การป้องกันที่สะอาดที่สุดคือการใช้ semaphore ครอบการเรียกโมเดล คำขอที่เกินขีดจำกัดจะรออยู่ในคิวภายในกระบวนการของคุณ แทนที่จะถูกปฏิเสธจาก API:
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)
หากคุณยังคงได้รับ HTTP 429 ให้ตรวจสอบรหัสข้อผิดพลาด concurrency หมายถึงมีการเรียกมากเกินไปในครั้งเดียว rate_limited หมายถึงมีการเรียกมากเกินไปต่อนาที และ 429 พร้อม Retry-After: 5 หมายถึงการโอเวอร์โหลดชั่วคราว; ให้รอห้าวินาที การรีเทรตของ SDK จัดการกรณีเหล่านี้ได้ส่วนใหญ่ คำขอที่ล้มเหลวหรือถูกปฏิเสธจะไม่ถูกเรียกเก็บเงิน ดังนั้นการรีเทรตจึงไม่เพิ่มค่าใช้จ่ายในบิล
การป้องกันอีกอย่างหนึ่งคือการควบคุมจังหวะต่อผู้ใช้ หากบุคคลเดียวส่งข้อความสิบข้อความในสิบวินาที ให้เรียงลำดับคำขอของพวกเขาด้วยล็อกต่อแชท เพื่อให้คำตอบมาถึงตามลำดับ และแชทหนึ่งแชทไม่สามารถใช้ช่องทั้งแปดได้
บุคลิก กฎ และแชทกลุ่ม
พรอมต์ระบบ (system prompt) คือส่วนที่บอทได้รับบุคลิกภาพของมัน เขียนเหมือนคำแนะนำสั้นๆ: บอทคือใคร พูดอย่างไร คำตอบควรยาวแค่ไหน และห้ามทำอะไรบ้าง สำหรับบอทบทบาทสมมติหรือบอทเพื่อนสนทนาสำหรับผู้ใหญ่ ให้บรรยายฉากและโทนเสียงในไม่กี่บรรทัดแล้วปล่อยให้ผู้ใช้เป็นผู้ควบคุมต่อ พรอมต์ที่เฉพาะเจาะจงดีกว่าพรอมต์ที่ยาวนาน; โมเดลปฏิบัติตามบุคลิกห้าบรรทัดที่ชัดเจนได้ดีกว่ากฎหนึ่งหน้า
กฎบางข้ออยู่นอกเหนือพรอมต์ โมเดลจะตอบโดยไม่มีการปฏิเสธเนื้อหาสำหรับการใช้งานผู้ใหญ่ที่ถูกต้องตามกฎหมาย แต่เนื้อหาทางเพศที่เกี่ยวข้องกับผู้เยาว์ (minors) จะไม่อนุญาตเด็ดขาด และคุณควรบังคับใช้นี้ฝั่งของคุณเช่นกัน หากบอทของคุณเปิดให้สาธารณชนเข้าถึง ให้ระบุไว้ในคำอธิบาย เพิ่มประกาศอายุในข้อความเริ่มต้น และจำไว้ว่า Telegram มีข้อกำหนดของตัวเองสำหรับบอทที่คุณต้องปฏิบัติตามเช่นกัน การสนทนาของผู้ใช้ของคุณจะไปที่ API และพรอมต์ไม่ถูกนำไปใช้ในการฝึกโมเดล; แจ้งผู้ใช้ของคุณว่าบอทของคุณเก็บข้อมูลอะไรไว้
ในแชทกลุ่ม อย่าตอบทุกข้อความ ตอบเฉพาะเมื่อมีการกล่าวถึงบอทหรือเมื่อมีคนตอบกลับข้อความหนึ่งของบอท และเพิกเฉยต่อข้อความที่ส่งโดยบอทอื่น ใน python-telegram-bot คุณสามารถตรวจสอบ update.message.entities เพื่อหาการกล่าวถึง หรือเปรียบเทียบ update.message.reply_to_message.from_user.id กับ ID ของบอทเอง
เมื่อเกิดข้อผิดพลาด ให้บันทึกส่วนหัวของคำตอบ X-Request-Id สำหรับการเรียกแต่ละครั้ง คุณสามารถอ่านผ่านอินเทอร์เฟซ raw response ของ SDK ได้ หน้า สนับสนุน คือสถานที่ที่จะถามเกี่ยวกับคำขอเฉพาะ
การรันใช้งานจริง
การดึงข้อมูล ตามที่แสดงไว้ข้างต้นนั้นเหมาะสมสำหรับบอทขนาดเล็ก: กระบวนการจะถาม Telegram เกี่ยวกับข้อความใหม่ในลูปและไม่ต้องใช้ที่อยู่สาธารณะ รันภายใต้ systemd หรือคอนเทนเนอร์ที่มีการรีสตาร์ทอัตโนมัติ และเก็บความลับสองตัวไว้ใน environment ของไฟล์หน่วยหรือที่เก็บความลับ การตั้งค่าเว็บฮุคลดโหลดเมื่อ idle แต่ต้องการ HTTPS และ URL สาธารณะ ดังนั้นให้เริ่มด้วยการดึงข้อมูล
ประมาณการค่าใช้จ่ายก่อนเชิญผู้คน API คิดเงิน $0.15 ต่อ 1M input tokens และ $0.50 ต่อ 1M output tokens การตอบกลับทั่วไปที่มีประวัติที่ตัดแล้ว 2,000 input tokens และ 500 output tokens มีค่าใช้จ่าย 2,000 x $0.15 / 1M = $0.0003 สำหรับ input บวก 500 x $0.50 / 1M = $0.00025 สำหรับ output ซึ่งรวมเป็น $0.00055 การตอบกลับหนึ่งพันครั้งมีค่าใช้จ่าย $0.55 หากแชทเติบโตเป็น 10,000 input tokens ต่อการตอบกลับ ส่วน input เพียงอย่างเดียวกลายเป็น $0.0015 ดังนั้นการตัดส่วนเกินจึงคุ้มค่าอย่างรวดเร็ว
เมื่อคุณต้องการการเก็บถาวร ให้เก็บประวัติแต่ละแชทเป็น JSON ใน SQLite หรือ Redis โหลดเมื่อข้อความแรกหลังจากการรีสตาร์ท และเขียนกลับหลังจากแต่ละการตอบกลับ เพิ่มขีดจำกัดข้อความรายวันต่อผู้ใช้หากบอทเป็นสาธารณะ เพื่อให้ผู้ใช้ที่กระตือรือร้นคนหนึ่งไม่สามารถทำให้ยอดเงินหมดลง เอกสาร API ระบุพารามิเตอร์ทั้งหมดที่คุณสามารถปรับแต่งได้ และ เช็กลิสต์การใช้งานจริงของคีย์ ครอบคลุมการหมุนคีย์และการตรวจสอบส่วนหัวยอดเงิน
คู่มือเพิ่มเติม
ถาม-ตอบ
ควรใช้ไลบรารีใดสำหรับฝั่ง Telegram?
ไลบรารีใดก็ได้ใช้ได้เพราะฝั่งโมเดลเป็น API HTTP ธรรมดา คู่มือนี้ใช้ python-telegram-bot เวอร์ชัน 20 หรือใหม่กว่า ซึ่งทำงานแบบอะซิงโครนัส และเข้ากันได้ดีกับไคลเอนต์ OpenAI แบบ async
ทำไมบอทของฉันถึงตอบกลับตัวเองหรือตอบทุกคนในแชทกลุ่ม?
ในกลุ่ม จำกัด handler สำหรับข้อความที่กล่าวถึงบอทหรือตอบกลับบอท และละเว้นข้อความจากบอท มิฉะนั้นข้อความทุกข้อความในกลุ่มจะกระตุ้นการเรียกโมเดล
การสนทนาของบอทมีค่าใช้จ่ายเท่าไหร่?
การแลกเปลี่ยนสั้นๆ ของ 2,000 input tokens และ 500 output tokens มีค่าใช้จ่าย $0.00055 ดังนั้นหนึ่งพันครั้งมีค่าใช้จ่าย $0.55 ประวัติที่ยาวมีค่าใช้จ่ายมากขึ้นเพราะถูกส่งใหม่ในแต่ละการตอบกลับ
สามารถใช้บอทสำหรับการสวมบทบาทสำหรับผู้ใหญ่ได้หรือไม่?
โมเดลถูกปรับแต่งให้ตอบโดยไม่ปฏิเสธเนื้อหาสำหรับการใช้งานผู้ใหญ่ที่ถูกต้องตามกฎหมาย และบอทสำหรับนิยายและการแชทแบบเพื่อนคู่สนทนาเป็นกรณีทั่วไป เนื้อหาทางเพศที่เกี่ยวข้องกับผู้เยาว์ไม่อนุญาตเด็ดขาด และ Telegram มีกฎของตัวเองที่คุณต้องปฏิบัติตาม
คีย์ของคุณอยู่ห่างแค่อีกขั้นตอนเดียว
สร้างบัญชี คัดลอกคีย์ และเปลี่ยน URL พื้นฐาน นั่นคือการตั้งค่าทั้งหมด