Premiers pas avec les modèles de prompts côté serveur


Dans chaque requête adressée à un modèle, vous envoyez un prompt, ainsi qu'un schéma et des configurations facultatifs pour contrôler la réponse du modèle. Lorsque vous utilisez Firebase AI Logic, vous pouvez envoyer toutes ces informations directement à partir de votre code client ou les spécifier côté serveur à l'aide de modèles de prompts côté serveur.

Lorsque vous utilisez des modèles de prompts côté serveur, vous stockez votre prompt, votre schéma et vos configurations côté serveur. Votre application ne transmet du client au serveur que la clé (l'ID du modèle) faisant référence à un modèle spécifique, ainsi que les entrées requises pour ce modèle.

Lorsque vous utilisez des modèles de prompts côté serveur, vous stockez votre prompt et vos configurations côté serveur, et vous ne fournissez qu'une clé (l'ID du modèle) dans la base de code de votre application. Voici quelques avantages de cette approche :

  • Protection contre l'exposition de votre prompt côté client

  • Mise à jour de votre prompt et de votre configuration sans publier de nouvelle version de l'application

Ce guide explique comment commencer à utiliser les modèles de prompts côté serveur.

Accéder à la vue d'ensemble Accéder aux instructions détaillées

Modèles et fonctionnalités compatibles


Vue d'ensemble

Voici le workflow de base pour utiliser les modèles de prompts côté serveur :

  1. Créez le modèle à l'aide de l'interface utilisateur guidée de la Firebase console.

  2. Testez le modèle dans une requête réelle à l'aide de l'expérience de test de la Firebase console.

  3. Accédez au modèle à partir du code de votre application à l'aide de templateGenerativeModel.

Format de base d'un modèle de prompt côté serveur

Pour Firebase AI Logic, la console Firebase fournit une interface utilisateur guidée qui vous permet de spécifier le préambule et le contenu du modèle.

Les modèles de prompts côté serveur utilisent une syntaxe et un format basés sur Dotprompt. Pour en savoir plus, consultez la section Format, syntaxe et exemples de modèles.

L'exemple de modèle ci-dessous présente les composants les plus importants d'un modèle pour une requête d'exemple adressée à un Gemini modèle :

---
model: 'gemini-3-flash-preview'
---

{{role "system"}}
All output must be a clearly structured invoice document.
Use a tabular or clearly delineated list format for line items.

{{role "user"}}
Create an example customer invoice for a customer named {{customerName}}.

  • La section supérieure entre les triples tirets contient le nom du modèle, ainsi que, éventuellement, toute configuration de modèle, validation d'entrée ou schéma que vous souhaitez envoyer dans la requête. Elle est écrite sous forme de paires clé/valeur et est généralement appelée préambule YAML.

  • Le corps du modèle contient le prompt. Il peut également inclure des instructions système et des valeurs d’entrée (à l’aide de la syntaxe Handlebars).

Utiliser votre modèle dans le code

Cliquez sur votre fournisseur Gemini API pour afficher le contenu spécifique au fournisseur et le code sur cette page.

L'exemple de code client ci-dessous montre comment utiliser le modèle dans votre code :

Swift 


// ...

// Initialize the Gemini Developer API backend service
// Create a `TemplateGenerativeModel` instance
let model = FirebaseAI.firebaseAI(backend: .googleAI()).templateGenerativeModel()

let customerName = "Jane"

do {
    let response = try await model.generateContent(
        // Specify your template ID
        templateID: "my-first-template-v1-0-0",
        // Provide the values for any input variables required by your template.
        inputs: [
            "customerName": customerName
        ]
    )
    if let text = response.text {
        print("Response Text: \(text)")
    }
} catch {
    print("An error occurred: \(error)")
}
print("\n")

Kotlin 


// ...

// Initialize the Gemini Developer API backend service
// Create a `TemplateGenerativeModel` instance
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).templateGenerativeModel()

val customerName = "Jane"

val response = model.generateContent(
    // Specify your template ID
    "my-first-template-v1-0-0",
    // Provide the values for any input variables required by your template.
    mapOf(
        "customerName" to customerName
    )
)

val text = response.text
println(text)

Java 


// ...

// Initialize the Gemini Developer API backend service
// Create a `TemplateGenerativeModel` instance
TemplateGenerativeModel generativeModel = FirebaseAI.getInstance().templateGenerativeModel();

TemplateGenerativeModelFutures model = TemplateGenerativeModelFutures.from(generativeModel);

String customerName = "Jane";

Future response = model.generateContent(
    // Specify your template ID
    "my-first-template-v1-0-0",
    // Provide the values for any input variables required by your template.
    mapOf("customerName", customerName)
);
addCallback(response,
       new FutureCallback() {
           public void onSuccess(GenerateContentResponse result) {
             System.out.println(result.getText());
           }
           public void onFailure(Throwable t) {
             reportError(t);
           }
    }
executor);

Web 


// ...

// Initialize the Gemini Developer API backend service
const ai = getAI(app, { backend: new GoogleAIBackend() });

// Create a `TemplateGenerativeModel` instance
const model = getTemplateGenerativeModel(ai);

const customerName = 'Jane';

const result = await model.generateContent(
  // Specify your template ID
  'my-first-template-v1-0-0',
  // Provide the values for any input variables required by your template
  {
    customerName: customerName,
  }
);

const response = result.response;
const text = response.text();

Dart 


// ...

// Initialize the Gemini Developer API backend service
// Create a `TemplateGenerativeModel` instance
var _model = FirebaseAI.googleAI().templateGenerativeModel()

var customerName = 'Jane';

var response = await _model.generateContent(
        // Specify your template ID
        'my-first-template-v1-0-0',
        // Provide the values for any input variables required by your template
        inputs: {
           'customerName': customerName,
        },
      );

var text = response?.text;
print(text);

Unity 


// ...

// Initialize the Gemini Developer API backend service
var firebaseAI = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `TemplateGenerativeModel` instance
var model = firebaseAI.GetTemplateGenerativeModel();

var customerName = "Jane";

try
{
   var response = await model.GenerateContentAsync(
      // Specify your template ID
      "my-first-template-v1-0-0",
      // Provide the values for any input variables required by your template
      new Dictionary<string, object> {
         { "customerName", customerName },
      }
   );
   Debug.Log($"Response Text: {response.Text}");
}
catch (Exception e) {
  Debug.LogError($"An error occurred: {e.Message}");
}


Instructions détaillées

Cette section fournit des instructions détaillées pour créer, tester et utiliser des modèles de prompts côté serveur.

Avant de commencer

  • Si ce n'est pas déjà fait, consultez le guide de démarrage, qui explique comment configurer votre projet Firebase, connecter votre application à Firebase, ajouter le SDK, initialiser le service backend pour le fournisseur Gemini API de votre choix et créer une instance GenerativeModel.

  • Assurez-vous de disposer des autorisations requises pour créer et gérer des modèles de prompts côté serveur. Par défaut, toutes ces autorisations sont incluses dans le rôle Propriétaire.

  • Si vous utilisez les Vertex AI Gemini API et si votre cas d'utilisation nécessite des restrictions géographiques, nous acceptons les workflows avancés pour les modèles.

Étape 1 : Créer un modèle de prompt côté serveur

Dans la plupart des cas d'utilisation, vous créez et gérez des modèles de prompts côté serveur dans la Firebase console.

  1. Dans la console Firebase, accédez à l'onglet AI Services > AI Logic > Prompt templates.

  2. Cliquez sur Create new template (Créer un modèle), puis sélectionnez une option de modèle de démarrage.

    • Ces modèles de démarrage fournissent le format et la syntaxe de certains cas d'utilisation courants. Quelle que soit l'option que vous sélectionnez, vous pouvez modifier complètement le modèle pour répondre à vos besoins.

    • Ce guide de démarrage suppose que vous avez sélectionné l'option Input + System Instructions (Entrée + Instructions système).

  3. Saisissez les identifiants du modèle :

    • Nom du modèle : il s'agit d'un nom à afficher pour le modèle (par exemple, My First Template). Il n'est visible que dans les interfaces Firebase, comme la console Firebase.

    • ID du modèle : il doit s'agir d'un ID unique pour le modèle dans votre projet Firebase (par exemple, my-first-template-v1-0-0). Vous ferez référence à cet ID dans la requête de votre application.

  4. Modifiez la section Configuration (frontmatter) du modèle, si nécessaire.

    • Cette section doit inclure au minimum un nom de modèle, comme suit :

      ---
model: 'gemini-3-flash-preview'
---

    • Vous pouvez également spécifier la configuration du modèle et les commandes d'entrée et & de sortie, etc. Pour en savoir plus et découvrir d'autres options, consultez la section Format, syntaxe et exemples de modèles.

  5. Modifiez la section Prompt and (as applicable) system instructions (Prompt et instructions système (le cas échéant)) du modèle, si nécessaire.

    • Cette section doit inclure au minimum le prompt textuel à envoyer au modèle.

      Write a story about a magic backpack.

    • Vous pouvez également créer des prompts plus complexes, comme les options suivantes. Pour en savoir plus et découvrir d'autres options, consultez la section Format, syntaxe et exemples de modèles.

      • (Facultatif et le cas échéant) Spécifiez les instructions système à l'aide de la {{role "system"}} syntaxe, et le prompt textuel à l'aide de la {{role "user"}} syntaxe.

      • (Facultatif) Spécifiez les variables d'entrée à l'aide de la syntaxe Handlebars (par exemple, {{customerName}}). Vous pouvez fournir une valeur par défaut dans le modèle, mais la valeur de cette variable d'entrée est généralement transmise dans la requête.

      {{role "system"}}
All output must be a clearly structured invoice document.
Use a tabular or clearly delineated list format for line items.

{{role "user"}}
Create an example customer invoice for a customer named {{customerName}}.

Étape 2 : Tester votre modèle dans la console Firebase

La console Firebase fournit une expérience de test pour votre modèle. Cette expérience vous permet de voir ce qui se passe lorsque votre modèle est utilisé, à la fois le format de la requête et le résultat d'une requête réelle.

  1. Cliquez sur Save template (Enregistrer le modèle) pour pouvoir tester votre modèle.

    Vous pouvez toujours modifier, voire supprimer le modèle ultérieurement. La seule valeur que vous ne pourrez pas modifier ultérieurement est l'ID du modèle.

  2. Si votre prompt utilise des variables d'entrée, incluez des valeurs de test dans le champ Test input (Entrée de test). Pour cet exemple :

      {
    "customerName": "Jane"
  }

  3. Si plusieurs fournisseurs Gemini API sont activés dans votre projet Firebase, vous pouvez choisir celui à utiliser pour la requête de test. Si cette option s'affiche dans la console, sélectionnez Gemini Developer API ou Vertex AI Gemini API.

    Notez que cette sélection ne s'applique qu'aux requêtes envoyées via l' Firebase expérience de test de la console. Dans la requête réelle de votre application, vous spécifiez le fournisseur Gemini API de votre choix comme vous le feriez pour n'importe quelle requête.

  4. Cliquez sur le bouton Create formatted test request (Créer une requête de test formatée).

    Examinez la requête de test formatée résultante à droite de l'écran et itérez sur l'un des champs de votre modèle.

  5. Lorsque vous êtes satisfait de la requête de test formatée, cliquez sur le bouton Run prompt test (Exécuter le test de prompt).

    Examinez la réponse de test résultante à droite de l'écran et itérez sur l'un des champs de votre modèle.

  6. Si vous êtes prêt à accéder au modèle à partir du code de votre application, verrouillez le modèle en cliquant sur l' icône de verrouillage dans le coin supérieur droit du modèle.

  7. Cliquez sur Close (Fermer) pour quitter l'expérience de modification.

Étape 3 : Accéder à votre modèle à partir de votre code

Cliquez sur votre fournisseur Gemini API pour afficher le contenu spécifique au fournisseur et le code sur cette page.

Une requête utilisant un modèle de prompt côté serveur ressemble à d'autres requêtes, avec les ajustements suivants :

  • Utilisez un templateGenerativeModel (ou templateImagenModel, si nécessaire).
  • Indiquez l'ID du modèle.
  • Fournissez les valeurs de toutes les entrées de variables requises par votre modèle.

Notez qu'après avoir créé ou mis à jour votre modèle, vous devrez peut-être attendre quelques minutes avant qu'il ne se propage sur les serveurs Firebase avant d'y accéder à partir de votre code.

Swift

Créez une instance templateGenerativeModel (ou templateImagenModel) pour utiliser un modèle dans votre requête.


// ...

// Initialize the Gemini Developer API backend service
// Create a `TemplateGenerativeModel` instance
let model = FirebaseAI.firebaseAI(backend: .googleAI()).templateGenerativeModel()

let customerName = "Jane"

do {
    let response = try await model.generateContent(
        // Specify your template ID
        templateID: "my-first-template-v1-0-0",
        // Provide the values for any input variables required by your template.
        inputs: [
            "customerName": customerName
        ]
    )
    if let text = response.text {
        print("Response Text: \(text)")
    }
} catch {
    print("An error occurred: \(error)")
}
print("\n")

Kotlin

Créez une instance templateGenerativeModel (ou templateImagenModel) pour utiliser un modèle dans votre requête.


// ...

// Initialize the Gemini Developer API backend service
// Create a `TemplateGenerativeModel` instance
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).templateGenerativeModel()

val customerName = "Jane"

val response = model.generateContent(
    // Specify your template ID
    "my-first-template-v1-0-0",
    // Provide the values for any input variables required by your template.
    mapOf(
        "customerName" to customerName
    )
)

val text = response.text
println(text)

Java

Créez une instance templateGenerativeModel (ou templateImagenModel) pour utiliser un modèle dans votre requête.


// ...

// Initialize the Gemini Developer API backend service
// Create a `TemplateGenerativeModel` instance
TemplateGenerativeModel generativeModel = FirebaseAI.getInstance().templateGenerativeModel();

TemplateGenerativeModelFutures model = TemplateGenerativeModelFutures.from(generativeModel);

String customerName = "Jane";

Future response = model.generateContent(
    // Specify your template ID
    "my-first-template-v1-0-0",
    // Provide the values for any input variables required by your template.
    mapOf("customerName", customerName)
);
addCallback(response,
       new FutureCallback() {
           public void onSuccess(GenerateContentResponse result) {
             System.out.println(result.getText());
           }
           public void onFailure(Throwable t) {
             reportError(t);
           }
    }
executor);

Web

Créez une instance templateGenerativeModel (ou templateImagenModel) pour utiliser un modèle dans votre requête.


// ...

// Initialize the Gemini Developer API backend service
const ai = getAI(app, { backend: new GoogleAIBackend() });

// Create a `TemplateGenerativeModel` instance
const model = getTemplateGenerativeModel(ai);

const customerName = 'Jane';

const result = await model.generateContent(
  // Specify your template ID
  'my-first-template-v1-0-0',
  // Provide the values for any input variables required by your template
  {
    customerName: customerName,
  }
);

const response = result.response;
const text = response.text();

Dart

Le plug-in Flutter sera bientôt compatible avec les modèles de prompts côté serveur.

Créez une instance templateGenerativeModel (ou templateImagenModel) pour utiliser un modèle dans votre requête.


// ...

// Initialize the Gemini Developer API backend service
// Create a `TemplateGenerativeModel` instance
var _model = FirebaseAI.googleAI().templateGenerativeModel()

var customerName = 'Jane';

var response = await _model.generateContent(
        // Specify your template ID
        'my-first-template-v1-0-0',
        // Provide the values for any input variables required by your template
        inputs: {
           'customerName': customerName,
        },
      );

var text = response?.text;
print(text);

Unity

Créez une instance templateGenerativeModel (ou templateImagenModel) pour utiliser un modèle dans votre requête.


// ...

// Initialize the Gemini Developer API backend service
var firebaseAI = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `TemplateGenerativeModel` instance
var model = firebaseAI.GetTemplateGenerativeModel();

var customerName = "Jane";

try
{
   var response = await model.GenerateContentAsync(
      // Specify your template ID
      "my-first-template-v1-0-0",
      // Provide the values for any input variables required by your template
      new Dictionary<string, object> {
         { "customerName", customerName },
      }
   );
   Debug.Log($"Response Text: {response.Text}");
}
catch (Exception e) {
  Debug.LogError($"An error occurred: {e.Message}");
}
Firebase Remote Config


Étape suivante