Inicio rápido: análisis del contenido del texto

Requisitos previos

• Una cuenta de Azure. Si no tiene ninguna, puede crearla gratis.
• Un recurso Azure AI.

Configuración

Siga estos pasos para usar la página de prueba de seguridad del contenido:

1. Vaya a Azure AI Foundry y vaya al proyecto o centro. A continuación, seleccione la pestaña Guardrails + controls (Límites de protección y controles ) en el panel de navegación izquierdo y seleccione la pestaña Pruébelo .
2. En la página Pruébelo , puede experimentar con varias características de protección y controles, como el contenido de texto e imagen, usando umbrales ajustables para filtrar por contenido inapropiado o dañino.

Captura de pantalla de la página probarla para los controles y barreras de protección.

Análisis de texto

1. Seleccione el panel Contenido de texto moderado.
2. Agregue texto al campo de entrada o seleccione texto de ejemplo en los paneles de la página.
3. Haga clic en Ejecutar prueba. El servicio devuelve todas las categorías detectadas con el nivel de gravedad de cada una (0-Seguro, 2-Bajo, 4-Medio, 6-Alto). También devuelve un resultado binario AceptadoRechazado en función de los filtros que configure. Use la matriz de la pestaña Configure filters de la derecha para establecer los niveles de gravedad permitidos o prohibidos para cada categoría. A continuación, puede volver a ejecutar el texto para ver cómo funciona el filtro.

Visualización y exportación de código

Puede usar la característica View Code en la página Analyze text content o Analyze image content para ver y copiar el código de ejemplo, que incluye la configuración de las funciones de filtrado de gravedad, listas de bloqueados y moderación. A continuación, puede implementar el código en su entorno.

Recorte de pantalla del botón Ver código.

Requisitos previos

• Una suscripción Azure: Crear una gratuita
• Una vez que tenga la suscripción de Azure, crear un recurso de seguridad de contenido en el portal de Azure para obtener la clave y el punto de conexión. Escriba un nombre único para el recurso, seleccione la suscripción y, después, un grupo de recursos, una región admitida (consulte Región de disponibilidad) y el plan de tarifa admitido. Seleccione Crear.
  • El recurso tarda unos minutos en implementarse. Cuando termine, seleccione Ir al recurso. En el panel de la izquierda, en Administración de recursos, seleccione Clave y punto de conexión de la suscripción. El punto de conexión y cualquiera de las claves se usan para llamar a las API.
• Rol de usuario de Cognitive Services o superior en el recurso de Seguridad de Contenidos
• cURL instalado

Análisis de contenido de texto

En la sección siguiente se muestra una solicitud de ejemplo con cURL. Pegue el comando siguiente en un editor de texto y realice los cambios siguientes.

1. Reemplace por la dirección URL del punto de conexión asociada con el recurso.
2. Reemplace por una de las claves que vienen con el recurso.
3. Opcionalmente, reemplace el campo del cuerpo por su propio texto que le gustaría analizar.

   Sugerencia

   Granularidad y tamaño del texto

   Consulte Requisitos de entrada para conocer las limitaciones máximas de longitud 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"
}'

Los campos siguientes deben incluirse en la dirección URL:

Los parámetros del cuerpo de la solicitud se definen en esta tabla:

Consulte el siguiente cuerpo de solicitud de ejemplo:

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

Abra una ventana del símbolo del sistema, pegue el comando cURL editado y ejecútelo.

Salida

Debería ver los resultados de la moderación del texto mostrados como datos JSON en la salida de la consola. Por ejemplo:

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

Los campos JSON de la salida se definen aquí:

Referencias: API REST de seguridad de contenido, Text Analysis API

Reference documentation | Library source code | Package (NuGet) | Samples

Requisitos previos

• Una suscripción Azure: Crear una gratuita
• El IDE de Visual Studio con la carga de trabajo de desarrollo de escritorio de .NET habilitada. O bien, si no planea usar Visual Studio IDE, necesita la versión actual de .NET Core.
• Una vez que tenga la suscripción de Azure, crear un recurso de seguridad de contenido en el portal de Azure para obtener la clave y el punto de conexión. Escriba un nombre único para el recurso, seleccione la suscripción y, después, un grupo de recursos, una región admitida (consulte Región de disponibilidad) y el plan de tarifa admitido. Seleccione Crear.
  • El recurso tarda unos minutos en implementarse. Cuando termine, seleccione Ir al recurso. En el panel de la izquierda, en Administración de recursos, seleccione Clave y punto de conexión de la suscripción. El punto de conexión y cualquiera de las claves se usan para llamar a las API.
• Rol de usuario de Cognitive Services o superior en el recurso de Seguridad de Contenidos

Configurar la aplicación

Cree una aplicación de C#.

dotnet new console -n content-safety-quickstart

dotnet build

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

dotnet add package Azure.AI.ContentSafety

Creación de variables de entorno

En este ejemplo, escribirá las credenciales en variables de entorno del equipo local que ejecuta la aplicación.

Para establecer la variable de entorno para la clave y el punto de conexión, abra una ventana de consola y siga las instrucciones correspondientes a su sistema operativo y su entorno de desarrollo.

• Para establecer la variable de entorno , reemplace por una de las claves del recurso.
• Para establecer la variable de entorno , reemplace por el punto de conexión del 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'

Análisis de contenido de texto

En el directorio del proyecto, abra el archivo Program.cs que se creó anteriormente. Pegue el código siguiente:

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();
    }
  }
}

Reemplace por el contenido de texto que desea usar.

dotnet build
dotnet run

Analyze text succeeded:
Hate severity: 0
SelfHarm severity: 0
Sexual severity: 0
Violence severity: 0

Documentación de referencia | Código fuente de la biblioteca | Paquete (PyPI) | Ejemplos |

Requisitos previos

• Una suscripción Azure: Crear una gratuita
• Una vez que tenga la suscripción de Azure, crear un recurso de seguridad de contenido en el portal de Azure para obtener la clave y el punto de conexión. Escriba un nombre único para el recurso, seleccione la suscripción y, después, un grupo de recursos, una región admitida (consulte Región de disponibilidad) y el plan de tarifa admitido. Seleccione Crear.
  • El recurso tarda unos minutos en implementarse. Cuando termine, seleccione Ir al recurso. En el panel de la izquierda, en Administración de recursos, seleccione Clave y punto de conexión de la suscripción. El punto de conexión y cualquiera de las claves se usan para llamar a las API.
• Rol de usuario de Cognitive Services o superior en el recurso de Seguridad de Contenidos
• Python 3.x
  • La instalación de Python debe incluir pip. Puede comprobar si tiene pip instalado mediante la ejecución de en la línea de comandos. Obtenga pip instalando la versión más reciente de Python.

Creación de variables de entorno

En este ejemplo, escribirá las credenciales en variables de entorno del equipo local que ejecuta la aplicación.

Para establecer la variable de entorno para la clave y el punto de conexión, abra una ventana de consola y siga las instrucciones correspondientes a su sistema operativo y su entorno de desarrollo.

• Para establecer la variable de entorno , reemplace por una de las claves del recurso.
• Para establecer la variable de entorno , reemplace por el punto de conexión del 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'

Análisis de contenido de texto

En la sección siguiente se explica una solicitud de ejemplo con el SDK de Python.

1. Abra un símbolo del sistema, vaya a la carpeta del proyecto y cree un archivo denominado quickstart.py.

2. Ejecute este comando para instalar la biblioteca de Azure AI Content Safety:

   pip install azure-ai-contentsafety
   

3. Copie en quickstart.py el código siguiente:

   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. Reemplace por el contenido de texto que desea usar.

   Sugerencia

   Granularidad y tamaño del texto

   Consulte Requisitos de entrada para conocer las limitaciones máximas de longitud de texto.

5. Luego ejecute la aplicación con el comando en el archivo de inicio rápido.

   python quickstart.py
   

Salida prevista

El script generará puntuaciones de gravedad para cada categoría de contenido:

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

Los niveles de gravedad oscilan entre 0 (seguro) y 6 (alto riesgo).

Referencias: ContentSafetyClient, AnalyzeTextOptions, TextCategory

Reference documentation | Library source code | Artifact (Maven) | Samples

Requisitos previos

• Una suscripción Azure: Crear una gratuita
• La versión actual del kit de desarrollo de Java (JDK)
• La herramienta de compilación de Gradle u otro administrador de dependencias.
• Una vez que tenga la suscripción de Azure, crear un recurso de seguridad de contenido en el portal de Azure para obtener la clave y el punto de conexión. Escriba un nombre único para el recurso, seleccione la suscripción y, después, un grupo de recursos, una región admitida (consulte Región de disponibilidad) y el plan de tarifa admitido. Seleccione Crear.
  • El recurso tarda unos minutos en implementarse. Cuando termine, seleccione Ir al recurso. En el panel de la izquierda, en Administración de recursos, seleccione Clave y punto de conexión de la suscripción. El punto de conexión y cualquiera de las claves se usan para llamar a las API.
• Rol de usuario de Cognitive Services o superior en el recurso de Seguridad de Contenidos

Configurar la aplicación

Cree un proyecto de Gradle.

En una ventana de la consola (como cmd, PowerShell o Bash), cree un directorio para la aplicación y vaya a él.

mkdir myapp && cd myapp

Ejecute el comando desde el directorio de trabajo. Este comando creará archivos de compilación esenciales para Gradle, como build.gradle.kts, que se usa en tiempo de ejecución para crear y configurar la aplicación.

gradle init --type basic

Cuando se le solicite que elija un DSL, seleccione Kotlin.

En el directorio de trabajo, ejecute el siguiente comando para crear una carpeta de origen del proyecto:

mkdir -p src/main/java

Vaya a la nueva carpeta y cree un archivo llamado ContentSafetyQuickstart.java.

Instalación del SDK de cliente

En este inicio rápido se usa el administrador de dependencias Gradle. Puede encontrar la biblioteca de cliente y la información de otros administradores de dependencias en el repositorio central de Maven.

Busque build.gradle.kts y ábralo con el IDE o el editor de texto que prefiera. A continuación, cópielo en la siguiente configuración de compilación. Esta configuración define el proyecto como una aplicación Java cuyo punto de entrada es la clase ContentSafetyQuickstart. Importa la biblioteca de Azure AI Vision.

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

Creación de variables de entorno

En este ejemplo, escribirá las credenciales en variables de entorno del equipo local que ejecuta la aplicación.

Para establecer la variable de entorno para la clave y el punto de conexión, abra una ventana de consola y siga las instrucciones correspondientes a su sistema operativo y su entorno de desarrollo.

• Para establecer la variable de entorno , reemplace por una de las claves del recurso.
• Para establecer la variable de entorno , reemplace por el punto de conexión del 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'

Análisis de contenido de texto

Abra ContentSafetyQuickstart.java en el editor o IDE que prefiera y pegue el siguiente código. Reemplace por el contenido de texto que desea 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());
        }
    }
}

Vuelva a la carpeta raíz del proyecto y compile la aplicación con:

gradle build

A continuación, ejecútela con el comando :

gradle run

Salida

La aplicación genera puntuaciones de gravedad para cada categoría de contenido:

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

Los niveles de gravedad oscilan entre 0 (seguro) y 6 (alto riesgo). Las puntuaciones más altas indican contenido más grave en esa categoría.

Referencias: ContentSafetyClient, AnalyzeTextOptions, AnalyzeTextResult

Documentación de referencia | Código fuente de la biblioteca | Paquete (npm) | Ejemplos |

Requisitos previos

• Una suscripción Azure: Crear una gratuita
• La versión actual de Node.js
• Una vez que tenga la suscripción de Azure, crear un recurso de seguridad de contenido en el portal de Azure para obtener la clave y el punto de conexión. Escriba un nombre único para el recurso, seleccione la suscripción y, después, un grupo de recursos, una región admitida (consulte Región de disponibilidad) y el plan de tarifa admitido. Seleccione Crear.
  • El recurso tarda unos minutos en implementarse. Cuando termine, seleccione Ir al recurso. En el panel de la izquierda, en Administración de recursos, seleccione Clave y punto de conexión de la suscripción. El punto de conexión y cualquiera de las claves se usan para llamar a las API.
• Rol de usuario de Cognitive Services o superior en el recurso de Seguridad de Contenidos

Configurar la aplicación

Cree una nueva aplicación Node.js. En una ventana de la consola (como cmd, PowerShell o Bash), cree un directorio para la aplicación y vaya a él.

mkdir myapp && cd myapp

Ejecute el comando para crear una aplicación de nodo con un archivo .

npm init

Instalación del SDK de cliente

Instale el paquete npm :

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

Instale también el módulo para usar variables de entorno:

npm install dotenv

el archivo de la aplicación se actualizará con las dependencias.

Creación de variables de entorno

En este ejemplo, escribirá las credenciales en variables de entorno del equipo local que ejecuta la aplicación.

Para establecer la variable de entorno para la clave y el punto de conexión, abra una ventana de consola y siga las instrucciones correspondientes a su sistema operativo y su entorno de desarrollo.

• Para establecer la variable de entorno , reemplace por una de las claves del recurso.
• Para establecer la variable de entorno , reemplace por el punto de conexión del 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'

Análisis de contenido de texto

Cree un nuevo archivo en el directorio index.js. Ábralo en el editor o IDE que prefiera y pegue el siguiente código. Reemplace por el contenido de texto que desea 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);
});

Ejecute la aplicación con el comando en el archivo de inicio rápido.

node index.js

Salida

La aplicación genera puntuaciones de gravedad para cada categoría de contenido:

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

Los niveles de gravedad oscilan entre 0 (seguro) y 6 (alto riesgo).

Referencias: Cliente REST de seguridad de contenido, Text Analysis API

Documentación de referencia | Código fuente de la biblioteca | Paquete (npm) | Ejemplos |

Requisitos previos

• Una suscripción Azure: Crear una gratuita
• LTS de Node.js
• TypeScript
• Visual Studio Code
• Una vez que tenga la suscripción de Azure, crear un recurso de seguridad de contenido en el portal de Azure para obtener la clave y el punto de conexión. Escriba un nombre único para el recurso, seleccione la suscripción y, después, un grupo de recursos, una región admitida (consulte Región de disponibilidad) y el plan de tarifa admitido. Seleccione Crear.
  • El recurso tarda unos minutos en implementarse. Cuando termine, seleccione Ir al recurso. En el panel de la izquierda, en Administración de recursos, seleccione Clave y punto de conexión de la suscripción. El punto de conexión y cualquiera de las claves se usan para llamar a las API.
• Rol de usuario de Cognitive Services o superior en el recurso de Seguridad de Contenidos

Configurar la aplicación

1. Cree una nueva aplicación TypeScript. En una ventana de la consola (como cmd, PowerShell o Bash), cree un directorio para la aplicación y vaya a él.

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

2. Inicialice un nuevo proyecto de Node.js con TypeScript:

   npm init -y
   npm pkg set type=module
   

3. Instale los paquetes necesarios:

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

4. Instalar dependencias de desarrollo:

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

5. Cree un archivo en el directorio del proyecto:

   {
     "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. Actualice para incluir un script para compilar archivos TypeScript:

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

7. Cree un directorio para el código typeScript.

Creación de variables de entorno

En este ejemplo, escribirá las credenciales en variables de entorno del equipo local que ejecuta la aplicación.

Para establecer la variable de entorno para la clave y el punto de conexión, abra una ventana de consola y siga las instrucciones correspondientes a su sistema operativo y su entorno de desarrollo.

• Para establecer la variable de entorno , reemplace por una de las claves del recurso.
• Para establecer la variable de entorno , reemplace por el punto de conexión del 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'

Análisis de contenido de texto

Cree un archivo en el directorio denominado . Ábralo en el editor o IDE que prefiera y pegue el siguiente código. Reemplace por el contenido de texto que desea analizar.

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);
}

Compilación y ejecución de la aplicación

1. Compile el código typeScript:

npm run build

1. Ejecute la aplicación:

npm start

Salida

La aplicación genera puntuaciones de gravedad para cada categoría de contenido:

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

Los niveles de gravedad oscilan entre 0 (seguro) y 6 (alto riesgo).

Referencias: Cliente REST de seguridad de contenido, AzureKeyCredential