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

Dans chaque requête envoyée à un modèle, vous envoyez un prompt, ainsi que, de manière facultative, un schéma et des configurations pour contrôler la réponse du modèle. Lorsque vous utilisez Firebase AI Logic, vous pouvez envoyer toutes ces informations directement depuis 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 le code de votre application. Voici quelques avantages de cette approche :

• Éviter d'exposer votre prompt côté client

• Mettre à jour votre requête et votre configuration sans publier de nouvelle version de l'application

Ce guide explique comment commencer à utiliser les modèles de requêtes de serveur.

arrow_downward Accéder à la présentation générale arrow_downward Accéder aux instructions détaillées

Modèles et fonctionnalités compatibles

• Utilisez des modèles de requêtes côté serveur avec l'un des modèles Gemini et Imagen compatibles avec Firebase AI Logic, à l'exception des modèles Gemini Live.

• Consultez la liste des fonctionnalités qui ne sont pas encore disponibles.

Vue d'ensemble

Voici le workflow de base pour utiliser les modèles d'invite de serveur :

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

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

3. Accédez au modèle depuis votre application.

Format de base des modèles de prompts côté serveur

Pour Firebase AI Logic, la console Firebase fournit une interface utilisateur guidée qui vous permet de spécifier le contenu d'un 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 Format, syntaxe et exemples de modèles.

Voici les composants les plus importants d'un exemple de requête adressée à un modèle Gemini :

---
model: 'gemini-2.5-flash'
---

{{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 trois tirets contient le nom du modèle, ainsi que, éventuellement, toute configuration, validation d'entrée ou schéma de modèle que vous souhaitez envoyer dans la requête. Il est rédigé sous forme de paires clé/valeur et est généralement appelé frontmatter YAML.

• Le corps du modèle contient la requête. 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

Voici comment utiliser le modèle dans votre code :

// ...

// 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")

// ...

// Initialize the Gemini Developer API backend service
// Create a `TemplateGenerativeModel` instance
val model = Firebase.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)

// ...

// 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);

// ...

// 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 = response.result;
const text = response.text();

Instructions détaillées

Cette section fournit des instructions détaillées pour créer, tester et utiliser des modèles d'invite de serveur.

Avant de commencer

• Si ce n'est pas déjà fait, suivez le guide de démarrage. Il explique comment configurer votre projet Firebase, associer votre application à Firebase, ajouter le SDK, initialiser le service de 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 d'invite côté serveur. Par défaut, toutes ces autorisations sont incluses dans le rôle "Propriétaire".

  Afficher les autorisations requises

  • firebasevertexai.googleapis.com/promptTemplates.create
  • firebasevertexai.googleapis.com/promptTemplates.get
  • firebasevertexai.googleapis.com/promptTemplates.update
  • firebasevertexai.googleapis.com/promptTemplates.delete
  • firebasevertexai.googleapis.com/promptTemplates.list

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

Étape 1 : Créez un modèle de requête de serveur

Dans la plupart des cas d'utilisation, vous créez et gérez des modèles de requête de serveur dans la console Firebase.

1. Dans la consoleFirebase, accédez à l'onglet Firebase AI Logic Modèles de requêtes.

2. Cliquez sur Créer un modèle, puis sélectionnez une option de modèle de départ.

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

   • Ce guide de démarrage suppose que vous avez sélectionné l'option Input + System Instructions.

3. Saisissez les identifiants du modèle :

   • Nom du modèle : 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 provenant de votre application.

     • Nous vous recommandons d'utiliser un système de gestion des versions pour vos ID de modèles.

     • Les ID de modèle peuvent comporter 63 caractères au maximum et contenir des lettres minuscules, des chiffres et des traits d'union.

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

   • Cette section doit au moins inclure un nom de modèle, comme ceci :

     ---
     model: 'gemini-2.5-flash'
     ---
     

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

5. Modifiez la section Requête et (le cas échéant) instructions système du modèle, si nécessaire.

   • Cette section doit au moins inclure la requête textuelle à envoyer au modèle.

     Write a story about a magic backpack.
     

   • Vous pouvez également créer des requêtes plus complexes, comme celles ci-dessous. Pour en savoir plus et découvrir d'autres options, consultez Format, syntaxe et exemples de modèles.

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

     • (Facultatif) Spécifiez les variables d'entrée à l'aide de la syntaxe Handlebars (comme {{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 : Testez votre modèle dans la console Firebase

La console Firebase vous permet de tester votre modèle. Cette expérience vous permet de voir ce qui se passera lorsque votre modèle sera utilisé, à la fois le format de la demande et la sortie d'une demande réelle.

1. Cliquez sur Enregistrer le modèle pour pouvoir le tester.

   Vous pourrez toujours modifier ou même 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 requête utilise des variables d'entrée, incluez des valeurs de test dans le champ Test input (Tester l'entrée). 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 demande 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 demandes envoyées via l'expérience de test de la console Firebase. 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 Créer une requête de test formatée.

   Examinez la demande de test mise en forme qui s'affiche à droite de l'écran et modifiez les champs de votre modèle si nécessaire.

   Développer pour afficher un exemple de requête de test formatée

   {
     "model": "projects/YOUR_PROJECT_ID/models/gemini-2.5-flash",
     "contents": [{
       "parts": [{
         "text": "Create an example customer invoice for a customer named Jane"
       }],
       "role": "user"
     }],
     "systemInstruction": {
       "parts": [{
         "text": "All output must be a clearly structured invoice document.\nUse a tabular or clearly delineated list format for line items."
       }]
     }
   }
   

5. Lorsque vous êtes satisfait de la demande de test formatée, cliquez sur le bouton Exécuter le test d'invite.

   Examinez la réponse au test qui s'affiche à droite de l'écran, puis modifiez les champs de votre modèle si nécessaire.

   Développer pour afficher un exemple de réponse au test

   {
     "candidates": [{
       "content": {
         "parts": [{
           "text": "```\n--------------------------------------------------------------------------------\n                         **INVOICE**\n--------------------------------------------------------------------------------\n\n**Creative Solutions Inc.**\n123 Business Lane, Suite 100\nAnytown, USA 12345\nPhone: (555) 123-4567\nEmail: info@creativesolutions.com\n\n**INVOICE NO:** INV-2023-001\n**INVOICE DATE:** October 26, 2023\n**DUE DATE:** November 25, 2023\n\n**BILL TO:**\nJane\n456 Client Street, Apt 2B\nAnytown, USA 12346\nPhone: (555) 987-6543\nEmail: jane@example.com\n\n--------------------------------------------------------------------------------\n**ITEM DESCRIPTION**               **QTY**   **UNIT PRICE**   **AMOUNT**\n--------------------------------------------------------------------------------\nWebsite Design Services            1         $800.00          $800.00\nContent Creation (Blog Posts)      4         $120.00          $480.00\nMonthly Hosting \u0026 Maintenance      1         $50.00           $50.00\nConsultation Fee                   2         $75.00           $150.00\n--------------------------------------------------------------------------------\n\n**SUMMARY:**\nSubtotal:                                                     $1,480.00\nSales Tax (8%):                                               $118.40\n--------------------------------------------------------------------------------\n**TOTAL DUE:**                                                **$1,598.40**\n--------------------------------------------------------------------------------\n\n**PAYMENT TERMS:**\nPayment is due within 30 days of the invoice date. Please make checks payable to Creative Solutions Inc. For electronic payments, please contact us for details.\n\nThank you for your business!\n```"
         }],
         "role": "model"
       },
       "finishReason": "STOP",
       "index": 0
     }],
     "usageMetadata": {
       "promptTokenCount": 34,
       "candidatesTokenCount": 418,
       "totalTokenCount": 890,
       "promptTokensDetails": [{
         "modality": "TEXT",
         "tokenCount": 34
       }],
       "thoughtsTokenCount": 438
     },
     "modelVersion": "gemini-2.5-flash",
     "responseId": "3w4Vad6yF-y1vdIP_q_zgAw",
     "turnToken": "v1:ChczdzRWYWQ2eUYteTF2ZElQX3FfemdBdxIXM3c0VmFkNnlGLXkxdmRJUF9xX3pnQXc"
   }
   

6. Si vous êtes prêt à accéder au modèle à partir du code de votre application, verrouillez-le en cliquant sur l'icône de verrouillage lock en haut à droite du modèle.

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

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

Une requête utilisant un modèle de requête serveur ressemble aux autres requêtes, avec les ajustements suivants :

• Utilisez templateGenerativeModel (ou templateImagenModel, si nécessaire).
• Indiquez l'ID du modèle.
• Indiquez les valeurs des 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 pour qu'il se propage sur les serveurs Firebase avant de pouvoir y accéder depuis votre code.

// ...

// 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")

// ...

// Initialize the Gemini Developer API backend service
// Create a `TemplateGenerativeModel` instance
val model = Firebase.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)

// ...

// 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);

// ...

// 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 = response.result;
const text = response.text();

Étape suivante

• Découvrez les bonnes pratiques et les points à prendre en compte pour utiliser les modèles de prompts côté serveur.

• Découvrez en détail le format et la syntaxe des modèles, ainsi que des exemples.

• Gérer les modèles, y compris les modifier, les verrouiller et contrôler les versions