Grok / xAI pour le code : API, Build et lab (2026)

À la fin de ce tutoriel, vous saurez ce qu’est xAI et la famille Grok côté code, comment obtenir une clé API, appeler grok-4.6 ou grok-build-0.1, installer l’agent Grok Build en terminal, et quand préférer Grok face à Claude Code, Codex ou Cursor — avec un lab DevOps concret (script / YAML) et les garde-fous sécurité.

Niveau : Intermédiaire · Temps estimé : 35–45 min · Versions testées : API xAI (https://api.x.ai/v1), modèles grok-4.6 et grok-build-0.1 (beta publique) · Dernière vérification : 2026-09-11

Prérequis

• Un terminal (bash, zsh ou PowerShell) et un éditeur (VS Code, Cursor, Neovim…)
• Notions de base : variables d’environnement, JSON, Git
• Un compte console.x.ai avec crédits (ou abonnement SuperGrok / X Premium Plus pour Grok Build abonné)
• Optionnel : Python 3.10+ ou Node.js 18+ pour les SDK
• Avoir parcouru (idéalement) le hub ia-parcours-devops-2026 et le tuto Cursor de la série

Coût estimé : quelques centimes à quelques dollars selon le volume de tokens. Vérifiez toujours la page pricing / console avant un lab long. Aucune ressource cloud AWS/Azure n’est créée ici.

Ce que nous allons construire

Grok / xAI pour le code (leçon 41)
  ├── Panorama xAI · Grok · Grok Build
  ├── Modèles : grok-4.6 (frontière) vs grok-build-0.1 (rapide code)
  ├── Accès : console.x.ai · clé API · OpenAI-compatible
  ├── Lab 1 : premier appel Responses API (debug code)
  ├── Lab 2 : prompt DevOps (script bash ou YAML K8s)
  ├── Grok Build CLI (TUI + mode headless -p)
  ├── Comparaison courte vs Claude Code / Codex / Cursor
  └── Sécurité : secrets, review, prompt injection

(Schéma à remplacer par une image locale Excalidraw / draw.io, alt : « Parcours Grok xAI : API, modèles code, Grok Build CLI et intégrations IDE ».)

Étape 1 — Pourquoi Grok intéresse un DevOps en 2026

xAI publie la famille Grok et une API développeur compatible avec les écosystèmes OpenAI / Anthropic (changer base_url + clé). Pour le code, deux portes d’entrée dominent :

1. L’API (api.x.ai) — intégrable dans vos scripts, bots CI, gateways (OpenRouter, Vercel AI Gateway, Cloudflare).
2. Grok Build — agent de coding en terminal (TUI fullscreen), aussi utilisable en headless (grok -p "…") pour automatiser.

En pratique DevOps, Grok sert à : expliquer un runbook, proposer un patch Dockerfile, relire un manifeste Kubernetes, générer un snip terraform fmt-friendly, ou orchestrer des outils via function calling / MCP dans Grok Build.

Étape 2 — Les modèles utiles pour le code

Modèle	Rôle	Points clés (doc xAI, 2026)
grok-4.6	Frontière : coding, agentic, knowledge work	Fenêtre ~500k tokens · reasoning (low→xhigh) · tools (function calling, web search, X search, code execution) · input ~2 $/1M · output ~6 $/1M (<200k prompt ; tarifs plus élevés au-delà)
grok-build-0.1	Coding agentique rapide (beta publique)	Optimisé web/debug/MCP · ~100+ tokens/s · ~1 $/1M in · ~2 $/1M out · même famille que l’agent Grok Build

Knowledge cutoff annoncé pour grok-4.6 : février 2026 (vérifier la fiche modèle). Les prix et quotas évoluent : la source de vérité reste la console et docs.x.ai.

Choix simple :

• Besoin de qualité / raisonnement / gros contexte → grok-4.6
• Besoin de vitesse / itérations agent (boucles outils) → grok-build-0.1 dans un harness (Grok Build, Cursor, etc.)

Étape 3 — Obtenir une clé et pointer l’API

1. Créez un compte sur console.x.ai et chargez des crédits.
2. Générez une clé API (page API Keys).
3. Exportez-la (jamais dans Git) :

export XAI_API_KEY="xai-..."
# ou fichier .env local (gitignore)

Base URL officielle :

https://api.x.ai/v1

L’API propose notamment Responses et Chat Completions. Les SDK openai (Python/Node), xai-sdk, et Vercel AI SDK (@ai-sdk/xai) fonctionnent en changeant l’endpoint.

Étape 4 — Lab 1 : premier appel (debug d’une fonction)

Sans installer grand-chose, testez avec curl :

curl https://api.x.ai/v1/responses 
  -H "Authorization: Bearer $XAI_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{
    "model": "grok-4.6",
    "input": "Find and fix the bug, then explain it: function median(a){a.sort();return a[a.length/2]}"
  }'

Équivalent Python (SDK OpenAI compatible) :

import os
from openai import OpenAI

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

response = client.responses.create(
    model="grok-4.6",
    input=(
        "Find and fix the bug, then explain it: "
        "function median(a){a.sort();return a[a.length/2]}"
    ),
)
print(response.output_text)

Vous devez obtenir une correction (tri destructif, index médian pair/impair) et une explication claire. Si 401 : clé / export. Si 429 : rate limit — ralentissez.

Astuce perf : pour les conversations longues, la doc recommande un prompt_cache_key (Responses) pour stabiliser le cache et éviter de repayer le prompt froid.

Étape 5 — Lab 2 : prompt DevOps (script de santé CI)

Scénario : vous voulez un script bash qui vérifie kubectl / docker et échoue proprement en CI.

curl https://api.x.ai/v1/responses 
  -H "Authorization: Bearer $XAI_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{
    "model": "grok-build-0.1",
    "input": "Écris un script bash set -euo pipefail nommé check-tools.sh qui vérifie la présence de kubectl, docker et jq ; affiche version si OK ; exit 1 avec message clair si manquant. Pas de secrets. Commentaires FR courts."
  }'

Ensuite :

1. Copiez le script dans un fichier local.
2. Relisez-le (pas de curl | bash aveugle sur du code généré).
3. chmod +x check-tools.sh && ./check-tools.sh
4. Committez seulement après review humaine.

Variante YAML : demandez un Deployment Kubernetes minimal (1 replica, probes, non-root) et validez avec kubectl apply --dry-run=client -f … si un cluster/kubeconfig de lab est dispo.

Étape 6 — Grok Build : agent coding dans le terminal

Grok Build est l’agent xAI : TUI interactive, édition de fichiers, commandes shell, MCP, skills, mode plan, sous-agents, et mode headless pour scripts.

Installation (macOS / Linux / Git Bash) — commande officielle documentée :

curl -fsSL https://x.ai/cli/install.sh | bash

Windows PowerShell :

irm https://x.ai/cli/install.ps1 | iex

Puis :

cd votre-repo
grok

• Première fois : auth navigateur, ou export XAI_API_KEY=... en headless / CI.
• Accès abonné : early beta pour SuperGrok et X Premium Plus (selon annonces xAI) ; l’API reste utilisable avec crédits console.
• Headless :

grok -p "Explique l architecture de ce dépôt en 10 puces"
grok -p "Propose un patch pour le Dockerfile" --output-format streaming-json

Conventions repo : AGENTS.md, hooks, plugins, MCP (y compris fichiers style .mcp.json) sont repris pour coller à vos règles d’équipe. Dans Cursor et d’autres harness, grok-4.6 / grok-build-0.1 sont aussi branchables via gateways — vérifiez le sélecteur de modèles de votre IDE.

Étape 7 — Comparaison courte (équitable)

Outil	Force typique	Limite typique
Grok / Grok Build	API OpenAI-compatible, agent TUI + headless, modèles code dédiés, tools serveur (search, code exec)	Écosystème encore jeune vs Claude/GPT ; betas et quotas à surveiller
Claude Code	Très fort sur gros refactors / CLAUDE.md	Abonnement / API Anthropic séparés
OpenAI Codex	Intégration GitHub / IDE OpenAI	Moins « terminal agent » natif selon le produit
Cursor	IDE agentique bout-en-bout ; peut héberger Grok comme modèle	Licence IDE + coût modèles

Aucun outil n’est « le seul bon ». En stack DevOps 2026, beaucoup d’équipes composent : Cursor ou Claude Code au quotidien, Grok via API pour un bot interne, OpenRouter pour basculer de modèle sans réécrire le client.

Étape 8 — Sécurité et hygiène

• Jamais de secrets (tokens cloud, kubeconfig prod, .env) dans le prompt ou collés dans un chat public.
• Traitez le code généré comme une PR junior : tests, lint, dry-run, revue.
• Méfiez-vous du prompt injection si vous branchez web search / docs non fiables dans un agent.
• Clés API : scope minimal, rotation, stockage vault/CI secrets — pas dans l’historique shell commitable.
• En CI headless (grok -p), isolez le workspace et évitez les permissions write sur la prod.

Vérification

1. echo $XAI_API_KEY affiche une valeur (sans la coller dans un ticket).
2. L’appel curl Responses sur grok-4.6 renvoie du texte utile (pas 401/403).
3. Vous savez choisir grok-4.6 vs grok-build-0.1.
4. (Optionnel) grok --version / session TUI démarre, ou headless -p répond.
5. Vous avez relus et exécuté localement le script lab sans coller de secret.

Nettoyage

• Révoquez les clés de test inutiles dans la console.
• Supprimez les fichiers lab locaux non commités (check-tools.sh jetable).
• Aucune infra cloud à détruire pour ce tuto.

Erreurs fréquentes

Symptôme	Cause	Correction
401 Unauthorized	Clé absente / mal exportée	export XAI_API_KEY=… ; régénérer la clé
Réponses « génériques » hors date	Mauvais modèle ou prompt vague	Nommer grok-4.6 / grok-build-0.1 + contexte repo
Facture surprise	Gros contexte / boucles agent	Surveiller usage console ; prompt_cache_key ; plafonds budget
grok introuvable	PATH / install incomplète	Relancer le script d’install ; rouvrir le terminal
Code cassé en CI	Review zéro	Dry-run, tests, revue humaine avant merge

Quiz (3 questions)

1. Quelle base URL utiliser avec le SDK OpenAI pour Grok ?
– A. https://api.openai.com/v1
– B. https://api.x.ai/v1
– C. https://grok.com/api/v2

2. Quel modèle privilégier pour un agent coding rapide en beta xAI (2026) ?
– A. grok-imagine-image-2.0
– B. grok-build-0.1
– C. Un modèle local Ollama sans API

3. Quelle pratique est correcte avant d’exécuter un script généré par Grok ?
– A. Le coller directement en prod avec des secrets
– B. Le relire, le tester en local / dry-run, puis seulement committer
– C. Désactiver tous les logs pour aller plus vite

Réponses : 1‑B · 2‑B · 3‑B

Compléments opérationnels

Documentez Grok/xAI dans votre stack avec un brief gold (debug fonction + script santé CI). Mesurez qualité vs Claude Code et Codex sur le même dépôt lab. Budgétez tokens, refusez always-allow, versionnez les NOTES. Le hub /ia/ et le parcours restent la boussole : tronc commun prompts/sécu avant d’ajouter un vendor. Industrialisez les prompts gagnants via ai-skills-concept.

Pour les appels API, journalisez request ids sans coller de secrets. Si vous utilisez un agent terminal xAI (« Grok Build » selon offres), appliquez la même discipline Git que pour Aider/Claude Code : plan, diff, tests, commit humain. Mettez à jour stack-ia-perso-devops-2026 après une semaine d’essais honnêtes.

FAQ

Grok remplace-t-il Claude Code ou Codex ?
Non. C’est une option modèle/API et un agent xAI éventuel — comparez sur vos labs. Voir claude-vs-gpt-code et codex-vs-claude-code.

Où placer Grok dans la stack ?
Backup ou expérimentation dans stack-ia-perso-devops-2026, après le tronc commun du parcours.

Comment éviter les fuites de secrets ?
Clés en env, jamais dans Git ni prompts. Même hygiène que claude-api-premiers-appels.

Lien prompt injection ?
ai-prompt-injection-securite.

Hub IA ?
/ia/.

OpenRouter pour Grok ?
Parfois disponible via agrégateurs — openrouter-multi-modeles ; vérifier IDs vendor.

Pour aller plus loin

• Doc officielle : Quickstart, Grok 4.6, Tools, Grok Build
• Annonce : Grok Build 0.1 on API
• Console : console.x.ai
• Sur ce site : enchaînez Ollama (LLM locaux), puis OpenRouter (multi-modèles)

Maillage série IA (Outils 2026)

← Précédent	Gemini CLI & Deep Research — gemini-cli-deep-research
→ Suivant	Ollama : LLM locaux — ollama-llm-locaux
Aussi	Cursor Agent / Composer 2026 · Continue.dev · Aider · OpenRouter multi-modèles · MCP servers DevOps
Carte	Hub IA · Claude ×9 · Codex ×6 · ChatGPT ×12 · Skills/agents ×8 · IDE/CLI (Cursor…Grok…Perplexity) · Patterns & sécurité ×5