> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.

# NVIDIA NIM

> Utilisez Weave pour tracer et journaliser les appels LLM effectués via la bibliothèque ChatNVIDIA

Une fois `weave.init()` appelé, Weave suit et journalise automatiquement les appels LLM effectués via la bibliothèque [ChatNVIDIA](https://python.langchain.com/docs/integrations/chat/nvidia_ai_endpoints/). Ce guide explique aux développeurs Python qui utilisent ChatNVIDIA comment capturer les traces, encapsuler leurs propres fonctions sous forme d’ops et organiser leurs expériences avec la classe `Model` de Weave, afin de déboguer et comparer plus efficacement leurs applications LLM, et d’itérer plus rapidement sur celles-ci.

<Tip>
  Pour découvrir les derniers tutoriels, consultez [Weights & Biases on NVIDIA](https://wandb.ai/site/partners/nvidia).
</Tip>

<h2 id="tracing">
  Traçage
</h2>

Stocker les traces de vos applications LLM dans une base de données centrale, aussi bien pendant le développement qu’en production, vous aide à déboguer les problèmes et à constituer un jeu de données d’exemples difficiles sur lesquels évaluer votre application au fil de ses améliorations. La section suivante explique comment activer le traçage automatique des appels ChatNVIDIA.

<Tabs>
  <Tab title="Python">
    Weave peut capturer automatiquement les traces de la [bibliothèque Python ChatNVIDIA](https://python.langchain.com/docs/integrations/chat/nvidia_ai_endpoints/).

    Pour lancer la capture, appelez `weave.init([PROJECT-NAME])` avec le nom de projet de votre choix.

    ```python lines {4} theme={"system"}
    from langchain_nvidia_ai_endpoints import ChatNVIDIA
    import weave
    client = ChatNVIDIA(model="mistralai/mixtral-8x7b-instruct-v0.1", temperature=0.8, max_tokens=64, top_p=1)
    weave.init('emoji-bot')

    messages=[
        {
          "role": "system",
          "content": "You are AGI. You will be provided with a message, and your task is to respond using emojis only."
        }]

    response = client.invoke(messages)
    ```

    Une fois ce code exécuté, Weave capture l’appel ChatNVIDIA dans le projet que vous avez indiqué. Vous pouvez alors y examiner les entrées, les sorties et les métadonnées.
  </Tab>

  <Tab title="TypeScript">
    ```plaintext theme={"system"}
    This feature is not available in TypeScript yet since this library is only in Python.
    ```
  </Tab>
</Tabs>

<Frame>
  <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/weave/_media/chatnvidia_trace.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=1020e3f17b858c95bb8dac1bd08d8f4f" alt="chatnvidia_trace.png" width="1042" height="671" data-path="products/wandb/weave/_media/chatnvidia_trace.png" />
</Frame>

<h2 id="track-your-own-ops">
  Suivre vos propres ops
</h2>

<Tabs>
  <Tab title="Python">
    Encapsuler une fonction avec `@weave.op` permet de capturer les entrées, les sorties et la logique de l’application, afin de déboguer le parcours des données dans votre application. Vous pouvez imbriquer les ops sur plusieurs niveaux et construire une arborescence des fonctions que vous souhaitez suivre. Cela active également la gestion automatique des versions du code au fil de vos expériences, pour capturer les modifications ponctuelles que vous n’avez pas encore commitées dans Git.

    Créez une fonction décorée avec [`@weave.op`](/fr/products/wandb/weave/guides/tracking/ops) qui appelle la [bibliothèque Python ChatNVIDIA](https://python.langchain.com/docs/integrations/chat/nvidia_ai_endpoints/).

    Dans l’exemple suivant, deux fonctions sont encapsulées avec op. Vous pouvez ainsi observer comment les étapes intermédiaires, comme l’étape de récupération dans une application RAG, influent sur le comportement de votre application.

    ```python lines {1,9,11,29,31,33} theme={"system"}
    import weave
    from langchain_nvidia_ai_endpoints import ChatNVIDIA
    import requests, random
    PROMPT="""Emulate the Pokedex from early Pokémon episodes. State the name of the Pokemon and then describe it.
            Your tone is informative yet sassy, blending factual details with a touch of dry humor. Be concise, no more than 3 sentences. """
    POKEMON = ['pikachu', 'charmander', 'squirtle', 'bulbasaur', 'jigglypuff', 'meowth', 'eevee']
    client = ChatNVIDIA(model="mistralai/mixtral-8x7b-instruct-v0.1", temperature=0.7, max_tokens=100, top_p=1)

    @weave.op
    def get_pokemon_data(pokemon_name):
        # Il s’agit d’une étape de votre application, comme l’étape de récupération dans une application RAG
        url = f"https://pokeapi.co/api/v2/pokemon/{pokemon_name}"
        response = requests.get(url)
        if response.status_code == 200:
            data = response.json()
            name = data["name"]
            types = [t["type"]["name"] for t in data["types"]]
            species_url = data["species"]["url"]
            species_response = requests.get(species_url)
            evolved_from = "Unknown"
            if species_response.status_code == 200:
                species_data = species_response.json()
                if species_data["evolves_from_species"]:
                    evolved_from = species_data["evolves_from_species"]["name"]
            return {"name": name, "types": types, "evolved_from": evolved_from}
        else:
            return None

    @weave.op
    def pokedex(name: str, prompt: str) -> str:
        # Il s’agit de votre op racine, qui appelle d’autres ops
        data = get_pokemon_data(name)
        if not data: return "Error: Unable to fetch data"

        messages=[
                {"role": "system","content": prompt},
                {"role": "user", "content": str(data)}
            ]

        response = client.invoke(messages)
        return response.content

    weave.init('pokedex-nvidia')
    # Obtenir les données d’un Pokémon spécifique
    pokemon_data = pokedex(random.choice(POKEMON), PROMPT)
    ```

    Accédez à Weave et cliquez sur `get_pokemon_data` dans l’interface utilisateur pour afficher les entrées et les sorties de cette étape.
  </Tab>

  <Tab title="TypeScript">
    ```plaintext theme={"system"}
    Cette fonctionnalité n’est pas encore disponible en TypeScript, car cette bibliothèque n’existe qu’en Python.
    ```
  </Tab>
</Tabs>

<Frame>
  <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/weave/_media/nvidia_pokedex.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=82de986311df2f7cb9ff89d47bb1a823" alt="nvidia_pokedex.png" width="1037" height="573" data-path="products/wandb/weave/_media/nvidia_pokedex.png" />
</Frame>

<h2 id="create-a-model-for-easier-experimentation">
  Créer un `Model` pour faciliter l’expérimentation
</h2>

<Tabs>
  <Tab title="Python">
    Il est difficile d’organiser ses expériences lorsque de nombreux éléments évoluent en même temps. La classe [`Model`](/fr/products/wandb/weave/guides/core-types/models) vous permet de capturer et d’organiser les détails expérimentaux de votre application, comme votre prompt système ou le modèle que vous utilisez. Vous pouvez ainsi organiser et comparer plus facilement les 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 [`Model`](/fr/products/wandb/weave/guides/core-types/models)s capturent des paramètres structurés qui contrôlent le comportement de votre application, ce qui permet de trouver facilement les paramètres les plus efficaces. Vous pouvez également utiliser les Weave Models avec `serve` et les [`Evaluation`](/fr/products/wandb/weave/guides/core-types/evaluations)s.

    Dans l’exemple suivant, vous pouvez expérimenter avec `model` et `system_message`. Chaque fois que vous modifiez l’un de ces éléments, vous obtenez une nouvelle *version* de `GrammarCorrectorModel`.

    ```python lines theme={"system"}
    import weave
    from langchain_nvidia_ai_endpoints import ChatNVIDIA

    weave.init('grammar-nvidia')

    class GrammarCorrectorModel(weave.Model): # Remplacer par `weave.Model`
      system_message: str

      @weave.op()
      def predict(self, user_input): # Remplacer par `predict`
        client = ChatNVIDIA(model="mistralai/mixtral-8x7b-instruct-v0.1", temperature=0, max_tokens=100, top_p=1)

        messages=[
              {
                  "role": "system",
                  "content": self.system_message
              },
              {
                  "role": "user",
                  "content": user_input
              }
              ]

        response = client.invoke(messages)
        return response.content

    corrector = GrammarCorrectorModel(
        system_message = "You are a grammar checker, correct the following user input.")
    result = corrector.predict("That was so easy, it was a piece of pie!")
    print(result)
    ```
  </Tab>

  <Tab title="TypeScript">
    ```plaintext theme={"system"}
    Cette fonctionnalité n’est pas encore disponible en TypeScript, car cette bibliothèque n’existe qu’en Python.
    ```
  </Tab>
</Tabs>

<Frame>
  <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/weave/_media/chatnvidia_model.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=134c1c6df967c99d98b8a386451f2ab2" alt="chatnvidia_model.png" width="3338" height="1229" data-path="products/wandb/weave/_media/chatnvidia_model.png" />
</Frame>

<h2 id="usage-info">
  Informations d’utilisation
</h2>

Les remarques suivantes décrivent les fonctionnalités prises en charge par l’intégration ChatNVIDIA.

L’intégration ChatNVIDIA prend en charge `invoke`, `stream` et leurs variantes asynchrones. Elle prend également en charge l’utilisation d’outils.
ChatNVIDIA étant conçu pour fonctionner avec de nombreux types de modèles, il ne prend pas en charge l’appel de fonctions.


## Related topics

- [Introduction to third-party frameworks](/products/cks/clusters/frameworks/introduction.md)