Comandos

A manipulação de comandos é a principal maneira pela qual você, como desenvolvedor de apps, influencia a saída de 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 das respostas dos modelos.

O Genkit foi projetado com base na premissa de que solicitações são código. Você escreve e mantém seus comandos em arquivos de origem, rastreia alterações neles usando o mesmo sistema de controle de versões usado para seu código e os implanta com o código que chama seus modelos de IA generativa.

A maioria dos desenvolvedores descobrirá que a biblioteca Dotprompt incluída atende às necessidades de trabalhar com comandos no Genkit. No entanto, abordagens alternativas também são compatíveis com o trabalho direto com comandos.

Como definir comandos

As funções auxiliares de geração do Genkit aceitam comandos de string e você pode chamar modelos dessa forma para casos de uso diretos.

ai.Generate(context.Background(), model, ai.WithTextPrompt("You are a helpful AI assistant named Walt."))

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:

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

response, err := ai.GenerateText(context.Background(), model,
	ai.WithMessages(ai.NewUserMessage(helloPrompt("Fred"))))

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.

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 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.

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 comando definido dessa maneira. Isso permite testar comandos individuais fora do escopo dos fluxos em que eles podem ser usados.

Dotprompt

O Genkit inclui a biblioteca Dotprompt, que adiciona mais recursos aos comandos.

• Carregando comandos de .prompt arquivos de origem
• Modelos baseados no Handlebars
• 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()