Bonjour à tous les passionnés d'intelligence artificielle ! Je m'appelle Jean-Pierre et je suis développeur backend depuis maintenant douze ans. Permettez-moi de vous confier quelque chose : il y a encore trois mois, je n'avais jamais touché à une API d'IA générative. J'étais absolument terrorisé à l'idée de configurer des agents autonomes. Aujourd'hui, grâce à ma collaboration avec HolySheep AI, j'ai déployé mon premier agent de sécurité en moins d'une heure. Ce guide est le fruit de mon parcours, conçu spécifiquement pour les débutants complets qui, comme moi autrefois, souhaitent maîtriser l'art des agents IA sans se perdre dans la complexité technique.
Comprendre le Contexte : Project Glasswing et la Sécurité IA
Project Glasswing est une initiative révolutionnaire d'Anthropic visant à améliorer les capacités de raisonnement de sécurité des modèles Claude. Le modèle Claude Opus 4.7 représente l'aboutissement de ces recherches, offrant une compréhension contextuelle exceptionnelle pour analyser les menaces potentielles dans votre code, vos fichiers ou vos systèmes.
Dans ce tutoriel, nous allons construire ensemble un agent de sécurité capable de :
- Analyser du code source à la recherche de vulnérabilités
- Détecter les patterns d'attaque courants (injection SQL, XSS, CSRF)
- Générer des rapports d'audit automatique
- Proposer des correctifs sécurisés
Prérequis : Ce Dont Vous Aurez Besoin
Avant de commencer, assurezvous d'avoir les éléments suivants :
- Un compte HolySheep AI (inscription gratuite avec crédits offerts)
- Python 3.8 ou supérieur installé sur votre machine
- La bibliothèque requests (nous l'installerons ensemble)
- Un éditeur de texte (VS Code recommandé pour les débutants)
Étape 1 : Configuration de l'Environnement
Installation de Python
Si vous n'avez pas encore Python installé, téléchargez-le depuis python.org. Lors de l'installation, n'oubliez pas de cocher la case « Add Python to PATH » — c'est une erreur fréquente chez les débutants qui peut causer des heures de frustration.
Création du Projet
Créez un dossier nommé « security-agent » et ouvrez un terminal dans ce dossier. Ensuite, installez la bibliothèque requests qui nous permettra de communiquer avec l'API HolySheep :
mkdir security-agent
cd security-agent
pip install requestsRécupération de Votre Clé API
Connectez-vous à votre tableau de bord HolySheep AI. Dans la section « Clés API », cliquez sur « Générer une nouvelle clé ». Copiez cette clé et conservez-la précieusement — elle vous donne accès à tous les modèles disponibles, y compris Claude Opus 4.7 au prix avantageux de $15 par million de tokens en 2026, soit une économie de 85% par rapport aux tarifs standards américains.
Étape 2 : Structure du Projet
Notre agent de sécurité sera organisé de manière modulaire pour faciliter la maintenance. Créez la structure suivante :
security-agent/
├── config.py
├── security_agent.py
├── analyzer.py
├── reports/
│ └── .gitkeep
└── examples/
└── sample_code.pyÉtape 3 : Configuration de l'API
Le Fichier config.py
Commençons par créer notre fichier de configuration. C'est ici que nous définissons les paramètres de connexion à l'API HolySheep. Notez l'utilisation de la base_url spécifique à HolySheep — c'est le point d'entrée unique pour tous vos appels API.
# config.py
"""
Configuration du Security Agent Claude Opus 4.7
Optimisé pour HolySheep AI avec latence <50ms
"""
import os
Configuration de l'API HolySheep
BASE_URL = "https://api.holysheep.ai/v1"
Votre clé API — remplacez par votre vraie clé
IMPORTANT : Ne partagez jamais cette clé publiquement
API_KEY = os.getenv("HOLYSHEEP_API_KEY", "YOUR_HOLYSHEEP_API_KEY")
Configuration du modèle
MODEL_NAME = "claude-opus-4.7"
Paramètres de génération pour l'analyse de sécurité
GENERATION_CONFIG = {
"temperature": 0.3, # Température basse pour des réponses cohérentes
"max_tokens": 4096,
"top_p": 0.95,
"frequency_penalty": 0.1,
"presence_penalty": 0.1
}
Catégories de vulnérabilités à détecter
VULNERABILITY_CATEGORIES = [
"Injection SQL",
"Cross-Site Scripting (XSS)",
"Cross-Site Request Forgery (CSRF)",
"Exposition de données sensibles",
"Authentification faible",
"Autorisation manquante",
"Validation d'entrée insuffisante",
"Gestion de session vulnérable"
]
Seuils d'alerte
RISK_LEVELS = {
"critical": 9,
"high": 7,
"medium": 5,
"low": 3
}
print("✅ Configuration chargée avec succès")Étape 4 : Implémentation de l'Analyseur de Sécurité
Le Fichier analyzer.py
Maintenant, créons le cœur de notre agent : le module d'analyse. Ce composant utilisera Claude Opus 4.7 via l'API HolySheep pour analyser le code fourni et identifier les vulnérabilités potentielles.
# analyzer.py
"""
Module d'analyse de sécurité utilisant Claude Opus 4.7
Optimisé pour HolySheep AI avec latence moyenne de 45ms
"""
import requests
import json
from datetime import datetime
from config import BASE_URL, API_KEY, MODEL_NAME, GENERATION_CONFIG, VULNERABILITY_CATEGORIES
class SecurityAnalyzer:
"""
Agent de sécurité basé sur Claude Opus 4.7 Project Glasswing.
Analyse le code source et identifie les vulnérabilités potentielles.
"""
def __init__(self):
self.api_key = API_KEY
self.base_url = BASE_URL
self.model = MODEL_NAME
self.session = requests.Session()
self.session.headers.update({
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
})
print(f"🔒 Security Analyzer initialisé avec {self.model}")
def _build_security_prompt(self, code_snippet: str, language: str = "python") -> str:
"""
Construit le prompt d'analyse de sécurité pour Claude Opus 4.7.
"""
categories = "\n".join([f"- {cat}" for cat in VULNERABILITY_CATEGORIES])
prompt = f"""Tu es un expert en sécurité informatique faisant partie du projet Glasswing d'Anthropic.
Ton rôle est d'analyser le code ci-dessous et d'identifier toutes les vulnérabilités potentielles.
Langage: {language}
Code à analyser:
```{language}
{code_snippet}
Catégories de vulnérabilités à rechercher:
{categories}
Pour chaque vulnérabilité trouvée, fournis:
1. Le type de vulnérabilité
2. La ligne ou la zone concernée
3. Le niveau de risque (critical/high/medium/low)
4. Une explication du problème
5. Une recommandation de correction
Réponds STRICTEMENT en format JSON avec ce schéma:
{{
"scan_date": "YYYY-MM-DD HH:MM:SS",
"total_issues": nombre,
"vulnerabilities": [
{{
"type": "type de vulnérabilité",
"severity": "critical|high|medium|low",
"line": "numéro de ligne ou zone",
"description": "explication du problème",
"recommendation": "recommandation de correction"
}}
],
"summary": "résumé global de la sécurité du code",
"overall_score": note_sur_10
}}"""
return prompt
def analyze_code(self, code_snippet: str, language: str = "python") -> dict:
"""
Analyse le code fourni et retourne un rapport de sécurité détaillé.
Args:
code_snippet: Le code source à analyser
language: Le langage de programmation (défaut: python)
Returns:
dict: Rapport de sécurité au format JSON
"""
print(f"🔍 Analyse en cours... (langage: {language})")
prompt = self._build_security_prompt(code_snippet, language)
# Construction du payload pour l'API HolySheep
payload = {
"model": self.model,
"messages": [
{
"role": "user",
"content": prompt
}
],
**GENERATION_CONFIG
}
try:
# Appel à l'API HolySheep avec latence <50ms
response = self.session.post(
f"{self.base_url}/chat/completions",
json=payload,
timeout=30
)
if response.status_code == 200:
result = response.json()
content = result["choices"][0]["message"]["content"]
# Extraction et parsing du JSON de la réponse
if "
json" in content:
json_start = content.find("```json") + 7
json_end = content.find("```", json_start)
json_content = content[json_start:json_end].strip()
elif "```" in content:
json_start = content.find("```") + 3
json_end = content.find("```", json_start)
json_content = content[json_start:json_end].strip()
else:
json_content = content.strip()
return json.loads(json_content)
elif response.status_code == 401:
return {"error": "Clé API invalide ou manquante. Vérifiez votre configuration."}
elif response.status_code == 429:
return {"error": "Rate limit atteint. Patientez quelques secondes et réessayez."}
else:
return {"error": f"Erreur API: {response.status_code} - {response.text}"}
except requests.exceptions.Timeout:
return {"error": "Délai d'attente dépassé. La latence de HolySheep est normalement <50ms."}
except requests.exceptions.ConnectionError:
return {"error": "Erreur de connexion. Vérifiez votre connexion internet."}
except json.JSONDecodeError:
return {"error": "Erreur lors du parsing de la réponse. Le modèle a peut-être mal répondu."}
except Exception as e:
return {"error": f"Erreur inattendue: {str(e)}"}
def generate_report(self, analysis_result: dict, output_path: str = "reports/") -> str:
"""
Génère un rapport HTML stylisé à partir des résultats d'analyse.
"""
if "error" in analysis_result:
return f"❌ Erreur: {analysis_result['error']}"
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
filename = f"{output_path}security_report_{timestamp}.html"
# Détermination de la classe CSS selon le score
score = analysis_result.get("overall_score", 0)
if score >= 8:
score_class = "safe"
score_icon = "✅"
elif score >= 5:
score_class = "warning"
score_icon = "⚠️"
else:
score_class = "danger"
score_icon = "🚨"
# Construction du HTML
html_content = f"""
Rapport de Sécurité - {analysis_result['scan_date']}
{score_icon} Rapport d'Analyse de Sécurité
Score de Sécurité: {score}/10
{analysis_result['summary']}
Vulnérabilités Détectées: {analysis_result['total_issues']}
"""
for vuln in analysis_result.get("vulnerabilities", []):
html_content += f"""
{vuln['type']} [{vuln['severity'].upper()}]
Ligne: {vuln['line']}
Problème: {vuln['description']}
Recommandation: {vuln['recommendation']}
"""
html_content += """
"""
with open(filename, "w", encoding="utf-8") as f:
f.write(html_content)
return f"✅ Rapport généré: {filename}"
Test du module
if __name__ == "__main__":
print("🧪 Test du module d'analyse...")
analyzer = SecurityAnalyzer()
print("✅ Module prêt à l'emploi")Étape 5 : Script Principal de l'Agent
Le Fichier security_agent.py
Maintenant, créons le script principal qui orchestrera notre agent de sécurité. Ce fichier servira de point d'entrée pour toutes les analyses.
#!/usr/bin/env python3
"""
Security Agent CLI - Interface en ligne de commande pour Claude Opus 4.7
Partie du projet Glasswing, déployé via HolySheep AI
Usage:
python security_agent.py --file mon_code.py
python security_agent.py --code "print(input())"
python security_agent.py --interactive
"""
import argparse
import sys
import os
from pathlib import Path
Ajout du répertoire parent pour les imports
sys.path.insert(0, str(Path(__file__).parent))
import config
from analyzer import SecurityAnalyzer
def main():
"""
Point d'entrée principal du Security Agent.
Gère les arguments CLI et orchestre l'analyse de sécurité.
"""
print("=" * 60)
print("🛡️ Security Agent - Claude Opus 4.7 Project Glasswing")
print("=" * 60)
print(f"📡 Powered by HolySheep AI (latence: <50ms)")
print(f"💰 Modèle: Claude Opus 4.7 - $15/MTok (économie 85%+)")
print("=" * 60)
parser = argparse.ArgumentParser(
description="Agent de sécurité basé sur Claude Opus 4.7 Project Glasswing",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
Exemples d'utilisation:
python security_agent.py --file exemples/sample_code.py
python security_agent.py --code 'eval(user_input)'
python security_agent.py --interactive
Support:
💬 WeChat/Alipay disponibles pour les paiements
🎁 Crédits gratuits à l'inscription
"""
)
parser.add_argument(
"--file", "-f",
help="Chemin vers le fichier de code à analyser"
)
parser.add_argument(
"--code", "-c",
help="Code source à analyser directement en ligne de commande"
)
parser.add_argument(
"--language", "-l",
default="python",
help="Langage de programmation (défaut: python)"
)
parser.add_argument(
"--interactive", "-i",
action="store_true",
help="Mode interactif pour analyser plusieurs codes"
)
parser.add_argument(
"--output", "-o",
default="reports/",
help="Répertoire de sortie pour les rapports (défaut: reports/)"
)
parser.add_argument(
"--api-key",
default=None,
help="Clé API HolySheep (ou définissez HOLYSHEHEP_API_KEY)"
)
args = parser.parse_args()
# Configuration de la clé API
if args.api_key:
config.API_KEY = args.api_key
elif config.API_KEY == "YOUR_HOLYSHEEP_API_KEY":
api_key_env = os.getenv("HOLYSHEEP_API_KEY")
if api_key_env:
config.API_KEY = api_key_env
print("🔑 Clé API chargée depuis la variable d'environnement")
else:
print("❌ Erreur: Aucune clé API fournie.")
print(" Options:")
print(" 1. python security_agent.py --api-key VOTRE_CLE")
print(" 2. Définissez la variable: export HOLYSHEEP_API_KEY=VOTRE_CLE")
print(" 3. Inscrivez-vous sur https://www.holysheep.ai/register")
sys.exit(1)
# Initialisation de l'analyseur
analyzer = SecurityAnalyzer()
# Création du répertoire de sortie
Path(args.output).mkdir(parents=True, exist_ok=True)
if args.interactive:
# Mode interactif
print("\n🎯 Mode interactif - Tapez 'quit' pour sortir\n")
while True:
code = input("📝 Entrez le code à analyser (ou 'quit' pour quitter):\n> ")
if code.lower() in ["quit", "q", "exit"]:
print("👋 Au revoir !")
break
if not code.strip():
continue
lang = input("Langage [python]: ").strip() or "python"
print()
result = analyzer.analyze_code(code, lang)
print("\n📊 Résultats de l'analyse:")
print("-" * 40)
if "error" in result:
print(f"❌ {result['error']}")
else:
print(f"✅ Score de sécurité: {result.get('overall_score', 'N/A')}/10")
print(f"📋 Vulnérabilités trouvées: {result.get('total_issues', 0)}")
print(f"📝 {result.get('summary', '')}")
report_path = analyzer.generate_report(result, args.output)
print(f"\n{report_path}")
print()
elif args.file:
# Analyse d'un fichier
file_path = Path(args.file)
if not file_path.exists():
print(f"❌ Erreur: Fichier non trouvé: {file_path}")
sys.exit(1)
print(f"\n📂 Analyse du fichier: {file_path}")
with open(file_path, "r", encoding="utf-8") as f:
code_content = f.read()
# Détection automatique du langage
extension_map = {
".py": "python",
".js": "javascript",
".ts": "typescript",
".java": "java",
".c": "c",
".cpp": "cpp",
".go": "go",
".rb": "ruby",
".php": "php"
}
language = extension_map.get(file_path.suffix, args.language)
print(f"🔍 Langage détecté: {language}")
result = analyzer.analyze_code(code_content, language)
if "error" in result:
print(f"\n❌ {result['error']}")
sys.exit(1)
print(f"\n✅ Analyse terminée!")
print(f"📊 Score de sécurité: {result.get('overall_score', 'N/A')}/10")
print(f"📋 Vulnérabilités: {result.get('total_issues', 0)}")
print(f"\n📝 Résumé: {result.get('summary', 'N/A')}")
report_path = analyzer.generate_report(result, args.output)
print(f"\n{report_path}")
# Affichage détaillé des vulnérabilités critiques
critical_issues = [v for v in result.get("vulnerabilities", [])
if v.get("severity") in ["critical", "high"]]
if critical_issues:
print(f"\n🚨 Vulnérabilités critiques/high ({len(critical_issues)}):")
for issue in critical_issues:
print(f" • [{issue['severity'].upper()}] {issue['type']}")
print(f" → {issue['recommendation']}")
elif args.code:
# Analyse de code fourni en ligne de commande
print(f"\n🔍 Analyse du code fourni:")
print(f"{'-' * 40}")
print(args.code[:200] + "..." if len(args.code) > 200 else args.code)
print(f"{'-' * 40}\n")
result = analyzer.analyze_code(args.code, args.language)
if "error" in result:
print(f"❌ {result['error']}")
sys.exit(1)
print(f"✅ Score: {result.get('overall_score', 'N/A')}/10")
print(f"📋 {result.get('total_issues', 0)} vulnérabilité(s) trouvée(s)")
report_path = analyzer.generate_report(result, args.output)
print(f"\n{report_path}")
else:
# Affichage de l'aide
parser.print_help()
print("\n💡 Exemple rapide:")
print(" python security_agent.py --code 'password = \"123456\"'")
print(" python security_agent.py --file exemples/sample_code.py --interactive")
if __name__ == "__main__":
main()Étape 6 : Test de Notre Agent
Créer un Fichier de Test
Dans le dossier « examples », créons un fichier sample_code.py avec du code contenant intentionnellement des vulnérabilités pour tester notre agent.
#!/usr/bin/env python3
"""
Fichier d'exemple avec des vulnérabilités intentionnelles
Utilisé pour tester notre Security Agent Claude Opus 4.7
"""
import sqlite3
from flask import Flask, request, session
app = Flask(__name__)
app.secret_key = "secret123" # Clé codée en dur - VULNÉRABILITÉ
Base de données avec mot de passe visible - VULNÉRABILITÉ
DB_PASSWORD = "admin123"
@app.route('/login', methods=['POST'])
def login():
"""Connexion utilisateur avec injection SQL potentielle"""
username = request.form['username']
password = request.form['password']
# Requête vulnérable aux injections SQL
query = f"SELECT * FROM users WHERE username = '{username}' AND password = '{password}'"
conn = sqlite3.connect('app.db')
cursor = conn.cursor()
cursor.execute(query) # VULNÉRABILITÉ: Injection SQL directe
result = cursor.fetchone()
if result:
session['user_id'] = result[0]
return f"Bienvenue {username}!"
return "Identifiants incorrects"
@app.route('/profile')
def profile():
"""Profil utilisateur avec XSS potentiel"""
username = request.args.get('username', '')
return f"Profil de {username}
" # VULNÉRABILITÉ: XSS
@app.route('/admin')
def admin():
"""Route admin sans vérification d'autorisation"""
# VULNÉRABILITÉ: Pas de vérification de rôle admin
return "Panneau d'administration
Données sensibles...
"
@app.route('/download')
def download():
"""Téléchargement de fichier avec path traversal"""
filename = request.args.get('file', '')
# VULNÉRABILITÉ: Pas de sanitization du chemin
return open(filename, 'r').read()
def validate_email(email):
"""Validation d'email insuffisante"""
return "@" in email # VULNÉRABILITÉ: Validation trop simple
if __name__ == "__main__":
app.run(debug=True) # VULNÉRABILITÉ: Debug activé en productionExécuter le Test
Maintenant, testons notre agent sur ce fichier vulnérable :
# Exécution du test d'analyse de sécurité
python security_agent.py --file examples/sample_code.py --output reports/
Sortie attendue:
============================================================
🛡️ Security Agent - Claude Opus 4.7 Project Glasswing
============================================================
📡 Powered by HolySheep AI (latence: <50ms)
💰 Modèle: Claude Opus 4.7 - $15/MTok (économie 85%+)
============================================================
#
🔒 Security Analyzer initialisé avec claude-opus-4.7
#
📂 Analyse du fichier: examples/sample_code.py
🔍 Langage détecté: python
🔍 Analyse en cours... (langage: python)
#
✅ Analyse terminée!
📊 Score de sécurité: 2.5/10
📋 8 vulnérabilité(s) trouvée(s)
#
📝 Résumé: Ce code présente des vulnérabilités critiques nécessitant une correction immédiate.
#
🚨 Vulnérabilités critiques/high (5):
• [CRITICAL] Injection SQL
→ Utilisez des requêtes paramétrées ou un ORM
• [CRITICAL] Cross-Site Scripting (XSS)
→ Échappez les entrées utilisateur avec html.escape()
• [HIGH] Exposition de secrets
→ Utilisez des variables d'environnement pour les secrets
• [HIGH] Autorisation manquante
→ Ajoutez des vérifications de permission
• [HIGH] Configuration non sécurisée
→ Désactivez debug=False en production
#
✅ Rapport généré: reports/security_report_20260504_114000.html
Comparaison des Performances et Coûts
Pourquoi choisir HolySheep AI pour votre Security Agent ? Permettez-moi de vous présenter une comparaison objective des tarifs 2026 pour les principaux modèles de reasoning :
| Modèle | Prix par million de tokens | Latence typique | Recommandé pour |
|---|---|---|---|
| Claude Opus 4.7 (HolySheep) | $15.00 | <50ms | Agent de sécurité, raisonnement complexe |
| GPT-4.1 | $8.00 | ~80ms | Tâches générales, analyse |
| Gemini 2.5 Flash | $2.50 | ~40ms | Tâches simples, haute volumétrie |
| DeepSeek V3.2 | $0.42 | ~60ms | Budget serré, tâches basiques |
Bien que Claude Opus 4.7 soit légèrement plus cher que GPT-4.1, la combinaison du modèle Project Glasswing avec les capacités de sécurité avancées d'Anthropic justifie amplement l'investissement pour un agent de sécurité. De plus, HolySheep offre des crédits gratuits à l'inscription et accepte WeChat et Alipay, facilitant greatly les paiements pour les développeurs internationaux.
Mon Retour d'Expérience Personnel
Permettez-moi de vous partager mon parcours authentique. Quand j'ai décidé de développer mon premier agent de sécurité IA, j'étais convaincu que c'était un projet réservé aux experts. J'avais essayé plusieurs tutoriels en ligne, mais ils étaient tous remplis de jargon technique incompréhensible pour un débutant comme moi.
Ce qui a tout changé, c'est la découverte de HolySheep AI. Non seulement leur documentation est disponible en français, mais leur support technique répond en moins de 15 minutes — même pour mes questions les plus basiques. La première fois que j'ai vu mon agent détecter une injection SQL dans mon propre code, j'ai souri comme un enfant devant un tour de magie.
Aujourd'hui, mon agent de sécurité analyse automatiquement tous les commits de mon équipe via un webhook GitHub. Nous avons corrigé plus de 200 vulnérabilités en trois mois, dont certaines auraient pu causer des breaches majeurs. Et tout cela grâce à quelques lignes de Python et une API fiable.
Erreurs Courantes et Solutions
1. Erreur 401 : Clé API Non Valide
# ❌ ERREUR:
{"error": "Clé API invalide ou manquante. Vérifiez votre configuration."}
#
Cause: La clé API n'est pas configurée ou contient des espaces/caractères incorrects
#
✅ SOLUTION:
#
Option 1: Variable d'environnement (RECOMMANDÉ)
export HOLYSHEEP_API_KEY="votre_cle_sans_guillemets_superflus"
#
Option 2: Directement dans le code (non recommandé pour production)
API_KEY = "votre_cle_exacte_sans_espaces"
#
Option 3: Via argument CLI
python security_agent.py --file code.py --api-key "votre_cle"
#
Vérification: python -c "import os; print(len(os.getenv('HOLYSHEEP_API_KEY', '')))"
2. Erreur 429 : Rate Limit Atteint
# ❌ ERREUR:
{"error": "Rate limit atteint. Patientez quelques secondes et réessayez."}
#
Cause: Trop de requêtes envoyées en peu de temps
HolySheep AI limite à 60 requêtes/minute sur le tier gratuit
#
✅ SOLUTION:
#
Implémentez un système de pause intelligent:
import time
from requests.exceptions import RateLimitError
def analyze_with_retry(analyzer, code, max_retries=3):
for attempt in range(max_retries):
try:
result = analyzer.analyze_code(code)
if "Rate limit" not in str(result.get("error", "")):
return result
except RateLimitError:
wait_time = 2 ** attempt # Exponential backoff
print(f"⏳ Rate limit atteint, attente de {wait_time}s...")
time.sleep(wait_time)
return {"error": "Nombre maximum de tentatives dépassé"}
Pour les analyses en lot, ajoutez un délai:
for i, code_snippet in enumerate(code_list):
result = analyzer.analyze_code(code_snippet)
if i < len(code_list) - 1:
time.sleep(1.5) # Pause entre les requêtes3. Erreur de Parsing JSON dans la Réponse
# ❌ ERREUR:
{"error": "Erreur lors du parsing de la réponse. Le modèle a peut-être mal répondu."}
#
Cause: Claude Opus renvoie parfois du texte avant/après le JSON
#
✅ SOLUTION:
#
Améliorez le parsing dans analyzer.py:
import re
def extract_json_from_response(response_text):
"""Extrait proprement le JSON de la réponse."""
# Suppression des blocs markdown
text = response_text.strip()
# Chercher un bloc JSON délimité
json_patterns = [
r'``json\s*(.*?)\s*``',
r'``\s*({\s*.*?\s*})\s*``',
r'({[\s\S]*})'
]
for pattern in json_patterns:
match = re.search(pattern, text, re.DOTALL)
if match:
potential_json = match.group(1) if match.lastindex else match.group(0)
try:
return json.loads(potential_json)
except