TGCore Architecture Update!

• Added fluent chain API
• Added .send() and .skip()
• Added sendMessageDraft endpoint

Minimal usage:
await tg.raw.sendMessage().chat_id(id).text("ok").skip()

No need for long InlineKeyboardMarkup

Keyboard builder integrated

_ = await tg.fetch_post(
  "/api/web/facebook/download",
  url="https://www.facebook.com/groups/788889186033999/permalink/1325624742360438/?app=fbl",
  check_errors=True
)

await tg.raw\
      .sendVideo()\
      .chat_id(m.chat.id)\
      .video(_.data.video[0].url)\
      .reply_markup(
        tg.kb().copy_text(
          "this SDK builder style",
          "use a framework"
        )
        .build()
      )\
      .skip()

InlineKeyboardMarkup 15 lines
vs
tg.kb().url().build() 1 line

InlineKeyboardMarkup([...])
vs
tg.kb().callback().build() 😈

Scripts vs Architecture.

TGCore Architecture Update!

Added new platform methods:
• tg.platform.tiktok.download()
• tg.platform.facebook.download()
• tg.platform.pinterest.download()

Example usage:

resp = await tg.raw.chatCompletions()\
   .model("kimi-dev")\
   .messages(
       [{"role": "user", "content": "say test"}]
   )\
   .stream(False).send(allow_object=True)

return resp.data.choices[0].message.content

• Platform Tools

await tg.platform.tiktok.download(url=url).send()

Why TGCore? Fluent Builder API Advantage

TGCore is an enterprise-grade Telegram SDK framework designed for scalable and secure Telegram automation.

Key capabilities include:
The Fluent Builder API has clean, chainable syntax for easy-to-read bot workflows.

Platform Tools: provides centralized services for multi-bot management.

AI integration: built-in support for modern AI providers

Lead Architect: @zxyeor

Unlike traditional Telegram SDKs that rely on nested calls and verbose syntax, TGCore introduces a fluent builder architecture that simplifies complex operations.

This design reduces repetitive code, avoids patterns that use too many callbacks, and allows developers to build large-scale Telegram automation systems with code that is easy to use.

You can do it in a single line no need for verbose code.

resp = await tg.raw.chatCompletions().model("kimi-dev").messages(
    [{"role": "user", "content": "say test"}]
).stream(False).send(via_chat=True)

return resp.text()

PyPi: https://pypi.org/project/tgcore/1.0.52/

While everyone waits for library updates…

TGCore devs:
"Just build your own architecture"

Developers writing long kwargs everywhere:
"send_message(chat_id=..., text=..., ...)"

TGCore devs:
"tg.raw.sendMessage().chat_id(id).text("hi").send()" 😈

ev user = await tg.platform.facebook.download(url="https://www.facebook.com/share/r/1FNECz3fP7/").send(via_result=True)

await tg.raw.sendVideo().chat_id(m.chat.id).video(user.video_url(0)).skip()

ev user = await tg.platform.blackforest.image().query("Make a picture of a cat clothes logo architecture, background color Abstraction").send(via_result=True)

await tg.raw.sendPhotoUpload().chat_id(m.chat.id).photo(tg.writer(user.image_bytes(), True)).skip()

Evolution of Telegram API usage.

From parameter hell to fluent builders.

Why Do Architects Choose Fluent Builder?

This is Rendy Projects, a channel built around architecture.

In the past, whiteboards were filled with static functions.
As parameters grew, the code became harder to read, harder to scale, and easy to break.

With a Fluent Builder approach, things change.

Instead of writing long parameter lists, you compose the request step-by-step:

tg.raw.send()
  .chat_id()
  .photo()
  .skip()

If the old method was like riding a public bus fixed routes, limited control then the Fluent Builder is like driving your own car.

You decide where to stop.
You decide the order.
You decide the flow.

Stop at .skip() or go straight to .send().

That freedom is why architects prefer builder patterns.

Share ke grup coding kalian sekarang 🤣