> ## 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.
# Groq
> Suivez et surveillez l’inférence LPU de Groq avec Weave, en capturant les appels de modèle, les métriques de performance et les enchaînements de fonctions pour les applications LLM.
Vous voulez tester les modèles Groq sur Weave sans rien configurer ? Essayez le [LLM Playground](../tools/playground).
[Groq](https://groq.com/) est une entreprise d’infrastructure IA qui fournit une inférence IA rapide. Le LPU Inference Engine de Groq est une plateforme matérielle et logicielle conçue pour la vitesse de calcul, la qualité et l’efficacité énergétique. Weave suit et journalise automatiquement les appels de complétion de chat de Groq.
Cette page explique comment utiliser Weave pour tracer les appels de complétion de chat de Groq, encapsuler vos propres fonctions en tant qu’ops Weave et organiser vos expériences à l’aide d’objets `Model`.
## Tracing
Il est important de stocker les traces des applications de modèles de langage dans un emplacement centralisé, aussi bien pendant le développement qu’en production. Ces traces peuvent vous aider à déboguer votre application et servir de jeu de données pour l’améliorer.
Weave capture automatiquement les traces pour [Groq](https://groq.com/). Pour commencer le suivi, appelez `weave.init(project_name="")` et utilisez la bibliothèque normalement. Remplacez les valeurs entre `<>` par les vôtres.
```python lines theme={null}
import os
import weave
from groq import Groq
weave.init(project_name="groq-project")
client = Groq(
api_key=os.environ.get("GROQ_API_KEY"),
)
chat_completion = client.chat.completions.create(
messages=[
{
"role": "user",
"content": "Explain the importance of fast language models",
}
],
model="llama3-8b-8192",
)
```
| 
|
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Weave suit et journalise désormais tous les appels LLM effectués via la bibliothèque Groq. Vous pouvez consulter les traces dans l'interface web de Weave. |
## Suivez vos propres ops
Décorez une fonction avec `@weave.op` pour capturer les entrées, les sorties et la logique de l'application afin que vous puissiez déboguer la façon dont les données circulent dans votre application. Vous pouvez imbriquer des ops en profondeur et créer une arborescence de fonctions que vous souhaitez suivre. Cela gère également automatiquement les versions du code pendant que vous expérimentez, afin de capturer des détails ad hoc qui n'ont pas été commités dans git.
Créez une fonction décorée avec [`@weave.op`](/fr/weave/guides/tracking/ops).
Dans l'exemple suivant, la fonction `recommend_places_to_visit`, décorée avec `@weave.op`, recommande des lieux à visiter dans une ville.
```python lines theme={null}
import os
import weave
from groq import Groq
weave.init(project_name="groq-test")
client = Groq(
api_key=os.environ.get("GROQ_API_KEY"),
)
@weave.op()
def recommend_places_to_visit(city: str, model: str="llama3-8b-8192"):
chat_completion = client.chat.completions.create(
messages=[
{
"role": "system",
"content": "You are a helpful assistant meant to suggest places to visit in a city",
},
{
"role": "user",
"content": city,
}
],
model="llama3-8b-8192",
)
return chat_completion.choices[0].message.content
recommend_places_to_visit("New York")
recommend_places_to_visit("Paris")
recommend_places_to_visit("Kolkata")
```
| 
|
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Décorez la fonction `recommend_places_to_visit` avec `@weave.op` pour tracer ses entrées, ses sorties et tous les appels LM internes effectués dans la fonction. |
## Créez un `Model` pour faciliter l’expérimentation
Il est difficile d’organiser l’expérimentation lorsqu’il y a de nombreux éléments en jeu. En utilisant la classe [`Model`](../core-types/models), vous pouvez capturer et organiser les détails expérimentaux de votre application, comme le 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 la gestion des versions du code et de la capture des entrées et des sorties, les [`Model`](../core-types/models)s capturent des paramètres structurés qui contrôlent le comportement de votre application, vous aidant à trouver les paramètres les plus efficaces. Vous pouvez également utiliser des Weave Models avec `serve` et des [`Evaluation`](../core-types/evaluations)s.
Dans l’exemple suivant, vous pouvez expérimenter avec `GroqCityVisitRecommender`. À chaque modification de l’un de ces éléments, vous obtenez une nouvelle *version* de `GroqCityVisitRecommender`.
```python lines theme={null}
import os
from groq import Groq
import weave
class GroqCityVisitRecommender(weave.Model):
model: str
groq_client: Groq
@weave.op()
def predict(self, city: str) -> str:
system_message = {
"role": "system",
"content": """
You are a helpful assistant meant to suggest places to visit in a city
""",
}
user_message = {"role": "user", "content": city}
chat_completion = self.groq_client.chat.completions.create(
messages=[system_message, user_message],
model=self.model,
)
return chat_completion.choices[0].message.content
weave.init(project_name="groq-test")
city_recommender = GroqCityVisitRecommender(
model="llama3-8b-8192", groq_client=Groq(api_key=os.environ.get("GROQ_API_KEY"))
)
print(city_recommender.predict("New York"))
print(city_recommender.predict("San Francisco"))
print(city_recommender.predict("Los Angeles"))
```
| 
|
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Tracez et gérez les versions de vos appels à l’aide d’un [`Model`](../core-types/models). |
### Servir un Weave Model
Une fois que vous disposez d’un `Model` versionné, vous pouvez le déployer en tant que service pour des tests ou des applications en aval. À partir d’une référence Weave vers n’importe quel objet `weave.Model`, vous pouvez lancer un serveur FastAPI et le [Serve](https://docs.wandb.ai/weave/guides/tools/serve).
| [
](https://wandb.ai/geekyrakshit/groq-test/weave/objects/GroqCityVisitRecommender/versions/6O1xPTJ9yFx8uuCjJAlI7KgcVYxXKn7JxfmVD9AQT5Q) |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Vous pouvez trouver la référence Weave de n’importe quel `weave.Model` en ouvrant le modèle, puis en la copiant depuis l’UI. |
Servez votre modèle avec la commande suivante dans le terminal :
```shell theme={null}
weave serve weave://your_entity/project-name/YourModel:
```