É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 de générer du texte, des contenus multimédias ou des données en sortie.

Avant de commencer

Pour en savoir plus sur l'écriture de tout type de plug-in Genkit, y compris de plug-ins de modèle, consultez Écrire des plug-ins Genkit. En particulier, notez que chaque plug-in doit exporter un type conforme à l'interface genkit.Plugin, qui inclut une fonction Name() et une fonction Init().

Définitions de modèle

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

Une définition de modèle se compose de trois composants:

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

Voici à quoi ressemble le code dans les grandes lignes:

type MyModelConfig struct {
    ai.GenerationCommonConfig
    AnotherCustomOption string
    CustomOption        int
}

DefineModel(g, providerID, "my-model",
    &ai.ModelInfo{
        Label: "My Model",
        Supports: &ai.ModelSupports{
            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, mr *ai.ModelRequest, _ ai.ModelStreamCallback) (*ai.ModelResponse, error) {
        // Verify that the request includes a configuration that conforms to your schema.
        if _, ok := mr.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 capacités du modèle

Chaque définition de modèle doit contenir, dans ses métadonnées, une valeur ai.ModelInfo qui déclare les fonctionnalités compatibles avec le modèle. Genkit utilise ces informations pour déterminer certains comportements, par exemple pour 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 multi-tours, il est incorrect de lui transmettre un historique des messages.

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. Genkit dispose d'un type ai.GenerationCommonConfig qui contient des options fréquemment prises en charge par les services de modèles d'IA générative, que vous pouvez 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 la tâche principale d'un plug-in de modèle Genkit : transformer le ai.ModelRequest du format commun de Genkit en un format compatible avec l'API de votre modèle, puis transformer la réponse de votre modèle en format ai.ModelResponse utilisé par Genkit.

Il peut parfois être nécessaire de manipuler ou de modifier les données pour contourner les limites du modèle. 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, 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 de votre plug-in. Il peut s'agir de:

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

  • Une fonction ModelRef, qui crée une référence de modèle associée à sa configuration pouvant valider le type et être transmise ensemble:

    func ModelRef(name string, config *MyModelConfig) *ai.ModelRef {
    return ai.NewModelRef(name, config)
}

  • Facultatif: fonction DefineModel(), qui permet aux utilisateurs de définir des modèles 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 permet d'accéder à trop de modèles pour pouvoir tous les enregistrer. Par exemple, le plug-in Ollama peut fournir l'accès à des dizaines de modèles différents, et d'autres sont ajoutés fréquemment. Pour cette raison, il ne définit aucun modèle automatiquement et nécessite que l'utilisateur appelle DefineModel() pour chaque modèle qu'il souhaite utiliser.

    • Pour permettre à vos utilisateurs d'utiliser les nouveaux modèles que vous n'avez pas encore ajoutés à votre plug-in.

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