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 :
- Métadonnées déclarant les capacités du modèle.
- Type de configuration avec les paramètres spécifiques compatibles avec le modèle.
- Une fonction de génération qui accepte un
ai.GenerateRequest
et renvoie unai.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 deai.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.