AI सामग्री मॉडरेशन गाइड

Discuse टेक्स्ट और इमेजों में sentiment/toxicity, स्पैम, अवांछित भाषा, अपशब्द, लिंक और स्पष्ट इमेजरी की जाँच करता है, फिर हर कैटेगरी के लिए अलग-अलग परिणाम लौटाता है ताकि आपका कोड सामग्री को अपने-आप approve, flag या reject कर सके। आप सामग्री को एक ही endpoint, POST https://api.discuse.com/api/v2/check, पर भेजते हैं और संरचित स्कोर वापस पढ़ते हैं। इस गाइड में बताया गया है कि ये जाँचें कैसे काम करती हैं, इनके आसपास के मॉडरेशन पैटर्न क्या हैं, और Discuse API को अपनी pipeline में कैसे जोड़ा जाए।

AI सामग्री मॉडरेशन क्या है?

AI सामग्री मॉडरेशन संभावित रूप से हानिकारक सामग्री का अपने-आप पता लगाने और उसे वर्गीकृत करने के लिए मशीन-लर्निंग मॉडल का उपयोग करता है। जहाँ कोई मानव समीक्षक एक बार में एक आइटम पढ़ता है, वहीं ये मॉडल सामग्री आते ही उसे स्कोर कर देते हैं, ताकि सबमिशन दूसरे उपयोगकर्ताओं तक पहुँचने से पहले जाँचे जा सकें।

यह कैसे काम करता है?

सामग्री सबमिट करें: टेक्स्ट और/या मीडिया URLs को मॉडरेशन API पर भेजें।
जाँच चलाएँ: API सक्षम की गई जाँचें चलाता है (भावना, भाषा, स्पैम, अपशब्द, इमेज, लिंक, एंटीवायरस)।
हर श्रेणी को स्कोर करें: हर जाँच स्कोर और एक hit फ़्लैग लौटाती है, जो बताता है कि वह आपके कॉन्फ़िगर किए गए थ्रेशोल्ड को पार कर गई या नहीं।
निर्णय लें: स्वीकृत करने, फ़्लैग करने या अस्वीकार करने के लिए has_violations (और हर जाँच के स्कोर) पढ़ें।

Discuse के साथ, अनुरोध इस तरह दिखता है:

const response = await fetch('https://api.discuse.com/api/v2/check', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-API-Key': process.env.DISCUSE_API_KEY
  },
  body: JSON.stringify({
    content: { text: 'message to check', image_urls: ['https://...'] },
    settings: { check_sentiment: true, check_spam: true, check_images: true }
  })
});
const result = await response.json(); // { has_violations, results: { sentiment, spamfinder, images, ... }, usage }

Discuse की हर जाँच में क्या शामिल है?

जाँच (`settings` टॉगल)	इसमें क्या शामिल है	मुख्य परिणाम फ़ील्ड
`check_sentiment`	टेक्स्ट में नकारात्मकता, विषाक्तता, अश्लीलता, धमकियाँ, अपमान	`sentiment.is_toxic`, `sentiment.toxicity`, `sentiment.score`, `sentiment.hit`
`check_spam`	टेक्स्ट का स्पैम वर्गीकरण	`spamfinder.label`, `spamfinder.confidence`, `spamfinder.is_spam`, `spamfinder.hit`
`check_language`	क्या टेक्स्ट अपेक्षित भाषा से मेल खाता है	`language.language`, `language.confidence`, `language.hit`
`check_badwords`	कस्टम अपशब्द सूची से मेल	`badwords.hit`, `badwords.matched_words`
`check_images`	इमेज URLs में स्पष्ट यौन चित्रण	`images.porn`, `images.sexual`, `images.neutral`, `images.hit`
`check_links`	लिंक की प्रतिष्ठा	`links.status`, `links.hit`
`check_antivirus`	दस्तावेज़/फ़ाइल URLs में मैलवेयर	`antivirus.status`, `antivirus.hit`

हर टॉगल एक बूलियन है। किसी स्कोर को hit में बदलने वाले संख्यात्मक थ्रेशोल्ड डैशबोर्ड में हर प्रोजेक्ट के लिए कॉन्फ़िगर किए जाते हैं, प्रति अनुरोध पास नहीं किए जाते — थ्रेशोल्ड कॉन्फ़िगरेशन गाइड देखें।

AI मॉडरेशन के लाभ

पैमाना

AI इतनी अधिक मात्रा में कंटेंट प्रोसेस कर सकता है, जितना मानव टीमें नहीं कर सकतीं। एक ही API कॉल मिलीसेकंड में परिणाम लौटा देती है, इसलिए मॉडरेशन समीक्षा कतार में पिछड़ने के बजाय सबमिशन की रफ़्तार के साथ चलता रहता है। सीमांत मामलों के लिए ऑटोमेटेड जाँचों को मानव कतार के साथ जोड़ें (नीचे बताया गया है)।

गति

रीयल-टाइम जाँचों से आप कंटेंट प्रकाशित होने से पहले ही उसकी स्क्रीनिंग कर सकते हैं:

// Pre-moderation: Check content before publishing
async function publishPost(content) {
  const moderation = await checkContent(content);

  if (moderation.has_violations) {
    return { published: false, reason: moderation.message };
  }

  // Content passes moderation
  return await saveAndPublish(content);
}

निरंतरता

AI सभी कंटेंट पर समान नियम एकसमान तरीके से लागू करता है, बिना थकान के और समीक्षकों के बीच किसी भिन्नता के बिना। निर्णय दोहराए जा सकते हैं: समान प्रोजेक्ट थ्रेशोल्ड के साथ वही इनपुट वही hit फ़्लैग देता है, जिससे प्रवर्तन ऑडिट योग्य बनता है।

मॉडरेशन आर्किटेक्चर

प्री-मॉडरेशन फ्लो

User Submits → AI Check → Decision
                 ↓
    ┌───────────┼───────────┐
    ↓           ↓           ↓
  Allow      Review       Block
    ↓           ↓           ↓
 Publish   Human Queue   Reject

पोस्ट-मॉडरेशन फ्लो

User Submits → Publish → AI Check → Action
                           ↓
              ┌────────────┼────────────┐
              ↓            ↓            ↓
            Safe       Borderline    Violation
              ↓            ↓            ↓
           Keep       Flag/Review    Remove

हाइब्रिड तरीका (अनुशंसित)

Discuse प्रतिक्रिया किसी भी सक्षम जाँच के अपनी कॉन्फ़िगर की गई सीमा पार करते ही has_violations सेट कर देती है, और हर श्रेणी के मूल स्कोर भी दिखाती है, ताकि आप उसके ऊपर अपना कॉन्फ़िडेंस बैंड जोड़ सकें:

async function moderateContent(content) {
  const result = await checkContent(content);

  // Build a confidence figure from the scores you care about.
  // e.g. the toxicity score and the spam classifier confidence.
  const confidence = Math.max(
    result.results?.sentiment?.toxicity ?? 0,
    result.results?.spamfinder?.confidence ?? 0,
    result.results?.images?.porn ?? 0
  );

  // High confidence: automate.
  if (confidence > 0.95) {
    return result.has_violations
      ? { action: 'auto_remove', reason: result.message }
      : { action: 'auto_approve' };
  }

  // Medium confidence: route to a human.
  if (confidence > 0.5) {
    await addToReviewQueue(content, result);
    return { action: 'pending_review' };
  }

  // Low confidence: approve, keep watching.
  return { action: 'approve_with_monitoring' };
}

AI मॉडरेशन लागू करना

चरण 1: अपनी नीति तय करें

API को कॉल करने से पहले तय करें कि कौन-सी सामग्री स्वीकार्य है और हर श्रेणी पर क्या कार्रवाई करनी है। Discuse में, हर श्रेणी के लिए संख्यात्मक कट-ऑफ आपकी प्रोजेक्ट सेटिंग्स (डैशबोर्ड) में होता है, इसलिए आपकी ऐप्लिकेशन नीति थ्रेशहोल्ड को दोबारा तय करने के बजाय API परिणाम को किसी कार्रवाई से मैप करती है:

const MODERATION_POLICY = {
  // What to do when a given Discuse check reports a hit.
  // Thresholds themselves are configured per project in the dashboard.
  actions: {
    sentiment: 'block',   // toxic / threatening text
    spam: 'block',
    badwords: 'flag',
    images: 'block',      // explicit imagery
    links: 'flag'
  }
};

चरण 2: API को इंटीग्रेट करें

इस अनुरोध के लिए सामग्री और वे चेक भेजें जिन्हें आप सक्षम करना चाहते हैं। हर check_* टॉगल एक वैकल्पिक boolean है, जो इस कॉल के लिए प्रोजेक्ट डिफ़ॉल्ट को ओवरराइड करता है:

async function checkContent(content) {
  const response = await fetch('https://api.discuse.com/api/v2/check', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-API-Key': process.env.DISCUSE_API_KEY
    },
    body: JSON.stringify({
      content: {
        text: content.text,
        image_urls: content.images
      },
      settings: {
        check_sentiment: true,
        check_spam: true,
        check_images: true
      }
    })
  });

  if (!response.ok) {
    throw new Error(`Discuse API returned ${response.status}`);
  }
  return response.json();
}

चरण 3: निर्णय लागू करें

hit रिपोर्ट करने वाले हर चेक को आपके द्वारा तय की गई कार्रवाई से मैप करें:

function applyModerationDecision(result) {
  const r = result.results || {};

  if (r.sentiment?.hit) return { action: MODERATION_POLICY.actions.sentiment, category: 'sentiment' };
  if (r.spamfinder?.hit) return { action: MODERATION_POLICY.actions.spam, category: 'spam' };
  if (r.images?.hit)    return { action: MODERATION_POLICY.actions.images, category: 'images' };
  if (r.badwords?.hit)  return { action: MODERATION_POLICY.actions.badwords, category: 'badwords' };
  if (r.links?.hit)     return { action: MODERATION_POLICY.actions.links, category: 'links' };

  return { action: 'allow' };
}

चरण 4: एज केस संभालें

async function handleModerationResult(content, result) {
  switch (result.action) {
    case 'block':
      await notifyUser(content.author, 'content_blocked', result);
      await logModeration(content, result);
      return false;

    case 'flag':
      await addToReviewQueue(content, result);
      await publishWithWarning(content);
      return true;

    case 'allow':
      await publish(content);
      return true;

    default:
      // Unknown action - fail safe by blocking
      await logError('unknown_moderation_action', result);
      return false;
  }
}

सर्वोत्तम अभ्यास

शुरुआत में सावधानी बरतें, समय के साथ समायोजित करें

शुरुआत में प्रोजेक्ट के थ्रेशहोल्ड अधिक सख्त रखें और false positives को मापने के बाद उन्हें धीरे-धीरे ढीला करें। Discuse में ये थ्रेशहोल्ड प्रोजेक्ट सेटिंग्स होते हैं, इसलिए ट्यूनिंग डैशबोर्ड में होती है (या settings update API के जरिए), हर request में नहीं। वर्कफ़्लो के लिए थ्रेशहोल्ड कॉन्फ़िगरेशन गाइड देखें।

मानव समीक्षा कतार बनाए रखें

AI को edge cases में मानव निर्णय क्षमता को बढ़ाना चाहिए, उसकी जगह नहीं लेनी चाहिए:

async function processReviewQueue() {
  const items = await getReviewQueue();

  for (const item of items) {
    // Present to human reviewer with AI context
    const reviewUI = {
      content: item.content,
      ai_scores: item.moderation_result,
      similar_decisions: await getSimilarPreviousDecisions(item)
    };

    // Human makes final decision
    const decision = await presentToReviewer(reviewUI);

    // Log for model improvement
    await logHumanDecision(item, decision);
  }
}

निगरानी करें और सुधारें

अपने मॉडरेशन सिस्टम को बेहतर बनाने के लिए प्रमुख मेट्रिक्स ट्रैक करें:

const METRICS = {
  // Accuracy metrics
  false_positive_rate: 'Content incorrectly blocked',
  false_negative_rate: 'Harmful content missed',

  // Operational metrics
  average_response_time: 'API latency',
  review_queue_depth: 'Human review backlog',

  // User impact
  appeal_rate: 'Users appealing decisions',
  appeal_success_rate: 'Appeals overturned'
};

अपीलों को सहजता से संभालें

जब कोई उपयोगकर्ता अपील करे, तो उसे अपने-आप फिर से निर्णय लेने के बजाय किसी मानव समीक्षक के पास भेजें। समीक्षक को संदर्भ के रूप में मूल Discuse स्कोर और उपयोगकर्ता का इतिहास दें:

async function handleAppeal(contentId, userId) {
  const original = await getContentWithModeration(contentId);

  await addToReviewQueue(contentId, {
    type: 'appeal',
    original_decision: original.moderation, // Discuse `results` saved at decision time
    author_history: await getAuthorHistory(userId)
  });

  return { status: 'pending', message: 'Under review' };
}

API में स्वयं per-request "context" या "author history" पैरामीटर नहीं होता — संदर्भ वह चीज़ है जिसे आप thresholds चुनते समय और समीक्षा के लिए रूट करते समय अपनी ओर लागू करते हैं।

आम कमियाँ

AI पर ज़रूरत से ज़्यादा निर्भर होना

हर निर्णय को ऑटोमेट करने का मतलब हर गलती को भी ऑटोमेट करना है। इन मामलों में इंसान को प्रक्रिया में शामिल रखें:

जटिल संदर्भगत निर्णय
अधिक जोखिम वाली सामग्री (कानूनी, सुरक्षा)
अपीलें और अपवाद वाले मामले

संदर्भ को नज़रअंदाज़ करना

वही शब्द संदर्भ के आधार पर हानिकारक या स्वीकार्य हो सकते हैं:

"I'm going to kill it at this interview!" // Positive
"I'm going to kill you"                    // Threat

Discuse हर संदेश को अलग-अलग स्कोर करता है; इसमें अनुरोध-स्तर का "context" पैरामीटर नहीं है। संदर्भ अपनी तरफ़ से लागू करें: सतह के अनुसार प्रोजेक्ट थ्रेशोल्ड को सख़्त या ढीला चुनें (सार्वजनिक पोस्ट बनाम डायरेक्ट मैसेज), और सीमा के करीब वाले hits को मानव समीक्षा के लिए भेजें।

सेट करके भूल जाना

कंटेंट मॉडरेशन में लगातार ट्यूनिंग की आवश्यकता होती है:

फ़ॉल्स पॉज़िटिव/नेगेटिव दरों की निगरानी करें
डेटा के आधार पर थ्रेशोल्ड अपडेट करें
नए कंटेंट पैटर्न की समीक्षा करें
मॉडल को फिर से ट्रेन या अपडेट करें

असंगत प्रवर्तन

नीति को नियम के आधार पर लागू करें, यह देखकर नहीं कि किसने पोस्ट किया है। मनमाने अपवादों के बजाय दस्तावेज़ित ट्रस्ट लेवल के आधार पर थ्रेशोल्ड तय करें:

// Avoid: per-person exceptions
if (user.isInfluencer) { /* lenient */ }

// Prefer: thresholds keyed to a documented trust level,
// configured the same way for everyone in that level.
const action = MODERATION_POLICY.actions[category];

अगले कदम

थ्रेशोल्ड कॉन्फ़िगर करना - अपनी मॉडरेशन को बारीकी से समायोजित करें
कंटेंट मॉडरेशन को स्केल करना - बड़ी मात्रा को संभालें
टेक्स्ट विश्लेषण - टेक्स्ट मॉडरेशन में गहराई से जानें
इमेज NSFW डिटेक्शन - विज़ुअल कंटेंट की सुरक्षा करें