tests/scripts/diagnostic_qwen_test.py

"""
Test de diagnostic pour évaluer les capacités MCP de Qwen2.5 0.5B
Approche simplifiée pour éviter les problèmes de chargement
"""

import sys
import os
import json
import time

# Ajouter le chemin pour les imports
sys.path.append(os.path.dirname(os.path.abspath(__file__)))

def test_model_loading():
    """Test simple de chargement du modèle"""
    
    print("🔍 TEST DE CHARGEMENT DU MODÈLE")
    print("=" * 50)
    
    # Vérifier que le modèle existe
    model_path = "qwen2.5-0.5b-instruct-q4_0.gguf"
    if not os.path.exists(model_path):
        print("❌ Modèle non trouvé")
        return False
    
    print(f"✅ Modèle trouvé: {model_path}")
    print(f"📏 Taille: {os.path.getsize(model_path) / (1024*1024):.1f} MB")
    
    # Essayer d'importer et d'initialiser
    try:
        from ai_analysis import AIAnalyzer
        print("✅ Module AIAnalyzer importé")
        
        analyzer = AIAnalyzer(model_path)
        print("✅ AIAnalyzer initialisé")
        
        if analyzer.model_available:
            print("✅ Modèle disponible selon AIAnalyzer")
            return True
        else:
            print("❌ Modèle non disponible selon AIAnalyzer")
            return False
            
    except Exception as e:
        print(f"❌ Erreur lors de l'initialisation: {e}")
        return False

def test_simple_inference():
    """Test d'inférence simple avec le modèle"""
    
    print("\n🧪 TEST D'INFÉRENCE SIMPLE")
    print("=" * 50)
    
    try:
        # Importer directement llama-cpp-python
        from llama_cpp import Llama
        
        model_path = "qwen2.5-0.5b-instruct-q4_0.gguf"
        
        print("🔄 Chargement du modèle avec Llama...")
        
        # Essayer différentes configurations
        for n_threads in [1, 2, 4]:
            try:
                llm = Llama(
                    model_path=model_path,
                    n_ctx=2048,
                    n_threads=n_threads,
                    verbose=False
                )
                
                print(f"✅ Modèle chargé avec {n_threads} threads")
                
                # Test simple
                prompt = "Réponds simplement avec 'TEST_RÉUSSI'"
                
                start_time = time.time()
                response = llm(
                    prompt,
                    max_tokens=10,
                    temperature=0.1
                )
                response_time = time.time() - start_time
                
                text = response['choices'][0]['text'].strip()
                
                print(f"⏱️  Temps de réponse: {response_time:.2f}s")
                print(f"📝 Réponse: {text}")
                
                if "TEST_RÉUSSI" in text:
                    print("✅ Test d'inférence réussi")
                    return True
                else:
                    print("⚠️  Réponse inattendue")
                    
            except Exception as e:
                print(f"❌ Erreur avec {n_threads} threads: {e}")
                continue
        
        return False
        
    except Exception as e:
        print(f"❌ Erreur lors de l'import de llama_cpp: {e}")
        return False

def test_mcp_capability_simulation():
    """Test simulé des capacités MCP (sans vrai modèle)"""
    
    print("\n🧠 TEST SIMULÉ DES CAPACITÉS MCP")
    print("=" * 50)
    
    # Basé sur la documentation et les spécifications de Qwen2.5 0.5B
    # Évaluation théorique des capacités
    
    capabilities = {
        "compréhension_instructions_simples": {
            "score": 8,
            "description": "Bon pour les commandes simples comme 'montre l'état du jeu'",
            "exemple": "User: 'get game state' → AI: {'tool': 'get_game_state'}"
        },
        "extraction_paramètres_basiques": {
            "score": 6,
            "description": "Capable d'extraire des paramètres simples comme des coordonnées",
            "exemple": "User: 'move to 100,200' → AI: {'tool': 'move_units', 'args': {'target_x': 100, 'target_y': 200}}"
        },
        "planification_multi_étapes": {
            "score": 4,
            "description": "Limité pour les stratégies complexes nécessitant plusieurs étapes",
            "exemple": "User: 'build base and defend' → Peut avoir du mal à décomposer"
        },
        "gestion_ambiguïté": {
            "score": 5,
            "description": "Capacité modérée à gérer les instructions ambiguës",
            "exemple": "User: 'move to enemy base' → Peut demander des coordonnées"
        },
        "compréhension_contexte_jeu": {
            "score": 7,
            "description": "Bon pour comprendre le contexte RTS de base",
            "exemple": "Comprend les concepts comme 'unités', 'bâtiments', 'ressources'"
        }
    }
    
    total_score = sum(cap["score"] for cap in capabilities.values())
    avg_score = total_score / len(capabilities)
    
    print("📊 ÉVALUATION THÉORIQUE BASÉE SUR LES SPÉCIFICATIONS:")
    
    for name, cap in capabilities.items():
        print(f"\n🔹 {name.replace('_', ' ').title()}:")
        print(f"   Score: {cap['score']}/10")
        print(f"   {cap['description']}")
        print(f"   Exemple: {cap['exemple']}")
    
    print(f"\n🎯 SCORE MOYEN THÉORIQUE: {avg_score:.1f}/10")
    
    return avg_score

def generate_assessment():
    """Générer une évaluation complète"""
    
    print("🔍 ÉVALUATION DES CAPACITÉS MCP DE QWEN2.5 0.5B")
    print("=" * 70)
    
    # Test de chargement
    model_loaded = test_model_loading()
    
    # Test d'inférence
    if model_loaded:
        inference_working = test_simple_inference()
    else:
        inference_working = False
    
    # Évaluation théorique
    theoretical_score = test_mcp_capability_simulation()
    
    # Rapport final
    print("\n" + "="*70)
    print("📊 RAPPORT FINAL D'ÉVALUATION")
    print("="*70)
    
    print(f"\n🔧 ÉTAT TECHNIQUE:")
    print(f"   Modèle chargé: {'✅' if model_loaded else '❌'}")
    print(f"   Inférence fonctionnelle: {'✅' if inference_working else '❌'}")
    
    print(f"\n🧠 CAPACITÉS MCP ESTIMÉES:")
    print(f"   Score théorique: {theoretical_score:.1f}/10")
    
    if theoretical_score >= 7:
        print("💪 TRÈS CAPABLE - Bon pour la plupart des tâches MCP")
    elif theoretical_score >= 5:
        print("👍 CAPABLE - Adapté pour les commandes simples à modérées")
    else:
        print("⚠️  LIMITÉ - Recommandé uniquement pour les tâches très simples")
    
    print(f"\n💡 RECOMMANDATIONS PRATIQUES:")
    
    if not model_loaded or not inference_working:
        print("1. 🔧 Résoudre d'abord les problèmes techniques de chargement")
        print("2. 📦 Vérifier l'installation de llama-cpp-python")
        print("3. 🔄 Tester avec différentes configurations")
    
    print("4. 🎯 Commencer par des commandes MCP très simples")
    print("5. 🔍 Tester progressivement la complexité")
    print("6. ✅ Ajouter une validation robuste")
    print("7. 🔄 Utiliser des prompts structurés")
    
    print(f"\n📈 STRATÉGIE D'IMPLÉMENTATION:")
    
    if theoretical_score >= 6:
        print("• Implémenter la traduction MCP avec confiance")
        print("• Commencer par: get_game_state, move_units simples")
        print("• Ajouter progressivement: paramètres complexes, séquences")
    else:
        print("• Utiliser des règles fixes pour les commandes simples")
        print("• Réserver Qwen2.5 pour l'analyse plutôt que la traduction")
        print("• Envisager un modèle plus grand pour les tâches complexes")
    
    # Résumé technique
    print(f"\n🔬 INFORMATIONS TECHNIQUES:")
    print("• Modèle: Qwen2.5-0.5B (0.5 milliard de paramètres)")
    print("• Type: Instruct (optimisé pour suivre des instructions)")
    print("• Format: GGUF (quantisé 4-bit)")
    print("• Taille: ~409 MB")
    print("• Capacité: Bon pour les tâches simples, limité pour les complexes")

if __name__ == "__main__":
    generate_assessment()