Erstellen einer KI-gestützten CLI mit Golang und Google Gemini

Ich habe kürzlich mit Golang eine KI-gestützte CLI namens GenCLI erstellt, über die Sie Fragen im Textformat stellen oder ihr ein Bild geben und vom Terminal aus nach Details dazu fragen können. Wenn das für Sie interessant klingt, ist dieser Blog genau das Richtige für Sie. Dabei erstellen wir eine CLI komplett von Grund auf und verleihen ihr mithilfe der Gemini-API von Google KI-Leistung. Falls Sie sich mein GenCLI ansehen möchten, finden Sie hier den Link. Ja, es ist Open Source.

Voraussetzung

• Vertrautheit mit Golang
• Cobra-Paket ausprobiert

Erste Schritte

Lassen Sie uns Schritt für Schritt vorgehen und jeden Prozess verstehen.

Erstellen Sie einen Ordner und öffnen Sie ihn in Ihrer bevorzugten IDE/Ihrem bevorzugten Editor. Ich verwende VS-Code und nenne den Ordner go-ai. Initialisieren Sie nun das Projekt, indem Sie den Befehl go mod init ausführen. Befehl. Der Pfad hier ist der Modulpfad. Wenn wir ein Modul (das Projekt) veröffentlichen, muss dies ein Pfad sein, von dem aus unser Modul von Go-Tools heruntergeladen werden kann. Dies wird unser GitHub-Repo-Link sein. Wir können später ein GitHub-Repo erstellen, aber wir können jetzt einen Link bereitstellen. Bei mir wird es so aussehen:

  go mod init github.com/Pradumnasaraf/go-ai 

Sobald Sie damit fertig sind, wird ein go.mod erstellt.

Obwohl wir alles manuell erstellen und tun können, um CLI zu erstellen. Aber das Tolle an Cobra Package ist, dass es über eine CLI verfügt, die Strukturen generiert, Dateien generiert und Pakete für die CLI installiert. Dies wird uns helfen, den Prozess zu beschleunigen und Fehler zu vermeiden. Um das Cobra CLI-Tool zu installieren, verwenden Sie den folgenden Befehl:

 go install github.com/spf13/cobra-cli@latest

Sobald Sie das getan haben, können Sie überprüfen, ob das Tool installiert ist, indem Sie cobra-cli im Terminal einbinden und Sie erhalten eine Liste der verfügbaren Tools. Führen Sie nun cobra-cli init aus, um das Projekt einzurichten. Nach der Ausführung werden automatisch ein cmd-Ordner, eine go.sum- und eine main.go-Datei erstellt. Um zu testen, ob es funktioniert oder nicht, führen Sie main.go aus. Im Terminal wird eine Ausgabe über die CLI angezeigt (wie im Screenshot unten)

Um mit der Gemini-API von Google zu kommunizieren und sie zu nutzen, müssen wir zunächst das Gemini Golang SKD-Paket installieren. Führen Sie dazu den folgenden Befehl aus.

go get github.com/google/generative-ai-go

Wie bei anderen APIs benötigen wir jetzt einen API-Schlüssel. Um das zu bekommen, gehen Sie hier vorbei: https://aistudio.google.com/app/apikey und holen Sie sich das. Es ist KOSTENLOS und Sie erhalten es in 30 Sekunden. Sobald Sie den API-Schlüsselsatz erhalten haben, ist er eine Umgebungsvariable, indem Sie den folgenden Befehl ausführen:

export GEMINI_API_KEY=<YOUR_API_KEY>

Das Problem bei dieser Methode besteht darin, dass die Umgebungsvariable nur für die aktuelle Sitzung vorhanden ist. Wenn Sie das Terminal schließen, ist sie verschwunden. Um dieses Problem zu vermeiden, fügen Sie den Befehl export zu einer Shell-Konfigurationsdatei hinzu, z. B. .bashrc, .bash_profile oder .zshrc (abhängig von Ihrer Shell). Auf diese Weise können Sie von überall im System auf die CLI zugreifen.

Jetzt ist es an der Zeit, einen Unterbefehl für die CLI zu erstellen, anstatt die Logik direkt in root.go zu schreiben. Der Grund dafür ist, dass wir, wenn wir in Zukunft mehr Funktionalität und mehr Unterbefehle einbinden möchten, einfach hinzufügen können, indem wir weitere Unterbefehle hinzufügen und den Root-Befehl nicht blockieren. Wenn Sie das nicht verstehen, machen Sie sich keine Sorgen, folgen Sie uns, die Dinge werden klar werden.

Um einen Unterbefehl zu erstellen, stellt Cobra CLI einen Add-Befehl zum Erstellen bereit. Führen Sie dazu den folgenden Befehl aus. Hier wird die Suche zu einem Unterbefehl. Sie können wählen, was Sie möchten.

cobra-cli add search

Sobald Sie es ausführen, wird im cmd-Verzeichnis eine neue Datei mit allen diesen vorab ausgefüllten Codes erstellt. Im Code initialisieren wir eine Variable „searchCmd“ mit einem Zeiger auf eine „cobra.Command“-Struktur und stellen Werte für Felder wie „Name des Unterbefehls“, „Verwendung“ usw. bereit. Die Funktion in „Run:“ wird immer dann ausgelöst, wenn wir den Unterbefehl ausführen. Befehl. Wie Sie sehen, fügen wir auch einen Befehl (Unterbefehl) für den Root-Befehl in der Init-Funktion hinzu. So sollte der vollständige Code aussehen.

package cmd

import (
    "fmt"

    "github.com/spf13/cobra"
)

// searchCmd represents the search command
var searchCmd = &cobra.Command{
    Use:   "search",
    Short: "A brief description of your command",
    Long: `A longer description that spans multiple lines and likely contains examples`,
    Run: func(cmd *cobra.Command, args []string) {
        fmt.Println("search called")
    },
}

func init() {
    rootCmd.AddCommand(searchCmd)
}

Um zu überprüfen, ob der Unterbefehl „Suche“ wie erwartet funktioniert, führen Sie jetzt die CLI mit dem Befehl „Suche“ aus. In Ihrem Terminal wird „Suche aufgerufen“ angezeigt.

go run main.go search 

Lassen Sie uns nun an der API-Seite arbeiten. Lassen Sie uns Pakete für die Google Gemini-API sowie andere für die Protokollierung und Aufgaben auf Betriebssystemebene erforderliche Pakete importieren. Hier ist eine vollständige Liste.

import (
    "context"
    "log"
    "os"

    "github.com/google/generative-ai-go/genai"
    "github.com/spf13/cobra"
    "google.golang.org/api/option"
)

Dann fügen wir eine Funktion namens getResponse hinzu. Diese Funktion hilft uns, mit der Gemini-API zu kommunizieren, die Antwort abzurufen und auszudrucken. Wenn Sie außerdem sehen, dass wir den Eingabeaufforderungstext „Schreiben Sie eine Geschichte über eine KI und Magie“ fest codiert haben, machen Sie sich keine Sorgen, wir werden das ändern, aber lassen Sie uns zunächst dafür sorgen, dass es funktioniert :). Dies ist ein vollständiger Funktionscode, der unterhalb Ihrer Init-Funktion eingefügt wird. Den gleichen Startcode finden Sie auf der Gemini-Website.

func getResponse() {

    ctx := context.Background()
    client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("GEMINI_API_KEY")))
    if err != nil {
        log.Fatal(err)
    }
    defer client.Close()

    model := client.GenerativeModel("gemini-1.5-flash")
    resp, err := model.GenerateContent(ctx, genai.Text("Write a story about a AI and magic"))
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(resp.Candidates[0].Content.Parts[0])
}

Now let's add getResponse function to the in the field Run: function. So that when we run the sun command it will call getResponse function. Now the code will look like this.

package cmd

import (
    "context"
    "fmt"
    "log"
    "os"

    "github.com/google/generative-ai-go/genai"
    "github.com/spf13/cobra"
    "google.golang.org/api/option"
)

// searchCmd represents the search command
var searchCmd = &cobra.Command{
    Use:   "search",
    Short: "A brief description of your command",
// Added the getResponse() function
    Run: func(cmd *cobra.Command, args []string) {
        getResponse()
    },
}

func init() {
    rootCmd.AddCommand(searchCmd)
}

func getResponse() {

    ctx := context.Background()
    client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("GEMINI_API_KEY")))
    if err != nil {
        log.Fatal(err)
    }
    defer client.Close()

    model := client.GenerativeModel("gemini-1.5-flash")
    resp, err := model.GenerateContent(ctx, genai.Text("Write a story about a AI and magic"))
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(resp.Candidates[0].Content.Parts[0])
}

If you getting a red squiggly line under the imported package names run go mod tidy. It will install the missing package and do a cleanup. Now, again execute the go run main.go search. This time you will get a response from the API for the Prompt we hardcoded, i.e, "Write a story about a AI and magic"

In case you are encountering the below error check if your environment variable is set properly with the right name. You can check by executing the printenv command in your terminal and see if it's present there or not.

Once everything is working, let’s make the prompt dynamic so that we don’t have to hardcode the prompt directly into the code and we provide it via the terminal.

To do that, add an ARG: field to the searchCmd struct so that the user at least needs to enter an argument after the sub-command. Also, we will modify the getResponse function to accept a slice of data because args will be in the slice format, and we will use the strings package to convert it into a sentence.

Lastly, replace the hardcoded text in genai.Text() with the userArgs variable we created to convert the slice into a sentence. This is how the complete code will look like; I have commented above on the changes we have to make for better understanding.

package cmd

import (
    "context"
    "fmt"
    "log"
    "os"
    "strings" // import strings package

    "github.com/google/generative-ai-go/genai"
    "github.com/spf13/cobra"
    "google.golang.org/api/option"
)

var searchCmd = &cobra.Command{
    Use:   "search",
    Short: "A brief description of your command",
    Args:  cobra.MinimumNArgs(1), // Minimum 1 arg required
    Run: func(cmd *cobra.Command, args []string) {
        getResponse(args)
    },
}

func init() {
    rootCmd.AddCommand(searchCmd)
}

// Function can now accept slice parameter 
func getResponse(args []string) {
        // Creating a sentence out of a slice
    userArgs := strings.Join(args[0:], " ") 

    ctx := context.Background()
    client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("GEMINI_API_KEY")))
    if err != nil {
        log.Fatal(err)
    }
    defer client.Close()

    model := client.GenerativeModel("gemini-1.5-flash")
        // change the hardcoded text to userArgs variable
    resp, err := model.GenerateContent(ctx, genai.Text(userArgs))
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(resp.Candidates[0].Content.Parts[0])
}

If you execute the go run main search now, it will give you an error message in the terminal saying at least one arg is required. This means our code is working perfectly.

Now let's execute the command the right way giving it an argument - a prompt/question.

As you can see, it provided us with the answer. We pass the prompt in quotes so that we can add special characters like "?", ".", etc. So here it is, a fully functional AI-powered CLI.

Now, if you want to publish the package so that your CLI can directly execute commands and be used from anywhere in the system, it’s very simple to do that. First, push your changes to GitHub and then head over to the URL https://pkg.go.dev/github.com/. In my case, it would be https://pkg.go.dev/github.com/Pradumnasaraf/go-ai. When you visit, you will see a request button; click on that to request adding the package to pkg.go.dev. Once you’re done, after a few hours, it will be on the website.

Once it’s live, you can simply download the CLI by using the go install command:

go install <repo-url>
go install github.com/Pradumnasaraf/go-ai@latest

And directly use the CLI with commands like go-ai, go-ai search, etc. If you encounter the error saying command not found: go-ai after running it, you need to add $GOPATH/bin to your $PATH environment variable. Refer to this guide for that.

That's it for this blog. This was a little longer than the blogs I usually write. I'm glad you're still reading and made it to the end—thank you so much for your support. I sometimes share tips on Twitter. You can connect with me there.

Das obige ist der detaillierte Inhalt vonErstellen einer KI-gestützten CLI mit Golang und Google Gemini. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!