guardrails

¿Qué son guardrails ?

guardrails es un marco de Python que ayuda a crear aplicaciones de IA confiables realizando dos funciones clave:

1. guardrails ejecuta protectores de entrada/salida en su aplicación que detectan, cuantifican y mitigan la presencia de tipos específicos de riesgos. Para ver el conjunto completo de riesgos, consulte guardrails Hub.
2. guardrails lo ayudan a generar datos estructurados a partir de LLM.

cubo guardrails

guardrails Hub es una colección de medidas prediseñadas de tipos específicos de riesgos (llamados "validadores"). Se pueden combinar varios validadores en protectores de entrada y salida que interceptan las entradas y salidas de los LLM. Visite guardrails Hub para ver la lista completa de validadores y su documentación.

Instalación

 pip install guardrails - ai 

Empezando

Cree protecciones de entrada y salida para la validación de LLM

1. Descargue y configure la CLI guardrails Hub.

   pip install guardrails -ai
   guardrails configure

2. Instale una barandilla desde guardrails Hub.

    guardrails hub install hub:// guardrails /regex_match

3. Cree una barrera a partir de la barandilla instalada.

    from guardrails import Guard , OnFailAction
   from guardrails . hub import RegexMatch
   
   guard = Guard (). use (
       RegexMatch , regex = "(?d{3})?-? *d{3}-? *-?d{4}" , on_fail = OnFailAction . EXCEPTION
   )
   
   guard . validate ( "123-456-7890" )  # Guardrail passes
   
   try :
       guard . validate ( "1234-789-0000" )  # Guardrail fails
   except Exception as e :
       print ( e )

   Producción:

    Validation failed for field with errors: Result must match (?d{3})?-? *d{3}-? *-?d{4}

4. Ejecute varias guardrails dentro de un Guard. Primero, instale las guardrails necesarias desde guardrails Hub.

    guardrails hub install hub:// guardrails /competitor_check
   guardrails hub install hub:// guardrails /toxic_language

   Luego, cree una Guardia a partir de las guardrails instaladas.

    from guardrails import Guard , OnFailAction
   from guardrails . hub import CompetitorCheck , ToxicLanguage
   
   guard = Guard (). use_many (
       CompetitorCheck ([ "Apple" , "Microsoft" , "Google" ], on_fail = OnFailAction . EXCEPTION ),
       ToxicLanguage ( threshold = 0.5 , validation_method = "sentence" , on_fail = OnFailAction . EXCEPTION )
   )
   
   guard . validate (
       """An apple a day keeps a doctor away.
       This is good advice for keeping your health."""
   )  # Both the guardrails pass
   
   try :
       guard . validate (
           """Shut the hell up! Apple just released a new iPhone."""
       )  # Both the guardrails fail
   except Exception as e :
       print ( e )

   Producción:

    Validation failed for field with errors: Found the following competitors: [['Apple']]. Please avoid naming those competitors next time, The following sentences in your response were found to be toxic:
   
   - Shut the hell up!

Utilice guardrails para generar datos estructurados a partir de LLM

Veamos un ejemplo en el que le pedimos a un LLM que genere nombres de mascotas falsos. Para hacer esto, crearemos un Pydantic BaseModel que represente la estructura de la salida que queremos.

 from pydantic import BaseModel , Field

class Pet ( BaseModel ):
    pet_type : str = Field ( description = "Species of pet" )
    name : str = Field ( description = "a unique pet name" )

Ahora, crea un Guardia de la clase Pet . Guard se puede utilizar para llamar al LLM de manera que la salida esté formateada en la clase Pet . En el fondo, esto se hace mediante cualquiera de dos métodos:

1. Llamada de funciones: para los LLM que admiten llamadas de funciones, generamos datos estructurados utilizando la sintaxis de llamadas de funciones.
2. Optimización del mensaje: para los LLM que no admiten llamadas a funciones, agregamos el esquema del resultado esperado al mensaje para que el LLM pueda generar datos estructurados.

 from guardrails import Guard
import openai

prompt = """
    What kind of pet should I get and what should I name it?

    ${gr.complete_json_suffix_v2}
"""
guard = Guard . for_pydantic ( output_class = Pet , prompt = prompt )

raw_output , validated_output , * rest = guard (
    llm_api = openai . completions . create ,
    engine = "gpt-3.5-turbo-instruct"
)

print ( validated_output )

Esto imprime:

 {
    "pet_type": "dog",
    "name": "Buddy
}

Servidor guardrails

guardrails se puede configurar como un servicio independiente servido por Flask con guardrails start , lo que le permite interactuar con él a través de una API REST. Este enfoque simplifica el desarrollo y la implementación de aplicaciones basadas en guardrails .

1. Instalar: pip install " guardrails -ai"
2. Configurar: guardrails configure
3. Cree una configuración: guardrails create --validators=hub:// guardrails /two_words --name=two-word-guard
4. Inicie el servidor de desarrollo: guardrails start --config=./config.py
5. Interactúe con el servidor de desarrollo a través de los fragmentos a continuación

 # with the guardrails client
import guardrails as gr

gr.settings.use_server = True
guard = gr.Guard(name='two-word-guard')
guard.validate('this is more than two words')

# or with the openai sdk
import openai
openai.base_url = "http://localhost:8000/guards/two-word-guard/openai/v1/"
os.environ["OPENAI_API_KEY"] = "youropenaikey"

messages = [
        {
            "role": "user",
            "content": "tell me about an apple with 3 words exactly",
        },
    ]

completion = openai.chat.completions.create(
    model="gpt-4o-mini",
    messages=messages,
)

Para implementaciones de producción, recomendamos utilizar Docker con Gunicorn como servidor WSGI para mejorar el rendimiento y la escalabilidad.

Preguntas frecuentes

Tengo problemas con guardrails . ¿Dónde puedo obtener ayuda?

Puede comunicarse con nosotros en Discord o Twitter.

¿Puedo usar guardrails con cualquier LLM?

Sí, guardrails se pueden utilizar con LLM propietarios y de código abierto. Consulte esta guía sobre cómo utilizar guardrails con cualquier LLM.

¿Puedo crear mis propios validadores?

Sí, puede crear sus propios validadores y contribuir con ellos a guardrails Hub. Consulte esta guía sobre cómo crear sus propios validadores.

¿ guardrails son compatibles con otros idiomas?

guardrails se pueden utilizar con Python y JavaScript. Consulte los documentos sobre cómo usar guardrails desde JavaScript. Estamos trabajando para agregar soporte para otros idiomas. Si desea contribuir a guardrails , comuníquese con nosotros en Discord o Twitter.

Contribuyendo

¡Agradecemos las contribuciones a guardrails !

Comience revisando los problemas de Github y consulte la Guía de contribución. ¡No dudes en abrir un número o comunicarte con nosotros si deseas contribuir al proyecto!