Bezpečnost obsahu Azure AI klientská knihovna REST pro JavaScript – verze 1.0.0

Článek
12/13/2023

/Stroji

Bezpečnost obsahu Azure AI detekuje v aplikacích a službách škodlivý obsah generovaný uživateli a AI. Zabezpečení obsahu zahrnuje rozhraní API pro text a obrázky, která umožňují detekovat materiály, které jsou škodlivé.

Rozhraní API pro analýzu textu: Vyhledá v textu sexuální obsah, násilí, nenávist a sebepoškozování s více úrovněmi závažnosti.
Rozhraní API pro analýzu obrázků: Skenuje na obrázcích sexuální obsah, násilí, nenávist a sebepoškozování s více úrovněmi závažnosti.
Rozhraní API pro správu seznamu blokovaných bloků textu: Výchozí klasifikátory AI jsou dostatečné pro většinu potřeb zabezpečení obsahu. Možná ale budete muset vyhledat podmínky, které jsou specifické pro váš případ použití. Můžete vytvořit seznamy blokovaných termínů pro použití s rozhraním Text API.

Při používání této knihovny se velmi spoléhejte na naši dokumentaci ke klientům REST .

Klíčové odkazy:

Začínáme

Aktuálně podporovaná prostředí

LtS verze Node.js

Požadavky

K použití tohoto balíčku potřebujete předplatné Azure .
Prostředek Bezpečnost obsahu Azure AI, pokud žádný prostředek neexistuje, můžete vytvořit nový.

Nainstalujte balíček `@azure-rest/ai-content-safety`.

Nainstalujte klientskou knihovnu REST Bezpečnost obsahu Azure AI REST pro JavaScript pomocí npmpříkazu :

npm install @azure-rest/ai-content-safety

Vytvoření a ověření `ContentSafetyClient`

Získání koncového bodu

Koncový bod prostředku služby Bezpečnost obsahu Azure AI můžete najít pomocí webu Azure Portal nebo Azure CLI:

# Get the endpoint for the Azure AI Content Safety service resource
az cognitiveservices account show --name "resource-name" --resource-group "resource-group-name" --query "properties.endpoint"

Vytvoření ContentSafetyClient pomocí AzureKeyCredential

Krok 1: Získání klíče rozhraní API

Klíč rozhraní API najdete na webu Azure Portal nebo spuštěním následujícího příkazu Azure CLI :

az cognitiveservices account keys list --name "<resource-name>" --resource-group "<resource-group-name>"

Krok 2: Vytvoření Třídy ContentSafetyClient s využitím AzureKeyCredential

Pokud chcete jako credential parametr použít klíč rozhraní API, předejte klíč jako řetězec do instance .AzureKeyCredential

import ContentSafetyClient from "@azure-rest/ai-content-safety";
import { AzureKeyCredential } from "@azure/core-auth";

const endpoint = process.env["CONTENT_SAFETY_ENDPOINT"] || "<endpoint>";
const key = process.env["CONTENT_SAFETY_API_KEY"] || "<key>";
const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

Vytvoření objektu ContentSafetyClient s Microsoft Entra ID (dříve Azure Active Directory (AAD)) s přihlašovacími údaji tokenu

Krok 1: Povolení ID Microsoft Entra pro váš prostředek. Postup povolení AAD pro váš prostředek najdete v tomto dokumentu ověřování služeb Cognitive Services Ověření pomocí ID Microsoft Entra.

Hlavní kroky jsou:
- Vytvořte prostředek s vlastní subdoménou.
- Vytvořte instanční objekt a přiřaďte mu roli uživatele služeb Cognitive Services.
Krok 2: Nastavte hodnoty ID klienta, ID tenanta a tajného klíče klienta aplikace AAD jako proměnné prostředí: AZURE_CLIENT_ID, AZURE_TENANT_ID AZURE_CLIENT_SECRET

Pokud chcete provést ověření pomocí AAD, musíte nejprve npm nainstalovat @azure/identity. Po nastavení můžete zvolit, jaký typ přihlašovacích údajů@azure/identity se má použít. Jako příklad lze k ověření klienta použít DefaultAzureCredential .

import ContentSafetyClient from "@azure-rest/ai-content-safety";
import { DefaultAzureCredential } from "@azure/identity";

const endpoint = process.env["CONTENT_SAFETY_ENDPOINT"] || "<endpoint>";
const client = ContentSafetyClient(endpoint, new DefaultAzureCredential());

Klíčové koncepty

Dostupné funkce

Tato služba má k dispozici různé typy analýz. Následující tabulka popisuje aktuálně dostupná rozhraní API.

Funkce	Popis
Rozhraní API pro analýzu textu	Vyhledá v textu sexuální obsah, násilí, nenávist a sebepoškozování s více úrovněmi závažnosti.
Rozhraní API pro analýzu obrázků	Skenuje na obrázcích sexuální obsah, násilí, nenávist a sebepoškozování s více úrovněmi závažnosti.
Rozhraní API pro správu seznamu blokovaných bloků textu	Výchozí klasifikátory AI jsou dostatečné pro většinu potřeb zabezpečení obsahu. Možná ale budete muset zjistit podmínky, které jsou specifické pro váš případ použití. Můžete vytvořit seznamy blokovaných termínů pro použití s rozhraním Text API.

Kategorie škod

Zabezpečení obsahu rozpozná čtyři různé kategorie problematického obsahu.

Kategorie	Popis
Nenávidět	Nenávist označuje jakýkoli obsah, který napadá nebo používá pejorativní nebo diskriminující jazyk v odkazu na osobu nebo skupinu identit na základě určitých odlišujících atributů této skupiny. Patří sem mimo jiné rasa, etnická příslušnost, národnost, genderová identita a výraz, sexuální orientace, náboženství, imigrace, stav schopností, osobní vzhled a velikost těla.
Sexuální	Sex popisuje obsah související s anatomickými orgány a genitáliemi, romantickými vztahy, akty vykreslovanými erotickými nebo laskavými výrazy, těhotenstvím, fyzickým sexuálním jednáním – včetně těch, které jsou vykreslovány jako napadení nebo vynucené sexuální násilí proti chtě nikomu – prostituci, pornografii a zneužívání.
Násilí	Násilí popisuje obsah související s fyzickými činy, jejichž cílem je ublížit, zranit, poškodit nebo zabít někoho nebo něco. Zahrnuje také zbraně, zbraně a související subjekty, jako jsou výrobci, sdružení, právní předpisy a podobně.
Sebepoškozování	Sebepoškozování popisuje obsah související s fyzickými činnostmi, jejichž cílem je úmyslně ublížit, zranit nebo poškodit tělo nebo se zabít.

Klasifikace může být označená více popisky. Když například ukázka textu prochází modelem moderování textu, může být klasifikována jako sexuální obsah i násilí.

Úrovně závažnosti

Každá kategorie škod, na které se služba vztahuje, má také hodnocení úrovně závažnosti. Úroveň závažnosti označuje závažnost následků zobrazení obsahu s příznakem.

Text: Aktuální verze textového modelu podporuje úplné měřítko závažnosti 0–7. Ve výchozím nastavení bude odpověď výstupem 4 hodnoty: 0, 2, 4 a 6. Každá dvě sousední úrovně jsou mapovány na jednu úroveň. Uživatelé můžou v požadavku použít outputType a nastavit ho jako "EightSeverityLevels", aby získali 8 hodnot ve výstupu: 0,1,2,3,4,5,6,7. Podrobnosti najdete v definicích úrovní závažnosti textového obsahu .

[0,1] –> 0
[2,3] –> 2
[4,5] –> 4
[6,7] –> 6

Obrázek: Aktuální verze image modelu podporuje oříznutou verzi úplné škály závažnosti 0–7. Klasifikátor vrátí pouze závažnosti 0, 2, 4 a 6; každá dvě sousední úrovně jsou mapovány na jednu úroveň. Podrobnosti najdete v definicích úrovní závažnosti obsahu obrázků .

[0,1] –> 0
[2,3] –> 2
[4,5] –> 4
[6,7] –> 6

Správa seznamu blokovaných textů

Pro správu seznamu blokovaných textů se podporují následující operace:

Vytvoření nebo úprava seznamu blokovaných
Vypsat všechny seznamy blokovaných
Získání seznamu blokovaných podle blocklistName
Přidání blockItems do seznamu blokovaných
Odebrání blockItems ze seznamu blokovaných
Výpis všech blockItems v seznamu blokovaných položek podle blocklistName
Získání blockItem v seznamu blokovaných pomocí blockItemId a blocklistName
Odstranění seznamu blokovaných a všech jeho blockItems

Můžete nastavit seznamy blokovaných, které chcete použít při analýze textu, a pak můžete z vrácené odpovědi získat výsledek shody seznamu blokovaných.

Příklady

Následující část obsahuje několik fragmentů kódu, které pokrývají některé z nejběžnějších úloh služby Content Safety v TypeScriptu i JavaScriptu, mezi které patří:

Analýza textu
Analýza obrázku
Správa seznamu blokovaných textů

Analýza textu

Analýza textu bez seznamů blokovaných

TypeScript

import ContentSafetyClient, { isUnexpected  } from "@azure-rest/ai-content-safety";
import { AzureKeyCredential } from "@azure/core-auth";

async function main() {
  const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
  const key = "<api_key>";

  const credential = new AzureKeyCredential(key);
  const client = ContentSafetyClient(endpoint, credential);

  const text = "This is a sample text";
  const analyzeTextOption = { text: text };
  const analyzeTextParameters = { body: analyzeTextOption };

  const result = await client.path("/text:analyze").post(analyzeTextParameters);

  if (isUnexpected(result)) {
    throw result;
  }

  for (let i = 0; i < result.body.categoriesAnalysis.length; i++) {
    const textCategoriesAnalysisOutput = result.body.categoriesAnalysis[i];
    console.log(textCategoriesAnalysisOutput.category, " severity: ", textCategoriesAnalysisOutput.severity)
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

JavaScript

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");

async function main() {
  const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
  const key = "<api_key>";

  const credential = new AzureKeyCredential(key);
  const client = ContentSafetyClient(endpoint, credential);

  const text = "This is a sample text";
  const analyzeTextOption = { text: text };
  const analyzeTextParameters = { body: analyzeTextOption };

  const result = await client.path("/text:analyze").post(analyzeTextParameters);

  if (isUnexpected(result)) {
    throw result;
  }

  for (let i = 0; i < result.body.categoriesAnalysis.length; i++) {
    const textCategoriesAnalysisOutput = result.body.categoriesAnalysis[i];
    console.log(
      textCategoriesAnalysisOutput.category,
      " severity: ",
      textCategoriesAnalysisOutput.severity
    );
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Analýza textu pomocí seznamů blokovaných

TypeScript

import ContentSafetyClient, { CreateOrUpdateTextBlocklistParameters, isUnexpected } from "@azure-rest/ai-content-safety";
import { AzureKeyCredential } from "@azure/core-auth";

const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
const key = "<api_key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function createOrUpdateTextBlocklist() {
  const blocklistName = "TestBlocklist";
  const blocklistDescription = "Test blocklist management.";
  const createOrUpdateTextBlocklistParameters: CreateOrUpdateTextBlocklistParameters = {
    contentType: "application/merge-patch+json",
    body: {
      description: blocklistDescription,
    }
  }

  const result = await client.path("/text/blocklists/{blocklistName}", blocklistName).patch(createOrUpdateTextBlocklistParameters);

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("Blocklist created or updated: Name", result.body.blocklistName, ", Description: ", result.body.description);
}

async function addBlockItems() {
  const blocklistName = "TestBlocklist";
  const blockItemText1 = "sample";
  const blockItemText2 = "text";
  const addOrUpdateBlocklistItemsParameters = {
    body: {
      blocklistItems: [
        {
          description: "Test block item 1",
          text: blockItemText1
        },
        {
          description: "Test block item 2",
          text: blockItemText2
        }
      ]
    }
  };

  const result = await client.path("/text/blocklists/{blocklistName}:addOrUpdateBlocklistItems", blocklistName).post(addOrUpdateBlocklistItemsParameters);

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("Block items added: ");
  if (result.body.blocklistItems) {
    for (const blockItem of result.body.blocklistItems) {
      console.log("BlockItemId: ", blockItem.blocklistItemId, ", Text: ", blockItem.text, ", Description: ", blockItem.description);
    }
  }
}

async function analyzeTextWithBlocklists() {
  const blocklistName = "TestBlocklist";
  const inputText = "This is a sample to test text with blocklist.";
  const analyzeTextParameters = {
    body: {
      text: inputText,
      blocklistNames: [blocklistName],
      haltOnBlocklistHit: false
    }
  };

  const result = await client.path("/text:analyze").post(analyzeTextParameters);

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("Blocklist match results: ");
  if (result.body.blocklistsMatch) {
    for (const blocklistMatchResult of result.body.blocklistsMatch) {
      console.log("BlocklistName: ", blocklistMatchResult.blocklistName, ", BlockItemId: ", blocklistMatchResult.blocklistItemId, ", BlockItemText: ", blocklistMatchResult.blocklistItemText);
    }
  }
}

(async () => {
  await createOrUpdateTextBlocklist();
  await addBlockItems();
  await analyzeTextWithBlocklists();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

JavaScript

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");

const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
const key = "<api_key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function createOrUpdateTextBlocklist() {
  const blocklistName = "TestBlocklist";
  const blocklistDescription = "Test blocklist management.";
  const createOrUpdateTextBlocklistParameters = {
    contentType: "application/merge-patch+json",
    body: {
      description: blocklistDescription,
    },
  };

  const result = await client
    .path("/text/blocklists/{blocklistName}", blocklistName)
    .patch(createOrUpdateTextBlocklistParameters);

  if (isUnexpected(result)) {
    throw result;
  }

  console.log(
    "Blocklist created or updated: Name",
    result.body.blocklistName,
    ", Description: ",
    result.body.description
  );
}

async function addBlockItems() {
  const blocklistName = "TestBlocklist";
  const blockItemText1 = "sample";
  const blockItemText2 = "text";
  const addOrUpdateBlocklistItemsParameters = {
    body: {
      blocklistItems: [
        {
          description: "Test block item 1",
          text: blockItemText1,
        },
        {
          description: "Test block item 2",
          text: blockItemText2,
        },
      ],
    },
  };

  const result = await client
    .path("/text/blocklists/{blocklistName}:addOrUpdateBlocklistItems", blocklistName)
    .post(addOrUpdateBlocklistItemsParameters);

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("Block items added: ");
  if (result.body.blocklistItems) {
    for (const blockItem of result.body.blocklistItems) {
      console.log(
        "BlockItemId: ",
        blockItem.blocklistItemId,
        ", Text: ",
        blockItem.text,
        ", Description: ",
        blockItem.description
      );
    }
  }
}

async function analyzeTextWithBlocklists() {
  const blocklistName = "TestBlocklist";
  const inputText = "This is a sample to test text with blocklist.";
  const analyzeTextParameters = {
    body: {
      text: inputText,
      blocklistNames: [blocklistName],
      haltOnBlocklistHit: false,
    },
  };

  const result = await client.path("/text:analyze").post(analyzeTextParameters);

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("Blocklist match results: ");
  if (result.body.blocklistsMatch) {
    for (const blocklistMatchResult of result.body.blocklistsMatch) {
      console.log(
        "BlocklistName: ",
        blocklistMatchResult.blocklistName,
        ", BlockItemId: ",
        blocklistMatchResult.blocklistItemId,
        ", BlockItemText: ",
        blocklistMatchResult.blocklistItemText
      );
    }
  }
}

(async () => {
  await createOrUpdateTextBlocklist();
  await addBlockItems();
  await analyzeTextWithBlocklists();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Analýza obrázku

TypeScript

import ContentSafetyClient, { isUnexpected  } from "@azure-rest/ai-content-safety";
import { AzureKeyCredential } from "@azure/core-auth";
import fs from "fs";
import path from "path";

async function main() {
  const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
  const key = "<api_key>";

  const credential = new AzureKeyCredential(key);
  const client = ContentSafetyClient(endpoint, credential);

  const image_path = path.resolve(__dirname, "./samples-dev/example-data/image.png");

  const imageBuffer = fs.readFileSync(image_path);
  const base64Image = imageBuffer.toString("base64");
  const analyzeImageOption = { image: { content: base64Image } };
  const analyzeImageParameters = { body: analyzeImageOption };

  const result = await client.path("/image:analyze").post(analyzeImageParameters);

  if (isUnexpected(result)) {
    throw result;
  }

  for (let i = 0; i < result.body.categoriesAnalysis.length; i++) {
    const imageCategoriesAnalysisOutput = result.body.categoriesAnalysis[i];
    console.log(imageCategoriesAnalysisOutput.category, " severity: ", imageCategoriesAnalysisOutput.severity)
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

JavaScript

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");
const fs = require("fs");
const path = require("path");

async function main() {
  const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
  const key = "<api_key>";

  const credential = new AzureKeyCredential(key);
  const client = ContentSafetyClient(endpoint, credential);

  const image_path = path.resolve(__dirname, "./samples-dev/example-data/image.png");

  const imageBuffer = fs.readFileSync(image_path);
  const base64Image = imageBuffer.toString("base64");
  const analyzeImageOption = { image: { content: base64Image } };
  const analyzeImageParameters = { body: analyzeImageOption };

  const result = await client.path("/image:analyze").post(analyzeImageParameters);

  if (isUnexpected(result)) {
    throw result;
  }

  for (let i = 0; i < result.body.categoriesAnalysis.length; i++) {
    const imageCategoriesAnalysisOutput = result.body.categoriesAnalysis[i];
    console.log(
      imageCategoriesAnalysisOutput.category,
      " severity: ",
      imageCategoriesAnalysisOutput.severity
    );
  }
}

main().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Správa seznamu blokovaných textů

Vytvoření nebo aktualizace seznamu blokovaných textů

TypeScript

import ContentSafetyClient, { CreateOrUpdateTextBlocklistParameters, isUnexpected  } from "@azure-rest/ai-content-safety";
import { AzureKeyCredential } from "@azure/core-auth";
  
const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
const key = "<api_key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function createOrUpdateTextBlocklist() {
  const blocklistName = "TestBlocklist";
  const blocklistDescription = "Test blocklist management.";
  const createOrUpdateTextBlocklistParameters: CreateOrUpdateTextBlocklistParameters = {
    contentType: "application/merge-patch+json",
    body: {
      description: blocklistDescription,
    }
  }

  const result = await client.path("/text/blocklists/{blocklistName}", blocklistName).patch(createOrUpdateTextBlocklistParameters);

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("Blocklist created or updated: Name", result.body.blocklistName, ", Description: ", result.body.description);
}

(async () => {
  await createOrUpdateTextBlocklist();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

JavaScript

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");

const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
const key = "<api_key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function createOrUpdateTextBlocklist() {
  const blocklistName = "TestBlocklist";
  const blocklistDescription = "Test blocklist management.";
  const createOrUpdateTextBlocklistParameters = {
    contentType: "application/merge-patch+json",
    body: {
      description: blocklistDescription,
    },
  };

  const result = await client
    .path("/text/blocklists/{blocklistName}", blocklistName)
    .patch(createOrUpdateTextBlocklistParameters);

  if (isUnexpected(result)) {
    throw result;
  }

  console.log(
    "Blocklist created or updated: Name",
    result.body.blocklistName,
    ", Description: ",
    result.body.description
  );
}

(async () => {
  await createOrUpdateTextBlocklist();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Seznam blokovaných seznamů textu

TypeScript

import ContentSafetyClient, { isUnexpected  } from "@azure-rest/ai-content-safety";
import { AzureKeyCredential } from "@azure/core-auth";
  
const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
const key = "<api_key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function listTextBlocklists() {
  const result = await client.path("/text/blocklists").get();

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("List blocklists: ");
  if (result.body.value) {
    for (const blocklist of result.body.value) {
      console.log("BlocklistName: ", blocklist.blocklistName, ", Description: ", blocklist.description);
    }
  }
}

(async () => {
  await listTextBlocklists();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

JavaScript

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");

const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
const key = "<api_key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function listTextBlocklists() {
  const result = await client.path("/text/blocklists").get();

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("List blocklists: ");
  if (result.body.value) {
    for (const blocklist of result.body.value) {
      console.log(
        "BlocklistName: ",
        blocklist.blocklistName,
        ", Description: ",
        blocklist.description
      );
    }
  }
}

(async () => {
  await listTextBlocklists();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Získání seznamu blokovaných textů

TypeScript

import ContentSafetyClient, { isUnexpected  } from "@azure-rest/ai-content-safety";
import { AzureKeyCredential } from "@azure/core-auth";

const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
const key = "<api_key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function getTextBlocklist() {
  const blocklistName = "TestBlocklist";

  const result = await client.path("/text/blocklists/{blocklistName}", blocklistName).get();

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("Get blocklist: ");
  console.log("Name: ", result.body.blocklistName, ", Description: ", result.body.description);
}

(async () => {
  await getTextBlocklist();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

JavaScript

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");

const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
const key = "<api_key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function getTextBlocklist() {
  const blocklistName = "TestBlocklist";

  const result = await client.path("/text/blocklists/{blocklistName}", blocklistName).get();

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("Get blocklist: ");
  console.log("Name: ", result.body.blocklistName, ", Description: ", result.body.description);
}

(async () => {
  await getTextBlocklist();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Odstranění seznamu blokovaných textů

TypeScript

import ContentSafetyClient, { isUnexpected  } from "@azure-rest/ai-content-safety";
import { AzureKeyCredential } from "@azure/core-auth";

const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
const key = "<api_key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function deleteBlocklist() {
  const blocklistName = "TestBlocklist";

  const result = await client.path("/text/blocklists/{blocklistName}", blocklistName).delete();

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("Deleted blocklist: ", blocklistName);
}

(async () => {
  await deleteBlocklist();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

JavaScript

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");

const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
const key = "<api_key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function deleteBlocklist() {
  const blocklistName = "TestBlocklist";

  const result = await client.path("/text/blocklists/{blocklistName}", blocklistName).delete();

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("Deleted blocklist: ", blocklistName);
}

(async () => {
  await deleteBlocklist();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Přidání blockItems

TypeScript

import ContentSafetyClient, { CreateOrUpdateTextBlocklistParameters, isUnexpected  } from "@azure-rest/ai-content-safety";
import { AzureKeyCredential } from "@azure/core-auth";

const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
const key = "<api_key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function createOrUpdateTextBlocklist() {
  const blocklistName = "TestBlocklist";
  const blocklistDescription = "Test blocklist management.";
  const createOrUpdateTextBlocklistParameters: CreateOrUpdateTextBlocklistParameters = {
    contentType: "application/merge-patch+json",
    body: {
      description: blocklistDescription,
    }
  }

  const result = await client.path("/text/blocklists/{blocklistName}", blocklistName).patch(createOrUpdateTextBlocklistParameters);

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("Blocklist created or updated: Name", result.body.blocklistName, ", Description: ", result.body.description);
}

async function addBlockItems() {
  const blocklistName = "TestBlocklist";
  const blockItemText1 = "sample";
  const blockItemText2 = "text";
  const addOrUpdateBlocklistItemsParameters = {
    body: {
      blocklistItems: [
        {
          description: "Test block item 1",
          text: blockItemText1
        },
        {
          description: "Test block item 2",
          text: blockItemText2
        }
      ]
    }
  };

  const result = await client.path("/text/blocklists/{blocklistName}:addOrUpdateBlocklistItems", blocklistName).post(addOrUpdateBlocklistItemsParameters);

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("Block items added: ");
  if (result.body.blocklistItems) {
    for (const blockItem of result.body.blocklistItems) {
      console.log("BlockItemId: ", blockItem.blocklistItemId, ", Text: ", blockItem.text, ", Description: ", blockItem.description);
    }
  }
}

(async () => {
  await createOrUpdateTextBlocklist();
  await addBlockItems();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

JavaScript

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");

const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
const key = "<api_key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function createOrUpdateTextBlocklist() {
  const blocklistName = "TestBlocklist";
  const blocklistDescription = "Test blocklist management.";
  const createOrUpdateTextBlocklistParameters = {
    contentType: "application/merge-patch+json",
    body: {
      description: blocklistDescription,
    },
  };

  const result = await client
    .path("/text/blocklists/{blocklistName}", blocklistName)
    .patch(createOrUpdateTextBlocklistParameters);

  if (isUnexpected(result)) {
    throw result;
  }

  console.log(
    "Blocklist created or updated: Name",
    result.body.blocklistName,
    ", Description: ",
    result.body.description
  );
}

async function addBlockItems() {
  const blocklistName = "TestBlocklist";
  const blockItemText1 = "sample";
  const blockItemText2 = "text";
  const addOrUpdateBlocklistItemsParameters = {
    body: {
      blocklistItems: [
        {
          description: "Test block item 1",
          text: blockItemText1,
        },
        {
          description: "Test block item 2",
          text: blockItemText2,
        },
      ],
    },
  };

  const result = await client
    .path("/text/blocklists/{blocklistName}:addOrUpdateBlocklistItems", blocklistName)
    .post(addOrUpdateBlocklistItemsParameters);

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("Block items added: ");
  if (result.body.blocklistItems) {
    for (const blockItem of result.body.blocklistItems) {
      console.log(
        "BlockItemId: ",
        blockItem.blocklistItemId,
        ", Text: ",
        blockItem.text,
        ", Description: ",
        blockItem.description
      );
    }
  }
}

(async () => {
  await createOrUpdateTextBlocklist();
  await addBlockItems();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Seznam blockItems

TypeScript

import ContentSafetyClient, { isUnexpected  } from "@azure-rest/ai-content-safety";
import { AzureKeyCredential } from "@azure/core-auth";

const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
const key = "<api_key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function listBlockItems() {
  const blocklistName = "TestBlocklist";

  const result = await client.path("/text/blocklists/{blocklistName}/blocklistItems", blocklistName).get();

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("List block items: ");
  if (result.body.value) {
    for (const blockItem of result.body.value) {
      console.log("BlockItemId: ", blockItem.blocklistItemId, ", Text: ", blockItem.text, ", Description: ", blockItem.description);
    }
  }
}

(async () => {
  await listBlockItems();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

JavaScript

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");

const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
const key = "<api_key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function listBlockItems() {
  const blocklistName = "TestBlocklist";

  const result = await client
    .path("/text/blocklists/{blocklistName}/blocklistItems", blocklistName)
    .get();

  if (isUnexpected(result)) {
    throw result;
  }

  console.log("List block items: ");
  if (result.body.value) {
    for (const blockItem of result.body.value) {
      console.log(
        "BlockItemId: ",
        blockItem.blocklistItemId,
        ", Text: ",
        blockItem.text,
        ", Description: ",
        blockItem.description
      );
    }
  }
}

(async () => {
  await listBlockItems();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Získání blockItem

TypeScript

import ContentSafetyClient, { isUnexpected  } from "@azure-rest/ai-content-safety";
import { AzureKeyCredential } from "@azure/core-auth";

const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
const key = "<api_key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function getBlockItem() {
  const blocklistName = "TestBlocklist";
  const blockItemText = "sample";
  const addOrUpdateBlocklistItemsParameters = {
    body: {
      blocklistItems: [
        {
          description: "Test block item 1",
          text: blockItemText
        }
      ]
    }
  };
  const result = await client.path("/text/blocklists/{blocklistName}:addOrUpdateBlocklistItems", blocklistName).post(addOrUpdateBlocklistItemsParameters);
  if (isUnexpected(result) || result.body.blocklistItems === undefined) {
    throw new Error("Block item not added.");
  }
  const blockItemId = result.body.blocklistItems[0].blocklistItemId;

  const blockItem = await client.path("/text/blocklists/{blocklistName}/blocklistItems/{blocklistItemId}", blocklistName, blockItemId).get();

  if (isUnexpected(blockItem)) {
    throw blockItem;
  }

  console.log("Get blockitem: ");
  console.log("BlockItemId: ", blockItem.body.blocklistItemId, ", Text: ", blockItem.body.text, ", Description: ", blockItem.body.description);
}

(async () => {
  await getBlockItem();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

JavaScript

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");

const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
const key = "<api_key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function getBlockItem() {
  const blocklistName = "TestBlocklist";
  const blockItemText = "sample";
  const addOrUpdateBlocklistItemsParameters = {
    body: {
      blocklistItems: [
        {
          description: "Test block item 1",
          text: blockItemText,
        },
      ],
    },
  };
  const result = await client
    .path("/text/blocklists/{blocklistName}:addOrUpdateBlocklistItems", blocklistName)
    .post(addOrUpdateBlocklistItemsParameters);
  if (isUnexpected(result) || result.body.blocklistItems === undefined) {
    throw new Error("Block item not added.");
  }
  const blockItemId = result.body.blocklistItems[0].blocklistItemId;

  const blockItem = await client
    .path(
      "/text/blocklists/{blocklistName}/blocklistItems/{blocklistItemId}",
      blocklistName,
      blockItemId
    )
    .get();

  if (isUnexpected(blockItem)) {
    throw blockItem;
  }

  console.log("Get blockitem: ");
  console.log(
    "BlockItemId: ",
    blockItem.body.blocklistItemId,
    ", Text: ",
    blockItem.body.text,
    ", Description: ",
    blockItem.body.description
  );
}

(async () => {
  await getBlockItem();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Odebrat blockItems

TypeScript

import ContentSafetyClient, { isUnexpected  } from "@azure-rest/ai-content-safety";
import { AzureKeyCredential } from "@azure/core-auth";

const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
const key = "<api_key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function removeBlockItems() {
  const blocklistName = "TestBlocklist";
  const blockItemText = "sample";
  const addOrUpdateBlocklistItemsParameters = {
    body: {
      blocklistItems: [
        {
          description: "Test block item 1",
          text: blockItemText
        }
      ]
    }
  };
  const result = await client.path("/text/blocklists/{blocklistName}:addOrUpdateBlocklistItems", blocklistName).post(addOrUpdateBlocklistItemsParameters);
  if (isUnexpected(result) || result.body.blocklistItems === undefined) {
    throw new Error("Block item not added.");
  }
  const blockItemId = result.body.blocklistItems[0].blocklistItemId;

  const removeBlocklistItemsParameters = {
    body: {
      blocklistItemIds: [blockItemId]
    }
  };
  const removeBlockItem = await client.path("/text/blocklists/{blocklistName}:removeBlocklistItems", blocklistName).post(removeBlocklistItemsParameters);

  if (isUnexpected(removeBlockItem)) {
    throw removeBlockItem;
  }

  console.log("Removed blockItem: ", blockItemText);
}

(async () => {
  await removeBlockItems();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

JavaScript

const ContentSafetyClient = require("@azure-rest/ai-content-safety").default,
  { isUnexpected } = require("@azure-rest/ai-content-safety");
const { AzureKeyCredential } = require("@azure/core-auth");

const endpoint = "https://<my-custom-subdomain>.cognitiveservices.azure.com/";
const key = "<api_key>";

const credential = new AzureKeyCredential(key);
const client = ContentSafetyClient(endpoint, credential);

async function removeBlockItems() {
  const blocklistName = "TestBlocklist";
  const blockItemText = "sample";
  const addOrUpdateBlocklistItemsParameters = {
    body: {
      blocklistItems: [
        {
          description: "Test block item 1",
          text: blockItemText,
        },
      ],
    },
  };
  const result = await client
    .path("/text/blocklists/{blocklistName}:addOrUpdateBlocklistItems", blocklistName)
    .post(addOrUpdateBlocklistItemsParameters);
  if (isUnexpected(result) || result.body.blocklistItems === undefined) {
    throw new Error("Block item not added.");
  }
  const blockItemId = result.body.blocklistItems[0].blocklistItemId;

  const removeBlocklistItemsParameters = {
    body: {
      blocklistItemIds: [blockItemId],
    },
  };
  const removeBlockItem = await client
    .path("/text/blocklists/{blocklistName}:removeBlocklistItems", blocklistName)
    .post(removeBlocklistItemsParameters);

  if (isUnexpected(removeBlockItem)) {
    throw removeBlockItem;
  }

  console.log("Removed blockItem: ", blockItemText);
}

(async () => {
  await removeBlockItems();
})().catch((err) => {
  console.error("The sample encountered an error:", err);
});

Poradce při potížích

protokolování

Povolení protokolování může pomoct odhalit užitečné informace o selháních. Pokud chcete zobrazit protokol požadavků a odpovědí HTTP, nastavte proměnnou AZURE_LOG_LEVEL prostředí na info. Případně je možné protokolování povolit za běhu voláním setLogLevel v :@azure/logger

const { setLogLevel } = require("@azure/logger");

setLogLevel("info");

Podrobnější pokyny k povolení protokolů najdete v dokumentaci k balíčkům @azure/protokolovacího nástroje.

Další kroky

Další dokumentace

Rozsáhlejší dokumentaci k Azure Content Safety najdete v Bezpečnost obsahu Azure AI docs.microsoft.com.

Přispívání

Pokud chcete přispívat do této knihovny, přečtěte si prosím průvodce přispívání , kde se dozvíte více o tom, jak sestavit a otestovat kód.

Sdílet prostřednictvím

Bezpečnost obsahu Azure AI klientská knihovna REST pro JavaScript – verze 1.0.0

Začínáme

Aktuálně podporovaná prostředí

Požadavky

Nainstalujte balíček `@azure-rest/ai-content-safety`.

Vytvoření a ověření `ContentSafetyClient`

Získání koncového bodu

Vytvoření ContentSafetyClient pomocí AzureKeyCredential

Vytvoření objektu ContentSafetyClient s Microsoft Entra ID (dříve Azure Active Directory (AAD)) s přihlašovacími údaji tokenu

Klíčové koncepty

Dostupné funkce

Kategorie škod

Úrovně závažnosti

Správa seznamu blokovaných textů

Příklady

Analýza textu

Analýza textu bez seznamů blokovaných

Analýza textu pomocí seznamů blokovaných

Analýza obrázku

Správa seznamu blokovaných textů

Vytvoření nebo aktualizace seznamu blokovaných textů

Seznam blokovaných seznamů textu

Získání seznamu blokovaných textů

Odstranění seznamu blokovaných textů

Přidání blockItems

Seznam blockItems

Získání blockItem

Odebrat blockItems

Poradce při potížích

protokolování

Další kroky

Další dokumentace

Přispívání

Další materiály

Sdílet prostřednictvím

Bezpečnost obsahu Azure AI klientská knihovna REST pro JavaScript – verze 1.0.0

Začínáme

Aktuálně podporovaná prostředí

Požadavky

Nainstalujte balíček @azure-rest/ai-content-safety.

Vytvoření a ověření ContentSafetyClient

Získání koncového bodu

Vytvoření ContentSafetyClient pomocí AzureKeyCredential

Vytvoření objektu ContentSafetyClient s Microsoft Entra ID (dříve Azure Active Directory (AAD)) s přihlašovacími údaji tokenu

Klíčové koncepty

Dostupné funkce

Kategorie škod

Úrovně závažnosti

Správa seznamu blokovaných textů

Příklady

Analýza textu

Analýza textu bez seznamů blokovaných

Analýza textu pomocí seznamů blokovaných

Analýza obrázku

Správa seznamu blokovaných textů

Vytvoření nebo aktualizace seznamu blokovaných textů

Seznam blokovaných seznamů textu

Získání seznamu blokovaných textů

Odstranění seznamu blokovaných textů

Přidání blockItems

Seznam blockItems

Získání blockItem

Odebrat blockItems

Poradce při potížích

protokolování

Další kroky

Další dokumentace

Přispívání

Další materiály

Nainstalujte balíček `@azure-rest/ai-content-safety`.

Vytvoření a ověření `ContentSafetyClient`