Iniziare a utilizzare Genkit con Go (alpha)

Le librerie Genkit per Go sono ora disponibili per l'anteprima. Poiché le librerie Go sono attualmente in versione alpha, potresti notare modifiche alle API e alle funzionalità man mano che lo sviluppo procede. Ti consigliamo di utilizzarlo solo per la prototipazione e la sperimentazione.

Se riscontri problemi con le librerie o con questa documentazione, segnalali nel nostro repository GitHub.

Per iniziare a utilizzare Genkit, installa il client Genkit e esegui genkit init in un progetto Go. Il resto di questa pagina ti mostra come.

Requisiti

Go 1.22 o versioni successive. Consulta la sezione Download e installazione della documentazione ufficiale di Go.
Node.js 20 o versioni successive (per l'interfaccia a riga di comando e l'interfaccia utente di Genkit). Consulta la sezione successiva per una breve guida all'installazione di Node.

Installa Genkit

Se non hai già Node 20 o versioni successive sul tuo sistema, installalo ora.

Consiglio: gli strumenti nvm e nvm-windows sono un modo pratico per installare versioni specifiche di Node se non è già installato sul tuo sistema. Questi strumenti installano Node su base utente, quindi non è necessario apportare modifiche a livello di sistema.

Per installare nvm:
Linux, macOS e così viaWindows
Esegui questo comando:
```
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
```
Scarica ed esegui il programma di installazione come descritto nella documentazione di nvm-windows.
Quindi, per installare Node e npm, apri una nuova shell ed esegui il seguente comando:
```
nvm install 20
```
Installa Genkit CLI eseguendo il seguente comando:
```
npm i -g genkit
```
Questo comando installa il client Genkit nella directory di installazione di Node in modo che possa essere utilizzato al di fuori di un progetto Node.

Crea ed esplora un progetto di esempio

Crea una nuova directory del progetto:
```
mkdir genkit-intro && cd genkit-intro
```

Inizializza un progetto Genkit:

genkit init

Seleziona Go come ambiente di runtime.
Seleziona il tuo modello:
Gemini (IA di Google)Gemini (Vertex AI)
Il modo più semplice per iniziare è utilizzare l'API Gemini di Google AI. Assicurati che sia disponibile nella tua regione.

Genera una chiave API per l'API Gemini utilizzando Google AI Studio. Poi, imposta la variabile di ambiente GOOGLE_GENAI_API_KEY sulla chiave:
```
export GOOGLE_GENAI_API_KEY=<your API key>
```
Se l'API Gemini di Google AI non è disponibile nella tua regione, ti consigliamo di utilizzare l'API Vertex AI, che offre anche Gemini e altri modelli. Devi avere un progetto Google Cloud abilitato alla fatturazione, abilitare l'API AI Platform e impostare alcune variabili di ambiente aggiuntive:
```
gcloud services enable aiplatform.googleapis.com
export GCLOUD_PROJECT=<your project ID>
export GCLOUD_LOCATION=us-central1
```
Consulta la pagina Prezzi di Vertex AI.
Specifica un nome qualsiasi per il modulo. Ad esempio: example/genkit-intro
Scegli le risposte predefinite per il resto delle domande, che inizieranno la cartella del progetto con del codice di esempio.

Il comando genkit init crea un modulo Go di esempio e installa le dipendenze richieste. Il file main.go contiene un singolo flusso, menuSuggestionFlow, che chiede a un LLM di suggerire un articolo per un ristorante con un determinato tema.

Questo file ha il seguente aspetto (i passaggi di configurazione del plug-in potrebbero essere diversi se hai selezionato 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/googlegenai"
)

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

	// Initialize Genkit with 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.
	g, err := genkit.Init(ctx, genkit.WithPlugins(&googlegenai.GoogleAI{}))
	if err != nil {
		log.Fatal(err)
	}

	// Define a simple flow that prompts an LLM to generate menu suggestions.
	genkit.DefineFlow(g, "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 := googlegenai.GoogleAIModel(g, "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 := genkit.Generate(ctx, g,
			ai.WithModel(m),
			ai.WithConfig(&ai.GenerationCommonConfig{Temperature: 1}),
			ai.WithPromptText(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
	})

	<-ctx.Done()
}

Man mano che sviluppi le funzionalità di AI della tua app con Genkit, probabilmente creerai flussi con più passaggi, come la preelaborazione dell'input, la costruzione di prompt più sofisticata, l'integrazione di origini di informazioni esterne per la Retrieval-Augmented Generation (RAG) e altro ancora.

Ora puoi eseguire ed esplorare le funzionalità di Genkit e il progetto di esempio in locale sul tuo computer. Scarica e avvia l'interfaccia utente per sviluppatori di Genkit:
```
genkit start
```
L'interfaccia utente per sviluppatori di Genkit è ora in esecuzione sulla tua macchina. Quando esegui modelli o flussi nel passaggio successivo, la macchina eseguirà le attività di orchestrazione necessarie per far funzionare insieme i passaggi del flusso. Le chiamate a servizi esterni come l'API Gemini continueranno a essere effettuate su server attivi.

Inoltre, poiché ti trovi in un ambiente di sviluppo, Genkit memorizza le tracce e lo stato del flusso in file locali.
L'interfaccia utente di Genkit Developer si scarica e si apre automaticamente quando esegui il comando genkit start.

L'interfaccia utente per gli sviluppatori ti consente di vedere i flussi che hai definito e i modelli che hai configurato, eseguirli ed esaminare le tracce delle esecuzioni precedenti. Prova alcune di queste funzionalità:
- Nella scheda Esegui, viene visualizzato un elenco di tutti i flussi che hai definito e di tutti i modelli configurati dai plug-in.
  
  Fai clic su menuSuggestionFlow e prova a eseguirlo con del testo di input (ad esempio "cat"). Se tutto va bene, riceverai un suggerimento per il menu di un ristorante a tema gatto.
- Nella scheda Esamina viene visualizzata una cronologia delle esecuzioni del flusso. Per ogni flusso, puoi vedere i parametri passati al flusso e una traccia di ogni passaggio durante l'esecuzione.