Scrivere un plug-in del modello Genkit

I plug-in dei modelli Genkit aggiungono uno o più modelli di AI generativa al registry Genkit. Un modello rappresenta qualsiasi modello generativo in grado di ricevere un prompt come input e generare testo, contenuti multimediali o dati come output.

Prima di iniziare

Per informazioni sulla scrittura di plug-in Genkit, consulta Scrittura di plug-in Genkit qualsiasi tipo di plug-in Genkit, compresi quelli per i modelli. In particolare, tieni presente che ogni plug-in deve esportare una funzione Init che gli utenti devono chiamare prima di utilizzare il plug-in.

Definizioni del modello

Di solito, un plug-in del modello effettua una o più chiamate ai.DefineModel nel Funzione Init: una volta per ogni modello il plug-in fornisce un'interfaccia a.

Una definizione del modello è composta da tre componenti:

Metadati che dichiarano le funzionalità del modello.
Un tipo di configurazione con eventuali parametri specifici supportati dal modello.
Una funzione di generazione che accetta un ai.GenerateRequest e restituisce un ai.GenerateResponse, presumibilmente utilizzando un modello di IA per generare quest'ultimo.

Ecco come si presenta a livello generale nel codice:

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

Dichiarazione delle funzionalità del modello

Ogni definizione di modello deve contenere, come parte dei metadati, un valore ai.ModelCapabilities che dichiara le funzionalità supportate dal modello. Genkit utilizza queste informazioni per determinare determinati comportamenti, come la verifica se determinati input sono validi per il modello. Ad esempio, se il modello non supporta le interazioni multi-turno, viene considerato un errore passare un messaggio storia.

Tieni presente che queste dichiarazioni si riferiscono alle capacità del modello fornite dal tuo plug-in e non necessariamente mappano in modo one-to-one le funzionalità del il modello sottostante e l'API del modello. Ad esempio, anche se l'API del modello non fornisce un modo specifico per definire i messaggi di sistema, il plug-in potrebbe comunque dichiarare il supporto per il ruolo di sistema e implementarlo come logica speciale che inserisce i messaggi di sistema nella richiesta all'utente.

Definizione dello schema di configurazione del modello

Per specificare le opzioni di generazione supportate da un modello, definisci ed esporta un tipo di configurazione. Genkit ha un tipo ai.GenerationCommonConfig che contiene opzioni spesso supportate dai servizi di modelli di IA generativa, che puoi incorporare o utilizzare direttamente.

La funzione di generazione deve verificare che la richiesta contenga il tipo di opzioni corretto.

Trasformazione di richieste e risposte

La funzione di generazione esegue il lavoro principale di un plug-in del modello Genkit: trasforma il ai.GenerateRequest dal formato comune di Genkit in un formato supportato dall'API del tuo modello, quindi trasforma la risposta del tuo modello nel formato ai.GenerateResponse utilizzato da Genkit.

A volte, potrebbe essere necessario massaggiare o manipolare i dati per aggirare il modello limitazioni. Ad esempio, se il modello non supporta in modo nativo una system potrebbe essere necessario trasformare il messaggio di sistema di un prompt in un modello di messaggi.

Esportazioni

Oltre alle risorse che tutti i plug-in devono esportare, ovvero una funzione Init e un tipo Config, un plug-in del modello deve esportare anche quanto segue:

Un tipo di configurazione di generazione, come discusso in precedenza.
Una funzione Model, che restituisce riferimenti ai modelli definiti dal plug-in. Spesso, può trattarsi semplicemente di:
```
func Model(name string) *ai.Model {
    return ai.LookupModel(providerID, name)
}
```
Facoltativo: una funzione DefineModel, che consente agli utenti di definire modelli che: il plug-in può fornire, ma che non definisci automaticamente. Esistono due motivi principali per cui potresti voler fornire una funzione di questo tipo:
- Il tuo plug-in dà accesso a troppi modelli per poter essere praticamente registrato ogni uno. Ad esempio, il plug-in Ollama può fornire accesso a decine di modelli diversi, con più frequenza. Per questo motivo, non definisce automaticamente alcun modello, ma richiede all'utente di chiamare DefineModel per ogni modello che vuole utilizzare.
- Per offrire agli utenti la possibilità di utilizzare i modelli rilasciati di recente che hai non ancora aggiunto al plug-in.
La funzione DefineModel di un plug-in è in genere un frontend di ai.DefineModel che definisce una funzione di generazione, ma consente all'utente di specificare il nome del modello e le relative funzionalità.