Présentation

La Gestion des prompts fournit un registre centralisé pour les prompts utilisés par vos applications LLM. Au lieu de coder en dur les modèles de prompts dans le code de l’application ou les fichiers de configuration, créez, versionnez et mettez à jour les prompts via Agent Observability, puis récupérez-les au moment de l’exécution.

La récupération au moment de l’exécution est prise en charge en Python via le SDK ddtrace. La récupération de prompts et le Suivi des prompts sont distincts : LLMObs.get_prompt() peut récupérer un prompt géré sans activer Agent Observability, mais Agent Observability doit être activé pour créer des spans LLM et leur associer des métadonnées de prompt.

Après avoir créé des versions de prompts, utilisez Prompt Experimentation pour les comparer avec un test A/B ou en déployer une progressivement avec un Déploiement contrôlé.

La Gestion des prompts fonctionne parallèlement au Suivi des prompts. Lorsque Agent Observability est activé, les prompts gérés transmis directement aux appels LLM pris en charge et instrumentés automatiquement sont associés aux spans résultants.

Prérequis

• Python 3.9 ou version ultérieure.
• ddtrace>=4.13.0
• Votre site Datadog et une clé d’API Datadog. La clé d’API est requise pour la récupération de prompts même si les traces sont envoyées via Datadog Agent.
• Une clé d’application Datadog avec les autorisations llm_observability_read, feature_flag_config_read et feature_flag_environment_config_read pour résoudre les prompts par environnement. Si vous sélectionnez une clé d’application existante dans Datadog, assurez-vous qu’elle dispose de ces autorisations.
• Pour gérer les prompts via l’API ou le SDK Python, la clé d’application nécessite également les autorisations llm_observability_write et feature_flag_config_write.

Installez le SDK

Installez ou mettez à niveau le dernier package ddtrace dans l’environnement Python utilisé par votre application :

pip install --upgrade ddtrace

Utilisez un prompt géré en Python

Intégrez la Gestion des prompts à un agent de codage

Intégrez un prompt géré avec l’agent de codage de votre choix en collant le prompt suivant :

Follow the instructions at https://docs.datadoghq.com/llm_observability/instrument/agentic.md to integrate the Datadog managed prompt <PROMPT_ID> into this application for environment <DEPLOYMENT_ENVIRONMENT> and track its use in Agent Observability.

Prompt variables: <PROMPT_VARIABLES>

When configuring the environment, use the following values:

DD_SITE=
DD_ENV=<DEPLOYMENT_ENVIRONMENT>

Optionnellement, ajoutez les identifiants Datadog sélectionnés afin que l’agent de codage puisse configurer et vérifier l’intégration au cours de la même session :

Selected Datadog credentials:

DD_API_KEY=<DATADOG_API_KEY>
DD_APP_KEY=<DATADOG_APP_KEY>

Treat these values as secrets and handle them according to the linked guide. Do not repeat or expose them.

Remarque : L’inclusion des clés d’API et d’application dans le prompt est facultative et n’est pas requise pour que l’agent de codage intègre la Gestion des prompts. Incluez-les uniquement dans une session d’agent de codage de confiance.

Une fois l’intégration terminée, exécutez votre application et déclenchez le flux LLM modifié. Revenez à la page des prompts pour voir l’utilisation ; les nouveaux appels de prompt peuvent mettre une minute à apparaître.

Configurer la récupération de prompts

Fournissez le site Datadog, les identifiants et l’environnement de déploiement via le workflow de configuration et de gestion des secrets déjà utilisé par votre application. Par exemple, utilisez le fichier d’environnement de l’application, la configuration Docker Compose ou Kubernetes, la plateforme de déploiement ou le gestionnaire de secrets. Au moment de l’exécution, les variables d’environnement suivantes doivent être définies avant d’importer ddtrace :

export DD_SITE="<DATADOG_SITE>"
export DD_API_KEY="<DATADOG_API_KEY>"
export DD_APP_KEY="<DATADOG_APP_KEY>"
export DD_ENV="<DEPLOYMENT_ENVIRONMENT>"

DD_ENV sélectionne l’environnement utilisé pour résoudre la version du prompt et doit correspondre à un environnement où le prompt est déployé.

Récupérez, formatez et utilisez un prompt

Conservez le prompt déjà utilisé par votre application comme solution de secours. La solution de secours permet à l’application de continuer à fonctionner en cas de défaillance du registre, de la résolution d’environnement, du réseau ou du serveur.

L’exemple suivant récupère et formate un prompt de chat, puis transmet les messages formatés directement à OpenAI :

from ddtrace.llmobs import LLMObs
from openai import OpenAI

default_messages = [
    {"role": "system", "content": "You are a support agent for {{company}}."},
    {"role": "user", "content": "{{question}}"},
]

variables = {
    "company": "Acme Inc.",
    "question": "How do I reset my password?",
}

prompt = LLMObs.get_prompt(
    "customer-support-greeting",
    fallback=default_messages,
)
messages = prompt.format(**variables)

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
)

prompt.format() renvoie une chaîne pour un prompt de texte et une liste de messages pour un prompt de chat. Transmettez la valeur formatée au paramètre de texte ou de messages correspondant de votre appel au fournisseur LLM.

Si la récupération échoue et qu’aucune solution de secours n’est fournie, get_prompt() génère une ValueError. Une solution de secours ne remplace pas l’authentification : DD_API_KEY est toujours requis, et DD_APP_KEY est également requis lorsque DD_ENV est défini.

Sans composition de prompt, combinez des prompts dans le code de l’application ou gérez le prompt final destiné au fournisseur en tant que prompt unique. Pour inclure un prompt géré dans un autre, consultez Réutiliser des prompts avec la composition. La composition de prompt est en Preview.

Sélectionnez une version

Sans DD_ENV, get_prompt() récupère la dernière version du prompt :

prompt = LLMObs.get_prompt("customer-support-greeting")

Avec DD_ENV, get_prompt() résout la version du prompt pour cet environnement. Cela nécessite DD_APP_KEY avec les autorisations de lecture répertoriées dans Prérequis.

Pour récupérer une version numérique exacte indépendamment de DD_ENV, passez version :

prompt = LLMObs.get_prompt("customer-support-greeting", version=2)

L’argument version prévaut sur la résolution de l’environnement.

Suivez l’utilisation du prompt

Pour associer un prompt géré à un span LLM, activez Agent Observability et exécutez l’application avec une instrumentation automatique via son workflow d’exécution existant.

Si l’application reçoit sa configuration avant le démarrage du processus Python, utilisez ddtrace-run. Par exemple, la commande shell équivalente est :

DD_SITE="<DATADOG_SITE>" \
DD_API_KEY="<DATADOG_API_KEY>" \
DD_APP_KEY="<DATADOG_APP_KEY>" \
DD_ENV="<DEPLOYMENT_ENVIRONMENT>" \
DD_SERVICE="<SERVICE_NAME>" \
DD_LLMOBS_ENABLED=1 \
ddtrace-run python app.py

Si l’application charge sa configuration en Python, chargez d’abord la configuration, puis importez ddtrace.auto avant d’importer le fournisseur LLM ou d’autres modules de l’application :

from dotenv import load_dotenv

load_dotenv()

import ddtrace.auto

from ddtrace.llmobs import LLMObs
from openai import OpenAI

Exécutez cette configuration avec la commande Python normale de l’application, telle que python app.py. N’utilisez pas non plus ddtrace-run ; cela initialise ddtrace avant que l’application ne puisse charger sa configuration.

Si l’application n’envoie pas de données via un Datadog Agent, définissez également DD_LLMOBS_AGENTLESS_ENABLED=1.

Pour un fournisseur instrumenté automatiquement pris en charge, passez la valeur renvoyée par prompt.format() directement à l’appel du fournisseur, comme indiqué dans Récupérer, formater et utiliser un prompt. Cela associe automatiquement le prompt géré au span résultant.

La copie, la reconstruction ou la conversion de la valeur formatée peut supprimer ses métadonnées de suivi de prompt. Par exemple, la concaténation d’un prompt système géré avec une question utilisateur crée une nouvelle chaîne sans ces métadonnées. Utilisez LLMObs.annotation_context() pour associer le prompt géré au span LLM résultant :

prompt = LLMObs.get_prompt(
    "customer-support-system-prompt",
    fallback="You are a helpful support agent writing for a {{audience}} audience.",
)
variables = {"audience": audience}
system_prompt = prompt.format(**variables)
combined_prompt = f"{system_prompt}\n\nUser question: {question}"

with LLMObs.annotation_context(
    prompt=prompt.to_annotation_dict(**variables),
):
    response = client.responses.create(
        model="gpt-4o",
        input=combined_prompt,
    )

Transmettez les mêmes variables à to_annotation_dict() que celles que vous transmettez à format() afin que le prompt suivi inclue les valeurs utilisées pour cet appel.

annotation_context() associe des métadonnées à un span LLM créé dans le contexte ; cela ne crée pas le span. Pour les fournisseurs qui ne sont pas instrumentés automatiquement, commencez par instrumenter manuellement l’appel LLM pour créer un span LLM. Un annotation_context() explicite prévaut sur le suivi automatique des prompts. Voir Suivi des prompts pour plus d’informations.

Créer et gérer des prompts

Créez des prompts et publiez de nouvelles versions dans l’interface utilisateur Prompts, via le SDK Python ou via l’API.

Créer un prompt

Promouvoir un prompt suivi

Pour promouvoir un prompt déjà suivi dans Agent Observability en un prompt géré, accédez à la page Prompts, ouvrez le prompt et cliquez sur Register. Vous pouvez ensuite mettre à jour le prompt dans l’interface utilisateur et le récupérer au moment de l’exécution.

Dans l’interface utilisateur à partir de zéro

Accédez à la page Prompts et cliquez sur + New Prompt.

Dans l’éditeur de prompt :

1. Ajoutez un ou plusieurs messages et attribuez à chacun un rôle : System, User ou Assistant.
2. Utilisez la syntaxe {{variable_name}} dans n’importe quel message pour ajouter du contenu dynamique.
3. Facultatif : Si vous avez accès à la Preview des espaces réservés de message, cliquez sur Add Message Placeholder. Consultez la section Insérer des messages au moment de l’exécution.
4. Facultatif : Cliquez sur Run pour tester le prompt avec des exemples de valeurs.
5. Cliquez sur Save Prompt pour ouvrir la boîte de dialogue d’enregistrement.

Structurez le prompt de manière à ce que la requête de l’utilisateur et le contexte soient injectés sous forme de variables :

Dans la boîte de dialogue d’enregistrement :

Cliquez sur Create Prompt pour enregistrer le prompt dans le registre.

Mettez à jour, listez et supprimez des prompts

Dans l’interface utilisateur

Ouvrez un prompt dans la page Prompts pour :

• Créez une nouvelle version : Cliquez sur Edit et mettez à jour les messages dans l’éditeur de prompt.
• Déployez une version vers un autre environnement : Sélectionnez une version et mettez à jour ses environnements Deployment.
• Supprimez un prompt : Sélectionnez Delete dans le menu d’options du prompt. Cela supprime le prompt et son historique de versions du registre.

Utilisez le SDK Python

Utilisez LLMObs.create_prompt() pour créer un prompt et déployer sa première version dans un ou plusieurs environnements. Les valeurs env_ids sont les identifiants d’environnement des Feature Flags, que vous pouvez obtenir à partir de l’API de liste des environnements :

from ddtrace.llmobs import LLMObs

chat_template = [
    {"role": "system", "content": "You are a support agent for {{company}}."},
    {"role": "user", "content": "{{question}}"},
]

created_prompt = LLMObs.create_prompt(
    "customer-support-greeting",
    chat_template,
    env_ids=["<FEATURE_FLAG_ENVIRONMENT_ID>"],
)

Pour publier et déployer une autre version, utilisez LLMObs.create_prompt_version() :

created_version = LLMObs.create_prompt_version(
    "customer-support-greeting",
    updated_chat_template,
    env_ids=["<FEATURE_FLAG_ENVIRONMENT_ID>"],
)

Traitez la création, le versionnage et le déploiement de prompts comme des opérations de configuration. Ne les effectuez pas lors du démarrage de l’application ou à partir d’un chemin de requête. Au moment de l’exécution, récupérez les prompts déployés avec LLMObs.get_prompt().

Ces méthodes nécessitent les autorisations de clé d’application et d’API répertoriées dans Prérequis.

Utilisez LLMObs.list_prompts() et LLMObs.list_prompt_versions() pour inspecter les prompts gérés, LLMObs.update_prompt() et LLMObs.update_prompt_version() pour mettre à jour les métadonnées ou les déploiements, et LLMObs.delete_prompt() pour supprimer un prompt et toutes ses versions.

Utilisez l’API

Utilisez l’API de gestion des prompts pour créer, récupérer, mettre à jour et supprimer des prompts et des versions de prompts. Consultez la référence de l’API Agent Observability pour les schémas d’endpoint, les types de médias de requête et des exemples.

Insérer des messages au moment de l’exécution

Les espaces réservés de message insèrent l’historique des conversations ou les interactions d’outils dans un prompt enregistré au moment de l’exécution. Une variable de texte, telle que {{question}}, remplace le texte à l’intérieur d’un message. Un espace réservé de message insère une liste de messages complets.

La version du prompt stocke le nom et la position de l’espace réservé, et non les messages que vous transmettez au moment de l’exécution. Pour déplacer l’historique dans le prompt, publiez une nouvelle version du prompt. Vous n’avez pas besoin de modifier le code de l’application.

Accès au SDK en Preview : Contactez le Datadog Support ou votre Customer Success Manager pour obtenir la version du SDK à utiliser pour votre langage.

Définir l’espace réservé

Dans l’éditeur de prompt, cliquez sur Add Message Placeholder et saisissez un nom, tel que history. Utilisez les flèches haut et bas pour déplacer l’espace réservé entre les messages. Utilisez un nom différent de toute variable de texte dans le prompt. L’éditeur affiche l’exigence de compatibilité du SDK avant que vous ne sauvegardiez.

Pour créer le même prompt avec le SDK Python, ajoutez un élément avec "type": "placeholder" à l’endroit où l’historique doit se trouver :

from ddtrace.llmobs import LLMObs

LLMObs.create_prompt(
    "support-assistant",
    [
        {"role": "system", "content": "You are a concise assistant for {{plan}} customers."},
        {"type": "placeholder", "name": "history"},
        {"role": "user", "content": "{{question}}"},
    ],
    env_ids=["<FEATURE_FLAG_ENVIRONMENT_ID>"],
)

Le nom de l’espace réservé, history, est la clé que votre application utilise pour transmettre des messages au moment de l’exécution. Ce n’est pas un rôle de message. Pour les exigences de configuration et les ID d’environnement, consultez la section Utiliser le SDK Python.

Fournir des valeurs d’exécution

Récupérez le prompt, puis transmettez la liste d’historique avec les variables de texte. Le SDK insère les messages d’historique dans l’ordre à la position de l’espace réservé.

prompt = LLMObs.get_prompt("support-assistant")

variables = {
    "plan": "enterprise",
    "question": "Can I export the report?",
    "history": [
        {"role": "user", "content": "Where are reports located?"},
        {"role": "assistant", "content": "Under Analytics."},
    ],
}
messages = prompt.format(**variables)

prompt, err := llmobs.GetPrompt(ctx, "support-assistant")
if err != nil {
	return err
}

variables := map[string]any{
	"plan":     "enterprise",
	"question": "Can I export the report?",
	"history": []map[string]any{
		{"role": "user", "content": "Where are reports located?"},
		{"role": "assistant", "content": "Under Analytics."},
	},
}
rendered, err := prompt.Format(variables)
if err != nil {
	return err
}
messages := rendered.Messages

const prompt = await tracer.llmobs.getPrompt('support-assistant')

const variables = {
  plan: 'enterprise',
  question: 'Can I export the report?',
  history: [
    { role: 'user', content: 'Where are reports located?' },
    { role: 'assistant', content: 'Under Analytics.' }
  ]
}
const messages = prompt.format(variables)

Le résultat contient quatre messages, sans élément d’espace réservé :

[
  {"role": "system", "content": "You are a concise assistant for enterprise customers."},
  {"role": "user", "content": "Where are reports located?"},
  {"role": "assistant", "content": "Under Analytics."},
  {"role": "user", "content": "Can I export the report?"}
]

Transmettez les messages formatés à votre fournisseur de modèle. Si un message inséré contient la syntaxe {{variable}}, le SDK la laisse sous forme de texte littéral.

Utilisez le même workflow de suivi de prompt que pour les autres prompts gérés. Les métadonnées du prompt préservent la définition de l’espace réservé plutôt que ses valeurs d’exécution ; les messages développés suivent les paramètres existants de capture d’entrée et de confidentialité.

Inclure les interactions avec les outils

Un espace réservé peut également insérer des appels d’outils et des réponses d’outils. Utilisez le format de message de votre fournisseur de modèle. Par exemple, dans le format OpenAI Chat Completions, définissez le tool_call_id de chaque réponse d’outil sur le id de son appel d’outil :

variables["history"] = [
    {
        "role": "assistant",
        "tool_calls": [{
            "id": "call_1",
            "type": "function",
            "function": {"name": "get_plan", "arguments": "{}"},
        }],
    },
    {"role": "tool", "tool_call_id": "call_1", "content": "enterprise"},
]
messages = prompt.format(**variables)

Le SDK insère ces messages sans modification. Votre application exécute l’outil et fournit sa réponse.

Exigences et limites des espaces réservés de message

• Transmettez une liste pour chaque espace réservé. Une liste vide ([]) n’insère aucun message.
• Les messages insérés peuvent contenir du texte, des appels d’outils d’assistant ou des réponses d’outils. Le SDK n’exécute pas les outils et ne valide pas les champs spécifiques au fournisseur.
• Si un prompt utilise le même nom d’espace réservé plus d’une fois, chaque occurrence insère la même liste. Des noms d’espaces réservés différents peuvent recevoir des listes différentes.
• Les espaces réservés imbriqués et le contenu multimodal, tel que les images ou l’audio, ne sont pas pris en charge.

Configuration de la version du prompt

Stockez les paramètres avec votre prompt afin de pouvoir mettre à jour et restaurer les deux en tant que version unique. Utilisez la configuration pour :

• Paramètres du modèle, tels que model et temperature.
• Schémas de sortie structurés, tels que response_format.
• Définitions d’outils, telles que tools et tool_choice.

La configuration est un objet JSON dont vous définissez les champs. Votre application lit et applique ces paramètres ; Datadog ne les applique pas automatiquement aux exécutions dans le Playground ou aux appels de modèle. Ne stockez pas de secrets dans la configuration.

Ajouter une configuration

1. Sur la page Prompts, cliquez sur New Prompt et rédigez votre modèle.

2. Cliquez sur Save Prompt. Saisissez un ID de prompt, développez Configuration (optional), et ajoutez des paramètres :

   {
     "model": "<MODEL_NAME>",
     "temperature": 0.2
   }
   

3. Remplacez <MODEL_NAME> par un modèle qui prend en charge ces paramètres, puis cliquez sur Create prompt.

L’éditeur nécessite un objet JSON valide. Son texte d’exemple est un espace réservé, pas une configuration enregistrée.

Mettre à jour la configuration

1. Ouvrez une version de prompt et sélectionnez l’onglet Configuration.
2. Cliquez sur Update configuration et modifiez les paramètres.
3. Cliquez sur Save version. Pour inspecter la différence avant d’enregistrer, cliquez d’abord sur Review changes.

Cela crée une version sans écraser l’original. Utilisez Compare pour inspecter les modifications de configuration.

Déployez la version dans un environnement lorsqu’elle est prête. Les applications récupérant cet environnement reçoivent son modèle et sa configuration sélectionnés ensemble. Pour restaurer les deux, déployez une version antérieure. La simple sauvegarde ne modifie pas la version utilisée par un environnement.

Utilisez la configuration dans votre application

Récupérez le prompt déployé dans l’environnement de votre application, puis transmettez sa configuration à votre client de modèle.

Aperçu de l’accès au SDK : Contactez Datadog Support ou votre Customer Success Manager pour connaître la version du SDK à utiliser pour votre langage.

Ces exemples utilisent un prompt nommé summarizer avec la configuration affichée ci-dessus.

from ddtrace.llmobs import LLMObs

prompt = LLMObs.get_prompt("summarizer")
config = prompt.config

model = config["model"]
temperature = config.get("temperature", 0.2)

const prompt = await tracer.llmobs.prompts.getPrompt('summarizer')
const config = prompt.config

const model = config.model
const temperature = config.temperature ?? 0.2

prompt, err := llmobs.GetPrompt(ctx, "summarizer")
if err != nil {
    return err
}
config := prompt.Config()

model := config["model"].(string)
temperature, ok := config["temperature"].(float64)
if !ok {
    temperature = 0.2
}

Création d’API : Vous pouvez également créer des prompts et des versions avec l’API de gestion des prompts. L’omission de config crée une configuration vide pour un nouveau prompt ou hérite de la dernière configuration pour une nouvelle version. Envoyez {} pour l’effacer.

Réutiliser des prompts avec la composition

La composition de prompts permet à un prompt d’en inclure un autre, afin que vous puissiez réutiliser des instructions partagées sans les copier. Par exemple, un assistant de support et un assistant de facturation peuvent inclure la même politique de réponse. Vous pouvez inclure un autre prompt de deux manières :

• Messages de chat : Inclure tout ou partie des messages d’un prompt de chat.
• Texte : Insérer le contenu d’un prompt textuel dans un message.

Chaque inclusion pointe vers une version exacte. La publication d’une nouvelle version du prompt inclus ne modifie pas les prompts qui l’incluent déjà.

Inclure les messages de chat

Dans l’interface utilisateur

L’exemple suivant ajoute une politique de réponse partagée à un prompt d’assistant de support.

1. Enregistrez un prompt avec l’ID response-policy et un System message : Answer concisely. If you do not know the answer, say so.
2. Sur la page Prompts, cliquez sur New Prompt. Dans le Prompt Editor, cliquez sur Include Prompt, sélectionnez la version 1 de response-policy, puis cliquez sur Add prompt.
3. Après le prompt inclus, ajoutez un User message contenant {{question}}. If the editor added empty messages, remove them.
4. Click Save, saisissez support-assistant-composed comme ID de prompt, puis cliquez sur Create prompt.

Votre prompt contient désormais :

System: Answer concisely. If you do not know the answer, say so.
User: {{question}}

Votre application récupère et formate le prompt comme d’habitude. Le prompt récupéré contient déjà les messages inclus, vous n’avez donc pas besoin de récupérer response-policy séparément.

Par défaut, une inclusion ajoute chaque message du prompt inclus, dans l’ordre. Pour n’inclure que certains messages, les réorganiser ou en répéter un, cliquez sur Included Prompt dans le Prompt Editor et sélectionnez Customize messages. La personnalisation ne modifie pas le prompt inclus.

Avec l’API

Utilisez un objet include dans template.messages pour référencer une version spécifique d’un prompt de chat. Cet exemple suppose un prompt de chat response-policy avec la version 1. Pour créer un prompt qui l’inclut, envoyez ce corps JSON à POST /api/v2/llm-obs/v1/prompts :

{
  "data": {
    "type": "prompt-templates",
    "attributes": {
      "prompt_id": "support-assistant-composed",
      "template": {
        "messages": [
          { "include": { "prompt_id": "response-policy", "version": 1 } },
          { "role": "user", "content": "{{question}}" }
        ]
      }
    }
  }
}

Pour les options d’authentification et de sélection de message, consultez Créer un prompt Agent Observability.

Inclure du texte dans un message

Pour réutiliser une expression au lieu de messages complets, cliquez sur Include Prompt, sélectionnez un prompt textuel et une version, puis cliquez sur Insert text. La référence est ajoutée à la fin du dernier message modifiable. Déplacez-la là où vous en avez besoin.

Par exemple, si la version 1 de response-style contient Answer concisely., écrivez :

{{>response-style version=1}} Answer {{question}}.

Le modèle résolu est :

Answer concisely. Answer {{question}}.

La référence se résout exactement au texte inclus, sans espaces ni sauts de ligne ajoutés. Spécifiez toujours une version. Sans cela, {{>response-style}} reste du texte littéral, et non une inclusion. Lors de la création d’un prompt sans accès à Preview, les références en ligne restent du texte littéral. Les versions composées précédemment enregistrées restent utilisables.

Dans les requêtes API, utilisez la même syntaxe dans un template de texte ou dans le content d’un message de chat.

Examiner et mettre à jour les inclusions

Sur une version enregistrée, Prompt Template affiche les références que vous avez créées. Resolved Prompt affiche les messages développés, avant que les variables d’exécution ne soient renseignées.

Lorsqu’une politique partagée change, utilisez son onglet Used By pour trouver les prompts qui y font référence. Ouvrez un prompt consommateur, remplacez l’inclusion par la nouvelle version source, puis testez, enregistrez et déployez le prompt mis à jour. Les versions existantes conservent leur contenu d’origine, même si la source est ensuite supprimée.

Utilisation avancée

Diffuser plusieurs versions à partir d’un seul environnement

La gestion des prompts s’appuie sur le produit Feature Flags de Datadog. Chaque environnement résout les appels get_prompt() vers une version par défaut, et peut également diffuser une version différente pour les appels qui correspondent à une règle de ciblage.

Par exemple, déployez une version de prompt instable auprès d’un sous-ensemble d’utilisateurs dans production avec une règle de ciblage, tandis que tous les autres continuent de recevoir la version stable :

## DD_ENV=production
prompt = LLMObs.get_prompt("my-prompt")               # resolves to the stable version
prompt = LLMObs.get_prompt("my-prompt", tag="unstable") # resolves to the unstable version

Pour configurer cela :

1. Dans la liste des versions du prompt, survolez un environnement et cliquez sur Targeting Rules.

2. Cliquez sur Add Targeting Rule.

3. Définissez le filtre de règle. Par exemple, faites correspondre les appels à get_prompt() qui transmettent l’attribut tag=unstable, et définissez la variante résultante sur la version de prompt instable.

4. Enregistrez la règle. Les appels avec tag=unstable se résolvent vers la version correspondante ; tous les autres appels retombent sur la version par défaut.

Passez les attributs référencés par vos règles de ciblage en tant qu’arguments nommés à get_prompt(). Les appels qui ne transmettent pas d’attribut correspondant continuent de se résoudre vers la version par défaut de l’environnement.

Pour récupérer une version exacte indépendamment de toute règle de ciblage, passez version comme décrit dans Select a version.

Pour aller plus loin

Documentation, liens et articles supplémentaires utiles:

Suivi des promptsDOCUMENTATION PlaygroundDOCUMENTATION SDK Agent ObservabilityDOCUMENTATION