> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-docs-sandboxes-integrations-placement.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Notebook d’introduction

<div id="weave-with-typescript-quickstart-guide">
  # Guide de démarrage rapide de Weave avec TypeScript
</div>

Vous pouvez utiliser W\&B Weave avec TypeScript pour :

* Journaliser et déboguer les entrées, les sorties et les traces des modèles de langage
* Créer des évaluations rigoureuses et directement comparables pour les cas d'utilisation des modèles de langage
* Organiser toutes les informations générées tout au long du flux de travail LLM, de l'expérimentation aux évaluations puis à la production

Pour plus d'informations, voir la [documentation Weave](/fr/).

<div id="function-tracking">
  ## Suivi des fonctions
</div>

Pour utiliser Weave dans votre code TypeScript, initialisez un nouveau projet Weave et ajoutez le wrapper `weave.op` aux fonctions que vous souhaitez suivre.

Après avoir ajouté `weave.op` et appelé la fonction, consultez le tableau de bord W\&B pour la voir apparaître dans votre projet.

Votre code est suivi automatiquement - consultez l’onglet Code dans l’UI !

```typescript lines theme={null}
async function initializeWeaveProject() {
    const PROJECT = 'weave-examples';
    await weave.init(PROJECT);
}
```

```typescript lines theme={null}
const stripUserInput = weave.op(function stripUserInput(userInput: string): string {
    return userInput.trim();
});
```

L’exemple suivant montre comment fonctionne le suivi de base des fonctions.

```typescript lines theme={null}
async function demonstrateBasicTracking() {
    const result = await stripUserInput("    hello    ");
    console.log('Résultat du suivi de base :', result);
}
```

<div id="openai-integration">
  ## Intégration à OpenAI
</div>

Weave suit automatiquement tous les appels à OpenAI, notamment :

* Utilisation des tokens
* Coûts de l’API
* Paires requête-réponse
* Configurations des modèles

<Note>
  En plus d’OpenAI, Weave prend en charge l’enregistrement automatique d’autres fournisseurs de LLM, comme Anthropic et Mistral. Pour la liste complète, voir [les fournisseurs de LLM dans la documentation sur les intégrations](../../guides/integrations#llm-providers).
</Note>

```typescript lines theme={null}
function initializeOpenAIClient() {
    return weave.wrapOpenAI(new OpenAI({
        apiKey: process.env.OPENAI_API_KEY
    }));
}
```

```typescript lines theme={null}
async function demonstrateOpenAITracking() {
    const client = initializeOpenAIClient();
    const result = await client.chat.completions.create({
        model: "gpt-4-turbo",
        messages: [{ role: "user", content: "Hello, how are you?" }],
    });
    console.log('OpenAI tracking result:', result);
}
```

<div id="nested-function-tracking">
  ## Suivi imbriqué des fonctions
</div>

Weave vous permet de suivre des flux de travail complexes en combinant plusieurs fonctions suivies
et des appels LLM, tout en préservant l’intégralité de la trace d’exécution. Cela offre notamment les avantages suivants :

* Visibilité complète sur le flux logique de votre application
* Débogage simplifié des chaînes d’opérations complexes
* Possibilités d’optimisation des performances

```typescript lines theme={null}
async function demonstrateNestedTracking() {
    const client = initializeOpenAIClient();
    
    const correctGrammar = weave.op(async function correctGrammar(userInput: string): Promise<string> {
        const stripped = await stripUserInput(userInput);
        const response = await client.chat.completions.create({
            model: "gpt-4-turbo",
            messages: [
                {
                    role: "system",
                    content: "You are a grammar checker, correct the following user input."
                },
                { role: "user", content: stripped }
            ],
            temperature: 0,
        });
        return response.choices[0].message.content ?? '';
    });

    const grammarResult = await correctGrammar("That was so easy, it was a piece of pie!");
    console.log('Nested tracking result:', grammarResult);
}
```

<div id="dataset-management">
  ## Gestion des jeux de données
</div>

Vous pouvez créer et gérer des jeux de données avec Weave à l’aide de la classe [`weave.Dataset`](/fr/weave/guides/core-types/datasets). À l’instar des [Weave `Models`](/fr/weave/guides/core-types/models), `weave.Dataset` permet de :

* Suivre et versionner vos données
* Organiser les cas de test
* Partager des jeux de données entre les membres de l’équipe
* Prendre en charge des évaluations systématiques

```typescript lines theme={null}
interface GrammarExample {
    userInput: string;
    expected: string;
}
```

```typescript lines theme={null}
function createGrammarDataset(): weave.Dataset<GrammarExample> {
    return new weave.Dataset<GrammarExample>({
        id: 'grammar-correction',
        rows: [
            {
                userInput: "That was so easy, it was a piece of pie!",
                expected: "That was so easy, it was a piece of cake!"
            },
            {
                userInput: "I write good",
                expected: "I write well"
            },
            {
                userInput: "LLM's are best",
                expected: "LLM's are the best"
            }
        ]
    });
}
```

<div id="evaluation-framework">
  ## Framework d’évaluation
</div>

Weave prend en charge le développement piloté par l’évaluation avec la [classe `Evaluation`](/fr/weave/guides/core-types/evaluations). Les évaluations vous aident à itérer de manière fiable sur votre application de GenAI. La classe `Evaluation` permet de :

* Évaluer les performances du `Model` sur un `Dataset`
* Appliquer des fonctions de scoring personnalisées
* Générer des rapports détaillés sur les performances
* Comparer les versions de modèles

Vous trouverez un tutoriel complet sur l’évaluation à l’adresse [http://wandb.me/weave\_eval\_tut](http://wandb.me/weave_eval_tut)

```typescript lines theme={null}
class OpenAIGrammarCorrector {
    private oaiClient: ReturnType<typeof weave.wrapOpenAI>;
    
    constructor() {
        this.oaiClient = weave.wrapOpenAI(new OpenAI({
            apiKey: process.env.OPENAI_API_KEY
        }));
        this.predict = weave.op(this, this.predict);
    }

    async predict(userInput: string): Promise<string> {
        const response = await this.oaiClient.chat.completions.create({
            model: 'gpt-4-turbo',
            messages: [
                { 
                    role: "system", 
                    content: "You are a grammar checker, correct the following user input." 
                },
                { role: "user", content: userInput }
            ],
            temperature: 0
        });
        return response.choices[0].message.content ?? '';
    }
}
```

```typescript lines theme={null}
async function runEvaluation() {
    const corrector = new OpenAIGrammarCorrector();
    const dataset = createGrammarDataset();
    
    const exactMatch = weave.op(
        function exactMatch({ modelOutput, datasetRow }: { 
            modelOutput: string; 
            datasetRow: GrammarExample 
        }): { match: boolean } {
            return { match: datasetRow.expected === modelOutput };
        },
        { name: 'exactMatch' }
    );

    const evaluation = new weave.Evaluation({
        dataset,
        scorers: [exactMatch],
    });

    const summary = await evaluation.evaluate({
        model: weave.op((args: { datasetRow: GrammarExample }) => 
            corrector.predict(args.datasetRow.userInput)
        )
    });
    console.log('Evaluation summary:', summary);
}
```

La fonction `main` suivante exécute toutes les démonstrations :

```typescript lines theme={null}
async function main() {
    try {
        await initializeWeaveProject();
        await demonstrateBasicTracking();
        await demonstrateOpenAITracking();
        await demonstrateNestedTracking();
        await runEvaluation();
    } catch (error) {
        console.error('Error running demonstrations:', error);
    }
}
```