Affichage des articles dont le libellé est LLM. Afficher tous les articles

1/12/2026

Projet 3 agents et la circulation des infos

Projet 3 agents et la circulation des infos.

Voici une checklist opérationnelle complète et un schéma unique pour ton système multi-agents A360/PQR + T2BI + RAPPORTS + Orchestrateur + Résilience LLM, hébergé sur serveur cloud.

✅ Checklist opérationnelle par phase

🧱 Phase 0 – Cadrage & Architecture

[ ] Définir les rôles précis des 3 agents (A360, T2BI, RAPPORTS)
[ ] Définir l’agent Orchestrateur (workflow, escalade, supervision)
[ ] Établir la matrice des modèles (PHI4, Gemma, Mistral, etc.)
[ ] Formaliser les niveaux d’escalade LLM (0 à 3)
[ ] Rédiger le document d’architecture cible

☁️ Phase 1 – Socle Cloud & Standardisation

[ ] Installer Ollama sur serveur (vérif port 11434, logs, modèles)
[ ] Créer arborescence commune (agents/, config/, logs/, etc.)
[ ] Adapter les scripts PS1 pour cloud (ou transposer en .sh)
[ ] Créer script d’installation global
[ ] Vérifier compatibilité RAM/VRAM pour chaque modèle

⚙️ Phase 2 – Industrialisation des Agents

A360/PQR

[ ] Adapter le script principal pour usage CLI
[ ] Ajouter logs, codes de retour, indicateurs de confiance
[ ] Tester le dashboard HTML sur serveur

T2BI

[ ] Définir les types de synthèses métier à produire
[ ] Implémenter le parsing des rapports A360
[ ] Générer les bullet points décideurs + tags d’impact

RAPPORTS

[ ] Créer gabarits Markdown / HTML / PPT
[ ] Générer rapports quotidiens et hebdo
[ ] Ajouter résumé exécutif + niveau de confiance

🧠 Phase 3 – Orchestrateur & Résilience

[ ] Créer script d’orchestration (pipeline complet)
[ ] Implémenter règles d’escalade LLM (fichier YAML)
[ ] Créer agent Auditor (lecture des logs + recommandations)
[ ] Définir seuils de passage à l’humain
[ ] Ajouter monitoring technique (Ollama, BDD, erreurs)
[ ] Documenter la gouvernance technique (rôles, permissions, escalade)

📊 Schéma unique – Architecture des agents

┌────────────────────────────┐
│        Entrée RSS          │
│    (13 sources Andorre)    │
└────────────┬───────────────┘
             │
             ▼
┌────────────────────────────┐
│        Agent A360/PQR      │
│  - Filtrage & analyse IA   │
│  - Scoring & dashboard     │
└────────────┬───────────────┘
             │
             ▼
┌────────────────────────────┐
│         Agent T2BI         │
│  - Synthèse métier         │
│  - Tendances & risques     │
└────────────┬───────────────┘
             │
             ▼
┌────────────────────────────┐
│        Agent RAPPORTS      │
│  - Livrables stratégiques │
│  - Résumés exécutifs       │
└────────────┬───────────────┘
             │
             ▼
┌────────────────────────────┐
│     Agent Orchestrateur    │
│  - Planification & logs    │
│  - Escalade LLM            │
│  - Monitoring & audit      │
└────────────┬───────────────┘
             │
             ▼
┌────────────────────────────┐
│     Escalade LLM Niveau 2  │
│  - Modèle avancé           │
│  - Analyse critique        │
└────────────┬───────────────┘
             │
             ▼
┌────────────────────────────┐
│     Liaison Humaine        │
│  - Synthèse pour opérateur │
│  - Décision finale         │
└────────────────────────────┘

La structure du projet :

A360/PQR (Andorra 360) existe et tourne en local (Ollama + Gemma, PS1, dashboard, planif).
Tu prépares un PPT sur les 6 étapes vers des Agents IA responsables.
Tu veux passer à un serveur cloud (32 Go RAM) avec 3 agents + 1 agent d’orchestration + plan de résilience/escalade LLM.

Je te propose un plan de travail en 4 grands blocs, avec des sous-phases actionnables.

Vue synthétique du plan de travail

Phase	Objectif principal	Livrable clé	Agents concernés
0. Cadrage & socle	Clarifier rôles, modèles, ressources	Doc d’architecture cible + matrice LLM	Tous
1. Socle commun cloud	Rejouer A360 en cloud + standardiser	Repo « socle-agents-w11-cloud »	Tous
2. Industrialisation des 3 agents	Formaliser A360, définir T2BI & RAPPORTS	3 agents opérationnels + scripts	A360/PQR, T2BI, RAPPORTS
3. Orchestrateur & résilience	Agent manager + escalade LLM + monitoring	Agent Orchestrateur + docs de gouvernance	Tous

Ensuite, tu pourras brancher ton PPT et ton discours de gouvernance directement sur cette structure.

Phase 0 – Cadrage et architecture cible

Objectif : poser noir sur blanc « qui fait quoi » et comment ça s’exécute sur le serveur.

Clarifier les 3 agents fonctionnels
- A360/PQR (existant) :
  Rôle : veille Andorre, scoring, dashboard, notifications (ton README).
  Entrées : flux RSS, config YAML.
  Sorties : Markdown, JSON, dashboard HTML, logs.
- T2BI : définir clairement la mission. Par exemple :
  Rôle : transformer les articles/événements en « intelligence métier » (Tendances, BI, risques/opportunités pour Andorre, etc.).
  Entrées : JSON + Markdown produits par A360.
  Sorties : synthèses thématiques (Politique, Économie, etc.), indicateurs clés, recommandations.
- RAPPORTS : l’agent éditeur / secrétariat stratégique.
  Rôle : assembler les sorties A360 + T2BI en livrables :
  - rapports hebdo/mensuels,
  - slides pour décisionnaires,
  - fiches synthèse (1 page).
Définir l’agent Orchestrateur
- Rôle :
  - planifier les runs des 3 agents,
  - gérer les dépendances (A360 → T2BI → RAPPORTS),
  - appliquer les plans d’escalade LLM,
  - décider quand escalader vers l’humain.
- C’est l’implémentation directe de ton schéma : Agent Routeur + Agent Critique + Agent de Liaison humaine.
Matrice des LLM et SLM

Pour chaque niveau d’escalade, décider quels modèles sont utilisés :
- Niveau 0 – LLM léger / SLM :
  - PHI4 ou Gemma 2B pour les tâches simples (classement, tags, filtres).
- Niveau 1 – Spécialistes :
  - Mistral, Gemma 7B pour analyse plus fine, résumés enrichis, BI.
- Niveau 2 – Avancé / critique :
  - modèle plus puissant (ex : Gemma 9B, Mistral Medium, autre) ou éventuellement un API externe si tu le souhaites (mais tu peux rester full local).
- Niveau 3 – Humain :
  - règles explicites de passage à l’humain : incertitude forte, conflit d’infos, sujet politique sensible, etc.

Livrable Phase 0 :
Un document d’architecture (Markdown) avec :

description des 4 agents,
matrice des modèles par niveau,
schéma d’escalade inspiré de ton diagramme, adapté à ces 3 agents.

Phase 1 – Socle commun sur serveur cloud

Objectif : rejouer ton environnement A360 sur le serveur cloud, en le transformant en socle pour tous les agents.

Infrastructure de base
- OS et stack :
  - Linux (type Ubuntu Server) ou Windows Server, mais tu connais bien Windows 11 + PS1 :
    - si VPS Linux : transposer les scripts PS1 en .sh pour la prod,
    - si Windows Server : réutiliser 80% de ta banque de scripts PS1.
- Ollama serveur :
  - installation standard,
  - pull des modèles : phi4, gemma, mistral (selon la matrice de Phase 0),
  - vérification port 11434 et logs (tu as déjà les scripts Check_port & Audit).
Standardisation des dossiers & conventions

Reprendre la structure A360 et la généraliser :
- agents/
  - A360/
  - T2BI/
  - RAPPORTS/
- config/
  - global.yaml
  - agent_A360.yaml
  - agent_T2BI.yaml
  - agent_RAPPORTS.yaml
- logs/agent_A360_*.log, etc.
- data/ (BDD SQLite ou PostgreSQL si cloud)
- reports/ (Markdown/HTML/PDF communs)
Socle de scripts
- Factoriser tes scripts PS1 existants en trois grandes familles :
  - Scripts d’action : lancer un agent (run_A360, run_T2BI, run_RAPPORTS).
  - Scripts d’orchestration : pipeline complet (A360 → T2BI → RAPPORTS).
  - Scripts de contrôle :
    - check Ollama,
    - check BDD,
    - check logs & erreurs critiques.

Livrables Phase 1 :

Un repo socle-agents-cloud avec :
- arbo standard,
- script d’installation global,
- scripts de contrôle génériques,
- documentation rapide (README infra).

Phase 2 – Industrialisation des 3 agents

Objectif : transformer les 3 agents en services quasi « plug-and-play », avec une logique commune mais des rôles clairs.

2.1 A360 / PQR (existante) – passage en mode « service »

Adapter le script principal pour pouvoir :
- être appelé par commande CLI (avec paramètres) :
  python veille_andorre.py --mode daily --max-articles 20
- être lancé par l’agent Orchestrateur (plus tard).
Ajouter un mode “service” :
- logs normalisés,
- codes de retour (succès, partiel, échec critique),
- indication de la confiance moyenne des analyses (pour alimentation de l’escalade).

2.2 Agent T2BI – intelligence métier

Entrée : JSON/Markdown générés par A360.
Tâches :
- regrouper les articles par thème / paroisse / impact,
- produire des « bullet points décideur » : risques, opportunités, signaux faibles,
- éventuellement produire des synthèses par horizon temporel (jour/semaine/mois).
Modèles :
- Niveau 0 : PHI4/Gemma 2B pour pré-classification,
- Niveau 1 : Mistral/Gemma plus gros pour les synthèses BI plus fines.
Sorties :
- fichiers T2BI_YYYYMMDD.json + .md,
- tags pour prioriser ce que l’agent RAPPORTS devra mettre en avant.

2.3 Agent RAPPORTS – livrables décisionnels

Entrée : outputs A360 + T2BI.
Rôle :
- générer :
  - rapport quotidien (markdown),
  - rapport hebdo stratégique,
  - éventuellement squelette de PPT (ou HTML) pour présentation.
Fonctions clés :
- respecter gabarits / sections fixes,
- inscrire le niveau de confiance / escalade utilisé,
- produire un résumé « exécutif » très court.

Livrables Phase 2 :

3 agents exécutables en ligne de commande,
documentation minimaliste pour chacun : Entrées / Sorties / Paramètres,
jeux de tests (scénarios simples & extrêmes).

Phase 3 – Agent Orchestrateur & résilience (plans d’escalade)

Objectif : implémenter ton schéma d’escalade LLM + gestion des 3 agents comme un système cohérent avec gouvernance et résilience.

3.1 Orchestrateur des workflows

Implémentation minimale :
- un script (Python ou PS1) qui :
  1. lance A360,
  2. lit son statut + métriques,
  3. lance T2BI si OK,
  4. lance RAPPORTS ensuite,
  5. enregistre un journal complet du run (JSON + log texte).
Version agent IA :
- un « super-agent » (LLM) qui :
  - analyse les logs des 3 agents,
  - détecte les anomalies récurrentes,
  - propose des ajustements (paramètres, escalade, filtrage).

3.2 Plan de résilience et escalade LLM

Définir les critères d’escalade :
- taux d’erreurs parsing / API,
- incohérences d’analyse (LLM Critic vs Specialist),
- sujet sensible (mots-clés : sécurité, crise, institutions, etc.),
- score de confiance < seuil.
Mettre en œuvre les niveaux :
1. Niveau 0 – LLM léger (SLM) :
  - premier passage pour toutes les tâches non critiques.
2. Niveau 1 – Agent Spécialiste :
  - si doute ou complexité détectée, appel Mistral/Gemma plus gros.
3. Niveau 2 – Modèle avancé / temps de calcul supérieur :
  - réservé aux cas rares (signal fort, sujet très sensible).
4. Niveau 3 – Escalade humaine :
  - génération d’un résumé pour humain + lien vers articles sources et logs.
Gouvernance :
- un fichier gouvernance_escalade.yaml :
  - règles par type de sujet,
  - seuils de confiance,
  - personnes à notifier (mail/Telegram) en cas d’escalade humaine.

3.3 Supervision et auto-contrôle

Monitoring technique :
- script qui surveille :
  - disponibilité d’Ollama,
  - taux d’erreurs des appels modèles,
  - taille des logs / BDD.
Monitoring IA :
- agent « Auditor » qui lit régulièrement les rapports et signale :
  - dérives possibles,
  - manques de couverture,
  - besoins de reparamétrage (mots-clés, filtres).

Livrables Phase 3 :

Agent Orchestrateur opérationnel (script + éventuellement interface simple),
fichier de configuration des plans d’escalade,
documentation de gouvernance (qui peut servir directement dans ton PPT / pour le responsable)

Voici un descriptif clair, structuré et prêt à intégrer dans ton PPT, correspondant au schéma unique.

📘 Descriptif du Schéma Unique – Système Multi‑Agents A360 / T2BI / RAPPORTS + Orchestrateur + Résilience LLM.

1. Vue d’ensemble

Le système repose sur trois agents spécialisés et un agent Orchestrateur chargé de coordonner l’ensemble.
Chaque agent traite une étape précise du cycle d’analyse : collecte → intelligence → synthèse → gouvernance.
L’ensemble fonctionne sur un serveur cloud avec Ollama et des modèles locaux (PHI4, Gemma, Mistral).

2. Agent A360 / PQR – Collecte et Analyse de Presse

Rôle : point d’entrée du système.
Il surveille automatiquement les sources d’information andorranes, filtre les contenus pertinents et réalise une première analyse IA.

Fonctions principales :

Collecte de 13 flux RSS andorrans
Filtrage contextuel (100+ mots-clés)
Analyse IA locale (Gemma/PHI4)
Scoring d’importance (1 à 5)
Catégorisation thématique
Génération de rapports Markdown/JSON
Dashboard HTML interactif

Sorties : articles analysés, scores, catégories, tendances brutes.

3. Agent T2BI – Intelligence Métier et Décisionnelle

Rôle : transformer les données brutes d’A360 en intelligence exploitable pour décideurs.

Fonctions principales :

Regroupement thématique (politique, économie, société…)
Analyse d’impact (résidents, entreprises, institutions)
Détection de signaux faibles
Synthèses stratégiques
Recommandations opérationnelles
Production de bullet points décideurs

Sorties : synthèses métier, analyses consolidées, indicateurs clés.

4. Agent RAPPORTS – Production de Livrables Stratégiques

Rôle : assembler les analyses A360 + T2BI en documents lisibles, structurés et prêts à diffuser.

Fonctions principales :

Rapport quotidien
Rapport hebdomadaire/mensuel
Résumé exécutif (1 page)
Mise en forme Markdown / HTML
Préparation de slides pour présentation
Intégration des niveaux de confiance et escalades

Sorties : livrables professionnels destinés aux responsables et décideurs.

5. Agent Orchestrateur – Coordination, Workflow et Gouvernance

Rôle : piloter automatiquement les trois agents, gérer les dépendances et assurer la cohérence globale.

Fonctions principales :

Planification des exécutions (A360 → T2BI → RAPPORTS)
Vérification des statuts, logs et erreurs
Gestion des dépendances entre agents
Application des règles d’escalade LLM
Supervision technique (Ollama, BDD, ressources)
Journalisation complète des opérations
Notification en cas d’incident ou d’escalade humaine

Sorties : pipeline complet, logs consolidés, décisions d’escalade.

6. Résilience par Plans d’Escalade LLM

Rôle : garantir la fiabilité, la sûreté et la cohérence des analyses.

Niveaux d’escalade :

Niveau 0 – SLM léger (PHI4, Gemma 2B)
Tâches simples, filtrage, pré‑analyse.
Niveau 1 – Agent Spécialiste (Gemma 7B, Mistral)
Analyse approfondie, synthèses complexes.
Niveau 2 – Modèle avancé
Cas sensibles, ambiguïtés, sujets critiques.
Niveau 3 – Escalade humaine
L’agent de liaison génère une synthèse pour un opérateur humain.

Critères d’escalade :

Confiance IA insuffisante
Sujet sensible (politique, sécurité, institutions)
Conflit d’informations
Erreurs répétées ou incohérences

7. Liaison Humaine – Supervision et Décision Finale

Rôle : intervenir uniquement lorsque l’IA atteint ses limites.

Fonctions :

Lecture d’un résumé généré automatiquement
Validation ou correction
Décision finale sur les cas sensibles

8. Bénéfices pour l’organisation

Automatisation complète de la veille et des rapports
Analyse locale, souveraine et confidentielle
Gouvernance claire et traçable
Résilience grâce aux plans d’escalade
Réduction du temps de traitement
Production de livrables professionnels pour décideurs

Pour en savoir plus sur moi, mes blogs :

https://www.ugaia.eu/ https://larselesrse.blogspot.com/

https://gouver2020.blogspot.com/

https://cluboffice2010.blogspot.com

https://www.erolgiraudy.eu/

https://github.com/peg500and

Sur YouTube :

https://www.youtube.com/@EROLGIRAUDY

Mes 15 livres :

https://www.ugaia.eu/p/mes-livres.html

Dans| le Catalogue général de la BnF :

https://catalogue.bnf.fr/rechercher.do?motRecherche=Giraudy+Erol&critereRecherche=0&depart=0&facetteModifiee=ok

Users Group Artificial Intelligence Agentique (U.G.A.I.A.) mon blog : https://www.ugaia.eu

Mes réseaux sociaux : http://about.me/giraudyerol

L' AI pour la Généalogie de UGAIA

L’intelligence artificielle des service pour les généalogistes : https://uga-ia.blogspot.com/

12/13/2025

Installer MISTRAL sur UBUNTU

Comment installer MISTRAL sur UBUNTU

Mon ancien PC 8 Giga de Mem.

Voici la méthode la plus simple et fiable pour installer et utiliser les modèles Mistral sur Ubuntu, sans Ollama, uniquement avec les outils officiels : `mistral` (client CLI), `mistral-runner`, et les modèles `.gguf` compatibles.

Je dispose de deux ordinateurs l'un pour Ubuntu et l'autre pour Windows 11.

Guide complet, clair et étape-par-étape.

✅ 1. Installer Python + dépendances

Mistral fournit un client officiel en Python.

sudo apt update
sudo apt install python3 python3-pip python3-venv -y

Créer un environnement (facultatif mais recommandé) :

python3 -m venv mistral-env
source mistral-env/bin/activate

✅ 2. Installer le client officiel Mistral AI

Le paquet mistralai permet d’interroger les modèles hébergés…
Mais pour faire tourner un modèle localement, il faut mistral-runner ou lmstudio / llama.cpp.

Installe le client quand même :

pip install mistralai

✅ 3. Installer mistral-runner (LE moteur local officiel)

Mistral a publié un runtime local : mistral-runner
→ Il fonctionne nativement sur Ubuntu
→ Il charge des modèles Mistral en local
→ Aucun Ollama requis

🔧 Installation

pip install mistral-runner

Vérification :

mistral-runner --help

✅ 4. Télécharger un modèle Mistral en `.gguf`

Tu peux utiliser les modèles officiels sur HuggingFace :

📦 Exemples :

Mistral 7B Instruct
https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.2-GGUF
Mistral Nemo (2024)
https://huggingface.co/mistralai/Mistral-Nemo-Instruct-2407-GGUF

Télécharger un modèle :

mkdir models
cd models
wget https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.2-GGUF/resolve/main/mistral-7b-instruct-v0.2.Q4_K_M.gguf
cd ..

✅ 5. Lancer le modèle avec mistral-runner

mistral-runner \
  --model models/mistral-7b-instruct-v0.2.Q4_K_M.gguf \
  --port 8080

L’API locale démarre sur :
👉 http://localhost:8080/v1/chat/completions
(compatible OpenAI API)

✅ 6. Tester une requête locale

En curl :

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
        "model": "local",
        "messages": [{"role": "user", "content": "Bonjour Mistral, comment vas-tu ?"}]
      }'

Ou en Python :

from openai import OpenAI
client = OpenAI(base_url="http://localhost:8080/v1", api_key="not-needed")

resp = client.chat.completions.create(
    model="local",
    messages=[{"role": "user", "content": "Explique moi Ubuntu"}],
)

print(resp.choices[0].message.content)

🧠 7. (Optionnel) Accélération GPU

🔹 NVIDIA

Installer CUDA :

sudo apt install nvidia-cuda-toolkit

Puis lancer avec :

mistral-runner --model models/...gguf --port 8080 --device cuda

🔹 Metal / AMD → non natif sur Linux

(Ubuntu = NVIDIA + CPU seulement)

🧩 Alternatives SANS Mistral-runner

Si tu veux utiliser d’autres moteurs :

✔ Llama.cpp (stable et performant)

sudo apt install cmake build-essential
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make -j
./main -m models/mistral.gguf -p "Bonjour"

✔ LM Studio (GUI, très simple)

Télécharge AppImage pour Linux
→ https://lmstudio.ai

📌 Résumé ultra-simple

Étape	Action
1	Installer Python
2	`pip install mistral-runner`
3	Télécharger un modèle Mistral `.gguf`
4	Lancer : `mistral-runner --model monmodele.gguf --port 8080`
5	Appeler via API locale

Voici la RAM recommandée pour utiliser les modèles Mistral sur Ubuntu, selon le modèle et le niveau de quantization (`Q4`, `Q5`, etc.).
C’est valable pour mistral-runner, llama.cpp, LM Studio, etc.

Quantization RAM minimum RAM confortable
Q4_K_M 6 Go 8–12 Go
Q5_K_M 8 Go 12–16 Go
Q6_K 12 Go 16 Go+
FP16 (full) 28–32 Go 32 Go+

Quantization	RAM minimum	RAM confortable
Q4_K_M	6 Go	8–12 Go
Q5_K_M	8 Go	12–16 Go
Q6_K	12 Go	16 Go+
FP16 (full)	28–32 Go	32 Go+

Pour un usage fluide sur Ubuntu : 8 Go minimum, 16 Go idéal.

il est possible d'utiliser une GPU externe (eGPU) avec un PC sous Ubuntu, mais cela dépend fortement du matériel et des limitations Linux.

Oui — il est possible d'utiliser une GPU externe (eGPU) avec un PC sous Ubuntu, mais cela dépend fortement du matériel et des limitations Linux.

Voici un guide clair, simple et réaliste.

🎛️ 1. Qu’est-ce qu’une eGPU ?

Une eGPU = un boîtier externe dans lequel tu mets une carte graphique (NVIDIA ou AMD), connecté à ton PC via Thunderbolt 3 ou 4.

🟦 2. Est-ce que les eGPU fonctionnent sous Ubuntu ?

✔ Oui, MAIS seulement dans certains cas :

Condition	Fonctionne ?
PC avec port Thunderbolt 3 ou 4 (type USB-C TB3/TB4)	✔ Oui
GPU NVIDIA	✔ Oui (pilotes propriétaires)
GPU AMD	✔ Oui (pilotes open source Mesa)
Boîtier Thunderbolt certifié Linux	✔ En général

❌ Ne fonctionne pas ou très mal :

Sur USB-C non-Thunderbolt → impossible
Sur ordinateurs non compatibles Thunderbolt Hot-Plug
Avec certains BIOS qui bloquent l’eGPU

🟩 3. Ce que dit la pratique sous Linux

✔ L’eGPU fonctionne très bien pour :

L’IA locale (mistral-runner, llama.cpp, vLLM, etc.)
L’inférence GPU (CUDA pour NVIDIA, ROCm pour AMD)
Du calcul scientifique

❌ Fonctionne mal pour :

Les jeux (performance réduite)
Le multi-GPU hybride (optimus)

Pour ton usage (tests IA avec Mistral), c’est parfait.

🟪 4. Configurations recommandées (testées sous Ubuntu)

🔧 1. Boîtier eGPU fiable

Razer Core X
Sonnet eGPU Breakaway Box
Akitio Node

Tous compatibles TB3/TB4 et "Linux-friendly".

🎮 2. Cartes graphiques compatibles

NVIDIA RTX : 3060, 3070, 4070, 4080…
✔ CUDA : parfait pour llama.cpp / mistral-runner / TensorRT-LLM
AMD Radeon : 6600, 6700XT, 6800XT
✔ ROCm 6.x (seulement certains modèles)

🟧 5. Installation sur Ubuntu (NVIDIA)

1️⃣ Vérifie la connexion Thunderbolt

boltctl list

2️⃣ Installe les drivers :

sudo ubuntu-drivers autoinstall

3️⃣ Vérifie que la carte est détectée :

nvidia-smi

4️⃣ Utilise-la dans tes moteurs IA :

mistral-runner --model ...gguf --device cuda

🟥 6. Limitations importantes

Le débit Thunderbolt limite la bande passante → perte de 10–30% de performance GPU.
Boot parfois nécessaire avec l’eGPU déjà branché.
Certains laptops Dell/HP/Lenovo limitent l’eGPU via BIOS.

1/12/2026