Verwendung der Ollama API in Golang

Dieser Artikel beschreibt, wie man die Ollama Dieses Dokument soll Entwicklern helfen, sich einzuarbeiten und die Möglichkeiten von Ollama voll auszuschöpfen. Ollama selbst wird in der Sprache Golang entwickelt, und der Schnittstellencode für die Golang-Sprachversion ist im offiziellen Repository-Verzeichnis unter https://github.com/ollama/ollama/tree/main/api und in der offiziellen Dokumentation unter Die offizielle Dokumentation finden Sie unter https://pkg.go.dev/github.com/ollama/ollama/api. Wenn Sie dieses Dokument studieren, können Sie Ollama leicht in Ihre Projekte integrieren.

Das offizielle Repository https://github.com/ollama/ollama/tree/main/api/examples提供了一些示例代 Code, und der unten stehende Code verweist auf diese Beispiele und ändert sie. Alle Beispiele sind verfügbar in dernotebook/C4/Golang_API_exampleMitte

Vorbereitung der Umwelt

Bevor Sie beginnen, stellen Sie sicher, dass Ihre Entwicklungsumgebung die folgenden Bedingungen erfüllt:

1. Golang-Entwicklungsumgebung, über dieGo-VersionÜberprüfen Sie die Golang-Version, die in diesem Artikel verwendete Version istgo1.23.6
   

   Referenz https://golang.google.cn/doc/install进行安装

2. Erstellen Sie ein Projektverzeichnis und initialisieren Sie es

mkdir ollama-demo && cd ollama-demo
go mod init ollama-demo

3. Installation von Abhängigkeiten

github.com/ollama/ollama/api abrufen

Verwendung

Einen Katalog erstellenChateine Datei im Katalog anlegenmain.godie wie folgt lautet (das Beispiel verwendet das Modell deepseek-r1:7b):

Paket main
importieren (
"kontext"
"fmt"
"log"
"github.com/ollama/ollama/api"
)
func main() {
client, err := api.ClientFromEnvironment()
if err ! = nil {
log.Fatal(err)
Fatal(err) }
messages := []api.Message{
api.Message{
Rolle: "Benutzer",
Inhalt: "Warum ist der Himmel blau?" ,
},
}
ctx := kontext.Hintergrund()
req := &api.ChatRequest{
Modell: "Tiefensuche-r1:7b".
Meldungen: Meldungen,
}
respFunc := func(resp api.ChatResponse) error {
fmt.Print(resp.Message.Content)
Inhalt) return nil
}
err = client.Chat(ctx, req, respFunc)
if err ! = nil {
log.Fatal(err)
}
}

in Bewegung sein go chat/main.go ausführen

Streaming-Ausgang

Einen Katalog erstellengenerate-streamingeine Datei im Katalog anlegenmain.go

Paket main
importieren (
"kontext"
"fmt"
"log"
"github.com/ollama/ollama/api"
)
func main() {
client, err := api.ClientFromEnvironment()
if err ! = nil {
log.Fatal(err)
Fatal(err)
// Standardmäßig wird GenerateRequest im Streaming-Verfahren ausgeführt.
req := &api.GenerateRequest{
Modell: "deepseek-r1:7b",
Prompt: "Warum ist der Himmel blau?" ,
}
ctx := Kontext.Hintergrund()
respFunc := func(resp api.GenerateResponse) error {
// Hier wird nur die Antwort gedruckt; GenerateResponse hat eine Reihe anderer // interessanter Felder, die Sie untersuchen möchten.
GenerateResponse hat eine Reihe weiterer // interessanter Felder, die Sie untersuchen sollten.
// Im Streaming-Modus sind die Antworten partiell, daher rufen wir fmt.Print (und nicht
// Print (und nicht Println) auf, um zu vermeiden, dass unerwünschte Zeilenumbrüche eingefügt werden.
Das // Modell fügt seine eigenen Zeilenumbrüche ein, wenn es das möchte.
Das // Modell fügt seine eigenen Zeilenumbrüche ein, wenn es das möchte. fmt.Print(resp. Response)
fmt.Print(resp. Response) return nil
fmt.Print(resp. Response) return nil }
err = client.Generate(ctx, req, respFunc)
if err ! = nil {
log.Fatal(err)
}
fmt.Println()
}

in Bewegung sein go generate-streaming/main.go ausführen

Strukturierte Ausgabe

Einen Katalog erstellenstrukturierte_Ausgabeeine Datei im Katalog anlegenmain.goDie folgenden

Paket main
importieren (
"kontext"
"kodierung/json"
"fmt"
"log"
"strings"
"github.com/ollama/ollama/api"
)
type CountryInfo struct {
Hauptstadt string `json: "Hauptstadt"`
Einwohnerzahl float64 `json: "Bevölkerung"`
Fläche float64 `json: "Fläche"`
}
func main() {
client, err := api.ClientFromEnvironment()
if err ! = nil {
log.Fatal(err)
Fatal(err) }
messages := []api.Message{
api.Message{
Role: "user",
Content: "Bitte stellen Sie Informationen über die Hauptstadt, die Bevölkerung und die Landfläche der Vereinigten Staaten bereit und geben Sie sie im JSON-Format zurück." ,
}
}
ctx := Kontext.Hintergrund()
req := &api.ChatRequest{
Modell: "deepseek-r1:7b",
Messages: messages, }
Stream: new(bool), // false
Format: []byte(`"json"`), // false, Stream: new(bool), // false
Optionen: map[string]interface{}{
"Temperatur": 0.0, // false
}, }
}
respFunc := func(resp api.ChatResponse) error {
fmt.Printf("%s\n", strings.TrimSpace(resp.Message.Content))
var info CountryInfo
err := json.Unmarshal([]byte(resp.Message.Content), &info)
if err ! = nil {
log.Fatal(err)
}
fmt.Printf("Hauptstadt: %s, Einwohnerzahl: %f, Fläche: %f", info.Hauptstadt, info.Einwohnerzahl, info.Fläche)
return nil
}
err = client.Chat(ctx, req, respFunc)
if err ! = nil {
log.Fatal(err)
}
}

Durch die Angabe vonChatRequestangefordertFormat: []byte("json"), Parameter, der es dem Modell ermöglicht, strukturierte Daten zurückzugeben, die dann durch denjson.UnmarshalAnalysiert die zurückgegebenen Daten.

in Bewegung sein go structured_output/main.go ausführen Die folgende Ausgabe kann erhalten werden:

{"Hauptstadt": "Washington, D.C.", "Bevölkerung": 3.672e6, "Fläche": 7.058e6}
Hauptstadt: Washington, D.C., Einwohnerzahl: 3672000.000000, Fläche: 7058000.000000