Alpha: Firebase Genkit for Go is in Alpha, which means that it is not subject to any SLA or deprecation policy and could change in backwards-incompatible ways. Throughout the Alpha period, Firebase Genkit and its documentation will be updated and improved.

Esta página foi traduzida pela API Cloud Translation.

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 o As bibliotecas Go estão atualmente na versão Alfa. Você pode ver mudanças na API e funcionais como o desenvolvimento avança. Recomendamos usá-lo apenas para prototipagem e exploração.

Se você descobrir 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
Node.js 20 ou mais recente (para a CLI e a interface do Genkit)

Recomendação: as APIs nvm e As ferramentas do nvm-windows são conveniente de instalar versões específicas do Node, caso ainda não instalado no sistema. Essas ferramentas instalam o Node por usuário, para que você sem precisar fazer alterações em todo o sistema.

Para instalar o nvm em um sistema semelhante ao Unix, como macOS ou Linux, execute este comando: comando:
```
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
```
Em seguida, para instalar o nó usando nvm, abra um novo shell e execute o seguinte: comando:
```
nvm install 20
```

Procedimento

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.
Crie um novo diretório do projeto:
```
mkdir genkit-intro && cd genkit-intro
```

Inicialize um projeto Genkit:

genkit init

Selecione Go como o ambiente de execução.
Selecione o modelo:
Gemini (IA do Google)
A maneira mais simples de começar é com a API Gemini da IA do Google. Confirme se é disponíveis na sua região.

Gere uma chave de API para a a API Gemini usando o Google AI Studio. Depois, defina o GOOGLE_GENAI_API_KEY variável de ambiente à 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 usando 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 IA API Platform e defina mais algumas variáveis de ambiente:
```
gcloud services enable aiplatform.googleapis.com
export GCLOUD_PROJECT=<your project ID>
export GCLOUD_LOCATION=us-central1
```
Consulte Preços da Vertex AI.
Especifique qualquer coisa no nome do módulo. Por exemplo: example/genkit-intro
Escolha respostas padrão para o restante das perguntas, o que irá a pasta do projeto com um exemplo de código.

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

O arquivo tem a seguinte aparência (as etapas de configuração do plug-in podem parecer 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 := m.Generate(ctx,
            ai.NewGenerateRequest(
                &ai.GenerationCommonConfig{Temperature: 1},
                ai.NewUserTextMessage(fmt.Sprintf(`Suggest an item for the menu of a %s themed restaurant`, input))),
            nil)
        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, err := resp.Text()
        if err != nil {
            return "", fmt.Errorf("menuSuggestionFlow: %v", err)
        }
        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 de trabalho com várias etapas, como pré-processamento de entrada, criação de prompts, integrando fontes de informações externas para geração aumentada de recuperação (RAG, na sigla em inglês) e muito mais.

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
```
A interface do desenvolvedor do Genkit agora está em execução na sua máquina. Quando você executa modelos ou fluxos na próxima etapa, a máquina vai realizar as tarefas de orquestração necessárias para fazer as etapas do seu fluxo funcionarem juntas; chamadas externas como a API Gemini, vão continuar sendo usados em servidores.

Além disso, como você está em um ambiente de desenvolvimento, o Genkit vai armazenar rastros e em arquivos locais.
A interface do desenvolvedor do Genkit é baixada e aberta automaticamente quando você executa o genkit start.

A interface do desenvolvedor permite ver quais fluxos você definiu e que modela configurados, executá-los e examinar os rastros de execuções anteriores. Teste algumas das estes recursos:
- Na guia Executar, há uma lista de todos os fluxos que você definido e de 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 um menu sugestão de restaurante temático de gatos.
- Na guia Inspect, é exibido um histórico de execuções de fluxo. Para cada é possível conferir os parâmetros que foram passados para o fluxo e um trace de cada etapa durante a execução.

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

Requisitos

Procedimento

Gemini (IA do Google)

Gemini (Vertex AI)