> ## 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.
# Groq
> Suivez et surveillez l’inférence LPU de Groq avec Weave, en capturant les appels de modèle, les métriques de performances et les chaînes de fonctions de vos applications LLM.
Vous souhaitez tester les modèles Groq dans Weave sans aucune configuration ? Essayez le [LLM Playground](/fr/products/wandb/weave/guides/tools/playground).
[Groq](https://groq.com/) est une entreprise d’infrastructure d’IA spécialisée dans l’inférence d’IA rapide. Le LPU Inference Engine de Groq est une plateforme matérielle et logicielle conçue pour offrir vitesse de calcul, qualité et efficacité énergétique. Weave suit et journalise automatiquement les appels de complétion de chat Groq.
Cette page explique comment utiliser Weave pour tracer les appels de complétion de chat Groq, encapsuler vos propres fonctions sous forme d’ops Weave et organiser vos expériences à l’aide d’objets `Model`.
Traçage
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 à suivre vos appels, appelez `weave.init(project_name="")`, puis utilisez la bibliothèque normalement. Remplacez les valeurs entre `<>` par les vôtres.
```python lines theme={"system"}
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. |
Suivre vos propres ops
Encapsulez une fonction avec `@weave.op` pour capturer les entrées, les sorties et la logique de votre application, afin de déboguer la circulation des données en son sein. Vous pouvez imbriquer des ops sur plusieurs niveaux et construire une arborescence des fonctions que vous souhaitez suivre. Le code est également versionné automatiquement au fil de vos expériences, ce qui permet de capturer des détails ponctuels qui n'ont pas encore été commités dans git.
Créez une fonction décorée avec [`@weave.op`](/fr/products/wandb/weave/guides/tracking/ops).
Dans l’exemple suivant, la fonction `recommend_places_to_visit` est encapsulée avec `@weave.op` et recommande des lieux à visiter dans une ville.
```python lines theme={"system"}
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 de LM internes effectués au sein de la fonction. |
Créer un `Model` pour faciliter l’expérimentation
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 vous aide à trouver les paramètres les plus efficaces. Vous pouvez également utiliser les Weave Models avec `serve` et avec les [`Evaluation`](/fr/products/wandb/weave/guides/core-types/evaluations)s.
Dans l’exemple suivant, vous pouvez expérimenter avec `GroqCityVisitRecommender`. Chaque fois que vous modifiez l’un de ces éléments, vous obtenez une nouvelle *version* de `GroqCityVisitRecommender`.
```python lines theme={"system"}
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 vos appels et gérez-en les versions à l’aide d’un [`Model`](/fr/products/wandb/weave/guides/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 le tester ou l’utiliser dans 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 [servir](/fr/products/wandb/weave/guides/tools/serve).
| [
](https://forge.coreweave.com/wandb/geekyrakshit/groq-test/weave/objects/GroqCityVisitRecommender/versions/6O1xPTJ9yFx8uuCjJAlI7KgcVYxXKn7JxfmVD9AQT5Q) |
| - |
| Pour trouver la référence Weave d’un `weave.Model`, accédez au modèle et copiez-la depuis l’interface utilisateur. |
Servez votre modèle en exécutant la commande suivante dans le terminal :
```shell theme={"system"}
weave serve weave://your_entity/project-name/YourModel:
```