How I Built OmniBot: Discord Activity, Local ruBERT, and Moderation Without a Black Box

Introduction

The landscape of online community management has evolved significantly, but one persistent challenge remains: effective content moderation that balances accuracy, privacy, and real-time performance. In a recent technical deep-dive published on Habr, a developer shared the journey of building OmniBot—a custom Discord bot designed to tackle these exact issues. The project is notable not just for its technical ambition but for its philosophical approach: using a locally hosted ruBERT model for moderation, avoiding reliance on opaque third-party APIs often described as 'black boxes.' This article explores the key insights from that build, examining how the developer combined Discord Activities, a locally deployed natural language processing (NLP) model, and transparent moderation logic to create a tool that prioritizes both community safety and user privacy.

The original article, which serves as the foundation for this analysis, details the practical challenges and solutions encountered during development. It offers a rare, behind-the-scenes look at how a solo developer can leverage modern AI tools without sacrificing control or incurring significant costs. For anyone interested in Discord bot development, applied NLP, or content moderation ethics, the case of OmniBot provides actionable lessons. Let's break down how it was built, the key decisions made, and what the future holds for such systems.

The Core Problem: Moderation as a Black Box

Many existing moderation solutions—whether on Discord, Telegram, or other platforms—rely on external APIs or cloud-based AI services. While these services are powerful, they often operate as 'black boxes': users send data to a remote server and receive a verdict (e.g., 'toxic' or 'safe') without understanding the reasoning behind it. This approach raises several concerns:

• Privacy: All messages are sent to a third party for analysis, potentially exposing sensitive community conversations.
• Latency: Network roundtrips can introduce delays, especially for real-time moderation.
• Cost: API calls accumulate, particularly for high-traffic servers.
• Transparency: It's difficult to audit or customize the model's behavior without access to its inner workings.

OmniBot's developer aimed to solve these issues by running a ruBERT model locally. ruBERT is a Russian-language adaptation of BERT (Bidirectional Encoder Representations from Transformers), a popular NLP model developed by Google. By hosting the model on the same server as the bot, the developer eliminated the need for external API calls, ensuring that all message processing stays within the local environment. This design choice directly addresses privacy and latency concerns while giving the developer full control over the model's fine-tuning and decision-making process.

How OmniBot Was Built: Technical Architecture

The article outlines a multi-component architecture that combines several technologies:

1. Discord Activity Integration: Instead of just a simple bot that reads and responds to messages, OmniBot leverages Discord's Activities feature. This allows users to interact with the bot via embedded apps directly within a voice or text channel. The developer implemented a real-time moderation dashboard that displays model predictions, flagged messages, and user reputation scores—all without leaving Discord.

2. Local ruBERT Deployment: The developer used a pre-trained ruBERT model from the Hugging Face model hub and fine-tuned it on a custom dataset of Russian-language toxic and non-toxic messages. The model was then deployed using ONNX Runtime for optimized inference on CPU, ensuring that it runs efficiently on modest hardware (a single VPS with 4 GB RAM). The inference pipeline processes messages in under 100 milliseconds on average, making it suitable for real-time use.

3. Moderation Pipeline Without a Black Box: The key innovation is the 'moderation without a black box' approach. Instead of returning a simple 'toxic/not toxic' label, OmniBot provides a detailed breakdown of why a message was flagged. For example, it highlights specific tokens (words or phrases) that contributed most to the decision, using techniques like attention visualization. This transparency allows moderators to understand and correct false positives or negatives, building trust in the system.

4. Data Storage and User Reputation: Flagged messages and moderation actions are stored in a local SQLite database. The bot maintains a reputation score for each user based on their history, allowing for graduated actions (e.g., warnings for first-time offenders, temporary mutes for repeat violations). This approach avoids permanent bans based on a single misjudgment.

Practical Examples and Code Snippets

The original article includes several code examples that illustrate key implementation steps. Here are a few highlights:

Discord Activity Setup

import discord
from discord import app_commands
from discord.ui import View, Button

class ModerationView(View):
    def __init__(self, message_id, toxicity_score):
        super().__init__()
        self.message_id = message_id
        self.toxicity_score = toxicity_score
        self.add_item(Button(label="Approve", style=discord.ButtonStyle.green, custom_id="approve"))
        self.add_item(Button(label="Flag", style=discord.ButtonStyle.red, custom_id="flag"))

This simple view creates interactive buttons that let moderators approve or flag messages directly in the chat, with actions logged to the database.

Loading and Running ruBERT Locally

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

model_name = "DeepPavlov/rubert-base-cased-conversational"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
model.eval()

def predict(text):
    inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
    with torch.no_grad():
        outputs = model(**inputs)
        logits = outputs.logits
        probabilities = torch.nn.functional.softmax(logits, dim=-1)
        return probabilities[0][1].item()  # Toxicity score

The developer notes that using the ONNX version of the model reduced inference time by 40% compared to the PyTorch implementation, which was critical for real-time performance.

Comparison: Local vs. Cloud Moderation

To help readers understand the trade-offs, the article includes a comparison table (presented here in Markdown format):

The table highlights that local deployment is ideal for communities with strict privacy requirements or high message volumes, while cloud APIs remain attractive for multi-language or low-maintenance setups.

Challenges Encountered During Development

The developer candidly discusses several obstacles:

• Model Bias: The initial ruBERT model showed a strong bias against certain topics (e.g., political discussions), flagging many benign messages as toxic. This was mitigated by curating a balanced fine-tuning dataset that included examples from diverse contexts.
• Memory Constraints: Running a large transformer model on a low-memory VPS required aggressive optimization. The developer used quantization (INT8) and model pruning to reduce the memory footprint from 1.2 GB to 350 MB.
• Discord Rate Limits: The bot had to handle Discord's API rate limits when processing multiple messages simultaneously. A custom queue system with exponential backoff was implemented to ensure reliability.
• False Positive Handling: Since the bot operates without a black box, moderators could review flagged messages and adjust the model's threshold dynamically. This feedback loop improved accuracy over time.

Real-World Use Case: A Community Server

The article describes a test deployment on a Russian-language gaming community server with approximately 5,000 active users. Over a two-week period, OmniBot processed over 50,000 messages, flagging 2.3% as potentially toxic. Of those flagged, moderators manually reviewed and confirmed 78% as correctly identified. The remaining 22% were false positives, which were used to further fine-tune the model. The developer reported that community feedback was overwhelmingly positive, with users appreciating the transparency of the moderation process.

The Role of ASI Biont in AI Education

For developers inspired by the OmniBot project to build their own AI-powered tools, understanding the underlying concepts is crucial. ASI Biont supports learning paths that cover NLP, model deployment, and ethical AI development. The platform offers structured courses that teach everything from transformer architectures to practical bot development, helping enthusiasts turn ideas like OmniBot into reality.

Conclusion

The OmniBot project demonstrates that effective, transparent, and privacy-respecting moderation is achievable with today's tools. By combining Discord Activities, a locally deployed ruBERT model, and a non-black-box approach, the developer created a system that empowers moderators without sacrificing user trust. The key takeaways are clear: local AI deployment is increasingly feasible for small to medium-scale applications, and transparency in moderation can build stronger communities. For those looking to replicate or improve upon this work, the original article provides an excellent starting point, covering both the technical details and the philosophical considerations that guided the build. As AI becomes more integrated into our daily digital interactions, projects like OmniBot serve as a blueprint for responsible innovation.

Source