Mit Genkit-Modell-Plug-ins werden der Genkit-Registrierung ein oder mehrere generative KI-Modelle hinzugefügt. Ein Modell ist ein beliebiges generatives Modell, das einen Prompt als Eingabe entgegennehmen und Text, Medien oder Daten als Ausgabe generieren kann.
Hinweis
Informationen zum Schreiben von Genkit-Plug-ins finden Sie unter Schreiben von Genkit-Plug-ins.
alle Arten von Genkit-Plug-ins, einschließlich Modell-Plug-ins. Beachten Sie insbesondere, dass jedes Plug-in eine Init
-Funktion exportieren muss, die Nutzer vor der Verwendung des Plug-ins aufrufen müssen.
Modelldefinitionen
In der Regel führt ein Modell-Plug-in in seiner Init
-Funktion einen oder mehrere ai.DefineModel
-Aufrufe aus – einmal für jedes Modell, für das das Plug-in eine Schnittstelle bereitstellt.
Eine Modelldefinition besteht aus drei Komponenten:
- Metadaten, die die Funktionen des Modells deklarieren.
- Ein Konfigurationstyp mit allen vom Modell unterstützten Parametern.
- Eine Generierungsfunktion, die ein
ai.GenerateRequest
annimmt und einai.GenerateResponse
, vermutlich mithilfe eines KI-Modells, um Letzteres zu generieren.
Im Großen und Ganzen sieht das im Code so aus:
type MyModelConfig struct {
ai.GenerationCommonConfig
AnotherCustomOption string
CustomOption int
}
name := "my-model"
genkit.DefineModel(g,
providerID, name,
&ai.ModelInfo{
Label: name,
Supports: &ai.ModelInfoSupports{
Multiturn: true, // Does the model support multi-turn chats?
SystemRole: true, // Does the model support syatem messages?
Media: false, // Can the model accept media input?
Tools: false, // Does the model support function calling (tools)?
},
Versions: []string{"my-model-001", "..."},
},
func(ctx context.Context,
genRequest *ai.ModelRequest,
_ ai.ModelStreamingCallback,
) (*ai.ModelResponse, error) {
// Verify that the request includes a configuration that conforms to
// your schema .
if _, ok := genRequest.Config.(MyModelConfig); !ok {
return nil, fmt.Errorf("request config must be type MyModelConfig")
}
// Use your custom logic to convert Genkit's ai.ModelRequest
// into a form usable by the model's native API.
apiRequest, err := apiRequestFromGenkitRequest(genRequest)
if err != nil {
return nil, err
}
// Send the request to the model API, using your own code or the
// model API's client library.
apiResponse, err := callModelAPI(apiRequest)
if err != nil {
return nil, err
}
// Use your custom logic to convert the model's response to Genkin's
// ai.ModelResponse.
response, err := genResponseFromAPIResponse(apiResponse)
if err != nil {
return nil, err
}
return response, nil
},
)
Modellfunktionen deklarieren
Jede Modelldefinition muss als Teil ihrer Metadaten einen ai.ModelCapabilities
-Wert enthalten, der angibt, welche Funktionen das Modell unterstützt.
Genkit nutzt diese Informationen, um bestimmte Verhaltensweisen zu bestimmen, z. B. die Verifizierung
ob bestimmte Eingaben für das Modell gültig sind. Wenn z. B. das Modell
keine Interaktionen in mehreren Schritten unterstützt, ist es ein Fehler,
.
Beachten Sie, dass sich diese Deklarationen auf die Funktionen des Modells wie angegeben beziehen. und entsprechen nicht unbedingt den Funktionen des das zugrunde liegende Modell und die Modell-API. Auch wenn die Modell-API beispielsweise keine bestimmte Möglichkeit zum Definieren von Systemmeldungen bietet, können Sie in Ihrem Plug-in die Unterstützung für die Systemrolle deklarieren und sie als spezielle Logik implementieren, die Systemmeldungen in die Nutzeraufforderung einfügt.
Konfigurationsschema des Modells definieren
Wenn Sie die Generierungsoptionen angeben möchten, die ein Modell unterstützt, definieren und exportieren Sie einen Konfigurationstyp. Genkit hat einen ai.GenerationCommonConfig
-Typ mit Optionen, die häufig von Diensten für generative KI-Modelle unterstützt werden. Sie können diese Optionen einbetten oder direkt verwenden.
Mit der Generierungsfunktion sollte überprüft werden, ob die Anfrage die richtige Optionen-Typ.
Anfragen und Antworten transformieren
Die Generierungsfunktion führt die Hauptaufgabe eines Genkit-Modell-Plug-ins aus:
ai.GenerateRequest
aus dem gängigen Genkit-Format in ein Format umwandeln
die von der API Ihres Modells unterstützt wird, und transformieren Sie dann die Antwort von
Ihr Modell in das von Genkit verwendete Format ai.GenerateResponse
um.
Manchmal erfordert dies möglicherweise das Massieren oder Bearbeiten von Daten, um das Modell zu umgehen
Einschränkungen. Wenn Ihr Modell beispielsweise system
nicht nativ unterstützt,
müssen Sie die Systemnachricht eines Prompts möglicherweise in ein Nutzermodell
Nachrichtenpaar.
Exporte
Zusätzlich zu den Ressourcen, die alle Plug-ins exportieren müssen (eine Init
-Funktion und ein Config
-Typ), sollte ein Modell-Plug-in auch Folgendes exportieren:
Ein Generierungskonfigurationstyp, wie bereits erwähnt.
Eine
Model
-Funktion, die Verweise auf die definierten Modelle Ihres Plug-ins zurückgibt. Oft kann das ganz einfach sein:func Model(name string) *ai.Model { return ai.LookupModel(providerID, name) }
Optional: Eine
DefineModel
-Funktion, mit der Nutzer Modelle definieren können, die von Ihrem Plug-in bereitgestellt werden können, die Sie aber nicht automatisch definieren. Es gibt Es gibt zwei Hauptgründe, warum Sie eine solche Funktion bereitstellen sollten:Ihr Plug-in bietet Zugriff auf zu viele Modelle, um jedes Modell praktisch zu registrieren eins. Das Ollama-Plug-in bietet beispielsweise Zugriff auf Dutzende verschiedener Modelle, die regelmäßig ergänzt werden. Aus diesem Grund werden keine Modelle automatisch definiert. Stattdessen muss der Nutzer
DefineModel
für jedes Modell aufrufen, das er verwenden möchte.Um Ihren Nutzern die Möglichkeit zu geben, neu veröffentlichte Modelle zu verwenden, noch nicht zu Ihrem Plug-in hinzugefügt.
Die Funktion
DefineModel
eines Plug-ins ist normalerweise ein Front-End fürai.DefineModel
die eine Generationsfunktion definiert, wobei der Nutzer jedoch den Modellnamen angeben kann und Modellfunktionen.