> ## 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.
# OpenAI
> Intégrez OpenAI avec Weave pour le tracing, l’évaluation et le monitoring
Ce guide vous montre comment intégrer les bibliothèques Python et TypeScript d’OpenAI avec Weave afin de tracer, d’évaluer et de surveiller votre application LLM. Il s’adresse aux développeurs qui utilisent déjà les SDK d’OpenAI et souhaitent avoir une meilleure visibilité sur leurs appels pendant le développement et en production.
Vous souhaitez tester des modèles OpenAI sur Weave sans aucune configuration préalable ? Essayez le [LLM Playground](../tools/playground).
## Tracing
Il est utile de stocker les traces des applications LLM dans une base de données centrale, aussi bien pendant le développement qu'en production. Utilisez ces traces pour le débogage, ainsi que pour constituer un jeu de données d'exemples difficiles servant à l'évaluation au fur et à mesure que vous améliorez votre application.
Weave peut capturer automatiquement les traces de la [bibliothèque Python `openai`](https://developers.openai.com/api/docs/libraries).
Pour commencer à capturer des traces, appelez `weave.init("[PROJECT_NAME]")` avec le nom de projet de votre choix. Weave patche automatiquement OpenAI, quel que soit le moment où vous l'importez, afin que tous les appels OpenAI suivants soient tracés.
Si vous ne spécifiez pas d'équipe W\&B lorsque vous appelez `weave.init()`, Weave utilise votre entité par défaut. Pour trouver ou mettre à jour votre entité par défaut, consultez [Paramètres utilisateur](https://docs.wandb.ai/platform/app/settings-page/user-settings/#default-team) dans la documentation W\&B Models.
### Patching automatique
Weave patche automatiquement OpenAI, que vous l’importiez avant ou après `weave.init()`. L’exemple suivant montre la configuration minimale requise pour commencer à tracer les appels :
```python Python lines {4} theme={null}
from openai import OpenAI
import weave
weave.init('emoji-bot') # OpenAI est automatiquement patché !
client = OpenAI()
response = client.chat.completions.create(
model="gpt-4",
messages=[
{
"role": "system",
"content": "You are AGI. You will be provided with a message, and your task is to respond using emojis only."
},
{
"role": "user",
"content": "How are you?"
}
]
)
```
```typescript twoslash TypeScript theme={null}
// @noErrors
import { OpenAI } from 'openai';
import { wrapOpenAI } from '@wandb/weave';
const openai = wrapOpenAI(new OpenAI());
// Tous les appels à OpenAI seront désormais tracés
openai.chat.completions.create(
{
model: "gpt-4",
messages: [
{
role: "system",
content: "You are AGI. You will be provided with a message, and your task is to respond using emojis only."
},
{
role: "user",
content: "How are you?"
}
]
}
);
```
### Facultatif : patching explicite
Pour contrôler plus finement le moment où le patching prend effet, patchez OpenAI explicitement plutôt que de vous appuyer sur le comportement automatique :
```python lines {3,4} theme={null}
import weave
weave.init('emoji-bot')
weave.integrations.patch_openai() # Activer le tracing OpenAI
from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
model="gpt-4",
messages=[
{"role": "user", "content": "Make me a emoji"}
]
)
```
[Voir une trace en temps réel](https://wandb.ai/capecape/emoji-bot/weave/calls/01928a78-6d8a-7e20-9b8c-0cbc8318a0c8)
Weave capture également les outils d’appel de fonctions pour [OpenAI Functions](https://platform.openai.com/docs/guides/function-calling) et [OpenAI Assistants](https://platform.openai.com/docs/assistants/overview).
## Sorties structurées
Weave prend en charge le tracing des sorties structurées OpenAI, ce qui est utile lorsque vous devez garantir que les réponses de votre LLM respectent un format spécifique. L’exemple suivant trace un appel qui extrait un objet `UserDetail` typé à partir d’un message utilisateur :
```python Python theme={null}
from openai import OpenAI
from pydantic import BaseModel
import weave
class UserDetail(BaseModel):
name: str
age: int
client = OpenAI()
weave.init('extract-user-details')
completion = client.beta.chat.completions.parse(
model="gpt-4o-2024-08-06",
messages=[
{"role": "system", "content": "Extract the user details from the message."},
{"role": "user", "content": "My name is David and I am 30 years old."},
],
response_format=UserDetail,
)
user_detail = completion.choices[0].message.parsed
print(user_detail)
```
## Prise en charge de l’asynchrone
Weave prend également en charge le tracing des appels OpenAI asynchrones, afin que les applications qui utilisent `AsyncOpenAI` bénéficient de la même visibilité que les applications synchrones.
```python Python theme={null}
from openai import AsyncOpenAI
import weave
client = AsyncOpenAI()
weave.init('async-emoji-bot')
async def call_openai():
response = await client.chat.completions.create(
model="gpt-4",
messages=[
{
"role": "system",
"content": "You are AGI. You will be provided with a message, and your task is to respond using emojis only."
},
{
"role": "user",
"content": "How are you?"
}
]
)
return response
# Appel de la fonction asynchrone
result = await call_openai()
```
## Prise en charge du streaming
Weave prend en charge le tracing des réponses en streaming d’OpenAI. La trace capturée reflète l’intégralité de la complétion diffusée en streaming, afin que vous puissiez examiner la sortie finale avec les paramètres de la requête.
```python Python theme={null}
from openai import OpenAI
import weave
client = OpenAI()
weave.init('streaming-emoji-bot')
response = client.chat.completions.create(
model="gpt-4",
messages=[
{
"role": "system",
"content": "You are AGI. You will be provided with a message, and your task is to respond using emojis only."
},
{
"role": "user",
"content": "How are you?"
}
],
stream=True
)
for chunk in response:
print(chunk.choices[0].delta.content or "", end="")
```
## Tracing des appels de fonction
Weave effectue le tracing des appels de fonction effectués par OpenAI lorsque vous utilisez des outils, ce qui vous aide à comprendre comment le modèle a invoqué chaque outil et avec quels arguments.
```python Python theme={null}
from openai import OpenAI
import weave
client = OpenAI()
weave.init('function-calling-bot')
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get the weather in a given location",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The location to get the weather for"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "The unit to return the temperature in"
}
},
"required": ["location"]
}
}
}
]
response = client.chat.completions.create(
model="gpt-4",
messages=[
{
"role": "user",
"content": "What's the weather like in New York?"
}
],
tools=tools
)
print(response.choices[0].message.tool_calls)
```
## Batch API
Weave prend en charge la Batch API d’OpenAI, qui vous permet de traiter plusieurs requêtes de manière asynchrone tout en continuant à capturer chaque requête dans vos traces.
```python Python theme={null}
from openai import OpenAI
import weave
client = OpenAI()
weave.init('batch-processing')
# Créer un fichier de lot
batch_input = [
{
"custom_id": "request-1",
"method": "POST",
"url": "/v1/chat/completions",
"body": {
"model": "gpt-4",
"messages": [{"role": "user", "content": "Hello, how are you?"}]
}
},
{
"custom_id": "request-2",
"method": "POST",
"url": "/v1/chat/completions",
"body": {
"model": "gpt-4",
"messages": [{"role": "user", "content": "What's the weather like?"}]
}
}
]
# Soumettre le lot
batch = client.batches.create(
input_file_id="your-file-id",
endpoint="/v1/chat/completions",
completion_window="24h"
)
# Récupérer les résultats du lot
completed_batch = client.batches.retrieve(batch.id)
```
## API Assistants
Weave prend en charge l’API Assistants d’OpenAI, ce qui vous permet de tracer des applications d’IA conversationnelle basées sur des assistants, des threads et des runs.
```python Python theme={null}
from openai import OpenAI
import weave
client = OpenAI()
weave.init('assistant-bot')
# Créer un assistant
assistant = client.beta.assistants.create(
name="Math Assistant",
instructions="You are a personal math tutor. Answer questions about math.",
model="gpt-4"
)
# Créer un thread
thread = client.beta.threads.create()
# Ajouter un message au thread
message = client.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content="What is 2+2?"
)
# Exécuter l’assistant
run = client.beta.threads.runs.create(
thread_id=thread.id,
assistant_id=assistant.id
)
# Obtenir la réponse de l’assistant
messages = client.beta.threads.messages.list(thread_id=thread.id)
```
## Suivi des coûts
Weave suit automatiquement le coût de vos appels à l’API OpenAI afin que vous puissiez surveiller les dépenses parallèlement aux performances. Vous pouvez consulter le détail des coûts dans l’interface Weave.
Le suivi des coûts est disponible pour tous les modèles OpenAI et est calculé d’après la tarification publiée par OpenAI.
## Tracing des fonctions personnalisées
Pour regrouper les appels à OpenAI dans votre propre logique applicative, tracez les fonctions personnalisées qui utilisent OpenAI en appliquant le décorateur `@weave.op`. Cela crée une trace parente pour la fonction, dans laquelle les appels OpenAI sous-jacents sont imbriqués.
```python Python theme={null}
from openai import OpenAI
import weave
client = OpenAI()
weave.init('custom-function-bot')
@weave.op
def generate_response(prompt: str) -> str:
response = client.chat.completions.create(
model="gpt-4",
messages=[
{
"role": "user",
"content": prompt
}
]
)
return response.choices[0].message.content
# Cet appel de fonction sera tracé
result = generate_response("Hello, how are you?")
```
## Étapes suivantes
Une fois le tracing configuré pour OpenAI, les appels de votre application sont désormais visibles dans Weave. Vous pouvez ensuite :
* **Afficher les traces dans l’interface Weave** : accédez à votre projet Weave pour consulter les traces de vos appels OpenAI.
* **Créer des évaluations** : utilisez vos traces pour constituer des jeux de données d’évaluation.
* **Surveiller les performances** : suivez la latence, les coûts et d’autres métriques.
* **Déboguer les problèmes** : utilisez les traces pour comprendre ce qui se passe dans votre application LLM.
Pour plus d’informations sur ces sujets, voir le [guide d’évaluation](../evaluation/scorers) et le [guide de suivi](../tracking).