Início Rápido: Analisar conteúdo de texto

Pré-requisitos

• Uma conta do Azure. Se você não tiver uma conta, é possível criar uma gratuitamente.
• Um recurso de IA do Azure.

Configuração

Siga estas etapas para usar a página Experimentar a Segurança do Conteúdo:

1. Acesse Azure AI Foundry e navegue até seu projeto/hub. Em seguida, selecione a guia Guardrails + controles na navegação esquerda e selecione a guia Experimentar .
2. Na página Experimentar , você pode experimentar vários recursos do Guardrails &controls, como conteúdo de texto e imagem, usando limites ajustáveis para filtrar conteúdo inadequado ou prejudicial.

Analisar o texto

1. Selecione o painel Moderar conteúdo de texto.
2. Adicione texto ao campo de entrada ou selecione o texto de exemplo nos painéis da página.
3. Selecione Executar teste. O serviço retorna todas as categorias que foram detectadas, com o nível de severidade para cada: 0-Seguro, 2-Baixo, 4-Médio, 6-Alto. Ele também retorna um resultado binário Aceito/Rejeitado, com base nos filtros configurados. Use a matriz no guia Configurar filtros para definir os níveis de severidade permitidos/proibidos de cada categoria. Depois, você pode reexecutar o texto para ver como o filtro funciona.

Exibir e exportar o código

Use o recurso Exibir Código nas páginas Analisar conteúdo de texto ou Analisar conteúdo de imagem para exibir e copiar o código de exemplo, que inclui a configuração para a filtragem de severidade, lista de bloqueados e funções de moderação. Depois, você pode implantar o código do seu lado.

Pré-requisitos

• Uma assinatura do Azure – crie uma gratuitamente
• Depois de ter sua assinatura do Azure, crie um recurso de Segurança de Conteúdo no portal do Azure para obter sua chave e ponto de extremidade. Insira um nome exclusivo para o recurso, selecione a assinatura e selecione um grupo de recursos, uma região com suporte (confira a Disponibilidade de região) e um tipo de preço com suporte. Em seguida, selecione Criar.
  • O recurso demora alguns minutos para implantar. Após a conclusão, selecione ir para o recurso. No painel à esquerda, em Gerenciamento de Recursos, selecione Chave de Assinatura e Ponto de Extremidade. O endpoint e uma das chaves são usados para chamar APIs.
• cURL instalado

Analisar conteúdo do texto

A seção a seguir percorre uma solicitação de exemplo com cURL. Cole o comando abaixo em um editor de texto e faça as seguintes alterações.

1. Substitua <endpoint> pelo URL do ponto de extremidade associado ao seu recurso.
2. substitua <your_subscription_key> por uma das chaves que vêm com o recurso.
3. Opcionalmente, substitua o campo "text" no corpo pelo próprio texto que você gostaria de analisar.

   Dica

   Tamanho e granularidade do texto

   Confira os requisitos de entrada para ver as limitações máximas de comprimento de texto.

curl --___location --request POST '<endpoint>/contentsafety/text:analyze?api-version=2024-09-01' \
--header 'Ocp-Apim-Subscription-Key: <your_subscription_key>' \
--header 'Content-Type: application/json' \
--data-raw '{
  "text": "I hate you",
  "categories": ["Hate", "Sexual", "SelfHarm", "Violence"],
  "blocklistNames": ["string"],
  "haltOnBlocklistHit": true,
  "outputType": "FourSeverityLevels"
}'

Os campos abaixo devem ser incluídos na URL:

Os parâmetros no corpo da solicitação são definidos nesta tabela:

Confira o seguinte corpo da solicitação de exemplo:

{
  "text": "I hate you",
  "categories": ["Hate", "Sexual", "SelfHarm", "Violence"],
  "blocklistNames": ["array"],
  "haltOnBlocklistHit": false,
  "outputType": "FourSeverityLevels"
}

Abra uma janela do prompt de comando, cole o comando cURL editado e execute.

Saída

Você deve ver os resultados da moderação de texto exibidos como dados JSON na janela do console. Por exemplo:

{
  "blocklistsMatch": [
    {
      "blocklistName": "string",
      "blocklistItemId": "string",
      "blocklistItemText": "string"
    }
  ],
  "categoriesAnalysis": [
    {
      "category": "Hate",
      "severity": 2
    },
    {
      "category": "SelfHarm",
      "severity": 0
    },
    {
      "category": "Sexual",
      "severity": 0
    },
    {
      "category": "Violence",
      "severity": 0
    }
  ]
}

Os campos JSON na saída são definidos aqui:

Documentação de referência | Código-fonte da biblioteca | Pacote (NuGet) | Exemplos

Pré-requisitos

• Uma assinatura do Azure – crie uma gratuitamente
• O IDE do Visual Studio com a carga de trabalho de desenvolvimento da área de trabalho do .NET habilitada. Ou, se você não planeja usar o IDE do Visual Studio, precisará da versão atual do .NET Core.
• Depois de ter sua assinatura do Azure, crie um recurso de Segurança de Conteúdo no portal do Azure para obter sua chave e ponto de extremidade. Insira um nome exclusivo para o recurso, selecione a assinatura e selecione um grupo de recursos, uma região com suporte (confira a Disponibilidade de região) e um tipo de preço com suporte. Em seguida, selecione Criar.
  • O recurso demora alguns minutos para implantar. Após a conclusão, selecione ir para o recurso. No painel à esquerda, em Gerenciamento de Recursos, selecione Chave de Assinatura e Ponto de Extremidade. O endpoint e uma das chaves são usados para chamar APIs.

Configurar o aplicativo

Criar um aplicativo em C#.

dotnet new console -n content-safety-quickstart

dotnet build

...
Build succeeded.
  0 Warning(s)
  0 Error(s)
...

dotnet add package Azure.AI.ContentSafety

Criar variáveis de ambiente

Neste exemplo, você gravará as credenciais em variáveis de ambiente no computador local que está executando o aplicativo.

Para definir a variável de ambiente para sua chave e endpoint, abra uma janela de console e siga as instruções para o seu sistema operacional e ambiente de desenvolvimento.

• Para definir a variável de ambiente CONTENT_SAFETY_KEY, substitua YOUR_CONTENT_SAFETY_KEY por uma das chaves do recurso.
• Para definir a variável de ambiente CONTENT_SAFETY_ENDPOINT, substitua YOUR_CONTENT_SAFETY_ENDPOINT pelo ponto de extremidade do recurso.

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Analisar conteúdo do texto

No diretório do projeto, abra o arquivo Program.cs que foi criado anteriormente. Cole o código a seguir:

using System;
using Azure.AI.ContentSafety;

namespace Azure.AI.ContentSafety.Dotnet.Sample
{
  class ContentSafetySampleAnalyzeText
  {
    public static void AnalyzeText()
    {
      // retrieve the endpoint and key from the environment variables created earlier
      string endpoint = Environment.GetEnvironmentVariable("CONTENT_SAFETY_ENDPOINT");
      string key = Environment.GetEnvironmentVariable("CONTENT_SAFETY_KEY");

      ContentSafetyClient client = new ContentSafetyClient(new Uri(endpoint), new AzureKeyCredential(key));

      string text = "Your input text";

      var request = new AnalyzeTextOptions(text);

      Response<AnalyzeTextResult> response;
      try
      {
          response = client.AnalyzeText(request);
      }
      catch (RequestFailedException ex)
      {
          Console.WriteLine("Analyze text failed.\nStatus code: {0}, Error code: {1}, Error message: {2}", ex.Status, ex.ErrorCode, ex.Message);
          throw;
      }

      Console.WriteLine("\nAnalyze text succeeded:");
      Console.WriteLine("Hate severity: {0}", response.Value.CategoriesAnalysis.FirstOrDefault(a => a.Category == TextCategory.Hate)?.Severity ?? 0);
      Console.WriteLine("SelfHarm severity: {0}", response.Value.CategoriesAnalysis.FirstOrDefault(a => a.Category == TextCategory.SelfHarm)?.Severity ?? 0);
      Console.WriteLine("Sexual severity: {0}", response.Value.CategoriesAnalysis.FirstOrDefault(a => a.Category == TextCategory.Sexual)?.Severity ?? 0);
      Console.WriteLine("Violence severity: {0}", response.Value.CategoriesAnalysis.FirstOrDefault(a => a.Category == TextCategory.Violence)?.Severity ?? 0);

    }
    static void Main()
    {
        AnalyzeText();
    }
  }
}

Substitua "Your input text" pelo conteúdo de texto que você gostaria de usar.

dotnet build
dotnet run

Documentação de referência | Código-fonte da biblioteca | Pacote (PyPI) | Amostras |

Pré-requisitos

• Uma assinatura do Azure – crie uma gratuitamente
• Depois de ter sua assinatura do Azure, crie um recurso de Segurança de Conteúdo no portal do Azure para obter sua chave e ponto de extremidade. Insira um nome exclusivo para o recurso, selecione a assinatura e selecione um grupo de recursos, uma região com suporte (confira a Disponibilidade de região) e um tipo de preço com suporte. Em seguida, selecione Criar.
  • O recurso demora alguns minutos para implantar. Após a conclusão, selecione ir para o recurso. No painel à esquerda, em Gerenciamento de Recursos, selecione Chave de Assinatura e Ponto de Extremidade. O endpoint e uma das chaves são usados para chamar APIs.
• Python 3.x
  • A instalação do Python deve incluir o pip. Você pode executar pip --version na linha de comando para verificar se o pip está instalado. Instale a versão mais recente do Python para obter o pip.

Criar variáveis de ambiente

Neste exemplo, você gravará as credenciais em variáveis de ambiente no computador local que está executando o aplicativo.

Para definir a variável de ambiente para sua chave e endpoint, abra uma janela de console e siga as instruções para o seu sistema operacional e ambiente de desenvolvimento.

• Para definir a variável de ambiente CONTENT_SAFETY_KEY, substitua YOUR_CONTENT_SAFETY_KEY por uma das chaves do recurso.
• Para definir a variável de ambiente CONTENT_SAFETY_ENDPOINT, substitua YOUR_CONTENT_SAFETY_ENDPOINT pelo ponto de extremidade do recurso.

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Analisar conteúdo do texto

A seção a seguir percorre uma solicitação de exemplo com o SDK do Python.

1. Abra um prompt de comando, navegue até a pasta do projeto e crie um novo arquivo chamado quickstart.py.

2. Execute este comando para instalar a biblioteca de Segurança de Conteúdo da IA do Azure:

   pip install azure-ai-contentsafety
   

3. Copie o seguinte código em quickstart.py:

   import os
   from azure.ai.contentsafety import ContentSafetyClient
   from azure.core.credentials import AzureKeyCredential
   from azure.core.exceptions import HttpResponseError
   from azure.ai.contentsafety.models import AnalyzeTextOptions, TextCategory
   
   def analyze_text():
       # analyze text
       key = os.environ["CONTENT_SAFETY_KEY"]
       endpoint = os.environ["CONTENT_SAFETY_ENDPOINT"]
   
       # Create an Azure AI Content Safety client
       client = ContentSafetyClient(endpoint, AzureKeyCredential(key))
   
       # Contruct request
       request = AnalyzeTextOptions(text="Your input text")
   
       # Analyze text
       try:
           response = client.analyze_text(request)
       except HttpResponseError as e:
           print("Analyze text failed.")
           if e.error:
               print(f"Error code: {e.error.code}")
               print(f"Error message: {e.error.message}")
               raise
           print(e)
           raise
   
       hate_result = next(item for item in response.categories_analysis if item.category == TextCategory.HATE)
       self_harm_result = next(item for item in response.categories_analysis if item.category == TextCategory.SELF_HARM)
       sexual_result = next(item for item in response.categories_analysis if item.category == TextCategory.SEXUAL)
       violence_result = next(item for item in response.categories_analysis if item.category == TextCategory.VIOLENCE)
   
       if hate_result:
           print(f"Hate severity: {hate_result.severity}")
       if self_harm_result:
           print(f"SelfHarm severity: {self_harm_result.severity}")
       if sexual_result:
           print(f"Sexual severity: {sexual_result.severity}")
       if violence_result:
           print(f"Violence severity: {violence_result.severity}")
   
   if __name__ == "__main__":
       analyze_text()
   

4. Substitua "Your input text" pelo conteúdo de texto que você gostaria de usar.

   Dica

   Tamanho e granularidade do texto

   Confira os requisitos de entrada para ver as limitações máximas de comprimento de texto.

5. Execute o aplicativo com o comando python no arquivo de início rápido.

   python quickstart.py
   

Documentação de referência | Código-fonte da biblioteca | Artefato (Maven) | Exemplos

Pré-requisitos

• Uma assinatura do Azure – crie uma gratuitamente
• A versão atual do JDK (Java Development Kit)
• A ferramenta de build Gradle ou outro gerenciador de dependência.
• Depois de ter sua assinatura do Azure, crie um recurso de Segurança de Conteúdo no portal do Azure para obter sua chave e ponto de extremidade. Insira um nome exclusivo para o recurso, selecione a assinatura e selecione um grupo de recursos, uma região com suporte (confira a Disponibilidade de região) e um tipo de preço com suporte. Em seguida, selecione Criar.
  • O recurso demora alguns minutos para implantar. Após a conclusão, selecione ir para o recurso. No painel à esquerda, em Gerenciamento de Recursos, selecione Chave de Assinatura e Ponto de Extremidade. O endpoint e uma das chaves são usados para chamar APIs.

Configurar o aplicativo

Criar um novo projeto Gradle.

Em uma janela de console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo e navegue até ele.

mkdir myapp && cd myapp

Execute o comando gradle init em seu diretório de trabalho. Esse comando criará arquivos de build essenciais para o Gradle, incluindo o build.gradle.kts, que é usado no runtime para criar e configurar seu aplicativo.

gradle init --type basic

Quando solicitado a escolher uma DSL, escolha Kotlin.

Em seu diretório de trabalho, execute o comando a seguir para criar uma pasta de origem do projeto:

mkdir -p src/main/java

Navegue até a nova pasta e crie um arquivo chamado ContentSafetyQuickstart.java.

Instalar o cliente SDK

Este início rápido usa o gerenciador de dependência do Gradle. Você pode encontrar a biblioteca de clientes e informações para outros gerenciadores de dependência no Repositório Central do Maven.

Localize o build.gradle.kts e abra-o com seu IDE ou editor de texto preferencial. Depois copie nessa configuração de build a seguir. Essa configuração define o projeto como um aplicativo Java, cujo ponto de entrada é a classe ContentSafetyQuickstart. Importa a biblioteca Azure para Visão de IA.

plugins {
    java
    application
}
application { 
    mainClass.set("ContentSafetyQuickstart")
}
repositories {
    mavenCentral()
}
dependencies {
    implementation(group = "com.azure", name = "azure-ai-contentsafety", version = "1.0.0")
}

Criar variáveis de ambiente

Neste exemplo, você gravará as credenciais em variáveis de ambiente no computador local que está executando o aplicativo.

Para definir a variável de ambiente para sua chave e endpoint, abra uma janela de console e siga as instruções para o seu sistema operacional e ambiente de desenvolvimento.

• Para definir a variável de ambiente CONTENT_SAFETY_KEY, substitua YOUR_CONTENT_SAFETY_KEY por uma das chaves do recurso.
• Para definir a variável de ambiente CONTENT_SAFETY_ENDPOINT, substitua YOUR_CONTENT_SAFETY_ENDPOINT pelo ponto de extremidade do recurso.

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Analisar conteúdo do texto

Abra ContentSafetyQuickstart.java no editor ou IDE de sua preferência e cole o código a seguir. Substitua <your text sample> pelo conteúdo de texto que você gostaria de usar.

import com.azure.ai.contentsafety.ContentSafetyClient;
import com.azure.ai.contentsafety.ContentSafetyClientBuilder;
import com.azure.ai.contentsafety.models.AnalyzeTextOptions;
import com.azure.ai.contentsafety.models.AnalyzeTextResult;
import com.azure.ai.contentsafety.models.TextCategoriesAnalysis;
import com.azure.core.credential.KeyCredential;
import com.azure.core.util.Configuration;


public class ContentSafetyQuickstart {
    public static void main(String[] args) {

        // get endpoint and key from environment variables
        String endpoint = System.getenv("CONTENT_SAFETY_ENDPOINT");
        String key = System.getenv("CONTENT_SAFETY_KEY");
        
        ContentSafetyClient contentSafetyClient = new ContentSafetyClientBuilder()
            .credential(new KeyCredential(key))
            .endpoint(endpoint).buildClient();

        AnalyzeTextResult response = contentSafetyClient.analyzeText(new AnalyzeTextOptions("<your text sample>"));

        for (TextCategoriesAnalysis result : response.getCategoriesAnalysis()) {
            System.out.println(result.getCategory() + " severity: " + result.getSeverity());
        }
    }
}

Navegue de volta para a pasta raiz do projeto e compile o aplicativo com:

gradle build

Em seguida, execute-o com o comando gradle run:

gradle run

Saída

Hate severity: 0
SelfHarm severity: 0
Sexual severity: 0
Violence severity: 0

Documentação de referência | Código-fonte da biblioteca | Pacote (npm) | Exemplos |

Pré-requisitos

• Uma assinatura do Azure – crie uma gratuitamente
• A versão atual do Node.js
• Depois de ter sua assinatura do Azure, crie um recurso de Segurança de Conteúdo no portal do Azure para obter sua chave e ponto de extremidade. Insira um nome exclusivo para o recurso, selecione a assinatura e selecione um grupo de recursos, uma região com suporte (confira a Disponibilidade de região) e um tipo de preço com suporte. Em seguida, selecione Criar.
  • O recurso demora alguns minutos para implantar. Após a conclusão, selecione ir para o recurso. No painel à esquerda, em Gerenciamento de Recursos, selecione Chave de Assinatura e Ponto de Extremidade. O endpoint e uma das chaves são usados para chamar APIs.

Configurar o aplicativo

Crie um aplicativo Node.js. Em uma janela de console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo e navegue até ele.

mkdir myapp && cd myapp

Execute o comando npm init para criar um aplicativo do Node com um arquivo package.json.

npm init

Instalar o cliente SDK

Instale o pacote npm @azure-rest/ai-content-safety:

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

Além disso, instale o módulo dotenv para usar variáveis de ambiente:

npm install dotenv

O arquivo package.json do seu aplicativo será atualizado para incluir as dependências.

Criar variáveis de ambiente

Neste exemplo, você gravará as credenciais em variáveis de ambiente no computador local que está executando o aplicativo.

Para definir a variável de ambiente para sua chave e endpoint, abra uma janela de console e siga as instruções para o seu sistema operacional e ambiente de desenvolvimento.

• Para definir a variável de ambiente CONTENT_SAFETY_KEY, substitua YOUR_CONTENT_SAFETY_KEY por uma das chaves do recurso.
• Para definir a variável de ambiente CONTENT_SAFETY_ENDPOINT, substitua YOUR_CONTENT_SAFETY_ENDPOINT pelo ponto de extremidade do recurso.

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Analisar conteúdo do texto

Crie um novo arquivo no seu diretório, index.js. Abra-o no editor ou IDE de sua preferência e cole o código a seguir. Substitua <your text sample> pelo conteúdo de texto que você gostaria de usar.

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

// Load the .env file if it exists
require("dotenv").config();

async function main() {
    // get endpoint and key from environment variables
    const endpoint = process.env["CONTENT_SAFETY_ENDPOINT"];
    const key = process.env["CONTENT_SAFETY_KEY"];
    
    const credential = new AzureKeyCredential(key);
    const client = ContentSafetyClient(endpoint, credential);
    
    // replace with your own sample text string 
    const text = "<your 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);
});

Execute o aplicativo com o comando node no seu arquivo de início rápido.

node index.js

Saída

Hate severity:  0
SelfHarm severity:  0
Sexual severity:  0
Violence severity:  0

Documentação de referência | Código-fonte da biblioteca | Pacote (npm) | Exemplos |

Pré-requisitos

• Uma assinatura do Azure – crie uma gratuitamente
• Node.js LTS
• TypeScript
• Código do Visual Studio
• Depois de ter sua assinatura do Azure, crie um recurso de Segurança de Conteúdo no portal do Azure para obter sua chave e ponto de extremidade. Insira um nome exclusivo para o recurso, selecione a assinatura e selecione um grupo de recursos, uma região com suporte (confira a Disponibilidade de região) e um tipo de preço com suporte. Em seguida, selecione Criar.
  • O recurso demora alguns minutos para implantar. Após a conclusão, selecione ir para o recurso. No painel à esquerda, em Gerenciamento de Recursos, selecione Chave de Assinatura e Ponto de Extremidade. O endpoint e uma das chaves são usados para chamar APIs.

Configurar o aplicativo

1. Crie um novo aplicativo TypeScript. Em uma janela de console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo e navegue até ele.

   mkdir content-safety-typescript && cd content-safety-typescript
   code .
   

2. Inicialize um novo projeto de Node.js com o TypeScript:

   npm init -y
   npm pkg set type=module
   

3. Instale os pacotes necessários:

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

4. Instalar as dependências de desenvolvimento:

   npm install typescript @types/node --save-dev
   

5. Crie um tsconfig.json arquivo no diretório do projeto:

   {
     "compilerOptions": {
       "target": "es2022",
       "module": "esnext",
       "moduleResolution": "bundler",
       "rootDir": "./src",
       "outDir": "./dist/",
       "esModuleInterop": true,
       "forceConsistentCasingInFileNames": true,
       "strict": true,
       "skipLibCheck": true,
       "declaration": true,
       "sourceMap": true,
       "resolveJsonModule": true,
       "moduleDetection": "force",
       "allowSyntheticDefaultImports": true,
       "verbatimModuleSyntax": false
     },
     "include": [
       "src/**/*.ts"
     ],
     "exclude": [
       "node_modules/**/*",
       "**/*.spec.ts"
     ]
   }
   

6. Atualize package.json para incluir um script para a criação de arquivos TypeScript:

   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js"
   }
   

7. Crie um src diretório para o código TypeScript.

Criar variáveis de ambiente

Neste exemplo, você gravará as credenciais em variáveis de ambiente no computador local que está executando o aplicativo.

Para definir a variável de ambiente para sua chave e endpoint, abra uma janela de console e siga as instruções para o seu sistema operacional e ambiente de desenvolvimento.

• Para definir a variável de ambiente CONTENT_SAFETY_KEY, substitua YOUR_CONTENT_SAFETY_KEY por uma das chaves do recurso.
• Para definir a variável de ambiente CONTENT_SAFETY_ENDPOINT, substitua YOUR_CONTENT_SAFETY_ENDPOINT pelo ponto de extremidade do recurso.

setx CONTENT_SAFETY_KEY 'YOUR_CONTENT_SAFETY_KEY'

setx CONTENT_SAFETY_ENDPOINT 'YOUR_CONTENT_SAFETY_ENDPOINT'

export CONTENT_SAFETY_KEY='YOUR_CONTENT_SAFETY_KEY'

export CONTENT_SAFETY_ENDPOINT='YOUR_CONTENT_SAFETY_ENDPOINT'

Analisar conteúdo do texto

Crie um arquivo no src diretório chamado index.ts. Abra-o no editor ou IDE de sua preferência e cole o código a seguir. Substitua <your text sample> pelo conteúdo de texto que você gostaria de analisar.

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

// Get endpoint and key from environment variables
const endpoint = process.env.CONTENT_SAFETY_ENDPOINT;
const key = process.env.CONTENT_SAFETY_KEY;

if (!endpoint || !key) {
  throw new Error("Missing required environment variables: CONTENT_SAFETY_ENDPOINT or CONTENT_SAFETY_KEY");
}

try {
  // Create client with Azure Key Credential
  const credential = new AzureKeyCredential(key);
  const client = ContentSafetyClient(endpoint, credential);
  
  // Replace with your own sample text string
  const text = "Replace with your text sample";
  const analyzeTextOption: AnalyzeTextOptions = { text };
  const analyzeTextParameters: AnalyzeTextParameters = { body: analyzeTextOption };
  
  // Call the Content Safety API to analyze the text
  const result: AnalyzeText200Response | AnalyzeTextDefaultResponse = await client.path("/text:analyze").post(analyzeTextParameters);
  
  if (isUnexpected(result)) {
    throw result;
  }
  
  // Process and display the analysis results
  console.log("Text analysis results:");
  
  const categoriesAnalysis = result.body.categoriesAnalysis as TextCategoriesAnalysisOutput[];
  
  for (const analysis of categoriesAnalysis) {
    console.log(`${analysis.category} severity: ${analysis.severity}`);
  }
} catch (error: any) {
  console.error("The sample encountered an error:", error.message);
}

Compile e execute o aplicativo

1. Crie o código TypeScript:

npm run build

1. Execute o aplicativo:

npm start

Saída

Text analysis results:
Hate severity: 0
SelfHarm severity: 0
Sexual severity: 0
Violence severity: 0