> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Créer des objets prompt
> Créez, publiez et utilisez des objets prompt pour les applications LLM
Créer, évaluer et affiner des prompts est une activité essentielle pour les ingénieurs IA.
De petites modifications d’un prompt peuvent avoir des effets importants sur le comportement de votre application.
W\&B Weave vous permet de créer des prompts, de les publier et de les faire évoluer au fil du temps.
Cette page s’adresse aux ingénieurs IA qui souhaitent créer des objets prompt réutilisables dans Weave et les publier afin que le code de l’application puisse y faire référence. En suivant ce guide, vous apprendrez à créer des prompts sous forme de chaîne unique et sur plusieurs tours de conversation, à les paramétrer avec des valeurs d’exécution et à les publier dans votre projet Weave. Pour savoir comment référencer, récupérer et gérer les versions des prompts publiés, voir [Stocker et suivre les versions des prompts](/fr/weave/guides/core-types/prompts-version.mdx).
Si vos besoins en prompts sont simples, vous pouvez utiliser les classes intégrées `weave.StringPrompt` ou `weave.MessagesPrompt`. Si vos besoins sont plus complexes, vous pouvez les sous-classer, ou sous-classer la classe de base `weave.Prompt` et redéfinir la méthode `format`.
Lorsque vous publiez un prompt avec `weave.publish`, il apparaît dans votre projet Weave sur la [page Prompts](/fr/weave/guides/core-types/prompts-version.mdx#view-prompts), où vous et vos collaborateurs pouvez le parcourir et le réutiliser.
## StringPrompt
`StringPrompt` journalise des prompts sous forme d’une chaîne unique que vous pouvez utiliser pour des messages système, des requêtes utilisateur ou toute entrée de texte autonome destinée à un LLM. Utilisez `StringPrompt` pour gérer des chaînes de prompt individuelles qui ne nécessitent pas la complexité de conversations à plusieurs messages.
```python lines {4,5,15} theme={null}
import weave
weave.init('intro-example')
system_prompt = weave.StringPrompt("You speak like a pirate")
weave.publish(system_prompt, name="pirate_prompt")
from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{
"role": "system",
"content": system_prompt.format()
},
{
"role": "user",
"content": "Explain general relativity in one paragraph."
}
],
)
```
```typescript twoslash lines theme={null}
// @noErrors
import * as weave from 'weave';
import OpenAI from 'openai';
async function main() {
// weave.init renvoie une instance de client
const weaveClient = await weave.init('wandb/prompt-examples');
const systemPrompt = new weave.StringPrompt({
content: 'You speak like a pirate',
name: 'your-prompt',
description: 'A helpful description of your prompt',
});
// Utilisez le client renvoyé par init
await weaveClient.publish(systemPrompt, 'pirate_prompt');
// Encapsulez le client OpenAI pour suivre les appels dans Weave
const client = weave.wrapOpenAI(new OpenAI());
const response = await client.chat.completions.create({
model: "gpt-4o",
messages: [
{
role: "system",
content: systemPrompt.content
},
{
role: "user",
content: "Explain general relativity in one paragraph."
}
],
});
}
main();
```
## MessagesPrompt
`MessagesPrompt` vous permet de journaliser des conversations sur plusieurs tours de conversation et des prompts de type chat. Il stocke un tableau d'objets de message (avec des rôles comme `system`, `user` et `assistant`) qui représentent un flux de conversation complet. Utilisez `MessagesPrompt` pour les LLM de type chat lorsque vous devez conserver le contexte sur plusieurs messages, définir des modèles de conversation spécifiques ou créer des modèles de conversation réutilisables.
```python lines {4,21} theme={null}
import weave
weave.init('intro-example')
prompt = weave.MessagesPrompt([
{
"role": "system",
"content": "You are a stegosaurus, but don't be too obvious about it."
},
{
"role": "user",
"content": "What's good to eat around here?"
}
])
weave.publish(prompt, name="dino_prompt")
from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
model="gpt-4o",
messages=prompt.format(),
)
```
```typescript twoslash lines theme={null}
// @noErrors
import * as weave from 'weave';
import OpenAI from 'openai';
async function main() {
// weave.init renvoie une instance de client
const weaveClient = await weave.init('wandb/prompt-examples');
const prompt = new weave.MessagesPrompt({
messages: [
{
"role": "system",
"content": "You are a stegosaurus, but don't be too obvious about it."
},
{
"role": "user",
"content": "What's good to eat around here?"
}
],
});
// Utilisez le client renvoyé par init
await weaveClient.publish(prompt, 'dino_prompt');
// Encapsulez le client OpenAI pour suivre les appels dans Weave
const client = weave.wrapOpenAI(new OpenAI());
const response = await client.chat.completions.create({
model: "gpt-4o",
messages: prompt.messages,
});
}
main();
```
## Paramétrer les prompts
Une fois que vous savez créer des prompts statiques, l’étape suivante consiste à les rendre réutilisables avec différentes entrées. `StringPrompt` et `MessagesPrompt` prennent tous deux en charge le contenu dynamique via le paramétrage. Cela vous permet de créer des modèles de prompt réutilisables avec des emplacements réservés (à l’aide de la syntaxe `{variable}`), que vous remplissez avec différentes valeurs à l’exécution. Le paramétrage est utile lorsque vos prompts doivent s’adapter à différentes entrées, à des données utilisateur ou à des contextes variés, tout en conservant une structure cohérente. La méthode `format()` accepte des paires clé-valeur pour remplacer ces emplacements réservés par des valeurs réelles.
```python lines {4,15} theme={null}
import weave
weave.init('intro-example')
prompt = weave.StringPrompt("Solve the equation {equation}")
weave.publish(prompt, name="calculator_prompt")
from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{
"role": "user",
"content": prompt.format(equation="1 + 1 = ?")
}
],
)
```
```typescript twoslash lines {8,23} theme={null}
// @noErrors
import * as weave from 'weave';
import OpenAI from 'openai';
async function main() {
// weave.init renvoie une instance de client
const weaveClient = await weave.init('wandb/prompt-examples');
const prompt = new weave.StringPrompt({
content: 'Solve the equation {equation}',
});
// Utiliser le client renvoyé par init
await weaveClient.publish(prompt, 'calculator_prompt');
// Encapsuler le client OpenAI pour suivre les appels dans Weave
const client = weave.wrapOpenAI(new OpenAI());
const response = await client.chat.completions.create({
model: "gpt-4o",
messages: [
{
role: "user",
content: prompt.format({ equation: "1 + 1 = ?" })
}
],
});
}
main();
```
Le même principe de paramétrage fonctionne aussi avec `MessagesPrompt` lorsque vous avez besoin d’emplacements réservés dans une conversation sur plusieurs tours de conversation.
```python lines {4,21} theme={null}
import weave
weave.init('intro-example')
prompt = weave.MessagesPrompt([
{
"role": "system",
"content": "You will be provided with a description of a scene and your task is to provide a single word that best describes an associated emotion."
},
{
"role": "user",
"content": "{scene}"
}
])
weave.publish(prompt, name="emotion_prompt")
from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
model="gpt-4o",
messages=prompt.format(scene="A dog is lying on a dock next to a fisherman."),
)
```
```typescript twoslash lines {8,29} theme={null}
// @noErrors
import * as weave from 'weave';
import OpenAI from 'openai';
async function main() {
// weave.init renvoie une instance de client
const weaveClient = await weave.init('wandb/prompt-examples');
const prompt = new weave.MessagesPrompt({
messages: [
{
"role": "system",
"content": "You will be provided with a description of a scene and your task is to provide a single word that best describes an associated emotion."
},
{
"role": "user",
"content": "{scene}"
}
]
});
// Utiliser le client renvoyé par init
await weaveClient.publish(prompt, 'emotion_prompt');
// Encapsuler le client OpenAI pour suivre les appels dans Weave
const client = weave.wrapOpenAI(new OpenAI());
const response = await client.chat.completions.create({
model: "gpt-4o",
messages: prompt.format({ scene: "A dog is lying on a dock next to a fisherman." }),
});
}
main();
```