Inhalte mit KI-Modellen generieren

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Im Mittelpunkt der generativen KI stehen KI-Modelle. Die beiden bekanntesten Beispiele für generative Modelle sind Large Language Models (LLMs) und Modelle zur Bildgenerierung. Diese Modelle nehmen eine Eingabe, einen sogenannten Prompt (am häufigsten Text, ein Bild oder eine Kombination aus beiden), und generieren daraus Text, ein Bild oder sogar Audio oder Video.

Die Ausgabe dieser Modelle kann überraschend überzeugend sein: LLMs generieren Text, der so aussieht, als könnte er von einem Menschen geschrieben worden sein, und Modelle zur Bildgenerierung können Bilder erstellen, die sehr nah an echten Fotos oder von Menschen erstellten Kunstwerken sind.

Darüber hinaus haben sich LLMs für Aufgaben bewährt, die über die einfache Textgenerierung hinausgehen:

• Computerprogramme schreiben
• Unteraufgaben planen, die für den Abschluss einer größeren Aufgabe erforderlich sind.
• Unorganisierte Daten organisieren
• Informationen aus einem Textkorpus verstehen und extrahieren.
• Automatisierte Aktivitäten ausführen, die auf einer Textbeschreibung der Aktivität basieren.

Es gibt viele Modelle von verschiedenen Anbietern. Jedes Modell hat seine eigenen Stärken und Schwächen. Ein Modell kann bei einer Aufgabe hervorragend abschneiden, bei anderen aber weniger gut abschneiden. Bei Apps, die Generative AI nutzen, kann es oft von Vorteil sein, je nach Aufgabe mehrere verschiedene Modelle zu verwenden.

Als App-Entwickler interagieren Sie in der Regel nicht direkt mit generativen KI-Modellen, sondern über Dienste, die als Web-APIs verfügbar sind. Auch wenn diese Dienste oft ähnliche Funktionen haben, werden sie alle über unterschiedliche und inkompatible APIs bereitgestellt. Wenn Sie mehrere Modelldienste nutzen möchten, müssen Sie jedes der proprietären SDKs verwenden, die möglicherweise nicht miteinander kompatibel sind. Wenn Sie von einem Modell auf das neueste und leistungsfähigste Modell umstellen möchten, müssen Sie diese Integration möglicherweise noch einmal erstellen.

Genkit löst dieses Problem, indem es eine einzige Oberfläche bietet, die die Details des Zugriffs auf potenziell jeden Dienst für generative KI-Modelle abstrahiert. Es sind bereits mehrere vorgefertigte Implementierungen verfügbar. Wenn Sie Ihre KI-gestützte App auf Genkit aufbauen, wird der erste Aufruf von generativer KI vereinfacht. Außerdem können Sie mehrere Modelle kombinieren oder ein Modell durch ein anderes ersetzen, sobald neue Modelle verfügbar sind.

Hinweis

Wenn Sie die Codebeispiele auf dieser Seite ausführen möchten, führen Sie zuerst die Schritte in der Anleitung Erste Schritte aus. Bei allen Beispielen wird davon ausgegangen, dass Sie Genkit bereits als Abhängigkeit in Ihrem Projekt installiert haben.

Von Genkit unterstützte Modelle

Genkit ist so flexibel, dass damit potenziell jeder Dienst für generative KI-Modelle verwendet werden kann. Die Kernbibliotheken definieren die gemeinsame Schnittstelle für die Arbeit mit Modellen und die Modell-Plug-ins definieren die Implementierungsdetails für die Arbeit mit einem bestimmten Modell und seiner API.

Das Genkit-Team verwaltet Plug-ins für die Arbeit mit Modellen von Vertex AI, Google Generative AI und Ollama:

• LLMs der Gemini-Familie über das Google Cloud Vertex AI-Plug-in
• Die LLMs der Gemini-Reihe über das Google AI-Plug-in
• Gemma 3, Llama 4 und viele weitere offene Modelle über das Ollama-Plug-in (Sie müssen den Ollama-Server selbst hosten).

Modell-Plug-ins laden und konfigurieren

Bevor du mit Genkit Inhalte generieren kannst, musst du ein Modell-Plug-in laden und konfigurieren. Wenn Sie aus der Anleitung „Einstieg“ hierher gelangt sind, haben Sie das bereits getan. Andernfalls lesen Sie den Einstiegsleitfaden oder die Dokumentation des jeweiligen Plug-ins und folgen Sie der Anleitung, bevor Sie fortfahren.

Die genkit.Generate()-Funktion

In Genkit ist die genkit.Generate()-Funktion die primäre Schnittstelle, über die Sie mit generativen KI-Modellen interagieren.

Der einfachste genkit.Generate()-Aufruf gibt das gewünschte Modell und einen Textprompt an:

import (
    "context"
    "log"

    "github.com/firebase/genkit/go/ai"
    "github.com/firebase/genkit/go/genkit"
    "github.com/firebase/genkit/go/plugins/googlegenai"
)

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

    g, err := genkit.Init(ctx,
        genkit.WithPlugins(&googlegenai.GoogleAI{}),
        genkit.WithDefaultModel("googleai/gemini-2.0-flash"),
    )
    if err != nil {
        log.Fatal(err)
    }

    resp, err := genkit.Generate(ctx, g,
        ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
    )
    if err != nil {
        log.Fatal(err)
    }

    log.Println(resp.Text())
}

Wenn Sie dieses kurze Beispiel ausführen, werden einige Informationen zur Fehlerbehebung und dann die Ausgabe des genkit.Generate()-Aufrufs ausgegeben. Dies ist in der Regel Markdown-Text wie im folgenden Beispiel:

## The Blackheart's Bounty

**A hearty stew of slow-cooked beef, spiced with rum and molasses, served in a
hollowed-out cannonball with a side of crusty bread and a dollop of tangy
pineapple salsa.**

**Description:** This dish is a tribute to the hearty meals enjoyed by pirates
on the high seas. The beef is tender and flavorful, infused with the warm spices
of rum and molasses. The pineapple salsa adds a touch of sweetness and acidity,
balancing the richness of the stew. The cannonball serving vessel adds a fun and
thematic touch, making this dish a perfect choice for any pirate-themed
adventure.

Wenn Sie das Script noch einmal ausführen, erhalten Sie eine andere Ausgabe.

Im vorherigen Codebeispiel wurde die Generierungsanfrage an das Standardmodell gesendet, das Sie bei der Konfiguration der Genkit-Instanz angegeben haben.

Sie können auch ein Modell für einen einzelnen genkit.Generate()-Aufruf angeben:

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-2.5-pro"),
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
)

Eine Modell-String-ID sieht so aus: providerid/modelid. Dabei identifiziert die Anbieter-ID (in diesem Fall googleai) das Plug-in und die Modell-ID ist eine plug-inspezifische String-ID für eine bestimmte Version eines Modells.

Diese Beispiele veranschaulichen auch einen wichtigen Punkt: Wenn Sie genkit.Generate() verwenden, um generative AI-Modelle aufzurufen, können Sie das gewünschte Modell ändern, indem Sie dem Modellparameter einen anderen Wert übergeben. Wenn Sie genkit.Generate() anstelle der SDKs für native Modelle verwenden, haben Sie die Flexibilität, mehrere verschiedene Modelle in Ihrer App einfacher zu verwenden und in Zukunft zu wechseln.

Bisher haben Sie nur Beispiele für die einfachsten genkit.Generate()-Aufrufe gesehen. genkit.Generate() bietet jedoch auch eine Schnittstelle für erweiterte Interaktionen mit generativen Modellen, wie in den folgenden Abschnitten beschrieben.

Systemaufforderungen

Einige Modelle unterstützen die Angabe eines Systemprompts, der dem Modell Anweisungen gibt, wie es auf Nachrichten von Nutzern reagieren soll. Mit dem Systemprompt können Sie Eigenschaften wie eine Persona angeben, die das Modell übernehmen soll, den Ton seiner Antworten und das Format seiner Antworten.

Wenn das von Ihnen verwendete Modell Systemaufforderungen unterstützt, können Sie eine mit der Option WithSystem() angeben:

resp, err := genkit.Generate(ctx, g,
    ai.WithSystem("You are a food industry marketing consultant."),
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
)

Bei Modellen, die keine Systemaufforderungen unterstützen, simuliert WithSystem() diese, indem die Anfrage so geändert wird, dass sie wie eine Systemaufforderung erscheint.

Modellparameter

Die Funktion genkit.Generate() nimmt eine WithConfig()-Option an, mit der Sie optionale Einstellungen festlegen können, die steuern, wie das Modell Inhalte generiert:

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-2.0-flash"),
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
    ai.WithConfig(&googlegenai.GeminiConfig{
        MaxOutputTokens: 500,
        StopSequences:   ["<end>", "<fin>"],
        Temperature:     0.5,
        TopP:            0.4,
        TopK:            50,
    }),
)

Die genauen unterstützten Parameter hängen vom jeweiligen Modell und der jeweiligen Modell-API ab. Die Parameter im vorherigen Beispiel sind jedoch für fast alle Modelle üblich. Im Folgenden werden diese Parameter erläutert:

Parameter zur Steuerung der Ausgabelänge

MaxOutputTokens

LLMs arbeiten mit Einheiten, die als Tokens bezeichnet werden. Ein Token wird in der Regel, aber nicht unbedingt, einer bestimmten Zeichenfolge zugeordnet. Wenn Sie einen Prompt an ein Modell übergeben, wird der Promptstring als einer der ersten Schritte in eine Sequenz von Tokens getaggt. Anschließend generiert der LLM eine Token-Sequenz aus der tokenisierten Eingabe. Schließlich wird die Token-Sequenz wieder in Text umgewandelt, was die Ausgabe ist.

Mit dem Parameter „Maximale Ausgabetokens“ wird festgelegt, wie viele Tokens mit dem LLM generiert werden sollen. Für jedes Modell wird möglicherweise ein anderer Tokenisierer verwendet. Als Faustregel gilt jedoch, dass ein einzelnes englisches Wort aus zwei bis vier Tokens besteht.

Wie bereits erwähnt, werden einige Tokens möglicherweise nicht zu Zeichenfolgen zugeordnet. Ein Beispiel hierfür ist, dass es oft ein Token gibt, das das Ende der Sequenz angibt: Wenn ein LLM dieses Token generiert, generiert es keine weiteren. Daher ist es möglich und häufig der Fall, dass ein LLM weniger Token als das Maximum generiert, weil es das „Stopp“-Token generiert hat.

StopSequences

Mit diesem Parameter können Sie die Tokens oder Tokenfolgen festlegen, die beim Generieren das Ende der LLM-Ausgabe anzeigen. Die richtigen Werte hängen in der Regel davon ab, wie das Modell trainiert wurde, und werden normalerweise vom Modell-Plug-in festgelegt. Wenn Sie das Modell jedoch aufgefordert haben, eine weitere Haltestellensequenz zu generieren, können Sie sie hier angeben.

Sie geben also Zeichenfolgen an, keine Tokens. In den meisten Fällen geben Sie eine Zeichenfolge an, die vom Tokenizer des Modells einem einzelnen Token zugeordnet wird.

Parameter für „Creativity“

Die Parameter Temperatur, Top-P und Top-K steuern gemeinsam, wie „kreativ“ das Modell sein soll. In diesem Abschnitt werden diese Parameter kurz erläutert. Wichtiger ist jedoch Folgendes: Mit diesen Parametern wird der Charakter der Ausgabe eines LLM angepasst. Die optimalen Werte für diese Parameter hängen von Ihren Zielen und Präferenzen ab und lassen sich wahrscheinlich nur durch Tests ermitteln.

Temperatur

LLMs sind im Grunde Maschinen zur Tokenvorhersage. Für eine bestimmte Tokenfolge (z. B. den Prompt) prognostiziert ein LLM für jedes Token in seinem Vokabular die Wahrscheinlichkeit, dass das Token als Nächstes in der Sequenz kommt. Die Temperatur ist ein Skalierungsfaktor, durch den diese Vorhersagen geteilt werden, bevor sie auf eine Wahrscheinlichkeit zwischen 0 und 1 normalisiert werden.

Niedrige Temperaturwerte zwischen 0,0 und 1,0 verstärken den Unterschied in den Wahrscheinlichkeiten zwischen den Tokens. Das Modell wird also noch unwahrscheinlicher ein Token generieren, das bereits als unwahrscheinlich eingestuft wurde. Das wird oft als weniger kreativ wahrgenommen. Obwohl 0,0 technisch gesehen kein gültiger Wert ist, wird er in vielen Modellen als Hinweis darauf interpretiert, dass sich das Modell deterministisch verhalten und nur das wahrscheinlichste Token berücksichtigen soll.

Hohe Temperaturwerte (über 1,0) komprimieren die Unterschiede in den Wahrscheinlichkeiten zwischen Tokens.Das Modell produziert dann mit höherer Wahrscheinlichkeit Tokens, die zuvor als unwahrscheinlich eingestuft wurden. Dies wird oft als kreativer Output wahrgenommen. Einige Modell-APIs setzen eine maximale Temperatur fest, oft 2.0.

TopP

Top-p ist ein Wert zwischen 0,0 und 1,0, der die Anzahl der möglichen Tokens steuert, die vom Modell berücksichtigt werden sollen. Dazu wird die kumulative Wahrscheinlichkeit der Tokens angegeben. Ein Wert von 1,0 bedeutet beispielsweise, dass alle möglichen Tokens berücksichtigt werden, aber die Wahrscheinlichkeit jedes Tokens berücksichtigt wird. Ein Wert von 0,4 bedeutet, dass nur die wahrscheinlichsten Tokens berücksichtigt werden, deren Wahrscheinlichkeiten zusammen 0,4 ergeben, und die verbleibenden Tokens ausgeschlossen werden.

TopK

Top-K ist ein Ganzzahlwert, mit dem auch die Anzahl der möglichen Tokens gesteuert wird, die vom Modell berücksichtigt werden sollen. Dies geschieht jedoch durch explizite Angabe der maximalen Anzahl von Tokens. Wenn Sie den Wert „1“ angeben, soll sich das Modell deterministisch verhalten.

Mit Modellparametern experimentieren

Mit der Entwickler-Benutzeroberfläche können Sie die Auswirkungen dieser Parameter auf die Ausgabe testen, die durch verschiedene Kombinationen von Modell und Prompt generiert wird. Wenn Sie die Entwickler-UI mit dem Befehl genkit start starten, werden automatisch alle Modelle geladen, die von den in Ihrem Projekt konfigurierten Plug-ins definiert wurden. Sie können schnell verschiedene Prompts und Konfigurationswerte ausprobieren, ohne diese Änderungen wiederholt im Code vornehmen zu müssen.

Modell mit Konfiguration koppeln

Da jeder Anbieter oder sogar ein bestimmtes Modell ein eigenes Konfigurationsschema haben oder bestimmte Einstellungen erfordern kann, ist es möglicherweise fehleranfällig, separate Optionen mit WithModelName() und WithConfig() festzulegen, da letztere nicht stark typisiert sind.

Wenn Sie ein Modell mit seiner Konfiguration verknüpfen möchten, können Sie eine Modellreferenz erstellen, die Sie stattdessen an den generate-Aufruf übergeben können:

model := googlegenai.GoogleAIModelRef("gemini-2.0-flash", &googlegenai.GeminiConfig{
    MaxOutputTokens: 500,
    StopSequences:   ["<end>", "<fin>"],
    Temperature:     0.5,
    TopP:            0.4,
    TopK:            50,
})

resp, err := genkit.Generate(ctx, g,
    ai.WithModel(model),
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
)
if err != nil {
    log.Fatal(err)
}

Der Konstruktor für die Modellreferenz erzwingt, dass der richtige Konfigurationstyp angegeben wird, was zu weniger Abweichungen führen kann.

Strukturierte Ausgabe

Wenn Sie generative KI als Komponente in Ihrer Anwendung verwenden, möchten Sie die Ausgabe oft in einem anderen Format als Nur-Text haben. Auch wenn Sie nur Inhalte generieren, die Nutzern angezeigt werden sollen, können Sie von strukturierten Ergebnissen profitieren, um sie Nutzern ansprechender zu präsentieren. Für erweiterte Anwendungen generativer KI, z. B. die programmatische Verwendung der Ausgabe des Modells oder die Eingabe der Ausgabe eines Modells in ein anderes, ist jedoch eine strukturierte Ausgabe unerlässlich.

In Genkit können Sie eine strukturierte Ausgabe von einem Modell anfordern, indem Sie beim Aufrufen von genkit.Generate() einen Ausgabetyp angeben:

type MenuItem struct {
    Name        string   `json:"name"`
    Description string   `json:"description"`
    Calories    int      `json:"calories"`
    Allergens   []string `json:"allergens"`
}

resp, err := genkit.Generate(ctx, g,
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
    ai.WithOutputType(MenuItem{}),
)
if err != nil {
  log.Fatal(err) // One possible error is that the response does not conform to the type.
}

Modellausgabetypen werden mit dem Paket invopop/jsonschema als JSON-Schema angegeben. Dies ermöglicht die Laufzeittypprüfung, die die Lücke zwischen statischen Go-Typen und der unvorhersehbaren Ausgabe generativer KI-Modelle schließt. Mit diesem System können Sie Code schreiben, der davon ausgehen kann, dass ein erfolgreicher generate-Aufruf immer eine Ausgabe zurückgibt, die Ihren Go-Typen entspricht.

Wenn Sie in genkit.Generate() einen Ausgabetyp angeben, führt Genkit im Hintergrund mehrere Aktionen aus:

• Ergänzt den Prompt um zusätzliche Informationen zum ausgewählten Ausgabeformat. Außerdem können Sie dem Modell so mitteilen, welche Inhalte genau Sie generieren möchten, z. B. nicht nur einen Menüpunkt vorschlagen, sondern auch eine Beschreibung und eine Liste der Allergene generieren.
• Prüft, ob die Ausgabe dem Schema entspricht.
• Wandelt die Modellausgabe in einen Go-Typ um.

Wenn Sie eine strukturierte Ausgabe aus einem erfolgreichen generate-Aufruf erhalten möchten, rufen Sie Output() für die Modellantwort mit einem leeren Wert des folgenden Typs auf:

var item MenuItem
if err := resp.Output(&item); err != nil {
    log.Fatalf(err)
}

log.Printf("%s (%d calories, %d allergens): %s\n",
    item.Name, item.Calories, len(item.Allergens), item.Description)

Alternativ können Sie genkit.GenerateData() für einen kürzeren Aufruf verwenden:

item, resp, err := genkit.GenerateData[MenuItem](ctx, g,
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
)
if err != nil {
  log.Fatal(err)
}

log.Printf("%s (%d calories, %d allergens): %s\n",
    item.Name, item.Calories, len(item.Allergens), item.Description)

Für diese Funktion ist der Parameter „Ausgabetyp“ erforderlich. Die Option WithOutputType() wird jedoch automatisch festgelegt und resp.Output() wird aufgerufen, bevor der Wert zurückgegeben wird.

Fehlerbehebung

Beachten Sie im vorherigen Beispiel, dass der genkit.Generate()-Aufruf zu einem Fehler führen kann. Ein möglicher Fehler kann auftreten, wenn das Modell keine Ausgabe generiert, die dem Schema entspricht. Die beste Strategie für den Umgang mit solchen Fehlern hängt von Ihrem genauen Anwendungsfall ab. Hier sind einige allgemeine Hinweise:

• Versuchen Sie es mit einem anderen Modell. Damit eine strukturierte Ausgabe möglich ist, muss das Modell in der Lage sein, eine Ausgabe im JSON-Format zu generieren. Die leistungsstärksten LLMs wie Gemini sind vielseitig genug, um dies zu tun. Kleinere Modelle wie einige der lokalen Modelle, die Sie mit Ollama verwenden würden, können jedoch möglicherweise keine strukturierte Ausgabe zuverlässig generieren, es sei denn, sie wurden speziell dafür trainiert.

• Vereinfachen Sie das Schema. LLMs haben möglicherweise Probleme beim Generieren komplexer oder verschachtelter Typen. Verwenden Sie klare Namen, weniger Felder oder eine flache Struktur, wenn Sie keine zuverlässigen strukturierten Daten generieren können.

• Wiederhole den genkit.Generate()-Anruf. Wenn das von Ihnen ausgewählte Modell nur selten keine konforme Ausgabe generiert, können Sie den Fehler wie einen Netzwerkfehler behandeln und die Anfrage mit einer Art Inkrementellem Back-off wiederholen.

Streaming

Wenn Sie große Mengen an Text generieren, können Sie die Nutzerfreundlichkeit verbessern, indem Sie die Ausgabe während der Generierung präsentieren, also streamen. Ein bekanntes Beispiel für Streaming in der Praxis findet sich in den meisten LLM-Chat-Apps: Nutzer können die Antwort des Modells auf ihre Nachricht lesen, während sie generiert wird. Dadurch wird die wahrgenommene Reaktionsfähigkeit der Anwendung verbessert und der Eindruck entsteht, mit einem intelligenten Gegenüber zu chatten.

In Genkit können Sie die Ausgabe mit der Option WithStreaming() streamen:

resp, err := genkit.Generate(ctx, g,
    ai.WithPrompt("Suggest a complete menu for a pirate themed restaurant."),
    ai.WithStreaming(func(ctx context.Context, chunk *ai.ModelResponseChunk) error {
        // Do something with the chunk...
        log.Println(chunk.Text())
        return nil
    }),
)
if err != nil {
    log.Fatal(err)
}

log.Println(resp.Text())

Multimodale Eingabe

In den bisherigen Beispielen wurden Textstrings als Prompts für das Modell verwendet. Dies ist zwar nach wie vor die gängigste Methode, generative KI-Modelle zu steuern, aber viele Modelle können auch andere Medien als Prompts akzeptieren. Medien-Prompts werden am häufigsten in Kombination mit Text-Prompts verwendet, die das Modell anweisen, eine bestimmte Aktion an den Medien auszuführen, z. B. ein Bild zu beschriften oder eine Audioaufnahme zu transkribieren.

Ob Medieneingaben akzeptiert werden und welche Medientypen verwendet werden können, hängt vollständig vom Modell und seiner API ab. Die Gemini 2.0-Modellreihe kann beispielsweise Bilder, Video und Audio als Prompts akzeptieren.

Wenn Sie einem Modell, das dies unterstützt, einen Medien-Prompt zur Verfügung stellen möchten, übergeben Sie anstelle eines einfachen Text-Prompts an genkit.Generate() ein Array, das aus einem Medien- und einem Textteil besteht. In diesem Beispiel wird ein Bild mit einer öffentlich zugänglichen HTTPS-URL angegeben.

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-2.0-flash"),
    ai.WithMessages(
        NewUserMessage(
            NewMediaPart("image/jpeg", "https://example.com/photo.jpg"),
            NewTextPart("Compose a poem about this image."),
        ),
    ),
)

Du kannst Mediendaten auch direkt übergeben, indem du sie als Daten-URL codierst. Beispiel:

image, err := ioutil.ReadFile("photo.jpg")
if err != nil {
    log.Fatal(err)
}

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-2.0-flash"),
    ai.WithMessages(
        NewUserMessage(
            NewMediaPart("image/jpeg", "data:image/jpeg;base64," + base64.StdEncoding.EncodeToString(image)),
            NewTextPart("Compose a poem about this image."),
        ),
    ),
)

Alle Modelle, die Medieneingabe unterstützen, unterstützen sowohl Daten- als auch HTTPS-URLs. Einige Modell-Plug-ins bieten Unterstützung für andere Medienquellen. Mit dem Vertex AI-Plug-in können Sie beispielsweise Cloud Storage-URLs (gs://) verwenden.

Nächste Schritte

Weitere Informationen zu Genkit

• Als App-Entwickler können Sie die Ausgabe von generativen KI-Modellen hauptsächlich über Prompts beeinflussen. Im Artikel Prompts mit Dotprompt verwalten erfahren Sie, wie Sie mit Genkit effektive Prompts entwickeln und in Ihrer Codebasis verwalten können.
• genkit.Generate() ist zwar der Kern jeder Anwendung mit generativer KI, aber in der Praxis sind vor und nach dem Aufruf eines generativen KI-Modells in der Regel zusätzliche Arbeiten erforderlich. Aus diesem Grund führt Genkit das Konzept von Flows ein. Diese werden wie Funktionen definiert, bieten aber zusätzliche Funktionen wie Beobachtbarkeit und vereinfachte Bereitstellung. Weitere Informationen finden Sie unter KI-Workflows definieren.

Erweiterte LLM-Nutzung

Es gibt Methoden, mit denen Sie in Ihrer App noch mehr von LLMs profitieren können.

• Eine Möglichkeit, die Fähigkeiten von LLMs zu verbessern, besteht darin, ihnen eine Liste mit Möglichkeiten zur Verfügung zu stellen, wie sie weitere Informationen von Ihnen anfordern oder Sie um eine bestimmte Aktion bitten können. Dies wird als Toolaufruf oder Funktionsaufruf bezeichnet. Modelle, die für diese Funktion trainiert wurden, können auf einen Prompt mit einer speziell formatierten Antwort reagieren, die der aufrufenden Anwendung mitteilt, dass sie eine Aktion ausführen und das Ergebnis zusammen mit dem ursprünglichen Prompt an das LLM zurücksenden soll. Genkit bietet Bibliotheksfunktionen, die sowohl die Promptgenerierung als auch die Elemente der Aufruf-Antwortschleife eines Tools automatisieren, das eine Implementierung aufruft. Weitere Informationen finden Sie unter Tools aufrufen.
• Retrieval-Augmented Generation (RAG) ist eine Methode, mit der domänenspezifische Informationen in die Ausgabe eines Modells eingefügt werden. Dazu werden relevante Informationen in einen Prompt eingefügt, bevor er an das Sprachmodell übergeben wird. Für eine vollständige RAG-Implementierung müssen mehrere Technologien kombiniert werden: Modelle zur Generierung von Text-Embeddings, Vektordatenbanken und Large Language Models. Unter Retrieval-Augmented Generation (RAG) erfahren Sie, wie Genkit die Koordination dieser verschiedenen Elemente vereinfacht.