Grok 3 API : Un guide étape par étape avec des exemples

Qu'est-ce que Grok 3 ?

Grok 3 est le dernier grand modèle de langage de xAI, conçu pour le raisonnement par étapes, la cohérence logique et les résultats structurés. Contrairement aux modèles de chat classiques qui privilégient le flux de la conversation, Grok 3 réfléchit avant de répondre, ce qui le rend idéal pour les tâches qui nécessitent une logique profonde, comme la prise de décision complexe, le raisonnement mathématique et l'analyse quantitative.

Grok 3 existe en deux versions différentes : le modèle normal et le modèle mini. Alors que le mini-modèle se concentre entièrement sur l'aspect raisonnement et permet d'accéder à ses traces de raisonnement, le modèle régulier est annoncé comme possédant des connaissances approfondies dans des domaines tels que la finance, les soins de santé, le droit et la science.

Les deux versions du modèle prennent en charge des fonctionnalités avancées telles que l'appel de fonctions natives et la génération de réponses structurées, ce qui permet aux développeurs de créer facilement des flux de travail d'IA fiables et prévisibles.

Si vous souhaitez en savoir plus sur l'architecture et les performances de Grok 3, n'hésitez pas à jeter un coup d'œil à cette présentation de Grok 3.

Préparation : Accéder à l'API Grok 3

Dans cette section, je vais vous expliquer comment créer une clé API, configurer un environnement Python pour vous connecter à l'API Grok, et faire votre première demande d'utilisateur.

Création d'une clé API

Pour authentifier le client Python auprès de l'API, nous devons créer une clé API. Le processus se déroule comme suit :

1. Allez à la page de documentation de page de documentation xAI.
2. Connectez-vous avec votre compte X, xAI ou Google, ou créez un compte xAI.
3. Cliquez sur "Créer une clé API", donnez-lui un nom et cliquez sur "Enregistrer".
4. Lorsque la clé est visible, copiez-la. Vous ne pourrez plus le voir par la suite, mais vous pouvez toujours en créer un nouveau, au cas où vous le perdriez.
5. Créez un fichier nommé .env dans le répertoire de votre projet et collez la clé dans le format suivant :

XAI_API_KEY=<your_api_key>

Prix de l'API Grok 3

Bien que l'utilisation de l'API soit souvent associée à des coûts inférieurs à ceux d'un abonnement premium, elle n'est pas gratuite. Au lieu d'un compte fixe par mois, qui commence à 30 dollars pour l'abonnement SuperGrok, le coût dépend entièrement du volume d'utilisation. Pour obtenir une vue d'ensemble des coûts potentiels, visitez la page de tarification de xAI.

Les prix indiqués sont par million de tokens, ce qui, selon une règle empirique correspond à environ 750 000 mots d'entrée ou de sortie en anglais.

Le modèle mini est nettement moins cher que le modèle normal. Les versions rapides de Grok 3 et Grok 3 mini utilisent exactement les mêmes modèles sous-jacents, mais sont servies par une infrastructure plus rapide, ce qui permet d'améliorer les temps de réponse.

Pour utiliser l'API, il faut acheter des crédits. Au début, il est recommandé d'utiliser des crédits prépayés plutôt que la facturation automatique, car c'est une bonne protection contre les coûts imprévus. Vous pouvez acheter des jetons et obtenir un aperçu de votre utilisation dans la console xAI sous Factures > Crédits.

Configuration de l'environnement Python

Maintenant que nous avons acquis une clé API et acheté des crédits, il est temps de configurer le client Python. Nous devons installer deux dépendances pour que nos demandes d'API soient exécutées avec succès :

• python-dotenv pour charger la clé API en tant que variable d'environnement à partir du fichier .env, et
• le client openai comme interface pour envoyer des requêtes à Grok 3.

Pour configurer l'environnement de notre projet, je vous recommande d'utiliser Anaconda afin d'éviter les conflits potentiels entre les différents paquets Python. Après avoir installé Anaconda, nous créons un environnement nommé grok3 en utilisant Python 3.10 et nous l'activons en utilisant les commandes suivantes dans le terminal :

conda create -n grok3 python=3.10
conda activate grok3

Enfin, les dépendances sont installées :

pip install python-dotenv openai

Envoi de la première demande de l'utilisateur

Il est temps de commencer à rédiger notre premier script ! Tout d'abord, nous devons importer les fonctions que nous utiliserons à partir des paquets que nous avons installés précédemment, ainsi que os pour lire la clé API.

import os
from dotenv import load_dotenv
from openai import OpenAI

La variable d'environnement variable d'environnement se référant à la clé API est rendue disponible en exécutant la fonction load_dotenv() importée du paquetage dotenv.

# Load environment variables
load_dotenv()

L'étape suivante consiste à initialiser le client. Nous appelons la fonction OpenAI avec notre clé API du fichier .env et l'URL du serveur Grok, et nous l'assignons à la variable client.

client = OpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
)

Demandons à Grok de nous conseiller sur ce qu'il faut faire à San Francisco s'il pleut. Ce que nous devons faire, c'est spécifier le model et notre messages, et les passer en tant qu'arguments à la fonction client.chat.completions.create. En option, nous pouvons également ajuster des paramètres tels que max_tokens pour contrôler la longueur de la réponse ou temperature pour influencer le caractère aléatoire.

# Send a basic reasoning query
response = client.chat.completions.create(
    model="grok-3",
    messages=[
        {"role": "user", "content": "What kind of activity would you suggest, if it rains in San Francisco? Answer in one sentence."}
    ],
    max_tokens=1000,
    temperature=0.2,  # lower temperature for more deterministic answers
)

Pour imprimer la réponse de Grok, nous devons l'extraire de l'objet résultant. Puisque nous avons appelé la variable stockant le résultat response, la réponse se trouve dans response.choices[0].message.content.

print(response.choices[0].message.content) # Print the response

If it rains in San Francisco, I suggest visiting indoor attractions like the San Francisco Museum of Modern Art or the California Academy of Sciences for an enriching and dry experience.

Raisonner avec Grok 3 Mini

Pour connaître le style de raisonnement de Grok, posons une question élémentaire qui nécessite un raisonnement logique. Nous utiliserons Grok 3 Mini pour cette première requête car il garantit une trace de raisonnement complète dans chaque réponse API, ce qui permet de suivre plus facilement le processus de réflexion du modèle étape par étape sans dépendre d'une ingénierie d'invite spéciale.

Le paramètre qui détermine la profondeur de réflexion du modèle est appelé reasoning_effort. Elle est exclusive à Grok 3 Mini et est réglée par défaut sur l'option la plus rapide ”low”. Le réglage de reasoning_effort="high" permet au modèle de parcourir le problème étape par étape avant de donner la réponse finale, ce qui est parfait pour des tâches telles que la planification, la prise de décision ou le raisonnement mathématique.

Imaginez que nous voulions utiliser Grok pour savoir quoi faire un jour de congé, en fonction du temps qu'il fait. Nous pourrions faire passer des prémisses Grok définissant une activité pour les jours ensoleillés et pluvieux, et une prémisse basée sur le temps réel.

response = client.chat.completions.create(
    model="grok-3-mini-beta",
    reasoning_effort="high",
    messages=[
        {"role": "user", "content": (
            "Premises:\n"
            "- If it is raining, the weather is suitable for indoor activities.\n"
        	"- Visiting a museum is an indoor activity.\n"
        	"- Today, it is raining.\n"
            "Question: What should we do today?"    	
        )}
    ],
    max_tokens=1000,
    temperature=0.2,
)

Pour utiliser la trace de raisonnement, nous devons d'abord analyser la réponse de l'API et extraire l'attribut reasoning_content de l'objet message. Le code suivant montre comment imprimer à la fois les étapes détaillées du raisonnement et la réponse finale, de la même manière qu'elles apparaîtraient dans une interface web.

# Print the reasoning trace if available
reasoning = getattr(response.choices[0].message, "reasoning_content", None)
 
if reasoning:
    print("Reasoning steps:\n")
    print(reasoning)
else:
    print("No detailed reasoning trace found.")
 
# Print the final answer
print("\nFinal Answer:\n")
print(response.choices[0].message.content)

Le résultat est le suivant :

Reasoning steps:
First, the premises are:
1. If it is raining, the weather is suitable for indoor activities.
2. Visiting a museum is an indoor activity.
3. Today, it is raining.
The question is: What should we do today?
I need to reason step by step based on the given premises.
From premise 3, today it is raining.
From premise 1, if it is raining, then the weather is suitable for indoor activities. Since it's raining today, the weather is suitable for indoor activities today.  	
From premise 2, visiting a museum is an indoor activity. So, if the weather is suitable for indoor activities, and visiting a museum is an indoor activity, it makes sense that visiting a museum would be a good choice today.
The conclusion should be that we should visit a museum or engage in some indoor activity. But the question is "What should we do today?" and the premises point towards indoor activities, with a specific example given.
Let me chain the logic:
- It is raining (premise 3).
- Therefore, weather is suitable for indoor activities (from premise 1).
- Visiting a museum is an indoor activity (premise 2).
- So, since the weather is suitable for indoor activities, and museum visiting is an indoor activity, it should be suitable to visit a museum.
The premises don't explicitly say that we should do the most suitable activity or anything like that. They just provide conditions and facts.
However, the question implies a recommendation based on the premises. Given that it's raining and indoor activities are suitable, and a museum is mentioned, it's logical to suggest visiting a museum.
I should stick to what's given. The premises don't suggest any other activities or constraints, so based on the information, visiting a museum is a reasonable suggestion.
Final answer should be something like: "We should visit a museum today."
To make it clear, I can phrase it as: "Since it is raining and the weather is suitable for indoor activities, and visiting a museum is an indoor activity, we should visit a museum today."
But since the instruction is to put the final answer in a box, probably a concise statement.
Looking back at the user's message, it's a reasoning exercise, so the answer should be direct.
Final Answer:
Based on the given premises:
- It is raining today (premise 3).
- If it is raining, the weather is suitable for indoor activities (premise 1).   	
- Therefore, the weather is suitable for indoor activities today.
- Visiting a museum is an indoor activity (premise 2).
A suitable activity for today would be an indoor one, such as visiting a museum. 	
**Recommendation:** We should visit a museum today.

Même s'il s'agit d'un exemple assez simple, nous pouvons voir comment Grok-3-mini passe soigneusement en revue chaque prémisse, en enchaînant la logique étape par étape avant d'arriver à une recommandation. Son raisonnement est méthodique et transparent, ce qui permet de retracer facilement la façon dont le modèle passe des faits à la proposition finale.

Appel de fonction avec Grok 3

L'une des caractéristiques qui rend Grok 3 intéressant est l'appel de fonction, qui lui permet de se connecter à des outils et systèmes externes. Cela permet au modèle non seulement de générer du texte, mais aussi de déclencher des actions telles que l'extraction de prévisions météorologiques, la recherche d'horaires d'événements, l'analyse d'entrées de base de données ou même le contrôle d'appareils intelligents.

Lorsque nous envoyons une demande d'utilisateur, Grok 3 peut reconnaître qu'il a besoin d'informations supplémentaires et demander un appel de fonction avec des arguments spécifiques. Le client Python exécute ensuite la fonction localement, renvoie le résultat à Grok 3 et reçoit la réponse finale, entièrement motivée.

Source : xAI

Préparation

Nous aurons besoin du paquet json pour accéder à la structure des arguments d'une fonction appelée par Grok, nous devons donc l'importer.

import json

Pour tester l'appel de fonction, nous devons définir une fonction de rappel qui sera appelée lorsque Grok la demandera dans sa réponse. Dans notre cas, la fonction get_weather_forecast est une simple fonction Python qui renvoie une prévision météorologique codée en dur. Je l'ai codé en dur à des fins de démonstration pour que l'explication reste simple et ne dépende pas de services externes.

# Define the dummy function
def get_weather_forecast(location: str, date: str) -> dict:
    """Simulated function to always return rainy weather."""
    return {
        "location": location,
        "date": “this weekend”, # hardcoded for demo purposes
        "forecast": "rainy"  # hardcoded for demo purposes
    }

Nous devons également définir l'outil disponible en spécifiant son nom, son objectif et les paramètres requis dans un schéma JSON, qui sera envoyé à Grok avec notre demande ultérieurement. Cette configuration permet à Grok 3 de savoir qu'il peut faire appel à cet outil chaque fois qu'il a besoin d'informations météorologiques pour son raisonnement.

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather_forecast",
            "description": "Get a simulated weather forecast for a given location and date.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city where the activity will take place."
                    },
                    "date": {
                        "type": "string",
                        "description": "The date for which the weather is needed, in YYYY-MM-DD format."
                    }
            	    },
            	    "required": ["location", "date"]
            }
        }
    }
]

Enfin, le site tools_map dictionary relie les noms de fonctions utilisés par Grok 3 aux fonctions Python locales réelles, ce qui permet au client d'exécuter correctement les appels d'outils demandés.

# Link the function names to the functions
tools_map = {
    "get_weather_forecast": get_weather_forecast
}

Si la définition manuelle des schémas d'outils convient parfaitement aux projets simples, l'utilisation d'un module de validation des données tel que Pydantic devient de plus en plus précieuse à mesure que les projets gagnent en taille et en complexité. Il permet la validation automatique des entrées de fonctions, une meilleure gestion des erreurs et un code plus propre et plus facile à maintenir.

Exécution

Voyons si Grok utilise notre fonction de prévision météorologique lorsqu'il est interrogé sur une activité suggérée à San Francisco ce week-end. Nous suivons la structure du processus d'appel de fonction :

1. Tout d'abord, nous envoyons notre demande initiale contenant notre question au Grok avec les informations disponibles sur tools.
2. Nous vérifions la réponse de Grok pour toute demande d'appel d'outil et, le cas échéant, nous appelons la fonction locale correspondante à l'aide de tools_map. Si Grok ne demande pas d'appel d'outil, nous pouvons le traiter en renvoyant la réponse initiale du modèle.
3. Ensuite, nous ajoutons le résultat à l'historique des messages ; et
4. Renvoyez-le à Grok pour qu'il complète le raisonnement et génère la réponse finale.

# Step 1: Send the initial user request
messages = [
    {"role": "user", "content": "What should I do this weekend in San Francisco?"}
]

response = client.chat.completions.create(
    model="grok-3",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)
 
# Step 2: Check if a tool call was requested
tool_calls = getattr(response.choices[0].message, "tool_calls", [])
 
if tool_calls:
    for tool_call in tool_calls:
        function_name = tool_call.function.name
        function_args = json.loads(tool_call.function.arguments)
 
        # Find and call the matching local function
        if function_name in tools_map:
            function_result = tools_map[function_name](**function_args)
 
            # Step 3: Add the function result back to the message history
            messages.append(response.choices[0].message)  # Grok's tool call message
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(function_result)
        	})
 
        	# Step 4: Send a new request including the tool response
            final_response = client.chat.completions.create(
                model="grok-3",
                messages=messages,
                tools=tools,
                tool_choice="auto"
        	)
 
        	# Print the final answer
            print("\nFinal Answer:")
            print(final_response.choices[0].message.content)
 
else:
    # No tool call: respond directly
    print("\nNo tool call was requested. Final Answer:")
    print(response.choices[0].message.content)

La fonction a été demandée et exécutée avec succès, comme l'indique la réponse de Grok :

Thanks for the weather update. Since it's going to be rainy this weekend in San Francisco, I’ll suggest some indoor activities to keep you entertained and dry. Here are a few ideas for your weekend: (...)

Vous avez peut-être remarqué l'argument tool_choice dans la demande initiale de l'utilisateur, qui fait référence au mode d'appel de la fonction. Par défaut, le mode "auto" permet à Grok 3 de décider si et quelle fonction appeler en fonction de la conversation. Nous pouvons également contrôler le comportement en forçant l'appel d'une fonction avec ”required”, en spécifiant une fonction exacte à appeler ou en désactivant complètement l'appel de fonction avec ”none”.

Sorties structurées avec Grok 3

Les sorties structurées permettent à Grok 3 de renvoyer des réponses dans un format strict et prédéfini, tel que JSON, au lieu d'un texte libre. Il est ainsi beaucoup plus facile d'analyser, de valider et d'intégrer automatiquement les réponses du modèle dans des applications ou des flux de travail.

En définissant un schéma dès le départ, nous pouvons nous assurer que les résultats de Grok sont cohérents, lisibles par une machine et prêts à être traités en aval. Il s'agit donc d'une fonctionnalité très utile pour les cas d'utilisation tels que les données structurées provenant de documents ou l'alimentation de systèmes en aval tels que les bases de données, les tableaux de bord ou les pipelines d'automatisation avec des informations générées par l'IA, sans avoir besoin d'une analyse de texte fragile.

Nous utilisons Pydantic pour définir le schéma de sortie car il offre un moyen plus propre et plus lisible de structurer des données complexes. Tant BaseModel que Field de pydantic doivent être importés pour que cette définition de schéma fonctionne correctement. Comme notre résultat comprend une liste d'étapes de raisonnement, nous importons également List du module Python typing pour spécifier plus précisément le type d'élément.

Bien qu'il soit également possible de définir le schéma à l'aide de JSON, j'ai constaté, lors de mes tests, que Grok 3 renvoyait parfois des résultats qui ne correspondaient pas exactement à la structure attendue. Le JSON renvoyé était similaire en termes de signification mais suivait un schéma différent, ce qui pouvait perturber les applications qui s'attendaient à une structure spécifique. En raison de cette incohérence, en particulier avec les éléments imbriqués comme les listes, je recommande vivement d'utiliser Pydantic pour garantir que la sortie structurée est validée et analysée de manière fiable.

from pydantic import BaseModel, Field
from typing import List

Notre schéma, appelé DecisionPlan, se compose de notre site initial situation et d'une liste de DecisionSteps, qui sont définis par leur numéro step, le reasoning qui les sous-tend et une suggestion de action.

# Define the schema for the structured output
class DecisionStep(BaseModel):
    step: int = Field(description="Step number in the decision process")
    reasoning: str = Field(description="Reasoning behind this step")
    action: str = Field(description="Suggested action at this step")
 
class DecisionPlan(BaseModel):
    situation: str = Field(description="The initial situation to consider")
    steps: List[DecisionStep] = Field(description="List of reasoning steps leading to the final action")

Il y a quelques éléments à prendre en compte en ce qui concerne la demande elle-même. Tout d'abord, nous devons utiliser client.beta.chat.completions.parse() au lieu de create(), afin que Grok sache que nous voulons que la sortie ait un format spécifique. Il s'agit du schéma que nous venons de définir et, par conséquent, nous transmettons notre DecisionPlan en tant qu'argument response_format.

Il peut être utile d'inclure toutes les instructions importantes pour une tâche spécifique dans l'invite système, car cela permet à Grok 3 de rester concentré sur la tâche tout au long de la conversation. En combinaison avec le schéma défini séparément, l'utilisateur n'a pas besoin de spécifier des champs obligatoires dans le JSON de sortie et peut se concentrer sur la tâche elle-même.

Nous pourrions, par exemple, facilement décomposer le processus de planification des activités en trois étapes bien définies :

# Send a prompt and request structured output
completion = client.beta.chat.completions.parse(
    model="grok-3",
    messages=[
        {"role": "system", "content": (
        "You are an expert travel planner."
        "When asked about activities, always break down the decision process into exactly 3 logical reasoning steps."
        "Return the output in structured JSON format following the provided schema, without any extra text."
        )},
        {"role": "user", "content": (
        "It's raining today in San Francisco. What indoor activity would you recommend?"
        )}
    ],
    response_format=DecisionPlan,
)

Après avoir analysé la sortie structurée de Grok 3, nous pouvons agir sur les résultats en résumant les principales recommandations, en déclenchant des flux de travail automatisés ou même en prenant d'autres décisions de manière programmatique.

Prenons le premier exemple et affichons uniquement notre situation et la recommandation finale de notre expert en voyages, Grok. Comme notre résultat est dans notre format JSON prédéfini, nous pouvons accéder facilement à la recommandation de l'étape finale :

# Access the parsed result
plan = completion.choices[0].message.parsed
 
# Use the final action to create a summary message
final_step = plan.steps[-1]
 
print(f"\nSummary:")
print(f"Situation: {plan.situation}")
print(f"Recommended Action: {final_step.action}")

Summary:
Situation: It's raining today in San Francisco, and an indoor activity is needed to make the most of the day.
Recommended Action: Visiting the California Academy of Sciences in Golden Gate Park for an educational and entertaining indoor experience.

Tout mettre en place : Construire une application de raisonnement simple avec Grok 3

Nous pouvons combiner l'appel de fonctions et les sorties structurées pour créer une application simple qui utilise le raisonnement de Grok. Nous pouvons copier et coller le code pour :

• Importation de tous les paquets et fonctions mentionnés ci-dessus ;
• Initialisation du client ;
• Définition du schéma de fonction, de la fonction fictive et de tools_map; et
• Définition du schéma de sortie.

Nous commençons par un appel à l'API en utilisant la fonction create() pour déclencher l'appel à l'outil. Pour permettre à l'utilisateur de saisir la question dans le terminal, nous remplaçons simplement notre question sur l'activité à San Francisco par input("> ").

Après avoir ajouté le function_result à la liste messages, nous avons un problème : au lieu de créer un autre appel à l'API qui utilise create(), we parse() and pass our DecisionPlan as the response_format`.

Voici le code complet de notre petite application :

import os
import json
from dotenv import load_dotenv
from openai import OpenAI
from pydantic import BaseModel, Field
from typing import List
 
# Load environment variables
load_dotenv()
 
# Initialize the client
client = OpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
)
 
# 1. Define the function schema (tool definition)
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather_forecast",
            "description": "Get a simulated weather forecast for a given location and date.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city where the activity will take place."
                	},
                    "date": {
                        "type": "string",
                        "description": "The date for which the weather is needed, in YYYY-MM-DD format."
                    }
            	    },
                "required": ["location", "date"]
        	}
        }
    }
]
 
# 2. Dummy weather function (hardcoded)
def get_weather_forecast(location: str, date: str) -> dict:
    return {
        "location": location,
        "date": "this weekend",
        "forecast": "rainy"
    }
 
# 3. Tool mapping
tools_map = {
    "get_weather_forecast": get_weather_forecast
}
 
# 4. Define structured output schema using Pydantic
class DecisionStep(BaseModel):
	step: int = Field(description="Step number in the decision process")
	reasoning: str = Field(description="Reasoning behind this step")
	action: str = Field(description="Suggested action at this step")
 
class DecisionPlan(BaseModel):
	situation: str = Field(description="The initial situation to consider")
	steps: List[DecisionStep] = Field(description="List of reasoning steps leading to the final action")
 
# 5. Defining messages: system prompt and input
messages = [
    {"role": "system", "content": (
        "You are an expert travel planner. When asked about weekend plans, "
        "first get the weather forecast via the tool provided. Then, based on the result, "
        "break down your reasoning into exactly 3 steps and return structured JSON only."
    )},
    {"role": "user", "content": input("> ")} # enter the question in the terminal
]
 
# 6. First API call to trigger the tool call
response = client.chat.completions.create(
    model="grok-3",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)
 
tool_calls = getattr(response.choices[0].message, "tool_calls", [])
 
if tool_calls:
    for tool_call in tool_calls:
        function_name = tool_call.function.name
        function_args = json.loads(tool_call.function.arguments)
        if function_name in tools_map:
            function_result = tools_map[function_name](**function_args)
 
        	# Add the assistant's tool call message and the tool result to the message history
            messages.append(response.choices[0].message)
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(function_result)
        	})
 
        	# 7. Second API call with parse() to get structured output
            final_response = client.beta.chat.completions.parse(
                model="grok-3",
                messages=messages,
                response_format=DecisionPlan
        	)
 
        	plan = final_response.choices[0].message.parsed
 
        	# 8. Use the output
            final_action = plan.steps[-1].action
 
            print(f"\nSummary:")
            print(f"Situation: {plan.situation}")
            print(f"Recommended Action: {final_action}")
 
else:
    print("No tool call was requested.")

Exemple d'exécution

Pour essayer l'application, nous nous rendons dans le répertoire de notre projet, nous chargeons notre environnement et nous exécutons le script :

cd <your/working/directory>
conda activate grok3
python app.py

Si nous demandons des conseils pour Helsinki, notre application Grok nous répond :

C'est une bonne suggestion, je le sais par expérience !

Conclusion

Nous avons abordé de nombreux sujets - concluons. Nous avons exploré comment travailler avec l'API Grok 3 pour exécuter des requêtes simples, gérer des traces de raisonnement et utiliser des fonctionnalités avancées telles que l'appel de fonction et les sorties structurées.

Nous avons combiné ces capacités dans un petit projet qui a montré comment Grok peut utiliser des outils externes et renvoyer des réponses structurées et exploitables. En combinaison avec des API (dans notre cas, une API météorologique), il est possible de créer des applications puissantes qui utilisent pleinement les atouts de Grok 3.

Si vous êtes arrivé jusqu'ici, vous souhaitez probablement en savoir plus sur les LLM. N'hésitez pas à consulter également ces ressources :

• GPT-Image-1 API : Un guide étape par étape avec des exemples
• Comment configurer et exécuter Qwen3 localement avec Ollama
• Fine-Tuning Qwen3 : Un guide pas à pas