Genkit-Modell-Plug-in schreiben

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 ein ai.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ür ai.DefineModel die eine Generationsfunktion definiert, wobei der Nutzer jedoch den Modellnamen angeben kann und Modellfunktionen.