A manipulação de comandos é a principal maneira de influenciar o resultado dos modelos de IA generativa. Por exemplo, ao usar LLMs, você pode criar comandos que influenciam o tom, o formato, a duração e outras características do as respostas dos modelos.
O Genkit foi projetado com base na premissa de que solicitações são código. Você escreve e manter seus prompts em arquivos de origem, rastrear as alterações neles usando a mesma versão de controle de acesso que você usa para seu código e você os implanta junto com o código que chamamos de modelos de IA generativa.
A maioria dos desenvolvedores descobrirá que a biblioteca Dotprompt incluída no atende às necessidades de trabalhar com comandos no Genkit. No entanto, é possível também é possível trabalhar diretamente com comandos.
Como definir comandos
As funções auxiliares de geração do Genkit aceitam prompts de string, e é possível chame modelos dessa forma para casos de uso simples.
Go
request := ai.GenerateRequest{Messages: []*ai.Message{
{Content: []*ai.Part{ai.NewTextPart("You are a helpful AI assistant named Walt.")}},
}}
model.Generate(context.Background(), &request, nil)
Na maioria dos casos, você precisa incluir algumas entradas fornecidas pelo usuário no comando. Você pode definir uma função para renderizá-los assim:
Go
func helloPrompt(name string) *ai.Part {
prompt := fmt.Sprintf("You are a helpful AI assistant named Walt. Say hello to %s.", name)
return ai.NewTextPart(prompt)
}
request := ai.GenerateRequest{Messages: []*ai.Message{
{Content: []*ai.Part{helloPrompt("Fred")}},
}}
response, err := model.Generate(context.Background(), &request, nil)
No entanto, uma desvantagem de definir comandos no código é que o teste exige a execução como parte de um fluxo. Para facilitar as iterações mais rápidas, o Genkit oferece um recurso para definir seus comandos e executá-los na interface do desenvolvedor.
Go
Use a função DefinePrompt
para registrar seus comandos com o Genkit.
type HelloPromptInput struct {
UserName string
}
helloPrompt := ai.DefinePrompt(
"prompts",
"helloPrompt",
nil, // Additional model config
jsonschema.Reflect(&HelloPromptInput{}),
func(ctx context.Context, input any) (*ai.GenerateRequest, error) {
params, ok := input.(HelloPromptInput)
if !ok {
return nil, errors.New("input doesn't satisfy schema")
}
prompt := fmt.Sprintf(
"You are a helpful AI assistant named Walt. Say hello to %s.",
params.UserName)
return &ai.GenerateRequest{Messages: []*ai.Message{
{Content: []*ai.Part{ai.NewTextPart(prompt)}},
}}, nil
},
)
Uma ação de comando define uma função que retorna um GenerateRequest
.
que pode ser usado com qualquer modelo. Também é possível definir um esquema de entrada
para o comando, que é análogo ao esquema de entrada de um fluxo.
Os comandos também podem definir as opções comuns de configuração do modelo, como
temperatura ou número de tokens de saída.
É possível renderizar esse comando em uma solicitação de modelo com a função auxiliar fornecida. Forneça as variáveis de entrada esperadas pelo comando e o modelo a ser chamado.
Go
request, err := helloPrompt.Render(context.Background(), HelloPromptInput{UserName: "Fred"})
if err != nil {
return err
}
response, err := model.Generate(context.Background(), request, nil)
Na interface do desenvolvedor do Genkit, você pode executar qualquer prompt definido dessa maneira. Isso permite testar comandos individuais fora do escopo e os fluxos em que podem ser usados.
Pontoprompt
O Genkit inclui a biblioteca Dotprompt, que adiciona da funcionalidade aos comandos.
- Carregando comandos de
.prompt
arquivos de origem - Modelos baseados em guidões
- Suporte a modelos de comando multiturno e conteúdo multimídia
- Definições de esquemas de entrada e saída concisas
- Uso fluido com o
generate()