Prácticas recomendadas de seguridad

Para conocer las medidas de protección que aplica OpenAI, consulta Clasificadores de seguridad, verificaciones de ciberseguridad y monitoreo de desalineación. Si tu aplicación atiende a menores de edad, sigue también la Guía para menores de 18 años.

Usa nuestra API de moderación gratuita

La API de moderación de OpenAI es gratuita y puede ayudar a reducir la frecuencia con la que aparece contenido inseguro en las respuestas generadas. Como alternativa, puedes desarrollar tu propio sistema de filtrado de contenido adaptado a tu caso de uso.

Si tu aplicación genera texto con la API Responses o Chat Completions, también puedes solicitar puntuaciones de moderación en la solicitud de generación.

Pruebas adversariales

Recomendamos realizar “red teaming” en tu aplicación para comprobar que resista entradas adversariales. Prueba tu producto con una amplia variedad de entradas y comportamientos de los usuarios, tanto un conjunto representativo como casos que reflejen intentos de hacer que tu aplicación “falle”. ¿Se desvía del tema? ¿Alguien puede reorientar fácilmente la función mediante inyecciones de prompts, por ejemplo, “ignora las instrucciones anteriores y haz esto en su lugar”?

Intervención humana en el proceso (HITL)

Siempre que sea posible, recomendamos que una persona revise los resultados antes de utilizarlos en la práctica. Esto es especialmente importante en ámbitos de alto riesgo y para la generación de código. Quienes revisen los resultados deben conocer las limitaciones del sistema y tener acceso a toda la información necesaria para verificarlos (por ejemplo, si la aplicación resume notas, la persona debe poder consultar fácilmente las notas originales).

Ingeniería de prompts

La “ingeniería de prompts” puede ayudar a delimitar el tema y el tono del texto generado. Esto reduce la probabilidad de producir contenido no deseado, incluso si un usuario intenta generarlo. Proporcionar contexto adicional al modelo (por ejemplo, algunos ejemplos de buena calidad del comportamiento deseado antes de la nueva entrada) puede facilitar que sus resultados sigan la dirección deseada.

“Conoce a tu cliente” (KYC)

En general, los usuarios deberían tener que registrarse e iniciar sesión para acceder a tu servicio. Vincular este servicio a una cuenta existente, como una de Gmail, LinkedIn o Facebook, puede ayudar, aunque quizás no sea adecuado para todos los casos de uso. Exigir una tarjeta de crédito o un documento de identidad reduce aún más el riesgo.

Restringe las entradas de los usuarios y limita los tokens de salida

Limitar la cantidad de texto que un usuario puede introducir en el prompt ayuda a evitar la inyección de prompts. Limitar la cantidad de tokens de salida ayuda a reducir la probabilidad de uso indebido.

Acotar las entradas o salidas posibles, especialmente si provienen de fuentes confiables, reduce las posibilidades de uso indebido de una aplicación.

Permitir que los usuarios ingresen datos mediante campos desplegables validados (por ejemplo, una lista de películas de Wikipedia) puede ser más seguro que permitir entradas de texto libre.

Siempre que sea posible, devolver resultados de un conjunto de materiales validados en el backend puede ser más seguro que devolver contenido nuevo generado (por ejemplo, dirigir la consulta de un cliente al artículo de soporte existente que mejor responda a ella, en lugar de intentar responderla desde cero).

Permite que los usuarios reporten problemas

En general, los usuarios deberían contar con un medio de fácil acceso para reportar fallas u otras inquietudes sobre el comportamiento de la aplicación (una dirección de correo electrónico publicada, un método para enviar tickets, etc.). Una persona debería supervisar este canal y responder según corresponda.

Comprende y comunica las limitaciones

Los modelos de lenguaje pueden generar alucinaciones con información inexacta, resultados ofensivos, sesgos y muchos otros problemas, por lo que quizá no sean adecuados para todos los casos de uso sin modificaciones importantes. Considera si el modelo es adecuado para tu propósito y evalúa el desempeño de la API con una amplia variedad de entradas posibles para identificar los casos en que podría disminuir. Ten en cuenta a tus clientes y la variedad de entradas que usarán, y asegúrate de que sus expectativas sean realistas.

Implementa identificadores de seguridad

Enviar identificadores de seguridad en tus solicitudes puede ayudar a OpenAI a monitorear y detectar abusos. Esto nos permite proporcionar a tu equipo información más útil para tomar medidas si detectamos alguna infracción de las políticas en tu aplicación.

Los identificadores de seguridad también pueden ayudar a tu equipo a responder más rápido ante los abusos. Ofrecen una forma estable de rastrear la actividad hasta un usuario final específico y reducen la probabilidad de que el uso indebido de una persona interrumpa el acceso del resto de tu organización.

Un identificador de seguridad debe ser una cadena que identifique de forma única a cada usuario. Aplica una función hash al nombre de usuario o a la dirección de correo electrónico para evitar enviarnos información que permita identificarlo. Si ofreces una vista previa de tu producto a usuarios que no han iniciado sesión, puedes enviar un ID de sesión en su lugar.

Los identificadores de seguridad se recomiendan para productos en los que los usuarios interactúan individualmente con un modelo, pero no son obligatorios. Incluye identificadores de seguridad en tus solicitudes a la API mediante el parámetro safety_identifier:

1
2
3
4
5
6
7
8
9
10
11
12import OpenAI from "openai";

const client = new OpenAI();

const response = await client.chat.completions.create({
  model: "gpt-6-astra",
  messages: [{ role: "user", content: "This is a test" }],
  max_completion_tokens: 5,
  safety_identifier: "user_123456",
});

console.log(response.choices[0].message.content);

1
2
3
4
5
6
7
8
9
10from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[{"role": "user", "content": "This is a test"}],
    max_completion_tokens=5,
    safety_identifier="user_123456",
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
)

func main() {
	client := openai.NewClient()
	response, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
		Model:               "gpt-6-astra",
		Messages:            []openai.ChatCompletionMessageParamUnion{openai.UserMessage("This is a test")},
		MaxCompletionTokens: openai.Int(5),
		SafetyIdentifier:    openai.String("user_123456"),
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.Choices[0].Message.Content)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

ChatCompletionCreateParams params =
    ChatCompletionCreateParams.builder()
        .model("gpt-6-astra")
        .addUserMessage("Help me plan a study schedule.")
        .safetyIdentifier("user_1234")
        .build();

client.chat().completions().create(params).choices().stream()
    .flatMap(choice -> choice.message().content().stream())
    .forEach(System.out::println);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15require "openai"

client = OpenAI::Client.new
completion = client.chat.completions.create(
  model: "gpt-6-astra",
  messages: [
    {
      role: :user,
      content: "Help me plan a study schedule."
    }
  ],
  safety_identifier: "user_1234"
)

puts(completion.choices.fetch(0).message.content)

1
2
3
4
5
6
7
8
9
10
11curl https://api.openai.com/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "gpt-6-astra",
"messages": [
{"role": "user", "content": "This is a test"}
],
"max_completion_tokens": 5,
"safety_identifier": "user123456"
}'

Para las solicitudes a Realtime API, proporciona el mismo identificador estable que preserva la privacidad mediante el encabezado OpenAI-Safety-Identifier. Cuando crees un secreto de cliente efímero de Realtime, incluye el encabezado en la solicitud del servidor que crea el secreto para que el identificador quede vinculado a esa sesión. Para las solicitudes de conexión directa por WebSocket o WebRTC realizadas desde un backend confiable, incluye el encabezado en la solicitud de conexión.

Los identificadores de seguridad no se transfieren entre API ni entre sesiones. Si tu aplicación ya envía safety_identifier en las solicitudes a la API Responses, pasa el mismo valor estable por separado al crear cada sesión de Realtime o conectarte a ella.

Revoca las claves de API comprometidas

Si crees que una clave de API se ha expuesto, se ha usado indebidamente o se ha comprometido de alguna otra forma, revócala de inmediato y reemplázala por una nueva. Ve a tu configuración de seguridad para ver todas las claves de API y revocar las que estén comprometidas.

Guía sobre MASI

OpenAI ha colaborado con expertos en seguridad infantil, incluidos NCMEC y Thorn, para ofrecer a los desarrolladores orientación práctica para proteger a los niños. Lee la guía sobre MASI.