OpenAI

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.

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. 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 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 :

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?"
    }
  ]
)

import { OpenAI } from 'openai';
import { wrapOpenAI } from '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 :

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

Weave capture également les outils d’appel de fonctions pour OpenAI Functions et OpenAI Assistants.

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 :

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.

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.

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.

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.

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.

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.

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 et le guide de suivi.

Premiers pas

Guides

Guides pratiques

Référence

Détails et assistance

Tracing

Patching automatique

Facultatif : patching explicite

Sorties structurées

Prise en charge de l’asynchrone

Prise en charge du streaming

Tracing des appels de fonction

Batch API

API Assistants

Suivi des coûts

Tracing des fonctions personnalisées

Étapes suivantes

​Tracing

​Patching automatique

​Facultatif : patching explicite

​Sorties structurées

​Prise en charge de l’asynchrone

​Prise en charge du streaming

​Tracing des appels de fonction

​Batch API

​API Assistants

​Suivi des coûts

​Tracing des fonctions personnalisées

​Étapes suivantes

Tracing

Patching automatique

Facultatif : patching explicite

Sorties structurées

Prise en charge de l’asynchrone

Prise en charge du streaming

Tracing des appels de fonction

Batch API

API Assistants

Suivi des coûts

Tracing des fonctions personnalisées

Étapes suivantes