guardrails

O que são guardrails ?

guardrails é uma estrutura Python que ajuda a construir aplicativos de IA confiáveis, executando duas funções principais:

1. guardrails executa protetores de entrada/saída em sua aplicação que detectam, quantificam e mitigam a presença de tipos específicos de riscos. Para ver o conjunto completo de riscos, confira guardrails Hub.
2. guardrails ajudam você a gerar dados estruturados de LLMs.

cubo guardrails

guardrails Hub é uma coleção de medidas pré-construídas de tipos específicos de riscos (chamadas de 'validadores'). Vários validadores podem ser combinados em guardas de entrada e saída que interceptam as entradas e saídas dos LLMs. Visite guardrails Hub para ver a lista completa de validadores e sua documentação.

Instalação

 pip install guardrails - ai 

Começando

Crie proteções de entrada e saída para validação LLM

1. Baixe e configure a CLI guardrails Hub.

   pip install guardrails -ai
   guardrails configure

2. Instale um guarda-corpo do cubo guardrails .

    guardrails hub install hub:// guardrails /regex_match

3. Crie uma proteção a partir do guarda-corpo instalado.

    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 )

   Saída:

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

4. Execute vários guardrails dentro de um Guard. Primeiro, instale os guardrails necessários do cubo guardrails .

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

   Em seguida, crie um Guarda a partir dos guardrails instalados.

    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 )

   Saída:

    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!

Use guardrails para gerar dados estruturados de LLMs

Vejamos um exemplo em que pedimos a um LLM para gerar nomes de animais de estimação falsos. Para fazer isso, criaremos um Pydantic BaseModel que representa a estrutura da saída que desejamos.

 from pydantic import BaseModel , Field

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

Agora, crie um Guard da classe Pet . O Guard pode ser usado para chamar o LLM de forma que a saída seja formatada para a classe Pet . Nos bastidores, isso é feito por um dos dois métodos:

1. Chamada de função: Para LLMs que suportam chamada de função, geramos dados estruturados usando a sintaxe de chamada de função.
2. Otimização de prompt: para LLMs que não suportam chamadas de função, adicionamos o esquema da saída esperada ao prompt para que o LLM possa gerar dados estruturados.

 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 )

Isso imprime:

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

servidor guardrails

guardrails pode ser configurado como um serviço independente servido pelo Flask com guardrails start , permitindo que você interaja com ele por meio de uma API REST. Essa abordagem simplifica o desenvolvimento e a implantação de aplicativos alimentados por guardrails .

1. Instalar: pip install " guardrails -ai"
2. Configurar: guardrails configure
3. Crie uma configuração: guardrails create --validators=hub:// guardrails /two_words --name=two-word-guard
4. Inicie o servidor de desenvolvimento: guardrails start --config=./config.py
5. Interaja com o servidor de desenvolvimento por meio dos snippets abaixo

 # 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 implantações de produção, recomendamos usar Docker com Gunicorn como servidor WSGI para melhorar desempenho e escalabilidade.

Perguntas frequentes

Estou tendo problemas com guardrails . Onde posso obter ajuda?

Você pode entrar em contato conosco no Discord ou no Twitter.

Posso usar guardrails com qualquer LLM?

Sim, guardrails podem ser usados ​​com LLMs proprietários e de código aberto. Confira este guia sobre como usar guardrails com qualquer LLM.

Posso criar meus próprios validadores?

Sim, você pode criar seus próprios validadores e contribuí-los para guardrails Hub. Confira este guia sobre como criar seus próprios validadores.

guardrails suportam outros idiomas?

guardrails podem ser usados ​​com Python e JavaScript. Confira a documentação sobre como usar guardrails de JavaScript. Estamos trabalhando para adicionar suporte para outros idiomas. Se você gostaria de contribuir com guardrails , entre em contato conosco no Discord ou no Twitter.

Contribuindo

Aceitamos contribuições para guardrails !

Comece verificando os problemas do Github e o Guia de Contribuição. Sinta-se à vontade para abrir um problema ou entrar em contato se quiser adicionar algo ao projeto!