Começar a usar o Genkit em Go (Alfa)

As bibliotecas Genkit do Firebase para Go já estão disponíveis para visualização. Como as bibliotecas Go estão atualmente em Alpha, você poderá ver alterações funcionais e de API à medida que o desenvolvimento avança. Recomendamos usá-las apenas para prototipagem e exploração.

Se você encontrar problemas com as bibliotecas ou com esta documentação, informe no nosso repositório do GitHub.

Para começar a usar o Genkit, instale a CLI do Genkit e execute genkit init em um projeto Go. O restante desta página mostra como fazer isso.

Requisitos

  • Go 1.22 ou mais recente. Consulte Fazer o download e instalar nos documentos oficiais do Go.

  • Node.js 20 ou mais recente (para a CLI e a interface do Genkit). Consulte a próxima seção para o guia rápido sobre a instalação do Node.

Instalar o Genkit

  1. Se você ainda não tem o Node 20 ou a versão mais recente no sistema, instale-o agora.

    Recomendação: as APIs nvm e as ferramentas do nvm-windows são uma maneira conveniente de instalar versões específicas do Node se ainda não estiver instalado em seu sistema. Essas ferramentas instalam o Node por usuário, então você não precisa fazer alterações em todo o sistema.

    Para instalar nvm:

    Linux, macOS etc.

    Execute este comando:

    curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

    Windows

    Faça o download e execute o instalador conforme descrito nos documentos do nvm-windows.

    Em seguida, para instalar o nó e npm, abra um novo shell e execute o seguinte comando:

    nvm install 20

  2. Instale a CLI do Genkit executando o seguinte comando:

    npm i -g genkit

    Esse comando instala a CLI do Genkit no diretório de instalação do nó para que possa ser usado fora de um projeto Node.

Criar e analisar um projeto de amostra

  1. Crie um novo diretório do projeto:

    mkdir genkit-intro && cd genkit-intro

  2. Inicialize um projeto Genkit:

    genkit init

    1. Selecione Go como o ambiente de execução.

    2. Selecione o modelo.

      Gemini (IA do Google)

      A maneira mais simples de começar é com a API Gemini da IA do Google. Confirme se ela está disponível na sua região.

      Gere uma chave de API para à API Gemini usando o Google AI Studio. Depois, defina a variável de ambiente GOOGLE_GENAI_API_KEY para sua chave:

      export GOOGLE_GENAI_API_KEY=<your API key>

      Gemini (Vertex AI)

      Se a API Gemini da IA do Google não estiver disponível na sua região, considere usar a API Vertex AI, que também oferece o Gemini e outros modelos. Você precisa ter um projeto do Google Cloud com faturamento, ativar a API AI Platform e definir mais algumas variáveis de ambiente:

      gcloud services enable aiplatform.googleapis.com
export GCLOUD_PROJECT=<your project ID>
export GCLOUD_LOCATION=us-central1

      Consulte os preços da Vertex AI.

    3. Especifique qualquer coisa no nome do módulo. Por exemplo: example/genkit-intro

    4. Escolha respostas padrão para o restante das perguntas, o que inicializará a pasta do seu projeto com algum exemplo de código.

    O comando genkit init cria um exemplo de módulo Go e instala as dependências necessárias. O arquivo main.go contém um único fluxo, menuSuggestionFlow, que solicita que um LLM sugira um item para um restaurante com um determinado tema.

    O arquivo tem a seguinte aparência (as etapas de configuração do plug-in podem ser diferentes se você selecionar a Vertex AI):

    package main

import (
	"context"
	"errors"
	"fmt"
	"log"

	// Import Genkit and the Google AI plugin
	"github.com/firebase/genkit/go/ai"
	"github.com/firebase/genkit/go/genkit"
	"github.com/firebase/genkit/go/plugins/googleai"
)

func main() {
	ctx := context.Background()

	// Initialize the Google AI plugin. When you pass nil for the
	// Config parameter, the Google AI plugin will get the API key from the
	// GOOGLE_GENAI_API_KEY environment variable, which is the recommended
	// practice.
	if err := googleai.Init(ctx, nil); err != nil {
		log.Fatal(err)
	}

	// Define a simple flow that prompts an LLM to generate menu suggestions.
	genkit.DefineFlow("menuSuggestionFlow", func(ctx context.Context, input string) (string, error) {
		// The Google AI API provides access to several generative models. Here,
		// we specify gemini-1.5-flash.
		m := googleai.Model("gemini-1.5-flash")
		if m == nil {
			return "", errors.New("menuSuggestionFlow: failed to find model")
		}

		// Construct a request and send it to the model API (Google AI).
		resp, err := ai.Generate(ctx, m,
			ai.WithConfig(&ai.GenerationCommonConfig{Temperature: 1}),
			ai.WithTextPrompt(fmt.Sprintf(`Suggest an item for the menu of a %s themed restaurant`, input)))
		if err != nil {
			return "", err
		}

		// Handle the response from the model API. In this sample, we just
		// convert it to a string. but more complicated flows might coerce the
		// response into structured output or chain the response into another
		// LLM call.
		text := resp.Text()
		return text, nil
	})

	// Initialize Genkit and start a flow server. This call must come last,
	// after all of your plug-in configuration and flow definitions. When you
	// pass a nil configuration to Init, Genkit starts a local flow server,
	// which you can interact with using the developer UI.
	if err := genkit.Init(ctx, nil); err != nil {
		log.Fatal(err)
	}
}

    Ao desenvolver os recursos de IA do seu app com o Genkit, você provavelmente criará fluxos com várias etapas, como pré-processamento de entrada, criação de comandos mais sofisticada, integração de fontes de informações externas para geração aumentada de recuperação (RAG) e muito mais.

  3. Agora é possível executar e explorar localmente os recursos do Genkit e o projeto de amostra na sua máquina. Faça o download e inicie a interface do desenvolvedor do Genkit:

    genkit start

    Você chegou a Interface do desenvolvedor do Genkit

    A interface do desenvolvedor do Genkit agora está em execução na sua máquina. Ao executar modelos ou fluxos na próxima etapa, sua máquina executará as tarefas de orquestração necessárias para que as etapas do seu fluxo funcionem juntas, as chamadas para serviços externos, como a API Gemini, continuarão sendo feitas em servidores ativos.

    Além disso, como você está em um ambiente de desenvolvimento, o Genkit armazenará traces e estado de fluxo em arquivos locais.

  4. A interface do desenvolvedor do Genkit é baixada e aberta automaticamente quando você executa o comando genkit start.

    A UI do desenvolvedor permite ver quais fluxos você definiu e modelos que você configurou, executá-los e examinar rastreamentos de execuções anteriores. Teste alguns destes recursos:

    • Na guia Executar, há uma lista de todos os fluxos que você definiu e todos os modelos que foram configurados por plug-ins.

      Clique em menuSuggestionFlow e tente executar com algum texto de entrada (por exemplo, "cat"). Se tudo correr bem, você será recompensado com uma sugestão de cardápio para um restaurante temático de gatos.

    • Na guia Inspect, é exibido um histórico de execuções de fluxo. Para cada fluxo, é possível conferir os parâmetros que foram passados para o fluxo e um trace de cada etapa durante a execução.