Écrire un plug-in de modèle Genkit

Les plug-ins de modèle Genkit ajoutent un ou plusieurs modèles d'IA générative au registre Genkit. Un modèle représente tout modèle génératif capable de recevoir une requête en entrée et générer du texte, des médias ou des données en sortie.

Avant de commencer

Consultez la section Écrire des plug-ins Genkit pour en savoir plus sur l'écriture tous types de plug-ins Genkit, y compris les plug-ins de modèle. En particulier, notez que chaque plug-in doit exporter une fonction Init, que les utilisateurs doivent appeler avant d'utiliser le plug-in.

Définitions de modèle

En général, un plug-in de modèle effectue un ou plusieurs appels ai.DefineModel dans sa fonction Init, une fois pour chaque modèle auquel le plug-in fournit une interface.

Une définition de modèle comprend trois composants :

  1. Métadonnées déclarant les capacités du modèle.
  2. Type de configuration avec les paramètres spécifiques compatibles avec le modèle.
  3. Une fonction de génération qui accepte un ai.GenerateRequest et renvoie un ai.GenerateResponse, probablement à l'aide d'un modèle d'IA pour générer ce dernier.

De manière générale, voici ce à quoi cela ressemble dans le code:

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
	},
)

Déclarer les fonctionnalités du modèle

Chaque définition de modèle doit contenir, dans ses métadonnées, une valeur ai.ModelCapabilities qui déclare les fonctionnalités compatibles avec le modèle. Genkit utilise ces informations pour déterminer certains comportements, comme vérifier si certaines entrées sont valides pour le modèle. Par exemple, si le modèle n'est pas compatible avec les interactions multitours, la transmission d'un message constitue une erreur historique.

Notez que ces déclarations font référence aux fonctionnalités du modèle telles que fournies par votre plug-in et ne correspondent pas nécessairement de manière individuelle aux fonctionnalités du modèle sous-jacent et de l'API du modèle. Par exemple, même si l'API du modèle ne fournit pas de méthode spécifique pour définir des messages système, votre plug-in peut toujours déclarer la prise en charge du rôle système et l'implémenter en tant que logique spéciale qui insère des messages système dans l'invite utilisateur.

Définir le schéma de configuration de votre modèle

Pour spécifier les options de génération compatibles avec un modèle, définissez et exportez un type de configuration. Le type ai.GenerationCommonConfig de Genkit contient souvent prises en charge par les services de modèles d'IA générative, intégrer ou utiliser directement.

Votre fonction de génération doit vérifier que la requête contient le type d'options approprié.

Transformer les requêtes et les réponses

La fonction de génération effectue le travail principal d'un plug-in de modèle Genkit: Transformer ai.GenerateRequest du format courant de Genkit en un format compatible avec l'API de votre modèle, puis la transformation de la réponse au format ai.GenerateResponse utilisé par Genkit.

Parfois, il peut être nécessaire de masser ou de manipuler les données pour contourner le modèle limites. Par exemple, si votre modèle n'est pas compatible en mode natif avec un message system, vous devrez peut-être transformer le message système d'une invite en paire de messages utilisateur-modèle.

Exportations

En plus des ressources que tous les plug-ins doivent exporter (une fonction Init et un type Config), un plug-in de modèle doit également exporter les éléments suivants :

  • Un type de configuration de génération, comme indiqué ci-dessus.

  • Une fonction Model, qui renvoie des références aux modèles définis dans votre plug-in. Souvent, il s'agit simplement de:

    func Model(name string) *ai.Model {
    return ai.LookupModel(providerID, name)
}

  • Facultatif: Une fonction DefineModel, qui permet aux utilisateurs de définir des modèles qui que votre plug-in peut fournir, mais que vous ne définissez pas automatiquement. Vous pouvez fournir une telle fonction pour deux raisons principales :

    • Votre plug-in donne accès à un trop grand nombre de modèles pour que presque chacun puisse les enregistrer. 1. Par exemple, le plug-in Ollama permet d'accéder à des dizaines de modèles différents, qui sont ajoutés plus fréquemment. Pour cette raison, il ne définissent automatiquement tous les modèles et oblige l'utilisateur à appeler DefineModel pour chaque modèle à utiliser.

    • Pour permettre à vos utilisateurs d'exploiter les nouveaux modèles dont vous disposez n'ont pas encore été ajoutées à votre plug-in.

    La fonction DefineModel d'un plug-in est généralement un frontend de ai.DefineModel qui définit une fonction de génération, mais qui permet à l'utilisateur de spécifier le nom et les fonctionnalités du modèle.