Lorsque vous intégrez Weave dans votre code, il suit et consigne automatiquement les appels LLM effectués avec le SDK Anthropic, aussi bien en Python qu’en TypeScript. Weave le fait en appelant automatiquement la méthode Messages.create() d’Anthropic.
Ce guide vous montre comment capturer les traces, encapsuler vos propres fonctions en tant qu’ops, créer un Model réutilisable pour l’expérimentation et suivre l’utilisation des outils lorsque vous travaillez avec le SDK Anthropic. Utilisez ces approches pour déboguer, comparer et faire évoluer des applications basées sur Claude sans écrire de code de journalisation personnalisé.
Weave capture automatiquement les traces du SDK Anthropic lorsque vous ajoutez weave.init("your-team-name/your-project-name") à votre code. Si vous ne spécifiez pas de nom d’équipe comme argument dans weave.init(), Weave journalise la sortie vers votre entité W&B par défaut. Si vous ne spécifiez pas de nom de projet, Weave ne parvient pas à s’initialiser.
Les exemples suivants montrent comment intégrer Weave dans un appel simple à Anthropic :
import weave
# utilisez la bibliothèque anthropic comme d'habitude
import os
from anthropic import Anthropic
weave.init("anthropic_project")
client = Anthropic(
api_key=os.environ.get("ANTHROPIC_API_KEY"),
)
message = client.messages.create(
max_tokens=1024,
messages=[
{
"role": "user",
"content": "Tell me a joke about a dog",
}
],
model="claude-3-opus-20240229",
)
print(message.content)
import Anthropic from '@anthropic-ai/sdk';
import * as weave from 'weave';
import { wrapAnthropic } from 'weave';
await weave.init('anthropic_project');
// Encapsulez le client Anthropic pour activer le tracing
const client = wrapAnthropic(new Anthropic());
const message = await client.messages.create({
max_tokens: 1024,
messages: [
{
role: 'user',
content: 'Tell me a joke about a dog',
}
],
model: 'claude-3-opus-20240229',
});
console.log(message.content);
weave.init() dans le code, Weave capture automatiquement les informations de tracing et affiche des liens. Vous pouvez consulter les traces dans l’interface Weave en cliquant sur ces liens.
Encapsuler avec vos propres ops
weave.init() à lui seul capture les appels du SDK Anthropic, le fait de décorer vos propres fonctions avec des ops vous donne des traces plus riches qui incluent la logique de votre application autour de chaque appel de modèle.
Les ops Weave versionnent automatiquement votre code au fil de vos expériences et en capturent les entrées et les sorties. Décorez une fonction avec @weave.op() en Python ou encapsulez-la avec weave.op() en TypeScript pour appeler Anthropic.messages.create(), et Weave suit automatiquement les entrées et les sorties pour vous.
Les exemples suivants montrent comment suivre une fonction :
import weave
import os
from anthropic import Anthropic
weave.init("anthropic_project")
client = Anthropic(
api_key=os.environ.get("ANTHROPIC_API_KEY"),
)
@weave.op()
def call_anthropic(user_input:str, model:str) -> str:
message = client.messages.create(
max_tokens=1024,
messages=[
{
"role": "user",
"content": user_input,
}
],
model=model,
)
return message.content[0].text
@weave.op()
def generate_joke(topic: str) -> str:
return call_anthropic(f"Tell me a joke about {topic}", model="claude-3-haiku-20240307")
print(generate_joke("chickens"))
print(generate_joke("cars"))
import Anthropic from '@anthropic-ai/sdk';
import * as weave from 'weave';
import { wrapAnthropic } from 'weave';
await weave.init('anthropic_project');
const client = wrapAnthropic(new Anthropic());
const callAnthropic = weave.op(async function callAnthropic(
userInput: string,
model: string
): Promise<string> {
const message = await client.messages.create({
max_tokens: 1024,
messages: [
{
role: 'user',
content: userInput,
}
],
model: model,
});
const content = message.content[0];
return content.type === 'text' ? content.text : '';
});
const generateJoke = weave.op(async function generateJoke(
topic: string
): Promise<string> {
return callAnthropic(`Tell me a joke about ${topic}`, 'claude-3-haiku-20240307');
});
console.log(await generateJoke('chickens'));
console.log(await generateJoke('cars'));
weave.op(), Weave capture le code de la fonction, ses entrées et sa sortie. Vous pouvez utiliser des ops pour suivre n’importe quelle fonction, y compris des fonctions imbriquées.
Créez un Model pour faciliter l’expérimentation
La classe weave.Model est disponible uniquement dans le SDK Python de Weave. Pour TypeScript, utilisez le wrapper weave.op() pour suivre des fonctions avec des paramètres structurés.
Model, vous pouvez capturer et organiser les détails de vos expériences dans votre application, comme votre prompt système ou le modèle que vous utilisez. Cela facilite l’organisation et la comparaison des différentes itérations de votre application.
En plus de gérer les versions du code et de capturer les entrées et les sorties, les modèles capturent des paramètres structurés qui contrôlent le comportement de votre application. Cela peut vous aider à déterminer quels paramètres fonctionnent le mieux. Vous pouvez également utiliser les modèles Weave avec serve et les évaluations.
Dans l’exemple suivant, vous pouvez expérimenter avec model et temperature :
import weave
# utiliser la bibliothèque anthropic comme d'habitude
import os
from anthropic import Anthropic
weave.init('joker-anthropic')
class JokerModel(weave.Model): # Remplacer par `weave.Model`
model: str
temperature: float
@weave.op()
def predict(self, topic): # Remplacer par `predict`
client = Anthropic()
message = client.messages.create(
max_tokens=1024,
messages=[
{
"role": "user",
"content": f"Tell me a joke about {topic}",
}
],
model=self.model,
temperature=self.temperature
)
return message.content[0].text
joker = JokerModel(
model="claude-3-haiku-20240307",
temperature = 0.1)
result = joker.predict("Chickens and Robots")
print(result)
JokerModel. Vous pouvez ainsi associer des données de trace à vos modifications de code et déterminer plus facilement quelles configurations sont les mieux adaptées à votre cas d’usage.
En plus des messages standard, Weave instrumente l’interface d’utilisation des outils d’Anthropic afin que vous puissiez tracer les flux de travail agentiques de bout en bout.
Anthropic fournit une interface d’outils qui permet à Claude de demander des appels de fonction. Weave suit automatiquement les définitions d’outils, les requêtes d’utilisation d’outils et les résultats des outils tout au long de la conversation.
Les exemples tronqués suivants montrent une configuration d’outil Anthropic :
message = client.messages.create(
max_tokens=1024,
messages=[
{
"role": "user",
"content": "What's the weather like in San Francisco?",
}
],
tools=[
{
"name": "get_weather",
"description": "Get the current weather in a given location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city and state, e.g. San Francisco, CA",
}
},
"required": ["location"],
},
},
],
model=model,
)
print(message)
const message = await client.messages.create({
max_tokens: 1024,
messages: [
{
role: 'user',
content: "What's the weather like in San Francisco?",
}
],
tools: [
{
name: 'get_weather',
description: 'Get the current weather in a given location',
input_schema: {
type: 'object',
properties: {
location: {
type: 'string',
description: 'The city and state, e.g. San Francisco, CA',
}
},
required: ['location'],
},
},
],
model: 'claude-3-opus-20240229',
});
console.log(message);
