Upload 251 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+tp_ia_chatbot-main/tp_ia_chatbot-main/etape_08_monitoring/image-1.png filter=lfs diff=lfs merge=lfs -text
+tp_ia_chatbot-main/tp_ia_chatbot-main/etape_08_monitoring/image.png filter=lfs diff=lfs merge=lfs -text

tp_ia_chatbot-main/tp_ia_chatbot-main/.gitignore

@@ -0,0 +1,12 @@
+venv/
+.env
+etape_05_rag/chroma_db/
+**/avis/
+**/__pycache__/
+**/*.pyc
+**/chat.db
+**/*.bin
+.claude
+.coverage
+**/chroma.sqlite3
+evaluation/

tp_ia_chatbot-main/tp_ia_chatbot-main/EVALUATION_TP.md

@@ -0,0 +1,73 @@
+# Évaluation TP — Chatbot IA : du prototype au déploiement
+
+> **Bloc CCP4 — Chef de Projet IA**
+
+Ce document est le point d'entrée des évaluations formatives du TP.
+Chaque étape a son propre fichier `EVALUATION_TP_ETAPE_XX.md` dans son dossier.
+
+**Règle d'or :** Lis le fichier d'évaluation **après** avoir exécuté l'étape, pas avant.
+Les questions de niveau 1 sont impossibles à répondre sans avoir lancé le code — c'est voulu.
+
+---
+
+## Philosophie du TP
+
+Une app IA, c'est avant tout **un logiciel à déployer, mesurer et sécuriser**.
+L'objectif n'est pas de produire du code parfait, mais de comprendre ce qui se passe,
+pourquoi ça marche (ou pas), et ce que cela implique en production.
+
+Les évaluations suivent 3 niveaux de questionnement :
+- **Niveau 1 — Observation** : tu as vu, tu peux répondre (impossible sans exécuter)
+- **Niveau 2 — Analyse** : tu comprends pourquoi le mécanisme fonctionne
+- **Niveau 3 — Décision** : tu ferais quoi en production, en tant que chef de projet ?
+
+---
+
+## Progression et fichiers d'évaluation
+
+| Étape | Thème | Niveau | Durée | Fichier |
+|-------|-------|--------|-------|---------|
+| 00 | Le Moteur — connexion LLM, variables d'env | Débutant | 30 min | [etape_00_moteur/EVALUATION_TP_ETAPE_00.md](etape_00_moteur/EVALUATION_TP_ETAPE_00.md) |
+| 01 | Le Chatbot Naïf — stateless, mémoire côté client | Débutant | 30 min | [etape_01_banane/EVALUATION_TP_ETAPE_01.md](etape_01_banane/EVALUATION_TP_ETAPE_01.md) |
+| 02 | KPIs — latence, TPS, coût, P95 | Débutant | 30 min | [etape_02_kpis/EVALUATION_TP_ETAPE_02.md](etape_02_kpis/EVALUATION_TP_ETAPE_02.md) |
+| 03 | Mémoire Tampon — fenêtre glissante, résumé | Intermédiaire | 45 min | [etape_03_memoire/EVALUATION_TP_ETAPE_03.md](etape_03_memoire/EVALUATION_TP_ETAPE_03.md) |
+| 04 | Persistance — SQLite vs JSON, sessions | Intermédiaire | 45 min | [etape_04_persistance/EVALUATION_TP_ETAPE_04.md](etape_04_persistance/EVALUATION_TP_ETAPE_04.md) |
+| 05 | RAG — ChromaDB, embeddings, hit rate | Intermédiaire | 60 min | [etape_05_rag/EVALUATION_TP_ETAPE_05.md](etape_05_rag/EVALUATION_TP_ETAPE_05.md) |
+| 06 | LangChain — abstraction, swap cloud/local | Intermédiaire | 45 min | [etape_06_langchain/EVALUATION_TP_ETAPE_06.md](etape_06_langchain/EVALUATION_TP_ETAPE_06.md) |
+| 07 | Docker & FastAPI — API REST, containerisation | Intermédiaire | 60 min | [etape_07_docker/EVALUATION_TP_ETAPE_07.md](etape_07_docker/EVALUATION_TP_ETAPE_07.md) |
+| 08 | Monitoring — Prometheus, Grafana, PromQL | Intermédiaire | 60 min | [etape_08_monitoring/EVALUATION_TP_ETAPE_08.md](etape_08_monitoring/EVALUATION_TP_ETAPE_08.md) |
+| 09 | Sécurité — JWT, rate limiting, injection prompt | Avancé | 60 min | [etape_09_securite/EVALUATION_TP_ETAPE_09.md](etape_09_securite/EVALUATION_TP_ETAPE_09.md) |
+| 10 | Test de charge — Locust, SLA, goulots | Avancé | 60 min | [etape_10_locust/EVALUATION_TP_ETAPE_10.md](etape_10_locust/EVALUATION_TP_ETAPE_10.md) |
+| 11 | Tests automatisés — pytest, mock, coverage | Avancé | 60 min | [etape_11_tests/EVALUATION_TP_ETAPE_11.md](etape_11_tests/EVALUATION_TP_ETAPE_11.md) |
+| 12 | Benchmark — LLM-as-Judge, qualité/prix | Avancé | 60 min | [etape_12_benchmark/EVALUATION_TP_ETAPE_12.md](etape_12_benchmark/EVALUATION_TP_ETAPE_12.md) |
+| 13 | Production-Ready — Dockerfile multi-stage, stack complète | Avancé | 90 min | [etape_13_deployable/EVALUATION_TP_ETAPE_13.md](etape_13_deployable/EVALUATION_TP_ETAPE_13.md) |
+| 14 | Deployed — Kubernetes, CI/CD, GitOps | Avancé | 90-120 min | [etape_14_deployed/EVALUATION_TP_ETAPE_14.md](etape_14_deployed/EVALUATION_TP_ETAPE_14.md) |
+
+---
+
+## Arc narratif du TP
+
+```
+00 → "Le LLM ne se souvient de rien — comment construire une mémoire ?"
+03 → "La mémoire a un coût — comment l'optimiser ?"
+05 → "Le LLM ne sait que ce qu'on lui donne — RAG comme mémoire externe"
+07 → "Le chatbot devient un service — comment l'exposer ?"
+08 → "On ne peut pas corriger ce qu'on ne voit pas — métriques"
+09 → "Un service exposé est une cible — sécurité en profondeur"
+10 → "Est-ce que ça tient la charge ? — test de limite"
+11 → "Est-ce qu'on peut livrer en confiance ? — tests automatisés"
+13 → "Toutes les briques ensemble — prêt pour la prod"
+14 → "La prod, c'est quoi concrètement ? — CI/CD + K8S + GitOps"
+```
+
+---
+
+## Lien avec le dossier E8
+
+Chaque fichier d'évaluation contient une section **"Lien avec le dossier E8"**.
+Ces questions sont directement réutilisables dans les parties :
+- Développement et choix d'architecture
+- Tests et validation
+- Déploiement et mise en production
+- Prévention des risques
+- Aspects réglementaires (RGPD, sécurité)

tp_ia_chatbot-main/tp_ia_chatbot-main/PRESENTATION_ETAPES.md

@@ -0,0 +1,610 @@
+# Présentation des étapes — TP Chatbot IA : du prototype au déploiement
+
+> **Usage** : Ce document est le prompt de référence pour présenter l'ensemble du projet.
+> Il donne le contexte, la progression pédagogique et les points saillants de chaque étape.
+> Les étapes 13 et 14 sont documentées en détail car elles constituent l'aboutissement technique du TP.
+
+## Contexte général
+
+Ce TP construit un chatbot d'entreprise de bout en bout — du premier appel API jusqu'au
+déploiement Kubernetes avec pipeline CI/CD. Chaque étape ajoute une brique, et chaque brique
+répond à un problème concret rencontré en production.
+
+**Stack finale :** Python · FastAPI · LangChain · ChromaDB · SQLite · Prometheus · Grafana ·
+Docker multi-stage · Nginx · JWT · pytest · Kubernetes (kind/GKE) · GitHub Actions · ArgoCD
+
+## Étapes 00 à 12 — Construction progressive
+
+### Étape 00 — Le Moteur
+**Ce qu'on fait :** Premier appel à un LLM (OpenAI ou modèle local via LM Studio).
+**Ce qu'on apprend :** Variables d'environnement, API REST d'OpenAI, concept cloud vs local.
+**Concept clé :** Le LLM est une boîte noire sans état — il ne retient rien entre les appels.
+
+### Étape 01 — Le Chatbot Naïf (La Banane)
+**Ce qu'on fait :** Un chatbot fonctionnel en ~15 lignes. On simule la mémoire en accumulant
+les messages dans une liste `msgs` envoyée à chaque appel.
+**Ce qu'on apprend :** Format `messages` (role: system/user/assistant), nature stateless du LLM,
+mémoire côté client = illusion.
+**Concept clé :** La "mémoire" n'est pas dans le modèle — elle est dans notre code. Si on
+redémarre le script, tout est perdu.
+
+### Étape 02 — Mesurer pour Comprendre (KPIs)
+**Ce qu'on fait :** Ajout de métriques en temps réel : latence, tokens/seconde, coût/requête, P95.
+**Ce qu'on apprend :** Mesurer avant d'optimiser. Différence cloud (~80 TPS) vs local (~15 TPS).
+Formule de coût : `(prompt_tokens × $0.00015 + completion_tokens × $0.00060) / 1000`.
+**Concept clé :** Sans mesure, on optimise au hasard. Le P95 capture les cas lents que la moyenne cache.
+
+### Étape 03 — La Mémoire Tampon
+**Ce qu'on fait :** Implémentation d'une fenêtre glissante (`MAX_HISTORY=8`) et d'un mode résumé
+automatique pour les longues conversations.
+**Ce qu'on apprend :** Le context window est une ressource limitée et payante. Stratégies :
+fenêtre fixe (simple) vs résumé (coûteux mais préserve l'essentiel).
+**Concept clé :** `coût ∝ nombre de tokens` — garder toute l'histoire est impraticable en prod.
+
+### Étape 04 — La Persistance
+**Ce qu'on fait :** Sauvegarde des conversations dans SQLite (et comparaison avec JSON).
+Sessions multi-utilisateurs, restauration au redémarrage.
+**Ce qu'on apprend :** SQLite vs JSON : race conditions, transactions ACID, scalabilité.
+`explorer_db.py` pour inspecter les données.
+**Concept clé :** JSON avec 1000 users simultanés = corruption garantie. SQLite gère les
+écritures concurrentes par verrous transactionnels.
+
+### Étape 05 — RAG (Retrieval-Augmented Generation)
+**Ce qu'on fait :** Connexion du chatbot à une base documentaire (ChromaDB). Indexation de
+fichiers `.txt` en chunks, recherche sémantique par embeddings, injection du contexte dans le prompt.
+**Ce qu'on apprend :** Pipeline RAG complet : embed → store → retrieve → inject → generate.
+KPI : Hit Rate > 80%.
+**Concept clé :** Le LLM ne "sait" que ce qu'on lui donne. RAG = mémoire longue terme
+externe, sans coût de contexte permanent.
+
+### Étape 06 — LangChain
+**Ce qu'on fait :** Refactorisation du code avec LangChain. Swap cloud/local en 1 ligne.
+`ConversationBufferWindowMemory`, `ConversationalRetrievalChain`.
+**Ce qu'on apprend :** Abstraction LLM — même code, backend différent. Gain : moins de
+boilerplate, plus de fonctionnalités.
+**Concept clé :** `ChatOpenAI` → `ChatOllama` en changeant une seule ligne. L'interopérabilité
+est la vraie valeur ajoutée de LangChain.
+
+### Étape 07 — Docker & FastAPI
+**Ce qu'on fait :** Exposition du chatbot via une API REST FastAPI. Containerisation Docker.
+Endpoints : `/health`, `/chat`, `/history/{id}`, `/sessions`, `/docs` (Swagger auto).
+**Ce qu'on apprend :** FastAPI, Pydantic, Docker build + run, docker-compose.
+**Concept clé :** L'API REST transforme le chatbot script en service interrogeable par
+n'importe quel client (web, mobile, autre service).
+
+### Étape 08 — Prometheus & Grafana
+**Ce qu'on fait :** Instrumentation avec `prometheus_client`. Dashboard Grafana avec
+latence P95, RPS, tokens, erreurs, mémoire processus.
+**Ce qu'on apprend :** Types de métriques (Counter, Histogram, Gauge), scraping Prometheus,
+PromQL de base, provisioning automatique de datasource.
+**Concept clé :** On ne peut pas corriger ce qu'on ne voit pas. Les métriques sont la
+fenêtre sur le comportement réel du service en production.
+
+### Étape 09 — Sécurité
+**Ce qu'on fait :** Authentification JWT, rate limiting (slowapi), filtrage prompt injection
+(12 patterns regex), sanitization XSS, CORS restreint, hachage bcrypt.
+**Ce qu'on apprend :** Chaque couche protège contre un vecteur d'attaque différent.
+**Concept clé :** Sécurité en profondeur — une seule couche ne suffit jamais.
+```
+Requête → CORS → Rate Limit → JWT → Sanitize → Prompt Guard → LLM
+```
+
+### Étape 10 — Test de Charge (Locust)
+**Ce qu'on fait :** Simulation de 5 / 20 / 50 / 100 utilisateurs simultanés. Mesure du
+taux d'échec, P50, P95, RPS.
+**Ce qu'on apprend :** Identifier le goulot d'étranglement (API ? LLM ? DB ?). SLA réalistes :
+taux d'échec < 1%, P95 < 5s, RPS > 20.
+**Concept clé :** Le test de charge révèle les limites avant que les vrais utilisateurs les
+atteignent. Mieux vaut crasher en test qu'en prod.
+
+### Étape 11 — Tests automatisés (pytest)
+**Ce qu'on fait :** 3 niveaux de tests : unitaires (fonctions isolées, LLM mocké),
+intégration (API + DB, LLM mocké), E2E (API réelle). Coverage ≥ 70% requis.
+**Ce qu'on apprend :** Pourquoi mocker le LLM (rapidité, coût, déterminisme).
+`conftest.py` et fixtures partagées. `pytest --cov`.
+**Concept clé :** Un test qui appelle l'API OpenAI coûte $0.001 et prend 2s. Avec 100 tests
+lancés 50 fois par jour, c'est $5/jour juste pour les tests.
+
+### Étape 12 — Benchmark LLM
+**Ce qu'on fait :** Comparaison objective de plusieurs modèles (GPT-4o, GPT-4o-mini, Mistral 7B)
+sur un jeu de 20 questions. Notation automatique par LLM-as-Judge (score 1-10).
+**Ce qu'on apprend :** Évaluation reproductible. Rapport qualité/prix. `eval_set.jsonl` comme
+source de vérité.
+**Concept clé :** GPT-4o-mini : 8.2/10 pour $0.004 vs GPT-4o : 9.1/10 pour $0.024.
+Pour 90% des cas d'usage, le mini gagne. Le benchmark le prouve objectivement.
+
+## Étape 13 — Production-Ready (`etape_13_deployable`)
+
+### Vue d'ensemble
+
+L'étape 13 est la **synthèse du projet** : toutes les briques précédentes sont
+réunies, durcies pour la production, et livrées comme une application déployable.
+C'est la première étape où le code passe de "ça marche sur ma machine" à
+"ça peut tourner en production".
+
+```
+Étudiants arrivent avec → chatbot fonctionnel (étapes 00-12, séparées)
+Étape 13 produit        → application unifiée, testée, containerisée, monitorée
+```
+
+### Ce qui est assemblé
+
+| Fonctionnalité | Source | Ajout étape 13 |
+|---|---|---|
+| LangChain + cloud/local swap | Étape 06 | — |
+| RAG ChromaDB (graceful fallback) | Étapes 04/05 | Fallback si collection absente |
+| Prometheus + Grafana | Étape 08 | Métriques étendues (voir ci-dessous) |
+| JWT + Rate limiting + Prompt guard | Étape 09 | — |
+| Suite de tests pytest | Étape 11 | Intégrée au build Docker |
+| **Dockerfile multi-stage** | **Nouveau** | Tests bloquants au build |
+| **Nginx reverse proxy** | **Nouveau** | TLS, proxy pass, headers de sécurité |
+| **Script d'évaluation RAG** | **Nouveau** | `eval_set.jsonl` + score keywords |
+| **Alertes Prometheus** | **Nouveau** | 5 règles d'alerte |
+| **Alertes Grafana** | **Nouveau** | Mémoire système > 95% |
+
+### Architecture
+
+```
+Client
+  │
+  ├── dev  → FastAPI :8000 (direct)
+  └── prod → Nginx :443 → FastAPI :8000
+                           │
+           ┌───────────────┼──────────────────┐
+           │               │                  │
+     JWT + Rate      LangChain LLM        Prometheus
+     Limit +            │                  /metrics
+     Prompt Guard    ┌──┴──────────┐
+                     │  ChromaDB   │ ← RAG optionnel
+                     │  (optionnel)│   (fallback silencieux)
+                     └─────────────┘
+                          │
+             ┌────────────┴────────────┐
+             │                         │
+          SQLite                  Named volume
+          (historique)            /app/data/
+```
+
+### Le Dockerfile multi-stage — point pédagogique clé
+
+```dockerfile
+Stage 1 : builder     → apt + pip (dépendances)
+Stage 2 : test        → pytest (exit 1 si échec → build bloqué)
+Stage 3 : production  → image finale, user non-root, sans outils de build
+```
+
+**Pourquoi c'est important :**
+- Les tests font partie du pipeline de build — on ne peut pas livrer du code cassé
+- L'image finale ne contient pas `pytest`, `gcc`, ni les sources intermédiaires
+- L'image de prod est plus petite et moins exposée
+
+**Effet en pratique :**
+```bash
+make dev-bg   # échoue si un test est rouge → le développeur ne peut pas ignorer
+```
+
+### Métriques Prometheus étendues
+
+L'étape 13 va bien au-delà du monitoring basique de l'étape 08 :
+
+#### Métriques métier
+| Métrique | Type | Nouveauté |
+|---|---|---|
+| `chat_requests_total` | Counter | Labels : modèle, status (`success`/`error`), rag (`true`/`false`) |
+| `chat_tokens_total` | Counter | Labels : `prompt`/`completion` |
+| `chat_latency_seconds` | Histogram | 8 buckets 0.1s → 30s |
+| `rag_retrieval_seconds` | Histogram | Latence ChromaDB séparément |
+| `chat_context_messages` | Gauge | **Nouveau** — taille de l'historique à chaque requête |
+| `chat_errors_total` | Counter | Par type d'exception |
+| `auth_attempts_total` | Counter | Par status (`success`/`failure`) |
+| `prompt_injection_blocked_total` | Counter | Tentatives d'injection bloquées |
+
+#### Métriques système (nouvelles)
+| Métrique | Type | Description |
+|---|---|---|
+| `process_memory_bytes` | Gauge | RAM RSS du processus Python |
+| `system_memory_total_bytes` | Gauge | RAM totale de la machine hôte |
+| `system_memory_used_bytes` | Gauge | RAM utilisée sur la machine hôte |
+| `process_cpu_percent` | Gauge | CPU % du processus chatbot |
+| `system_cpu_percent` | Gauge | CPU % global du système |
+| `gpu_utilization_percent` | Gauge | GPU % par carte NVIDIA (si disponible) |
+| `gpu_memory_used_bytes` | Gauge | VRAM utilisée par carte |
+| `gpu_memory_total_bytes` | Gauge | VRAM totale par carte |
+
+> Les métriques GPU utilisent `pynvml`. Détection automatique au démarrage :
+> si aucun GPU NVIDIA n'est présent, les jauges existent mais ne sont jamais renseignées
+> — les panels Grafana affichent "No data" sans erreur.
+
+### Dashboard Grafana
+
+Le dashboard `grafana/provisioning/dashboards/chatbot.json` contient ~550 lignes.
+Il est **provisionné automatiquement** (aucune action manuelle à l'import).
+
+**Panels :**
+- Requêtes totales + taux d'erreur (PromQL avec `or vector(0)` pour éviter "No data")
+- Latence P50 / P95 / P99
+- Tokens consommés (prompt vs completion)
+- Taux RAG vs direct
+- Mémoire : RSS processus + utilisée système + totale système (3 courbes)
+- CPU : processus + système (2 courbes)
+- GPU : utilisation % et VRAM (panels conditionnels)
+- Injections de prompt bloquées
+
+**Correctif clé :** La datasource doit avoir `uid: prometheus` (fixe) dans le YAML de
+provisioning. Sans ça, Grafana génère un uid aléatoire à chaque redémarrage — tous
+les panels perdent leur source et affichent "No data".
+
+### Alertes
+
+#### Prometheus (`prometheus-alerts.yml`)
+| Alerte | Condition | Sévérité |
+|---|---|---|
+| `ChatbotDown` | API indisponible > 1 min | critical |
+| `HighErrorRate` | Taux erreur > 10% sur 5 min | warning |
+| `HighLatency` | P95 > 5s sur 5 min | warning |
+| `HighMemoryUsage` | RAM processus > 500 MB | warning |
+| `PromptInjectionAttempts` | > 10 injections / 5 min | warning |
+
+#### Grafana (`grafana/provisioning/alerting/alerts.yml`)
+| Alerte | Condition | Sévérité |
+|---|---|---|
+| Mémoire système > 95% | `system_memory_used / system_memory_total > 95%` pendant 1 min | critical |
+
+### Évaluation RAG intégrée
+
+```bash
+make eval       # 15 questions → vérification par mots-clés attendus
+make smoke      # 5 questions rapides → alimente Grafana + vérifie l'API
+```
+
+Format `data/eval_set.jsonl` :
+```json
+{"id": "q001", "question": "Quel est le prix de CloudSync Pro ?",
+ "expected_keywords": ["29", "mois"], "category": "pricing", "difficulty": "facile"}
+```
+
+Sortie :
+```
+[PASS] q001  Quel est le prix de CloudSync Pro ?    2.9s  [RAG 3src]
+[FAIL] q003  Qui est le CEO de TechCorp ?           1.9s  [RAG 3src]
+       → Je n'ai pas cette information.
+       ✗ manquants : Marie Dupont
+
+Résultat : 7/15 PASS (47%)   1 PARTIEL   7 FAIL
+```
+
+### Commandes de référence
+
+```bash
+make dev-bg           # démarre la stack (rebuild si code changé)
+make stop             # arrête tout
+make status           # health check + statut des conteneurs
+make test             # 73 tests, coverage ≥ 70% requis
+make test-security    # bandit : zéro vulnérabilité critique
+make smoke            # 5 questions → vérifie l'API + alimente Grafana
+make eval             # évaluation complète RAG
+make index-rag-docker # indexation des documents dans le conteneur
+make prod             # stack production avec Nginx + TLS
+```
+
+### Problèmes connus documentés
+
+**Bug iptables Docker 28.4 + kernel 6.17+**
+Docker 28.4.0 crée de nouvelles chaînes nft au démarrage mais continue d'utiliser les
+anciennes chaînes `DOCKER-ISOLATION-STAGE-1/2` pour les bridges user-defined.
+Fix documenté dans `docker-compose.yml` (commentaire en-tête) :
+```bash
+# Fix temporaire
+sudo iptables -t filter -N DOCKER-ISOLATION-STAGE-1 2>/dev/null || true
+sudo iptables -t filter -N DOCKER-ISOLATION-STAGE-2 2>/dev/null || true
+sudo iptables -t filter -A DOCKER-ISOLATION-STAGE-2 -j RETURN
+# Vérification
+docker network create test-net && echo "OK" && docker network rm test-net
+```
+
+**GPU Docker passthrough**
+Nécessite NVIDIA Container Toolkit (pas dans les dépôts Ubuntu standard).
+Section GPU dans `docker-compose.yml` commentée par défaut avec instructions complètes.
+
+## Étape 14 — Déployé (`etape_14_deployed`)
+
+### Vue d'ensemble
+
+L'étape 14 répond à la question : **"L'application est prête — où et comment on la déploie ?"**
+Elle propose plusieurs stratégies selon le contexte (budget, équipe, infrastructure),
+toutes partageant la même image Docker produite à l'étape 13.
+
+```
+Étape 13 → image Docker → Étape 14 → déploiement(s)
+```
+
+### Quatre stratégies de déploiement
+
+```
+Besoin                          Solution
+────────────────────────────────────────────────────────
+Pipeline CI/CD visuel local   → act + Gitea + ArgoCD + kind  ← nouveau
+Tester K8S sans compte cloud  → Docker Compose VPS
+1 serveur, budget limité       → Docker Compose VPS
+Serverless, scale to zero      → Google Cloud Run
+Déjà sur AWS                   → ECS Fargate
+Forte charge, équipe DevOps    → GKE ou EKS
+```
+
+### Option 0 — Pipeline CI/CD local complet
+
+**Pourquoi c'est la première option :** Avant de déployer sur un vrai cloud, on valide
+le pipeline complet en local. L'architecture est **identique** à la production —
+seules les URLs changent.
+
+```
+git push → Gitea (:3001) → act (CI) → registry local (:5001)
+                                              ↕
+               ArgoCD (dans kind) ← surveille Gitea
+                      ↓
+               kind cluster (:8080) ← pull depuis registry local
+```
+
+**Composants :**
+
+| Composant | Local | Équivalent cloud |
+|---|---|---|
+| Git server | Gitea (Docker, port 3001) | GitHub |
+| CI runner | `act` (GitHub Actions local) | GitHub Actions runners |
+| Registry images | localhost:5001 | GHCR / ECR / Artifact Registry |
+| Kubernetes | kind (Docker local) | GKE / EKS / AKS |
+| GitOps | ArgoCD (dans kind) | ArgoCD (dans le cluster cloud) |
+
+**Installation en une commande :**
+```bash
+./scripts/setup-local-pipeline.sh setup
+```
+
+**Workflow de développement :**
+```bash
+# 1. Modifier le code
+# 2. CI local (lint + tests + docker build)
+./scripts/setup-local-pipeline.sh ci
+
+# 3. Build et push vers le registry local
+./scripts/setup-local-pipeline.sh push-image
+
+# 4. Pousser sur Gitea
+git push local main
+
+# 5. ArgoCD détecte et déploie automatiquement
+# Voir : https://localhost:8081 (port-forward ArgoCD)
+```
+
+### Option 1 — Docker Compose sur VPS
+
+La solution la plus simple pour un vrai déploiement.
+```bash
+./scripts/deploy-docker.sh --host user@votre-serveur.com
+```
+Le script se connecte en SSH, clone le repo, configure le `.env`, lance
+`docker compose -f docker/docker-compose.prod.yml up -d`.
+
+L'image est tirée depuis GHCR — pas de build sur le serveur.
+
+**Monitoring :** `docker-compose.prod.yml` référence directement les configs de l'étape 13 :
+```
+../etape_13_deployable/prometheus.yml              → config Prometheus
+../etape_13_deployable/grafana/provisioning/       → datasource + dashboard automatiques
+```
+Aucune configuration supplémentaire — Grafana démarre avec le dashboard préconfiguré.
+
+### Options 2 & 3 — Cloud (GCP / AWS)
+
+Documentées dans `docs/DEPLOY_GCP.md` et `docs/DEPLOY_AWS.md`.
+
+**GCP Cloud Run (serverless recommandé pour démarrer) :**
+```bash
+gcloud builds submit --tag europe-west1-docker.pkg.dev/MON_PROJET/chatbot/api
+gcloud run deploy chatbot-api \
+  --image europe-west1-docker.pkg.dev/MON_PROJET/chatbot/api \
+  --set-secrets OPENAI_API_KEY=openai-key:latest \
+  --min-instances 0 --max-instances 10
+```
+
+**AWS ECS Fargate :**
+```bash
+aws ecr get-login-password | docker login --username AWS --password-stdin $ECR_URI
+docker push $ECR_URI/chatbot-api:latest
+aws ecs create-service --cli-input-json file://ecs-service.json
+```
+
+### Kubernetes — Manifests détaillés
+
+Structure `k8s/` :
+
+```
+k8s/
+├── namespace.yaml               → namespace "chatbot"
+├── configmap.yaml               → variables non-sensibles
+├── secret.yaml                  → ⚠ placeholders uniquement
+├── pvc.yaml                     → 3 volumes : data, chroma, grafana
+├── chatbot-deployment.yaml      → Deployment + init container RAG
+├── chatbot-service.yaml         → ClusterIP
+├── chatbot-hpa.yaml             → HPA : 1 → 10 replicas (CPU 70% / RAM 80%)
+├── ingress.yaml                 → Nginx Ingress + TLS cert-manager
+├── kustomization.yaml           → orchestration des manifests
+├── monitoring/
+│   ├── prometheus-deployment.yaml          → Prometheus + RBAC + ServiceAccount
+│   ├── grafana-deployment.yaml            → Grafana + volumeMounts subPath
+│   └── grafana-provisioning-configmap.yaml → datasource uid:prometheus + dashboard provider
+└── argocd/
+    └── application.yaml                   → Application ArgoCD (GitOps)
+```
+
+**Points notables :**
+
+`chatbot-deployment.yaml` — init container RAG :
+L'image de l'application s'initialise avec un init container qui peut pré-indexer
+les documents RAG avant que le pod principal démarre.
+
+`chatbot-hpa.yaml` — HPA (Horizontal Pod Autoscaler) :
+```yaml
+minReplicas: 1
+maxReplicas: 10
+# Scale up si CPU > 70% ou mémoire > 80%
+# Scale down après 5 min de charge réduite
+```
+
+`grafana-deployment.yaml` — provisioning via subPath :
+```yaml
+volumeMounts:
+  - name: provisioning
+    mountPath: /etc/grafana/provisioning/datasources/datasources.yaml
+    subPath: datasources.yaml   # montage d'un seul fichier du ConfigMap
+  - name: provisioning
+    mountPath: /etc/grafana/provisioning/dashboards/dashboards.yaml
+    subPath: dashboards.yaml
+```
+
+`grafana-provisioning-configmap.yaml` — datasource avec uid fixe :
+```yaml
+datasources:
+  - name: Prometheus
+    uid: prometheus    # UID FIXE — requis pour que les panels trouvent la datasource
+    url: http://prometheus:9090
+```
+
+### Pipeline CI/CD GitHub Actions
+
+Trois workflows dans `.github/workflows/` :
+
+#### `ci.yml` — Déclenché sur chaque push/PR
+```
+lint     → ruff (style + erreurs statiques)
+tests    → pytest (working-directory: etape_13_deployable, coverage ≥ 70%)
+security → bandit (vulnérabilités) + safety (dépendances)
+docker   → build stage test + stage production (validation uniquement, pas de push)
+```
+
+#### `cd.yml` — Déclenché sur merge main ou tag `v*.*.*`
+```
+test           → reprend ci.yml (obligatoire)
+build-and-push → GHCR : tags sha-{short} + semver + latest
+                 SBOM généré pour traçabilité
+deploy-staging → SSH + Docker Compose (auto sur merge main)
+deploy-prod    → SSH + Docker Compose (déclenché par tag v*.*.*)
+```
+
+#### `security.yml` — Hebdomadaire
+```
+safety → audit des dépendances Python
+trivy  → scan de l'image Docker → résultats dans GitHub Security tab
+```
+
+**Déclencher manuellement :**
+```bash
+# Déployer en staging
+gh workflow run cd.yml --field environment=staging
+
+# Créer un tag de release (déclenche le déploiement prod)
+git tag -a v1.2.3 -m "Release v1.2.3"
+git push origin v1.2.3
+```
+
+### Kubernetes local avec kind — Déploiement pas à pas
+
+Pour tester les manifests sans compte cloud :
+
+```bash
+# 1. Créer le cluster (1 control-plane + 2 workers + Nginx Ingress + cert-manager)
+./scripts/local-cloud.sh setup
+
+# 2. Build et chargement de l'image dans kind (évite le pull depuis GHCR)
+docker build --target production -t chatbot-api:local etape_13_deployable/
+kind load docker-image chatbot-api:local --name chatbot-local
+
+# 3. Créer les secrets
+kubectl create namespace chatbot
+kubectl create secret generic chatbot-secrets \
+  --from-literal=openai-api-key="sk-votre-cle" \
+  --from-literal=secret-key="$(openssl rand -hex 32)" \
+  --from-literal=grafana-password="admin123" \
+  -n chatbot
+
+# 4. Déployer
+kubectl apply -k etape_14_deployed/k8s/
+kubectl rollout status deployment/chatbot-api -n chatbot --timeout=3m
+
+# 5. Déployer le monitoring
+kubectl apply -f etape_14_deployed/k8s/monitoring/grafana-provisioning-configmap.yaml
+kubectl apply -f etape_14_deployed/k8s/monitoring/prometheus-deployment.yaml
+kubectl apply -f etape_14_deployed/k8s/monitoring/grafana-deployment.yaml
+
+# Tester
+curl http://localhost:8080/health
+```
+
+### ArgoCD — GitOps visuel
+
+ArgoCD surveille le repo Git et synchronise automatiquement le cluster quand le code change.
+
+```bash
+# Installer ArgoCD dans le cluster
+kubectl create namespace argocd
+kubectl apply -n argocd \
+  -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml
+
+# Accéder à l'UI
+kubectl port-forward svc/argocd-server -n argocd 8081:443 &
+# → https://localhost:8081
+
+# Appliquer l'Application (surveille Gitea, déploie dans kind)
+kubectl apply -f etape_14_deployed/k8s/argocd/application.yaml
+```
+
+**Ce que l'UI ArgoCD montre :**
+- Arbre de toutes les ressources K8S (Deployment, Service, Ingress, PVC, HPA…)
+- Statut de synchronisation : `Synced` / `OutOfSync` / `Degraded`
+- Historique des déploiements avec possibilité de rollback en 1 clic
+- Diff entre l'état Git et l'état du cluster
+
+### Scaling et rollback K8S
+
+```bash
+# Scaling manuel
+kubectl scale deployment chatbot-api --replicas=5 -n chatbot
+
+# Rolling update (zero-downtime)
+kubectl set image deployment/chatbot-api chatbot=chatbot-api:v2 -n chatbot
+kubectl rollout status deployment/chatbot-api -n chatbot
+
+# Rollback
+kubectl rollout undo deployment/chatbot-api -n chatbot
+kubectl rollout undo deployment/chatbot-api --to-revision=2 -n chatbot
+
+# Historique
+kubectl rollout history deployment/chatbot-api -n chatbot
+```
+
+### Synthèse pédagogique étapes 13 & 14
+
+| Question | Étape 13 | Étape 14 |
+|---|---|---|
+| **Le code est-il correct ?** | Tests bloquants au build Docker | CI GitHub Actions obligatoire avant merge |
+| **Est-il sécurisé ?** | bandit + safety dans `make test-security` | `security.yml` hebdomadaire + Trivy |
+| **Comment le surveiller ?** | Prometheus + Grafana + alertes | Même stack, déployée dans K8S |
+| **Comment le livrer ?** | `make prod` (Docker Compose local) | GitHub Actions → GHCR → Staging → Prod |
+| **Comment le scaler ?** | — | HPA K8S (2 → 10 replicas) |
+| **Comment rollback ?** | `docker compose up` version précédente | `kubectl rollout undo` / ArgoCD 1 clic |
+| **Comment simuler tout ça ?** | — | act + Gitea + kind + ArgoCD (100% local) |
+
+## Arc narratif pour la présentation
+
+```
+00 → "Le LLM ne se souvient de rien — comment construire une mémoire ?"
+03 → "La mémoire a un coût — comment l'optimiser ?"
+05 → "Le LLM ne sait que ce qu'on lui donne — RAG comme mémoire externe"
+07 → "Le chatbot devient un service — comment l'exposer ?"
+08 → "On ne peut pas corriger ce qu'on ne voit pas — métriques"
+09 → "Un service exposé est une cible — sécurité en profondeur"
+10 → "Est-ce que ça tient la charge ? — test de limite"
+11 → "Est-ce qu'on peut livrer en confiance ? — tests automatisés"
+13 → "Toutes les briques ensemble — prêt pour la prod"
+14 → "La prod, c'est quoi concrètement ? — CI/CD + K8S + GitOps"
+```

tp_ia_chatbot-main/tp_ia_chatbot-main/README.md

@@ -0,0 +1,146 @@
+# TP IA — Construction d'un Chatbot de A à Z
+
+Bienvenue dans ce TP pratique (Travaux Pratiques) sur la construction d'un chatbot IA complet.
+Vous allez partir d'un simple script Python de 10 lignes et arriver à une API sécurisée,
+monitorée, testée et benchmarkée.
+
+---
+
+## Vue d'ensemble du projet
+
+```
+tp_ia_chatbot/
+├── etape_00_moteur/        # Connexion au LLM (cloud ou local)
+├── etape_01_banane/        # Chatbot naïf — le problème d'amnésie
+├── etape_02_kpis/          # Mesurer latence, TPS, coût
+├── etape_03_memoire/       # Fenêtre glissante + résumé automatique
+├── etape_04_persistance/   # SQLite et JSON — sauvegarder les sessions
+├── etape_05_rag/           # RAG avec ChromaDB — grounding dans vos docs
+├── etape_06_langchain/     # LangChain — framework d'orchestration
+├── etape_07_docker/        # API FastAPI dockerisée
+├── etape_08_monitoring/    # Prometheus + Grafana
+├── etape_09_securite/      # JWT, rate limiting, sanitisation
+├── etape_10_locust/        # Tests de charge avec Locust
+├── etape_11_tests/         # Tests unitaires, intégration, E2E
+└── etape_12_benchmark/     # Benchmark LLM-as-Judge
+```
+
+---
+
+## Prérequis
+
+| Outil | Version minimale | Utilisation |
+|-------|-----------------|-------------|
+| Python | 3.11+ | Langage principal |
+| pip | 23+ | Gestion des dépendances |
+| Docker | 24+ | Étapes 07, 08, 09 |
+| Docker Compose | 2.0+ | Orchestration des services |
+| LM Studio | optionnel | Modèle local (étape 00) |
+
+### Clé API OpenAI (recommandée)
+
+Les étapes utilisent par défaut l'API OpenAI. Créez un compte sur [platform.openai.com](https://platform.openai.com), générez une clé API, et gardez-la sous la main.
+
+### Alternative locale avec LM Studio
+
+Si vous n'avez pas de clé OpenAI, installez [LM Studio](https://lmstudio.ai/), téléchargez un modèle (ex: `mistral-7b-instruct`), démarrez le serveur local sur `http://localhost:1234`, et configurez `MODE=local` dans votre `.env`.
+
+---
+
+## Installation rapide
+
+```bash
+# Cloner / naviguer dans le projet
+cd tp_ia_chatbot
+
+# Chaque étape est autonome — exemple pour l'étape 01 :
+cd etape_01_banane
+cp .env.example .env
+# Éditez .env et ajoutez votre clé OPENAI_API_KEY
+pip install -r requirements.txt
+python chatbot_naif.py
+```
+
+---
+
+## Progression des étapes
+
+### Étape 00 — Le Moteur
+**Objectif :** Établir la connexion avec le LLM (cloud OpenAI ou local LM Studio).
+**Ce que vous apprenez :** API OpenAI, variables d'environnement, dotenv.
+
+### Étape 01 — Le Chatbot Naïf (La Banane)
+**Objectif :** Créer un chatbot fonctionnel en ~10 lignes. Constater l'amnésie.
+**Ce que vous apprenez :** La nature stateless des LLMs, le rôle de l'historique côté client.
+
+### Étape 02 — Les KPIs
+**Objectif :** Mesurer latence, tokens par seconde, coût estimé.
+**Ce que vous apprenez :** Métriques de performance LLM, analyse comparative.
+
+### Étape 03 — La Mémoire
+**Objectif :** Implémenter une fenêtre glissante et un résumé automatique.
+**Ce que vous apprenez :** Gestion du contexte, trade-off mémoire/coût.
+
+### Étape 04 — La Persistance
+**Objectif :** Sauvegarder les conversations dans SQLite ou JSON.
+**Ce que vous apprenez :** Bases de données légères, gestion de sessions.
+
+### Étape 05 — RAG (Retrieval-Augmented Generation)
+**Objectif :** Ancrer le chatbot dans vos propres documents.
+**Ce que vous apprenez :** ChromaDB, embeddings, chunking, évaluation RAG.
+
+### Étape 06 — LangChain
+**Objectif :** Utiliser le framework LangChain pour orchestrer le chatbot.
+**Ce que vous apprenez :** Chaînes LangChain, mémoire intégrée, LCEL.
+
+### Étape 07 — Docker
+**Objectif :** Exposer le chatbot comme une API REST dockerisée.
+**Ce que vous apprenez :** FastAPI, Docker, endpoints REST.
+
+### Étape 08 — Monitoring
+**Objectif :** Instrumenter l'API avec Prometheus et Grafana.
+**Ce que vous apprenez :** Métriques custom, dashboards, observabilité.
+
+### Étape 09 — Sécurité
+**Objectif :** Sécuriser l'API avec JWT, rate limiting, sanitisation.
+**Ce que vous apprenez :** Authentification, protection contre l'injection de prompt.
+
+### Étape 10 — Tests de Charge (Locust)
+**Objectif :** Tester la tenue en charge du chatbot.
+**Ce que vous apprenez :** Tests de performance, Locust, analyse des résultats.
+
+### Étape 11 — Tests Automatisés
+**Objectif :** Couvrir l'application avec des tests unitaires, d'intégration et E2E.
+**Ce que vous apprenez :** pytest, mocking, TestClient FastAPI, couverture de code.
+
+### Étape 12 — Benchmark LLM-as-Judge
+**Objectif :** Comparer plusieurs modèles sur un jeu d'évaluation standardisé.
+**Ce que vous apprenez :** Évaluation automatique, LLM-as-Judge, analyse comparative.
+
+---
+
+## Conseils pédagogiques
+
+1. **Ne sautez pas les étapes** — chaque étape introduit un concept qui sera réutilisé ensuite.
+2. **Lisez le README de chaque étape** avant de lancer le code.
+3. **Expérimentez** — modifiez les paramètres (MAX_HISTORY, modèles, etc.) pour comprendre l'impact.
+4. **Comparez** — l'étape 12 vous permettra de voir concrètement les différences entre modèles.
+
+---
+
+## Structure des coûts indicatifs (OpenAI gpt-4o-mini)
+
+| Étape | Appels estimés | Coût estimé |
+|-------|---------------|-------------|
+| 00 à 03 | ~50 | < 0,01 € |
+| 04 à 06 | ~200 | < 0,05 € |
+| 07 à 09 | ~500 | < 0,10 € |
+| 10 à 12 | ~2000 | < 0,50 € |
+
+*Tarifs indicatifs basés sur gpt-4o-mini à $0.15/1M tokens input, $0.60/1M tokens output.*
+
+---
+
+## Licence
+
+Projet éducatif — libre d'utilisation et de modification.

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_00_moteur/.env.example

@@ -0,0 +1,28 @@
+# Étape 00 — Variables d'environnement (partagées par toutes les étapes)
+# Copiez ce fichier en .env et remplissez vos valeurs
+
+# Clé API OpenAI (obligatoire pour le mode cloud)
+OPENAI_API_KEY=sk-your-key-here
+
+# Mode de connexion par défaut : "cloud" (OpenAI) ou "local" (LM Studio)
+MODE=local
+
+# --- Config CLOUD ---
+#CLOUD_MODEL=gpt-4o-mini
+
+# --- Config LOCAL (LM Studio) ---
+# 2. local — gpt-oss-20b (localhost)
+#LOCAL_BASE_URL=http://localhost:1234/v1
+#LOCAL_MODEL=openai/gpt-oss-20b
+
+# 3. local_mistral3 — ministral-3-3b (localhost)
+#LOCAL_BASE_URL=http://localhost:1234/v1
+#LOCAL_MODEL=mistralai/ministral-3-3b
+
+# 4. reseau_ministral14b — ministral-3-14b-reasoning (réseau 192.168.1.141) ← actif
+LOCAL_BASE_URL=http://192.168.1.141:1234/v1
+LOCAL_MODEL=mistralai/ministral-3-14b-reasoning
+
+# 5. reseau_gpt_oss_20b — gpt-oss-20b (réseau 192.168.1.141)
+#LOCAL_BASE_URL=http://192.168.1.141:1234/v1
+#LOCAL_MODEL=openai/gpt-oss-20b

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_00_moteur/EVALUATION_TP_ETAPE_00.md

@@ -0,0 +1,66 @@
+# 🧠 Évaluation — Étape 00 : Le Moteur
+
+> ⏱ Durée estimée : 30 min | Niveau : Débutant
+
+## 🎯 Enjeu central
+
+Avant d'écrire une seule ligne de logique, il faut que la connexion au LLM fonctionne.
+Cette étape pose la fondation : un LLM cloud ou local expose **la même interface REST**,
+les clés API ne doivent **jamais** être dans le code, et la latence de départ est déjà mesurable.
+
+---
+
+## ✅ Checklist de validation
+
+- [ ]  J'ai créé mon `.env` à partir de `.env.example` et ajouté ma clé API
+- [ ]  J'ai lancé `python demo_connexion.py` et obtenu une réponse du LLM (LM Studio en local)
+- [ ]  J'ai lancé `python demo_connexion.py` et obtenu une réponse du LLM (LM Studio sur un serveur local)
+- [ ]  J'ai noté la latence affichée (mode local LM Studio)
+- [ ]  J'ai vérifié que le fichier `.env` **n'apparaît pas** dans `git status`
+
+---
+
+## 🔍 Questions de compréhension
+
+### Niveau 1 — Observation
+
+1. Quelle latence as-tu obtenue lors de ton premier appel (`demo_connexion.py`) ? En combien de millisecondes ?
+2. Qu'affiche `python config.py` sur ton poste ? Quel mode est actif (cloud / local) et quel modèle est configuré ?
+3. Si tu ouvres ton `.env`, quelles variables y sont définies ? Laquelle serait catastrophique à exposer sur GitHub ?
+
+### Niveau 2 — Analyse
+
+1. Pourquoi utilise-t-on `python-dotenv` plutôt que d'écrire `api_key = "sk-..."` directement dans le code ? Que se passerait-il avec un `git push` avec la clé en dur ?
+2. Cloud et local utilisent la **même interface** (`client.chat.completions.create`). Qu'est-ce que ça implique pour le code des étapes suivantes ?
+
+### Niveau 3 — Décision
+
+1. Tu dois choisir entre cloud (OpenAI) et local (LM Studio) pour un chatbot interne à une banque. Quels critères guident ta décision ? Cite au moins 3 dimensions (coût, conformité, latence, confidentialité...).
+
+---
+
+## 🧪 Mini-expérience guidée
+
+Dans `demo_connexion.py`, change `max_tokens` à `5`. Que se passe-t-il ? La réponse est-elle complète ?
+
+**Observation :**
+
+```
+_____________________________________________________________
+_____________________________________________________________
+```
+
+---
+
+## 📋 Lien avec le dossier E8
+
+- **Architecture** : Décris en 3-5 phrases comment la gestion des clés API via variables d'environnement s'inscrit dans les bonnes pratiques de sécurité (secrets managers, AWS Secrets Manager, HashiCorp Vault).
+- **Réglementaire** : Si le chatbot utilise l'API OpenAI, les messages transitent par des serveurs américains. Quelles implications pour le RGPD et la souveraineté des données ?
+
+---
+
+## 💡 Pour aller plus loin
+
+- Teste LM Studio : compare la latence cloud vs local.
+- Calcule le coût de 10 000 messages de 500 tokens avec `gpt-4o-mini` (page pricing OpenAI).
+- Explore la différence entre `max_tokens` et `temperature`.

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_00_moteur/README.md

@@ -0,0 +1,125 @@
+# Étape 00 — Le Moteur
+
+## Objectif
+
+Établir la connexion avec un LLM, que ce soit via l'API cloud d'OpenAI ou via un modèle local avec LM Studio.
+
+## Concepts clés
+
+- **API OpenAI** : Interface REST standardisée pour les LLMs
+- **Variables d'environnement** : Ne jamais écrire les clés API en dur dans le code
+- **Mode cloud vs local** : Même interface, backends différents
+
+## Installation
+
+```
+# Créer un environemnet virtuel
+python -m venv venv
+source venv/bin/active
+```
+
+```
+# Installer LM Studio
+./LM-Studio-0.4.4-1-x64.AppImage 
+# /!\ Attention parfois il faut modifier une option
+[50827:0417/124432.581745:FATAL:sandbox/linux/suid/client/setuid_sandbox_host.cc:166] The SUID sandbox helper binary was found, but is not configured correctly. Rather than run without sandboxing I'm aborting now. You need to make sure that /tmp/.mount_LM-Stu4qQ6d5/chrome-sandbox is owned by root and has mode 4755.
+Trappe pour point d'arrêt et de trace (core dumped)
+fabien@fabien-B760M-DS3H-AX-DDR4:~/Téléchargements$ 
+fabien@fabien-B760M-DS3H-AX-DDR4:~/Téléchargements$ sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0
+kernel.apparmor_restrict_unprivileged_userns = 0
+fabien@fabien-B760M-DS3H-AX-DDR4:~/Téléchargements$ ./LM-Studio-0.4.4-1-x64.AppImage 
+
+# Ou lancer LM Studio sans sandbox
+./LM-Studio-0.4.4-1-x64.AppImage --no-sandbox
+
+# Ou gérer via un "bouble click" sous Ubuntu
+sudo apt install libfuse2
+
+# Installer un modèle simple
+mistralai/ministral-3-3b
+```
+
+
+```bash
+cd etape_00_moteur
+pip install -r requirements.txt
+cp .env.example .env
+```
+
+Éditez `.env` et ajoutez votre clé API :
+
+```
+OPENAI_API_KEY=sk-votre-vraie-cle-ici
+MODE=cloud
+```
+
+## Utilisation
+
+### Tester les connexions
+
+```bash
+python demo_connexion.py
+```
+
+Vous verrez quelles connexions fonctionnent et leur latence.
+
+### Tester la configuration
+
+```bash
+python config.py
+```
+
+## Changer de mode
+
+Dans votre `.env` :
+
+```bash
+# Pour utiliser OpenAI (cloud)
+MODE=cloud
+
+# Pour utiliser LM Studio (local)
+MODE=local
+```
+
+## Configuration LM Studio (optionnel)
+
+1. Téléchargez [LM Studio](https://lmstudio.ai/)
+2. Téléchargez un modèle (ex: `mistral-7b-instruct-v0.3`)
+3. Allez dans l'onglet "Local Server"
+4. Cliquez sur "Start Server" (port 1234 par défaut)
+5. Notez le nom exact du modèle chargé et mettez-le dans `LOCAL_MODEL`
+
+## Structure des fichiers
+
+```
+etape_00_moteur/
+├── config.py          ← Configuration centralisée (cloud/local)
+├── demo_connexion.py  ← Test des connexions avec timing
+├── .env.example       ← Template pour vos variables d'environnement
+├── requirements.txt   ← Dépendances Python
+└── README.md          ← Ce fichier
+```
+
+## Points importants
+
+- Ne commitez JAMAIS votre fichier `.env` (il contient votre clé API)
+- Le fichier `.env.example` sert de documentation — il peut être commité
+- `config.py` est réutilisé par les étapes suivantes via `sys.path`
+
+# Info réseau
+
+Pour récupérer l'IP local sous Ubuntu: `ip a` ou `hostname -I`.
+Si problème de firewall `sudo ufw allow 1234`
+
+Vérifier que LM Studio écoute bien partout:
+
+ss -tulnp | grep 1234 (on doit voir 0.0.0.0:1234, si on voit 127.0.0.1:1234 ça veut dire que c'est encore bloqué en local)
+
+
+Exemple de sortie:
+
+ $ hostname -I
+192.168.1.141 172.19.0.1 172.17.0.1 172.20.0.1 172.18.0.1 2001:861:5441:a6d0:8242:xx:yyy:ccc 2001:861:5441:a6d0:16fc:zz:aa:vvv
+
+ss -tulnp | grep 1234
+tcp   LISTEN 0      511                             0.0.0.0:1234       0.0.0.0:*    users:(("lm-studio",pid=17384,fd=127))

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_00_moteur/config.py

@@ -0,0 +1,154 @@
+"""
+Étape 00 — Le Moteur
+Configuration centralisée pour cloud (OpenAI) et local (LM Studio).
+
+Importez ce module depuis n'importe quelle étape pour éviter la duplication :
+    import sys, os
+    sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'etape_00_moteur'))
+    from config import CONFIG, list_configs, make_client, get_client, get_model
+"""
+import os
+from dotenv import load_dotenv
+import openai
+
+# Charge toujours depuis ce répertoire, indépendamment du cwd de l'appelant
+load_dotenv(os.path.join(os.path.dirname(__file__), ".env"))
+
+# Serveurs LM Studio — modifiez ici si les IPs changent
+LM_STUDIO_LOCAL  = "http://192.168.1.66:1235/v1"   # machine locale (exemple WSL2 sur Windows)
+LM_STUDIO_RESEAU = "http://192.168.1.141:1234/v1"  # serveur IA réseau loca
+
+CONFIG = {
+    "cloud": {
+        "base_url": None,
+        "api_key": os.environ.get("OPENAI_API_KEY", "sk-changeme"),
+        "model": os.environ.get("CLOUD_MODEL", "gpt-4o-mini"),
+        "price_input": 0.00015,   # $/1K tokens
+        "price_output": 0.00060,
+    },
+    "local_mistral7b": {
+        "base_url": os.environ.get("LOCAL_BASE_URL", "http://localhost:1234/v1"),
+        "api_key": "lm-studio",
+        "model": os.environ.get("LOCAL_MODEL", "mistral-7b-instruct"),
+        "price_input": 0.0,   # gratuit (local)
+        "price_output": 0.0,
+    },
+    "force_localhost_gpt_oss_20b": {
+        "base_url": LM_STUDIO_LOCAL,  # Windows host depuis WSL2 (LM Studio port 1235)
+        "api_key": "lm-studio",
+        "model": "openai/gpt-oss-20b",
+        "price_input": 0.0,
+        "price_output": 0.0,
+        "timeout": 120,  # MSI sans GPU dédié = lent, timeout généreux
+    },
+    "force_localhost_mistral7b": {
+        "base_url": LM_STUDIO_LOCAL,  # Windows host depuis WSL2 (LM Studio port 1235)
+        "api_key": "lm-studio",
+        "model": "mistralai/ministral-3-3b",
+        "price_input": 0.0,   # gratuit (local)
+        "price_output": 0.0,
+    },
+    "reseau_ministral3b": {
+        "base_url": LM_STUDIO_RESEAU,
+        "api_key": "lm-studio",
+        "model": "mistralai/ministral-3-3b",
+        "price_input": 0.0,   # gratuit (réseau local)
+        "price_output": 0.0,
+        "timeout": 120,       # modèle lourd sur réseau — timeout généreux
+    },
+    "reseau_ministral14b": {
+        "base_url": LM_STUDIO_RESEAU,
+        "api_key": "lm-studio",
+        "model": "mistralai/ministral-3-14b-reasoning",
+        "price_input": 0.0,   # gratuit (réseau local)
+        "price_output": 0.0,
+        "timeout": 120,       # modèle lourd sur réseau — timeout généreux
+    },
+    "reseau_gpt_oss_20b": {
+        "base_url": LM_STUDIO_RESEAU,
+        "api_key": "lm-studio",
+        "model": "openai/gpt-oss-20b",
+        "price_input": 0.0,   # gratuit (réseau local)
+        "price_output": 0.0,
+        "timeout": 120,       # modèle lourd sur réseau — timeout généreux
+    },
+}
+
+
+def clean_reply(text: str) -> str:
+    """Supprime les tokens de contrôle internes qui fuient dans certains modèles locaux.
+    Ex: <|channel|>commentary...<|message|>réponse → réponse"""
+    import re
+    # Retire tout bloc <|...|> et son contenu jusqu'au dernier <|...|>
+    cleaned = re.sub(r"<\|[^|]*\|>[^<]*", "", text)
+    # Si le nettoyage a retiré tout le texte, retourner l'original
+    return cleaned.strip() or text.strip()
+
+
+def list_configs() -> list[str]:
+    """Retourne la liste des noms de configs disponibles."""
+    return list(CONFIG.keys())
+
+
+def choose_mode() -> str:
+    """Sélection interactive du mode. Le MODE du .env est proposé par défaut."""
+    configs = list_configs()
+    default = os.environ.get("MODE", configs[0])
+    if default not in configs:
+        default = configs[0]
+
+    print("Configs disponibles :")
+    for i, name in enumerate(configs, 1):
+        marker = " ← défaut" if name == default else ""
+        print(f"  {i}. {name} — modèle : {CONFIG[name]['model']}{marker}")
+    choice = input(f"Choisissez (numéro ou nom, Entrée = {default}) : ").strip()
+
+    if not choice:
+        return default
+    if choice.isdigit() and 1 <= int(choice) <= len(configs):
+        return configs[int(choice) - 1]
+    if choice in configs:
+        return choice
+    print(f"  Choix invalide, utilisation de '{default}'")
+    return default
+
+
+def make_client(mode: str) -> openai.OpenAI:
+    """Crée un client OpenAI pour la config `mode`."""
+    if mode not in CONFIG:
+        raise ValueError(f"Mode inconnu : '{mode}'. Disponibles : {list_configs()}")
+    cfg = CONFIG[mode]
+    timeout = cfg.get("timeout", 30)
+    if cfg["base_url"]:
+        return openai.OpenAI(base_url=cfg["base_url"], api_key=cfg["api_key"], timeout=timeout)
+    return openai.OpenAI(api_key=cfg["api_key"], timeout=timeout)
+
+
+def get_client(mode: str = None) -> openai.OpenAI:
+    """Retourne un client OpenAI (mode actif par défaut via MODE dans .env)."""
+    return make_client(mode or os.environ.get("MODE", "cloud"))
+
+
+def get_model(mode: str = None) -> str:
+    """Retourne le modèle actif (mode actif par défaut via MODE dans .env)."""
+    m = mode or os.environ.get("MODE", "cloud")
+    if m not in CONFIG:
+        m = "cloud"
+    return CONFIG[m]["model"]
+
+
+# Accès direct au mode/config actifs (compat étape 00)
+MODE = os.environ.get("MODE", "cloud")
+if MODE not in CONFIG:
+    print(f"[ATTENTION] MODE='{MODE}' inconnu, utilisation de 'cloud' par défaut.")
+    MODE = "cloud"
+ACTIVE = CONFIG[MODE]
+
+
+if __name__ == "__main__":
+    print(f"Mode actif : {MODE}")
+    print(f"Modèle     : {get_model()}")
+    if ACTIVE["base_url"]:
+        print(f"Base URL   : {ACTIVE['base_url']}")
+    else:
+        print(f"Base URL   : (OpenAI par défaut)")

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_00_moteur/demo_connexion.py

@@ -0,0 +1,119 @@
+"""
+Étape 00 — Démo de connexion
+Teste les connexions cloud (OpenAI) et local (LM Studio) et affiche les résultats.
+"""
+import os
+import time
+from dotenv import load_dotenv
+import openai
+
+load_dotenv()
+
+TEST_PROMPT = "Réponds juste 'OK' en un mot."
+
+def test_connection(name: str, base_url, api_key: str, model: str) -> dict:
+    """Teste une connexion LLM et retourne les résultats."""
+    result = {
+        "name": name,
+        "model": model,
+        "success": False,
+        "reply": None,
+        "latency": None,
+        "error": None,
+    }
+
+    try:
+        if base_url:
+            client = openai.OpenAI(base_url=base_url, api_key=api_key)
+        else:
+            client = openai.OpenAI(api_key=api_key)
+
+        start = time.time()
+        response = client.chat.completions.create(
+            model=model,
+            messages=[{"role": "user", "content": TEST_PROMPT}],
+            max_tokens=10,
+            timeout=15,
+        )
+        result["latency"] = round(time.time() - start, 3)
+        result["reply"] = response.choices[0].message.content.strip()
+        result["success"] = True
+
+    except openai.AuthenticationError:
+        result["error"] = "Clé API invalide ou manquante"
+    except openai.APIConnectionError:
+        result["error"] = "Impossible de se connecter au serveur"
+    except openai.APITimeoutError:
+        result["error"] = "Timeout — le serveur ne répond pas"
+    except Exception as e:
+        result["error"] = str(e)
+
+    return result
+
+
+def print_result(res: dict):
+    status = "OK" if res["success"] else "ECHEC"
+    print(f"\n  [{status}] {res['name']} — modèle: {res['model']}")
+    if res["success"]:
+        print(f"        Réponse  : {res['reply']}")
+        print(f"        Latence  : {res['latency']}s")
+    else:
+        print(f"        Erreur   : {res['error']}")
+
+
+def main():
+    print("=" * 55)
+    print("  Étape 00 — Test de Connexion au Moteur LLM")
+    print("=" * 55)
+
+    results = []
+
+    # Test 1 : OpenAI Cloud
+    print("\n[1/2] Test connexion CLOUD (OpenAI)...")
+    api_key = os.environ.get("OPENAI_API_KEY", "sk-changeme")
+    r1 = test_connection(
+        name="Cloud OpenAI",
+        base_url=None,
+        api_key=api_key,
+        model="gpt-4o-mini",
+    )
+    print_result(r1)
+    results.append(r1)
+
+    # Test 2 : LM Studio Local
+    print("\n[2/2] Test connexion LOCAL (LM Studio)...")
+    
+    # On récupère l'URL du moteur ou on utilise l'IP Windows par défaut
+    local_url = os.environ.get("LOCAL_BASE_URL", "http://192.168.1.66:1235/v1")
+    local_model = os.environ.get("LOCAL_MODEL", "openai/gpt-oss-20b")
+
+    r2 = test_connection(
+        name="Local LM Studio",
+        base_url=local_url,
+        api_key="lm-studio",
+        model=local_model,
+    )
+    print_result(r2)
+    results.append(r2)
+
+    # Résumé
+    print("\n" + "=" * 55)
+    print("  RÉSUMÉ")
+    print("=" * 55)
+    working = [r for r in results if r["success"]]
+    if not working:
+        print("\n  ATTENTION : Aucune connexion ne fonctionne !")
+        print("  → Vérifiez votre OPENAI_API_KEY dans .env")
+        print("  → Ou démarrez LM Studio avec le serveur local")
+    else:
+        print(f"\n  {len(working)}/{len(results)} connexion(s) opérationnelle(s)")
+        print(f"\n  Recommandation MODE:")
+        if r1["success"]:
+            print("    MODE=cloud  ← OpenAI fonctionne")
+        if r2["success"]:
+            print("    MODE=local  ← LM Studio fonctionne")
+    print()
+
+
+if __name__ == "__main__":
+    main()

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_00_moteur/requirements.txt

@@ -0,0 +1,2 @@
+openai>=1.0.0
+python-dotenv>=1.0.0

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_01_banane/.env.example

@@ -0,0 +1,9 @@
+# Étape 01 — La config est mutualisée dans etape_00_moteur/.env
+# Copiez et remplissez etape_00_moteur/.env.example si ce n'est pas déjà fait.
+#
+# Variables lues depuis etape_00_moteur/.env :
+#   OPENAI_API_KEY  — clé API OpenAI (mode cloud)
+#   MODE            — "cloud" ou "local" (défaut si non saisi interactivement)
+#   CLOUD_MODEL     — modèle OpenAI (défaut : gpt-4o-mini)
+#   LOCAL_BASE_URL  — URL LM Studio (défaut : http://localhost:1234/v1)
+#   LOCAL_MODEL     — modèle LM Studio chargé

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_01_banane/01_chatbot_naif_no_message_stack.py

@@ -0,0 +1,57 @@
+"""
+Étape 01 — Le Chatbot SANS historique (version naïve)
+Démontre le problème d'amnésie : chaque appel est indépendant.
+Le LLM ne reçoit jamais les échanges précédents → il ne peut pas se souvenir.
+
+OBSERVATION CLÉS :
+- Le message utilisateur N'EST PAS ajouté à msgs avant l'appel
+- Chaque appel reçoit uniquement le system prompt → amnésie totale
+- Comparez avec 02_chatbot_naif.py qui accumule l'historique
+"""
+import os, sys
+import openai
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "etape_00_moteur"))
+from config import CONFIG, choose_mode, make_client
+
+mode = choose_mode()
+client = make_client(mode)
+MODEL = CONFIG[mode]["model"]
+
+# msgs contient SEULEMENT le system prompt — jamais mis à jour
+msgs = [{"role": "system", "content": "Tu es un assistant utile et concis. Réponds en français."}]
+
+print("=== Chatbot SANS Historique — Étape 01 (version 1/2) ===")
+print("Ce chatbot ne se souvient de RIEN, même dans la même session !")
+print("Tapez 'quit' pour quitter.\n")
+print("ASTUCE : Dites votre prénom, puis demandez-le → il ne saura pas répondre !\n")
+
+try:
+    while True:
+        q = input("Vous: ").strip()
+        if q.lower() in ("quit", "exit", "q"):
+            print("\nAu revoir !")
+            break
+        if not q:
+            continue
+
+        # On envoie la question en one-shot, sans l'ajouter à msgs
+        messages_one_shot = msgs + [{"role": "user", "content": q}]
+
+        try:
+            response = client.chat.completions.create(model=MODEL, messages=messages_one_shot)
+            reply = response.choices[0].message.content
+            print(f"IA: {reply}\n")
+            # NOTE : on ne fait RIEN avec reply → prochain appel = même contexte vide
+
+        except openai.AuthenticationError:
+            print("ERREUR: Clé API invalide. Vérifiez OPENAI_API_KEY dans etape_00_moteur/.env\n")
+        except openai.APIConnectionError:
+            print("ERREUR: Impossible de contacter l'API. Vérifiez votre connexion internet.\n")
+        except openai.RateLimitError:
+            print("ERREUR: Limite de débit atteinte. Attendez quelques secondes.\n")
+        except Exception as e:
+            print(f"ERREUR inattendue: {e}\n")
+
+except KeyboardInterrupt:
+    print("\n\nAu revoir !")

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_01_banane/02_chatbot_naif.py

@@ -0,0 +1,57 @@
+"""
+Étape 01 — Le Chatbot Naïf
+Un chatbot fonctionnel en ~10 lignes. Constat : l'IA est amnésique.
+
+OBSERVATION CLÉS :
+- Lors de cette session, le chatbot "se souvient" de tout (l'historique est en mémoire)
+- Si vous redémarrez le script, toute la mémoire disparaît
+- Le LLM lui-même n'a aucune mémoire — c'est NOUS qui gérons l'historique
+"""
+import os, sys
+import openai
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "etape_00_moteur"))
+from config import CONFIG, choose_mode, make_client
+
+mode = choose_mode()
+client = make_client(mode)
+MODEL = CONFIG[mode]["model"]
+
+msgs = [{"role": "system", "content": "Tu es un assistant utile et concis. Réponds en français."}]
+
+print("=== Chatbot Naïf — Étape 01 ===")
+print("Tapez 'quit' pour quitter.\n")
+print("ASTUCE : Dites votre prénom, puis demandez-le à nouveau après redémarrage !\n")
+
+try:
+    while True:
+        q = input("Vous: ").strip()
+        if q.lower() in ("quit", "exit", "q"):
+            print("\nAu revoir ! (Relancez le script : je ne me souviendrai de rien...)")
+            break
+        if not q:
+            continue
+
+        msgs.append({"role": "user", "content": q})
+
+        try:
+            response = client.chat.completions.create(model=MODEL, messages=msgs)
+            reply = response.choices[0].message.content
+            print(f"IA: {reply}\n")
+            msgs.append({"role": "assistant", "content": reply})
+
+        except openai.AuthenticationError:
+            print("ERREUR: Clé API invalide. Vérifiez OPENAI_API_KEY dans etape_00_moteur/.env\n")
+            msgs.pop()
+        except openai.APIConnectionError:
+            print("ERREUR: Impossible de contacter l'API. Vérifiez votre connexion internet.\n")
+            msgs.pop()
+        except openai.RateLimitError:
+            print("ERREUR: Limite de débit atteinte. Attendez quelques secondes.\n")
+            msgs.pop()
+        except Exception as e:
+            print(f"ERREUR inattendue: {e}\n")
+            msgs.pop()
+
+except KeyboardInterrupt:
+    print("\n\nAu revoir ! (Relancez le script : je ne me souviendrai de rien...)")

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_01_banane/EVALUATION_TP_ETAPE_01.md

@@ -0,0 +1,79 @@
+# 🧠 Évaluation — Étape 01 : Le Chatbot Naïf (La Banane)
+
+> ⏱ Durée estimée : 30 min | Niveau : Débutant
+
+## 🎯 Enjeu central
+
+Un LLM est **stateless** : il ne se souvient de rien entre deux appels. La "mémoire" du chatbot
+est une illusion que tu crées en renvoyant tout l'historique à chaque requête.
+Ça marche — mais ça ne survit pas au redémarrage, et ça grossit sans limite.
+
+---
+
+## ✅ Checklist de validation
+
+- [ ] J'ai lancé `02_chatbot_naif.py` et eu une vraie conversation
+- [ ] J'ai dit mon prénom, puis demandé "Quel est mon prénom ?" → réponse correcte
+- [ ] J'ai quitté (`quit`) et relancé → vérifié que le bot ne se souvient plus
+- [ ] J'ai observé comment la liste `msgs` grandit à chaque tour dans le code
+- [ ] J'ai comparé `01_chatbot_naif_no_message_stack.py` et `02_chatbot_naif.py`
+
+---
+
+## 🔍 Questions de compréhension
+
+### Niveau 1 — Observation
+1. Après 5 échanges, combien d'éléments contient `msgs` ? Décris le contenu du 3e élément.
+
+   > _________________________________________________________
+
+2. Que se passe-t-il exactement quand tu tapes `quit` et relances le script ? Quelle donnée est perdue ?
+
+   > _________________________________________________________
+
+3. Dans `01_chatbot_naif_no_message_stack.py` (sans historique), que répond le bot si tu lui donnes ton prénom puis demandes "Comment je m'appelle ?" à l'échange suivant ?
+
+   > _________________________________________________________
+
+### Niveau 2 — Analyse
+1. Pourquoi dit-on que la mémoire est une "illusion côté client" ? Qui fait vraiment le travail de mémorisation ?
+
+   > _________________________________________________________
+
+2. Si une conversation dure 200 échanges, combien de messages sont envoyés à l'API au 200e échange ? Quel impact sur le coût et la latence ?
+
+   > _________________________________________________________
+
+### Niveau 3 — Décision
+1. Tu déploies ce chatbot naïf pour 500 utilisateurs simultanés. Quels sont les 2 problèmes critiques du premier jour de prod ? Comment les hiérarchiser ?
+
+   > _________________________________________________________
+   > _________________________________________________________
+
+---
+
+## 🧪 Mini-expérience guidée
+
+Modifie le `system prompt` pour donner au bot une personnalité différente
+(ex : "Tu réponds uniquement en 10 mots maximum"). Lance une conversation et observe.
+
+**Comportement observé :**
+```
+_____________________________________________________________
+_____________________________________________________________
+```
+
+---
+
+## 📋 Lien avec le dossier E8
+
+- **Architecture** : Pourquoi l'architecture "stateless + historique côté client" est-elle à la fois une contrainte et un avantage pour un déploiement multi-utilisateurs ?
+- **Risques** : Si l'historique n'est pas plafonné, quel risque technique et financier émerge après quelques jours d'utilisation intensive ? Proposez une métrique à surveiller.
+
+---
+
+## 💡 Pour aller plus loin
+
+- Envoie la même question avec 0 et avec 10 échanges d'historique : compare la qualité des réponses.
+- Mesure la taille de `msgs` après 20 échanges et estime son coût en tokens (~4 chars = 1 token).
+- Lis la doc OpenAI sur le format `messages` : quels rôles existent au total ?

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_01_banane/README.md

@@ -0,0 +1,91 @@
+# Étape 01 — Le Chatbot Naïf (La Banane)
+
+## Objectif
+
+Créer un chatbot fonctionnel en une dizaine de lignes de Python.
+Constater et comprendre le problème fondamental : **l'amnésie du LLM**.
+
+## Le concept de la Banane
+
+Le "problème de la banane" illustre la nature stateless des LLMs :
+- Pendant une session : le chatbot semble avoir de la mémoire (grâce à `msgs`)
+- Après redémarrage : toute la "mémoire" disparaît
+
+Ce n'est pas un bug — c'est la nature fondamentale des LLMs.
+La mémoire est une **illusion** que nous créons côté client.
+
+## Ce que vous apprenez
+
+- L'API `client.chat.completions.create()` et ses paramètres
+- Le format `messages` : liste de dicts `{"role": ..., "content": ...}`
+- Les rôles : `system`, `user`, `assistant`
+- La nature **stateless** du LLM
+- Pourquoi l'historique doit être géré côté client
+
+## Installation
+
+```bash
+cd etape_01_banane
+pip install -r requirements.txt
+cp .env.example .env
+# Éditez .env avec votre clé API
+```
+
+## Utilisation
+
+### Version 1 — Sans historique (amnésie totale, même en session)
+```bash
+python 01_chatbot_naif_no_message_stack.py
+```
+
+### Version 2 — Avec historique de session (amnésie au redémarrage)
+```bash
+python 02_chatbot_naif.py
+```
+
+## Expériences à faire
+
+### Expérience 1 — Amnésie en session (version 1)
+1. Lancez `01_chatbot_naif_no_message_stack.py`
+2. Dites : `Je m'appelle [votre prénom]`
+3. Demandez : `Quel est mon prénom ?` → Il ne sait **déjà** plus ✗
+4. CONSTAT : chaque appel est indépendant, aucun historique côté client
+
+### Expérience 2 — Mémoire en session (version 2)
+1. Lancez `02_chatbot_naif.py`
+2. Dites : `Je m'appelle [votre prénom] et j'adore [un truc]`
+3. Demandez : `Quel est mon prénom ?` → Il répond correctement ✓
+4. Quittez avec `quit`
+
+### Expérience 3 — L'amnésie après redémarrage (version 2)
+1. Relancez `02_chatbot_naif.py`
+2. Demandez : `Quel est mon prénom ?` → Il ne sait plus ✗
+3. CONSTAT : la "mémoire" ne persiste pas entre les sessions
+
+### Expérience 4 — Inspecter le code
+Comparez les deux fichiers. Dans `02_chatbot_naif.py` :
+```python
+msgs = [{"role": "system", "content": "..."}]
+# On ajoute user + assistant à chaque tour
+msgs.append({"role": "user", "content": q})
+msgs.append({"role": "assistant", "content": reply})
+```
+C'est NOUS qui envoyons tout l'historique à chaque appel.
+
+## Fichiers
+
+```
+etape_01_banane/
+├── 01_chatbot_naif_no_message_stack.py  ← Amnésie totale (sans historique)
+├── 02_chatbot_naif.py                   ← Avec historique de session
+├── .env.example       ← Template d'environnement
+├── requirements.txt   ← Dépendances
+└── README.md          ← Ce fichier
+```
+
+## Question à méditer
+
+> Si le LLM est stateless et qu'on lui envoie l'historique complet à chaque appel,
+> que se passe-t-il quand la conversation devient très longue ?
+
+Réponse dans l'**Étape 03 — La Mémoire** !

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_01_banane/logs/prompts_demo.txt

@@ -0,0 +1,82 @@
+=== DÉMONSTRATION DU PROBLÈME D'AMNÉSIE ===
+
+Ce fichier montre deux sessions de conversation pour illustrer pourquoi
+on appelle ce problème "le problème de la banane" :
+si vous demandez à un chatbot naïf "qu'est-ce que je t'ai dit au début ?",
+il peut répondre "une banane" ... ou n'importe quoi d'autre lors du prochain lancement.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+--- Session 1 (normale — historique en mémoire pendant l'exécution) ---
+
+Vous: Je m'appelle Jean et j'adore programmer en Python.
+IA: Bonjour Jean ! C'est super que vous aimiez Python, c'est un excellent langage
+    de programmation. Que puis-je faire pour vous aujourd'hui ?
+
+Vous: Quel est mon prénom ?
+IA: Vous m'avez dit que vous vous appelez Jean !
+
+Vous: Quel est mon langage de programmation préféré ?
+IA: Vous m'avez dit que vous adorez Python, Jean !
+
+Vous: Donne-moi un projet sympa à faire en Python ce week-end.
+IA: Voici quelques idées de projets Python pour le week-end, Jean :
+    1. Un scraper web pour collecter des données qui vous intéressent
+    2. Un bot Discord ou Telegram
+    3. Un jeu de texte en console (pendu, quiz, etc.)
+    4. Un analyseur de vos dépenses personnelles en CSV
+    5. Un générateur de mots de passe sécurisé
+
+Vous: Merci, je vais faire le bot Telegram !
+IA: Excellent choix Jean ! Les bots Telegram sont très amusants à créer.
+    Vous aurez besoin de la bibliothèque python-telegram-bot...
+
+CONSTAT SESSION 1 : Tout fonctionne, le chatbot "se souvient" de votre prénom
+et de vos préférences — MAIS seulement parce que l'historique est en mémoire RAM.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+--- Session 2 (après redémarrage du script — PROBLÈME D'AMNÉSIE) ---
+
+[Le script a été arrêté et relancé. L'historique en mémoire est PERDU.]
+
+Vous: Quel est mon prénom ?
+IA: Je suis désolé, je ne connais pas votre prénom. Vous ne me l'avez pas encore dit !
+    Comment puis-je vous appeler ?
+
+Vous: Quel est mon langage de programmation préféré ?
+IA: Je n'ai aucune information sur vos préférences en matière de programmation.
+    Vous ne m'avez pas encore dit quel langage vous aimez. Lequel est-ce ?
+
+Vous: Pourtant je te l'ai dit il y a 5 minutes !
+IA: Je comprends votre frustration, mais je dois vous informer que je n'ai pas
+    accès aux conversations précédentes. Chaque nouvelle session repart de zéro.
+    Je n'ai aucune mémoire persistante entre les conversations.
+
+CONSTAT SESSION 2 : Le LLM est STATELESS. Il ne se souvient de rien entre
+les sessions. La "mémoire" de la session 1 était une ILLUSION gérée par NOUS
+(la liste `msgs` en Python). Dès qu'on redémarre, tout disparaît.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+--- Session 3 (illustration de la banane) ---
+
+Vous: Au début de notre conversation, je t'ai dit que j'aimais les bananes.
+IA: Je suis désolé, je n'ai aucune trace d'une conversation précédente entre nous.
+    Cette session vient de commencer ! Aimez-vous vraiment les bananes ?
+
+C'est le "problème de la banane" : vous pouvez dire n'importe quoi
+en début de session, mais si vous redémarrez, c'est comme si ça n'avait
+jamais existé.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+SOLUTIONS (abordées dans les étapes suivantes) :
+
+1. Étape 03 — Fenêtre glissante : garder les N derniers messages en RAM
+2. Étape 04 — Persistance SQLite : sauvegarder l'historique sur disque
+3. Étape 05 — RAG : accéder à une base de connaissances externe
+
+LA LEÇON FONDAMENTALE :
+Le LLM est un ORACLE stateless. Lui envoyer l'historique à chaque appel,
+c'est comme lui donner la mémoire. C'est NOTRE responsabilité de la gérer.

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_01_banane/requirements.txt

@@ -0,0 +1,2 @@
+openai>=1.0.0
+python-dotenv>=1.0.0

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_02_kpis/.env.example

@@ -0,0 +1,9 @@
+# Étape 02 — La config est mutualisée dans etape_00_moteur/.env
+# Copiez et remplissez etape_00_moteur/.env.example si ce n'est pas déjà fait.
+#
+# Variables lues depuis etape_00_moteur/.env :
+#   OPENAI_API_KEY  — clé API OpenAI (mode cloud)
+#   MODE            — "cloud" ou "local" (défaut si non saisi interactivement)
+#   CLOUD_MODEL     — modèle OpenAI (défaut : gpt-4o-mini)
+#   LOCAL_BASE_URL  — URL LM Studio (défaut : http://localhost:1234/v1)
+#   LOCAL_MODEL     — modèle LM Studio chargé

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_02_kpis/01_mesurer_kpis.py

@@ -0,0 +1,128 @@
+"""
+Étape 02 — Mesurer pour Comprendre
+Intégration des KPIs de performance : latence, TPS, coût.
+"""
+import os, sys, time
+import openai
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "etape_00_moteur"))
+from config import CONFIG, choose_mode, make_client
+
+mode = choose_mode()
+client = make_client(mode)
+MODEL = CONFIG[mode]["model"]
+price_input = CONFIG[mode]["price_input"]
+price_output = CONFIG[mode]["price_output"]
+
+msgs = [{"role": "system", "content": "Tu es un assistant utile et concis. Réponds en français."}]
+
+session_stats = {
+    "total_requests": 0,
+    "total_latency": 0.0,
+    "total_prompt_tokens": 0,
+    "total_completion_tokens": 0,
+    "total_cost": 0.0,
+    "latencies": [],
+}
+
+
+def calc_cost(prompt_tokens: int, completion_tokens: int) -> float:
+    return (prompt_tokens * price_input + completion_tokens * price_output) / 1000
+
+
+def print_kpis(latency: float, prompt_tokens: int, completion_tokens: int, cost: float):
+    tps = completion_tokens / latency if latency > 0 else 0
+    cost_str = f"${cost:.6f}" if price_output > 0 else "gratuit (local)"
+    total_str = f"${session_stats['total_cost']:.6f}" if price_output > 0 else "gratuit (local)"
+    print(f"\n  ┌─ KPIs ─────────────────────────────────────────┐")
+    print(f"  │ Latence    : {latency:.3f}s", end="")
+    status = "✓" if latency < 2 else ("⚠" if latency < 5 else "✗")
+    print(f"  {status} (cible < 2s)")
+    print(f"  │ TPS        : {tps:.1f} tokens/sec", end="")
+    status = "✓" if tps > 30 else "⚠"
+    print(f"  {status}")
+    print(f"  │ Tokens     : {prompt_tokens} in → {completion_tokens} out")
+    print(f"  │ Coût       : {cost_str}")
+    print(f"  │ Coût total : {total_str}")
+    print(f"  └────────────────────────────────────────────────┘\n")
+
+
+def print_session_summary():
+    n = session_stats["total_requests"]
+    if n == 0:
+        return
+    avg_latency = session_stats["total_latency"] / n
+    latencies = sorted(session_stats["latencies"])
+    p50_idx = int(0.50 * len(latencies))
+    p50 = latencies[min(p50_idx, len(latencies) - 1)]
+    p95_idx = int(0.95 * len(latencies))
+    p95 = latencies[min(p95_idx, len(latencies) - 1)]
+    cost_str = f"${session_stats['total_cost']:.6f}" if price_output > 0 else "gratuit (local)"
+    print(f"\n  ╔═ RÉSUMÉ DE SESSION ({'='*30})╗")
+    print(f"  ║ Requêtes        : {n}")
+    print(f"  ║ Latence moyenne : {avg_latency:.3f}s")
+    print(f"  ║ Latence P50     : {p50:.3f}s")
+    print(f"  ║ Latence P95     : {p95:.3f}s")
+    print(f"  ║ Tokens totaux   : {session_stats['total_prompt_tokens']} in / {session_stats['total_completion_tokens']} out")
+    print(f"  ║ Coût total      : {cost_str}")
+    print(f"  ╚{'═'*52}╝\n")
+
+
+print(f"=== Chatbot avec KPIs — Étape 02 ===")
+print(f"Modèle : {MODEL} | Mode : {mode}")
+print("Tapez 'stats' pour le résumé, 'quit' pour quitter.\n")
+
+try:
+    while True:
+        q = input("Vous: ").strip()
+        if q.lower() in ("quit", "exit", "q"):
+            break
+        if q.lower() == "stats":
+            print_session_summary()
+            continue
+        if not q:
+            continue
+
+        msgs.append({"role": "user", "content": q})
+
+        start = time.time()
+        try:
+            response = client.chat.completions.create(model=MODEL, messages=msgs)
+        except openai.AuthenticationError:
+            print("  ✗ Erreur : clé API invalide. Vérifiez OPENAI_API_KEY dans etape_00_moteur/.env\n")
+            msgs.pop()
+            continue
+        except openai.APIConnectionError:
+            print("  ✗ Erreur : impossible de se connecter. Vérifiez que LM Studio est démarré.\n")
+            msgs.pop()
+            continue
+        except Exception as e:
+            print(f"  ✗ Erreur inattendue : {e}\n")
+            msgs.pop()
+            continue
+
+        latency = time.time() - start
+        reply = response.choices[0].message.content
+        prompt_tokens = response.usage.prompt_tokens
+        completion_tokens = response.usage.completion_tokens
+        cost = calc_cost(prompt_tokens, completion_tokens)
+
+        msgs.append({"role": "assistant", "content": reply})
+
+        session_stats["total_requests"] += 1
+        session_stats["total_latency"] += latency
+        session_stats["total_prompt_tokens"] += prompt_tokens
+        session_stats["total_completion_tokens"] += completion_tokens
+        session_stats["total_cost"] += cost
+        session_stats["latencies"].append(latency)
+
+        print(f"IA: {reply}")
+        print_kpis(latency, prompt_tokens, completion_tokens, cost)
+
+        if session_stats["total_requests"] % 5 == 0:
+            print_session_summary()
+
+except KeyboardInterrupt:
+    print("\n\nRésumé final :")
+    print_session_summary()
+    print("Au revoir !")

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_02_kpis/02_kpis_comparatif.py

@@ -0,0 +1,142 @@
+"""
+Étape 02 — Comparaison des KPIs
+Lance les mêmes prompts sur les configs sélectionnées et compare les résultats.
+"""
+import os, sys, time, json
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "etape_00_moteur"))
+from config import CONFIG, list_configs, make_client, choose_mode
+
+try:
+    from tabulate import tabulate
+    HAS_TABULATE = True
+except ImportError:
+    HAS_TABULATE = False
+
+PROMPTS = [
+    "Explique le concept de mémoire dans les chatbots en 2 phrases.",
+    "Quelle est la différence entre GPT-4o et GPT-4o-mini ?",
+    "Donne-moi 3 avantages du RAG par rapport au fine-tuning.",
+    "Qu'est-ce que le context window d'un LLM ?",
+    "Explique TPS (Tokens Per Second) et pourquoi c'est important.",
+]
+
+
+def choose_configs() -> list[dict]:
+    """Sélection interactive des configs à comparer."""
+    configs = list_configs()
+    print("Configs disponibles :")
+    for i, name in enumerate(configs, 1):
+        cfg = CONFIG[name]
+        print(f"  {i}. {name} — modèle : {cfg['model']}")
+    print("Sélectionnez les configs à comparer (ex: '1 2', '1,2', 'cloud local').")
+    print("Appuyez sur Entrée pour toutes les sélectionner.")
+    choice = input("Votre choix : ").strip()
+
+    if not choice:
+        selected_names = configs
+    else:
+        parts = choice.replace(",", " ").split()
+        selected_names = []
+        for p in parts:
+            if p.isdigit() and 1 <= int(p) <= len(configs):
+                selected_names.append(configs[int(p) - 1])
+            elif p in configs:
+                selected_names.append(p)
+        if not selected_names:
+            print("  Sélection invalide, toutes les configs seront utilisées.")
+            selected_names = configs
+
+    return [
+        {
+            "name": name,
+            "label": f"{name} ({CONFIG[name]['model']})",
+            "model": CONFIG[name]["model"],
+            "client": make_client(name),
+            "price_input": CONFIG[name]["price_input"],
+            "price_output": CONFIG[name]["price_output"],
+        }
+        for name in selected_names
+    ]
+
+
+def run_benchmark(cfg: dict, prompts: list) -> list:
+    results = []
+    for i, prompt in enumerate(prompts):
+        print(f"  [{i+1}/{len(prompts)}] {prompt[:50]}...")
+        start = time.time()
+        try:
+            response = cfg["client"].chat.completions.create(
+                model=cfg["model"],
+                messages=[
+                    {"role": "system", "content": "Réponds en français, de façon concise."},
+                    {"role": "user", "content": prompt},
+                ],
+            )
+            latency = time.time() - start
+            pt = response.usage.prompt_tokens
+            ct = response.usage.completion_tokens
+            cost = (pt * cfg["price_input"] + ct * cfg["price_output"]) / 1000
+            tps = ct / latency if latency > 0 else 0
+            results.append({
+                "prompt": prompt[:40] + "...",
+                "latency": round(latency, 3),
+                "tps": round(tps, 1),
+                "prompt_tokens": pt,
+                "completion_tokens": ct,
+                "cost_mc": round(cost * 1000, 4),  # millicents
+            })
+        except Exception as e:
+            print(f"    Erreur: {e}")
+            results.append({
+                "prompt": prompt[:40] + "...",
+                "latency": -1, "tps": -1,
+                "prompt_tokens": -1, "completion_tokens": -1, "cost_mc": -1,
+            })
+    return results
+
+
+def print_results(cfg: dict, results: list):
+    label = cfg["label"]
+    is_free = cfg["price_output"] == 0
+    print(f"\n=== Résultats : {label} ===")
+    headers = ["Prompt", "Latence(s)", "TPS", "Tok. In", "Tok. Out", "Coût(m$)"]
+    rows = [
+        [
+            r["prompt"], r["latency"], r["tps"],
+            r["prompt_tokens"], r["completion_tokens"],
+            "gratuit" if is_free else r["cost_mc"],
+        ]
+        for r in results
+    ]
+    if HAS_TABULATE:
+        print(tabulate(rows, headers=headers, tablefmt="rounded_grid"))
+    else:
+        print(f"{'Latence':>10} {'TPS':>8} {'TokIn':>8} {'TokOut':>8} {'Coût':>10}")
+        for r in results:
+            cost_str = "  gratuit" if is_free else f"{r['cost_mc']:>10.4f}"
+            print(f"{r['latency']:>10.3f} {r['tps']:>8.1f} {r['prompt_tokens']:>8} {r['completion_tokens']:>8} {cost_str}")
+
+    valid = [r for r in results if r["latency"] > 0]
+    if valid:
+        avg_lat = sum(r["latency"] for r in valid) / len(valid)
+        avg_tps = sum(r["tps"] for r in valid) / len(valid)
+        cost_str = "gratuit" if is_free else f"{sum(r['cost_mc'] for r in valid):.4f} m$"
+        print(f"\nMoyennes → Latence: {avg_lat:.3f}s | TPS: {avg_tps:.1f} | Coût total: {cost_str}")
+
+
+if __name__ == "__main__":
+    print("=== Benchmark Comparatif — Étape 02 ===\n")
+
+    selected = choose_configs()
+    all_results = {}
+
+    for cfg in selected:
+        print(f"\n--- Benchmark : {cfg['label']} ---")
+        results = run_benchmark(cfg, PROMPTS)
+        print_results(cfg, results)
+        all_results[cfg["name"]] = {"model": cfg["model"], "results": results}
+
+    with open("benchmark_results.json", "w") as f:
+        json.dump(all_results, f, indent=2)
+    print("\nRésultats sauvegardés dans benchmark_results.json")

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_02_kpis/EVALUATION_TP_ETAPE_02.md

@@ -0,0 +1,79 @@
+# 🧠 Évaluation — Étape 02 : Mesurer pour Comprendre (KPIs)
+
+> ⏱ Durée estimée : 30 min | Niveau : Débutant
+
+## 🎯 Enjeu central
+
+On ne pilote pas ce qu'on ne mesure pas. Cette étape introduit les 4 KPIs fondamentaux
+d'un LLM en production : latence, TPS, coût par requête, P95.
+L'enjeu : prendre des décisions techniques basées sur des chiffres, pas des intuitions.
+
+---
+
+## ✅ Checklist de validation
+
+- [ ] J'ai lancé `01_mesurer_kpis.py` et posé au moins 5 questions
+- [ ] J'ai tapé `stats` et lu le résumé de session
+- [ ] J'ai noté mon P95 personnel
+- [ ] J'ai lancé `02_kpis_comparatif.py` et obtenu des résultats chiffrés
+
+---
+
+## 🔍 Questions de compréhension
+
+### Niveau 1 — Observation
+1. Quel TPS (tokens/seconde) as-tu observé ? Est-il dans la plage attendue pour le cloud (~80 TPS) ?
+
+   > _________________________________________________________
+
+2. Quel était ton coût moyen par requête en dollars ? Combien coûterait 10 000 requêtes/jour ?
+
+   > _________________________________________________________
+
+3. Quelle est la différence entre ta latence **moyenne** et ton **P95** ? Sur combien de requêtes ?
+
+   > _________________________________________________________
+
+### Niveau 2 — Analyse
+1. Pourquoi le P95 est-il plus utile que la moyenne ? Donne un exemple où la moyenne serait trompeuse.
+
+   > _________________________________________________________
+
+2. La formule est `(prompt_tokens × $0.00015 + completion_tokens × $0.00060) / 1000`. Pourquoi les tokens de complétion sont-ils 4× plus chers ? Qu'est-ce que ça implique pour la taille du system prompt ?
+
+   > _________________________________________________________
+
+### Niveau 3 — Décision
+1. Définis un SLA réaliste pour ce chatbot en production : seuils pour P50, P95 et coût journalier pour 1 000 utilisateurs actifs. Justifie chaque chiffre.
+
+   > _________________________________________________________
+   > _________________________________________________________
+
+---
+
+## 🧪 Mini-expérience guidée
+
+Pose la même question simple ("Quelle est la capitale de la France ?") 5 fois de suite.
+Note les latences individuelles. Sont-elles identiques ? Explique la variabilité.
+
+**Mes 5 latences :** `___s  ___s  ___s  ___s  ___s`
+
+**Explication :**
+```
+_____________________________________________________________
+```
+
+---
+
+## 📋 Lien avec le dossier E8
+
+- **Métriques** : Quels KPIs intégreriez-vous dans un tableau de bord de supervision ? Pourquoi le P95 est-il l'indicateur de référence pour les SLA ?
+- **Coûts** : Estimez le budget mensuel pour 500 employés faisant chacun 10 questions/jour. Détaillez l'hypothèse de coût par requête.
+
+---
+
+## 💡 Pour aller plus loin
+
+- Compare les TPS entre différents modèles (`gpt-4o` vs `gpt-4o-mini`).
+- Mesure le "coût du contexte" : 0 message d'historique vs 8 messages.
+- Cherche la définition de P50, P95, P99 dans le vocabulaire SRE.

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_02_kpis/README.md

@@ -0,0 +1,46 @@
+# Étape 02 — Mesurer pour Comprendre
+
+## Objectif
+Intégrer des KPIs de performance dans le chatbot dès le début.
+
+## KPIs mesurés
+| KPI | Description | Cible |
+|-----|-------------|-------|
+| Latence | Temps total de réponse | < 2s (P50) |
+| TPS | Tokens Per Second | Cloud ~80, Local ~15 |
+| Coût/requête | Tokens × prix modèle | < $0.001 |
+| Latence P95 | 95e percentile | < 5s |
+
+## Installation
+```bash
+pip install -r requirements.txt
+cp .env.example .env
+# Éditez .env avec votre clé API
+```
+
+## Scripts
+
+### `01_mesurer_kpis.py` — Chatbot avec métriques en temps réel
+```bash
+python 01_mesurer_kpis.py
+```
+Commandes disponibles :
+- `stats` : affiche le résumé de session
+- `quit` : quitte
+
+### `02_kpis_comparatif.py` — Benchmark comparatif
+```bash
+python 02_kpis_comparatif.py
+```
+
+## Exercice
+1. Lancez `01_mesurer_kpis.py` et posez 10 questions
+2. Tapez `stats` pour voir vos métriques
+3. Lancez `02_kpis_comparatif.py` pour voir le benchmark
+4. Comparez les résultats cloud vs local (si LM Studio installé)
+
+## Formule de coût
+```
+coût = (prompt_tokens × $0.00015 + completion_tokens × $0.00060) / 1000
+```
+Pour gpt-4o-mini. Consultez la page de tarification OpenAI pour les autres modèles.

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_02_kpis/logs/benchmark_results.json

@@ -0,0 +1,92 @@
+{
+  "reseau_ministral3b": {
+    "model": "mistralai/ministral-3-3b",
+    "results": [
+      {
+        "prompt": "Explique le concept de m\u00e9moire dans les ...",
+        "latency": 3.422,
+        "tps": 19.6,
+        "prompt_tokens": 31,
+        "completion_tokens": 67,
+        "cost_mc": 0.0
+      },
+      {
+        "prompt": "Quelle est la diff\u00e9rence entre GPT-4o et...",
+        "latency": 0.812,
+        "tps": 133.0,
+        "prompt_tokens": 35,
+        "completion_tokens": 108,
+        "cost_mc": 0.0
+      },
+      {
+        "prompt": "Donne-moi 3 avantages du RAG par rapport...",
+        "latency": 1.01,
+        "tps": 138.6,
+        "prompt_tokens": 32,
+        "completion_tokens": 140,
+        "cost_mc": 0.0
+      },
+      {
+        "prompt": "Qu'est-ce que le context window d'un LLM...",
+        "latency": 0.863,
+        "tps": 135.6,
+        "prompt_tokens": 27,
+        "completion_tokens": 117,
+        "cost_mc": 0.0
+      },
+      {
+        "prompt": "Explique TPS (Tokens Per Second) et pour...",
+        "latency": 1.716,
+        "tps": 141.6,
+        "prompt_tokens": 30,
+        "completion_tokens": 243,
+        "cost_mc": 0.0
+      }
+    ]
+  },
+  "force_localhost_mistral7b": {
+    "model": "mistralai/ministral-3-3b",
+    "results": [
+      {
+        "prompt": "Explique le concept de m\u00e9moire dans les ...",
+        "latency": 6.518,
+        "tps": 11.0,
+        "prompt_tokens": 31,
+        "completion_tokens": 72,
+        "cost_mc": 0.0
+      },
+      {
+        "prompt": "Quelle est la diff\u00e9rence entre GPT-4o et...",
+        "latency": 14.959,
+        "tps": 11.2,
+        "prompt_tokens": 35,
+        "completion_tokens": 168,
+        "cost_mc": 0.0
+      },
+      {
+        "prompt": "Donne-moi 3 avantages du RAG par rapport...",
+        "latency": 13.655,
+        "tps": 10.9,
+        "prompt_tokens": 32,
+        "completion_tokens": 149,
+        "cost_mc": 0.0
+      },
+      {
+        "prompt": "Qu'est-ce que le context window d'un LLM...",
+        "latency": 12.564,
+        "tps": 10.7,
+        "prompt_tokens": 27,
+        "completion_tokens": 135,
+        "cost_mc": 0.0
+      },
+      {
+        "prompt": "Explique TPS (Tokens Per Second) et pour...",
+        "latency": 13.028,
+        "tps": 11.0,
+        "prompt_tokens": 30,
+        "completion_tokens": 143,
+        "cost_mc": 0.0
+      }
+    ]
+  }
+}

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_02_kpis/prompts_benchmark.txt

@@ -0,0 +1,8 @@
+# Prompts de benchmark — Étape 02
+# Ces prompts testent différents types de réponses (longueur, complexité)
+
+1. Explique le concept de mémoire dans les chatbots en 2 phrases.
+2. Quelle est la différence entre GPT-4o et GPT-4o-mini ?
+3. Donne-moi 3 avantages du RAG par rapport au fine-tuning.
+4. Qu'est-ce que le context window d'un LLM ?
+5. Explique TPS (Tokens Per Second) et pourquoi c'est important en production.

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_02_kpis/requirements.txt

@@ -0,0 +1,3 @@
+openai>=1.0.0
+python-dotenv>=1.0.0
+tabulate>=0.9.0

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_03_memoire/.env.example

@@ -0,0 +1,3 @@
+OPENAI_API_KEY=sk-your-key-here
+MODEL=gpt-4o-mini
+MAX_HISTORY=8

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_03_memoire/01_memory_window.py

@@ -0,0 +1,103 @@
+"""
+Étape 03 — Window Memory
+Limite la fenêtre de contexte pour contrôler les coûts.
+Concept clé : le Context Window
+"""
+import os, sys, time
+import openai
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "etape_00_moteur"))
+from config import CONFIG, choose_mode, make_client, clean_reply
+
+mode = choose_mode()
+client = make_client(mode)
+MODEL = CONFIG[mode]["model"]
+MAX_HISTORY = int(os.environ.get("MAX_HISTORY", "8"))  # 4 paires user+assistant
+
+SYSTEM = {
+    "role": "system",
+    "content": (
+        "Tu es un assistant utile et concis. Réponds en français. "
+        "Si on te demande ce dont tu te souviens, liste les sujets abordés dans la conversation."
+    )
+}
+
+history = []
+
+def build_context():
+    """Retourne la fenêtre glissante des MAX_HISTORY derniers messages.
+    S'assure que la fenêtre commence toujours par un message 'user'."""
+    window = history[-MAX_HISTORY:]
+    # Si la fenêtre commence par un assistant, on saute ce message orphelin
+    while window and window[0]["role"] != "user":
+        window = window[1:]
+    return [SYSTEM] + window
+
+def count_approx_tokens(messages):
+    """Estimation rapide : ~4 chars = 1 token."""
+    total_chars = sum(len(m["content"]) for m in messages)
+    return total_chars // 4
+
+print(f"=== Window Memory — Étape 03 ===")
+print(f"Modèle : {MODEL} | Fenêtre : {MAX_HISTORY} messages ({MAX_HISTORY//2} échanges)\n")
+print("Commandes : 'fenetre' (voir contexte actuel), 'reset' (vider), 'quit'\n")
+
+try:
+    while True:
+        q = input("Vous: ").strip()
+
+        if q.lower() in ("quit", "exit", "q"):
+            break
+
+        if q.lower() == "fenetre":
+            msgs = build_context()
+            print(f"\n  Contexte actuel : {len(msgs)-1}/{MAX_HISTORY} messages d'historique")
+            print(f"  Tokens estimés  : ~{count_approx_tokens(msgs)}")
+            print(f"  Messages en mémoire :")
+            for m in history[-MAX_HISTORY:]:
+                role = "Vous" if m["role"] == "user" else "IA"
+                preview = m["content"][:60] + ("..." if len(m["content"]) > 60 else "")
+                print(f"    [{role}] {preview}")
+            print()
+            continue
+
+        if q.lower() == "reset":
+            history.clear()
+            print("  Mémoire effacée.\n")
+            continue
+
+        if not q:
+            continue
+
+        history.append({"role": "user", "content": q})
+
+        # Construction de la fenêtre glissante
+        msgs = build_context()
+        nb_old = max(0, len(history) - MAX_HISTORY)
+        if nb_old > 0:
+            print(f"  ⚠  {nb_old} message(s) ancien(s) oublié(s) (hors fenêtre)")
+
+        start = time.time()
+        try:
+            response = client.chat.completions.create(model=MODEL, messages=msgs)
+        except openai.AuthenticationError:
+            print("  ✗ Clé API invalide.\n")
+            history.pop()
+            continue
+        except Exception as e:
+            print(f"  ✗ Erreur : {e}\n")
+            history.pop()
+            continue
+
+        latency = time.time() - start
+        reply = clean_reply(response.choices[0].message.content)
+        tokens_in = response.usage.prompt_tokens
+        tokens_out = response.usage.completion_tokens
+
+        history.append({"role": "assistant", "content": reply})
+
+        print(f"IA: {reply}")
+        print(f"  [contexte: {len(msgs)-1}/{MAX_HISTORY} msgs | {tokens_in}→{tokens_out} tokens | {latency:.2f}s]\n")
+
+except KeyboardInterrupt:
+    print("\n\nAu revoir !")

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_03_memoire/02_memory_summary.py

@@ -0,0 +1,103 @@
+"""
+Étape 03 — Memory with Summarization (avancé)
+Quand l'historique dépasse MAX_HISTORY, résume les anciens messages
+avec le LLM et conserve ce résumé comme contexte compressé.
+"""
+import os, sys, time
+import openai
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "etape_00_moteur"))
+from config import CONFIG, choose_mode, make_client, clean_reply
+
+mode = choose_mode()
+client = make_client(mode)
+MODEL = CONFIG[mode]["model"]
+MAX_HISTORY = int(os.environ.get("MAX_HISTORY", "6"))
+SUMMARY_TRIGGER = MAX_HISTORY  # Résume quand on dépasse cette limite
+
+history = []
+summary = ""  # Résumé compressé des anciens échanges
+
+def summarize_old_messages(messages_to_summarize):
+    """Utilise le LLM pour résumer les anciens messages."""
+    text = "\n".join(
+        f"{'Utilisateur' if m['role']=='user' else 'Assistant'}: {m['content']}"
+        for m in messages_to_summarize
+    )
+    prompt = f"""Voici un historique de conversation. Fais un résumé concis (max 100 mots)
+des points clés : sujets abordés, informations importantes, préférences de l'utilisateur.
+
+Historique :
+{text}
+
+Résumé :"""
+    try:
+        response = client.chat.completions.create(
+            model=MODEL,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=150
+        )
+        return clean_reply(response.choices[0].message.content)
+    except Exception:
+        return f"[Résumé de {len(messages_to_summarize)} messages anciens]"
+
+def build_context():
+    global history, summary
+    system_content = "Tu es un assistant utile et concis. Réponds en français."
+    if summary:
+        system_content += f"\n\nRésumé de la conversation précédente :\n{summary}"
+
+    # Si l'historique dépasse la limite, on résume les anciens
+    if len(history) > SUMMARY_TRIGGER:
+        nb_to_summarize = len(history) - MAX_HISTORY // 2
+        to_summarize = history[:nb_to_summarize]
+        recent = history[nb_to_summarize:]
+        print(f"  [Résumé en cours de {len(to_summarize)} messages...]")
+        summary = summarize_old_messages(to_summarize)
+        history = recent
+        system_content += f"\n\nRésumé des échanges précédents :\n{summary}"
+        print(f"  [Résumé créé : {summary[:80]}...]\n")
+
+    return [{"role": "system", "content": system_content}] + history
+
+print(f"=== Memory with Summarization — Étape 03 (avancé) ===")
+print(f"Modèle : {MODEL} | Max avant résumé : {SUMMARY_TRIGGER} messages\n")
+print("Commandes : 'resume' (voir le résumé actuel), 'quit'\n")
+
+try:
+    while True:
+        q = input("Vous: ").strip()
+
+        if q.lower() in ("quit", "exit", "q"):
+            break
+
+        if q.lower() == "resume":
+            if summary:
+                print(f"\n  Résumé actuel :\n  {summary}\n")
+            else:
+                print("  Pas encore de résumé (historique court).\n")
+            continue
+
+        if not q:
+            continue
+
+        history.append({"role": "user", "content": q})
+        msgs = build_context()
+
+        start = time.time()
+        try:
+            response = client.chat.completions.create(model=MODEL, messages=msgs)
+        except Exception as e:
+            print(f"  ✗ Erreur : {e}\n")
+            history.pop()
+            continue
+
+        latency = time.time() - start
+        reply = clean_reply(response.choices[0].message.content)
+        history.append({"role": "assistant", "content": reply})
+
+        print(f"IA: {reply}")
+        print(f"  [historique: {len(history)} msgs | résumé: {'oui' if summary else 'non'} | {latency:.2f}s]\n")
+
+except KeyboardInterrupt:
+    print("\n\nAu revoir !")

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_03_memoire/EVALUATION_TP_ETAPE_03.md

@@ -0,0 +1,81 @@
+# 🧠 Évaluation — Étape 03 : La Mémoire Tampon
+
+> ⏱ Durée estimée : 45 min | Niveau : Intermédiaire
+
+## 🎯 Enjeu central
+
+Le contexte d'un LLM est une ressource limitée **et payante**. Garder tout l'historique
+indéfiniment est impraticable : ça coûte de plus en plus cher et ralentit les réponses.
+Deux stratégies s'affrontent : fenêtre glissante (simple, prévisible) vs résumé automatique
+(plus coûteux, mais préserve l'essentiel).
+
+---
+
+## ✅ Checklist de validation
+
+- [ ] J'ai lancé `01_memory_window.py` avec `MAX_HISTORY=4`
+- [ ] J'ai posé 10 questions sur des sujets différents et tapé `fenetre`
+- [ ] J'ai vérifié que les premières questions avaient disparu de la fenêtre
+- [ ] J'ai lancé `02_memory_summary.py` et comparé ce qu'il retient
+- [ ] J'ai changé `MAX_HISTORY` à 2 et observé l'effet sur la cohérence
+
+---
+
+## 🔍 Questions de compréhension
+
+### Niveau 1 — Observation
+1. Avec `MAX_HISTORY=4`, quel est le 1er message qui disparaît après le 3e échange ? Qu'est-ce qui le remplace ?
+
+   > _________________________________________________________
+
+2. Dans `memory_summary.py`, que contient le résumé généré après avoir dépassé la limite ? Reproduis un extrait.
+
+   > _________________________________________________________
+
+3. Avec `MAX_HISTORY=2`, si tu donnes ton prénom au 1er échange et poses une question au 3e, le bot se souvient-il de toi ? Pourquoi ?
+
+   > _________________________________________________________
+
+### Niveau 2 — Analyse
+1. La fenêtre glissante coupe les premiers messages. Pourquoi c'est problématique si le `system prompt` contient des instructions importantes que l'utilisateur ne voit pas ?
+
+   > _________________________________________________________
+
+2. Le résumé automatique fait **2 appels LLM** au lieu d'1. Dans quel cas est-ce justifié ? Dans quel cas est-ce une mauvaise idée ?
+
+   > _________________________________________________________
+
+### Niveau 3 — Décision
+1. Tu déploies un chatbot de support client (conversations de ~15 échanges en moyenne). Fenêtre glissante (`MAX_HISTORY=8`) ou résumé automatique ? Argumente : coût, fiabilité, expérience utilisateur.
+
+   > _________________________________________________________
+   > _________________________________________________________
+
+---
+
+## 🧪 Mini-expérience guidée
+
+Lance `memory_window.py` avec `MAX_HISTORY=20`. Conduis 25 échanges.
+Mesure la latence à l'échange 1 vs l'échange 25. Quelle tendance observes-tu ?
+
+**Latence échange 1 :** `___s` | **Latence échange 25 :** `___s`
+
+**Explication :**
+```
+_____________________________________________________________
+```
+
+---
+
+## 📋 Lien avec le dossier E8
+
+- **Architecture** : Quel mécanisme de gestion de la mémoire choisiriez-vous pour un assistant RH devant se souvenir du contexte d'un entretien de plusieurs heures ? Justifiez le choix technique.
+- **Coûts** : Calculez l'impact d'une fenêtre de 20 messages vs 4 messages sur le coût mensuel pour 1 000 utilisateurs / 10 échanges par jour. Formulez une recommandation.
+
+---
+
+## 💡 Pour aller plus loin
+
+- Essaie `MAX_HISTORY=0` : le bot est-il encore utilisable ?
+- Modifie le prompt de résumé dans `memory_summary.py` pour qu'il soit limité à 50 mots.
+- Cherche les tailles de context window : GPT-4o (128K), Mistral 7B (~8K). Qu'est-ce que ça change pour la stratégie ?

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_03_memoire/README.md

@@ -0,0 +1,44 @@
+# Étape 03 — La Mémoire Tampon
+
+## Objectif
+Simuler la mémoire avec une Window Memory et comprendre le Context Window.
+
+## Concept clé : Context Window
+| Modèle | Contexte max | Recommandation |
+|--------|-------------|----------------|
+| GPT-4o | 128K tokens | Fenêtre de 20 échanges |
+| GPT-4o-mini | 128K tokens | Fenêtre de 10 échanges |
+| Phi-3 local | 4K tokens | Fenêtre de 4 échanges |
+
+**Règle d'or :** `coût ∝ nombre de tokens envoyés`
+
+## Installation
+```bash
+pip install -r requirements.txt
+cp .env.example .env
+```
+
+## Scripts
+
+### `01_memory_window.py` — Fenêtre glissante simple
+```bash
+python 01_memory_window.py
+```
+Commandes : `fenetre`, `reset`, `quit`
+
+### `02_memory_summary.py` — Résumé automatique (avancé)
+```bash
+MAX_HISTORY=6 python 02_memory_summary.py
+```
+
+## Exercice
+1. Lancez `01_memory_window.py` avec `MAX_HISTORY=4`
+2. Posez 10 questions sur des sujets différents
+3. Tapez `fenetre` pour voir ce qui est retenu
+4. Vérifiez que les premières questions sont oubliées
+5. Comparez avec `02_memory_summary.py` : que retient-il ?
+
+## Variable d'environnement
+```
+MAX_HISTORY=8   # nombre de messages conservés (4 échanges)
+```

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_03_memoire/logs/01_memory_window.log

@@ -0,0 +1,81 @@
+(venv) root@MSI:/mnt/c/git/ai/tp_ia_chatbot/etape_03_memoire# python memory_window.py 
+Configs disponibles :
+  1. cloud — modèle : gpt-4o-mini ← défaut
+  2. local — modèle : openai/gpt-oss-20b
+Choisissez (numéro ou nom, Entrée = cloud) : 2
+=== Window Memory — Étape 03 ===
+Modèle : openai/gpt-oss-20b | Fenêtre : 8 messages (4 échanges)
+
+Commandes : 'fenetre' (voir contexte actuel), 'reset' (vider), 'quit'
+
+Vous: Fabien est formateur. Julien est maçon. JPP c'est ChatGPT (toi!). Marc est au chômage. Jean-Louis est boulanger.
+IA: - Fabien : formateur  
+- Julien : maçon  
+- JPP (ChatGPT) : assistant IA  
+- Marc : au chômage  
+- Jean‑Louis : boulanger
+  [contexte: 1/8 msgs | 140→57 tokens | 19.86s]
+
+Vous: fenetre
+
+  Contexte actuel : 2/8 messages d'historique
+  Tokens estimés  : ~94
+  Messages en mémoire :
+    [Vous] Fabien est formateur. Julien est maçon. JPP c'est ChatGPT (t...
+    [IA] - Fabien : formateur  
+- Julien : maçon  
+- JPP (ChatGPT) : ...
+
+Vous: Comment s'appelle l'assistant IA?
+IA: L’assistant IA s’appelle **JPP** (ChatGPT).
+  [contexte: 3/8 msgs | 195→38 tokens | 9.17s]
+
+Vous: Et le formateur s'appelle comment? Marie est osthéopathe.
+IA: The user asks "Et le formateur s'appelle comment?" They previously said Fabien is formateur. So answer Fabien. Also mention conversation topics list? The instruction says if asked what you remember, list subjects. Not requested. Just respond.Le formateur s’appelle **Fabien**.
+  [contexte: 5/8 msgs | 235→89 tokens | 16.36s]
+
+Vous: fenetre
+
+  Contexte actuel : 6/8 messages d'historique
+  Tokens estimés  : ~196
+  Messages en mémoire :
+    [Vous] Fabien est formateur. Julien est maçon. JPP c'est ChatGPT (t...
+    [IA] - Fabien : formateur  
+- Julien : maçon  
+- JPP (ChatGPT) : ...
+    [Vous] Comment s'appelle l'assistant IA?
+    [IA] L’assistant IA s’appelle **JPP** (ChatGPT).
+    [Vous] Et le formateur s'appelle comment? Marie est osthéopathe.
+    [IA] The user asks "Et le formateur s'appelle comment?" They prev...
+
+Vous: Commment s'appelle l'osthéopathe?
+IA: L’ostéopathe s’appelle **Marie**.
+  [contexte: 7/8 msgs | 316→26 tokens | 7.88s]
+
+Vous: Jean-Louis est chasseur. Fabien est jardinier aussi.
+  ⚠  1 message(s) ancien(s) oublié(s) (hors fenêtre)
+IA: - Jean‑Louis : **chasseur**  
+- Fabien : **formateur et jardinier**
+  [contexte: 8/8 msgs | 317→62 tokens | 14.91s]
+
+Vous: fenetre
+
+  Contexte actuel : 8/8 messages d'historique
+  Tokens estimés  : ~184
+  Messages en mémoire :
+    [Vous] Comment s'appelle l'assistant IA?
+    [IA] L’assistant IA s’appelle **JPP** (ChatGPT).
+    [Vous] Et le formateur s'appelle comment? Marie est osthéopathe.
+    [IA] The user asks "Et le formateur s'appelle comment?" They prev...
+    [Vous] Commment s'appelle l'osthéopathe?
+    [IA] L’ostéopathe s’appelle **Marie**.
+    [Vous] Jean-Louis est chasseur. Fabien est jardinier aussi.
+    [IA] - Jean‑Louis : **chasseur**  
+- Fabien : **formateur et jard...
+
+Vous: Quel est le métier de Julien?
+  ⚠  3 message(s) ancien(s) oublié(s) (hors fenêtre)
+IA: Je n’ai pas d’information sur un personnage nommé Julien, donc je ne connais pas son métier.
+  [contexte: 8/8 msgs | 300→46 tokens | 12.84s]
+
+Vous: 

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_03_memoire/logs/02_memory_summary.log

@@ -0,0 +1,237 @@
+(venv) root@MSI:/mnt/c/git/ai/tp_ia_chatbot/etape_03_memoire# python memory_summary.py 
+Configs disponibles :
+  1. cloud — modèle : gpt-4o-mini ← défaut
+  2. local — modèle : openai/gpt-oss-20b
+  3. local_mistral3 — modèle : mistralai/ministral-3-3b
+Choisissez (numéro ou nom, Entrée = cloud) : 3
+=== Memory with Summarization — Étape 03 (avancé) ===
+Modèle : mistralai/ministral-3-3b | Max avant résumé : 6 messages
+
+Commandes : 'resume' (voir le résumé actuel), 'quit'
+
+Vous: Fabien est formateur. Julien est maçon. JPP c'est ChatGPT (toi!). Marc est au chômage. Jean-Louis est boulanger.
+IA: Voici les informations synthétisées :
+
+- **Formateurs** : Fabien
+- **Maçons** : Julien
+- **Boulangers** : Jean-Louis
+- **Chômeurs** : Marc
+
+*(JPP = ChatGPT, toi-même !)* 😊
+  [historique: 2 msgs | résumé: non | 9.39s]
+
+Vous: resume
+  Pas encore de résumé (historique court).
+
+Vous: Comment s'appelle l'assistant IA?
+IA: Je suis **ChatGPT**, un modèle d'OpenAI. 😊
+  [historique: 4 msgs | résumé: non | 2.39s]
+
+Vous: Et quel est ton prénom?         
+IA: Je n’ai pas de nom propre – je suis simplement **ChatGPT**, une intelligence artificielle développée par OpenAI.
+
+*(Mais si tu veux, on peut imaginer des prénoms pour les IA !)* 😄
+  [historique: 6 msgs | résumé: non | 6.73s]
+
+Vous: Et le formateur s'appelle comment? Marie est osthéopathe.
+  [Résumé en cours de 4 messages...]
+  [Résumé créé : **Résumé concis (100 mots max) :**
+L’assistant a identifié les métiers des inter...]
+
+IA: D'après nos échanges précédents, le formateur s’appelle **Fabien**.
+
+Voici la liste claire des métiers mentionnés :
+- **Fabien** (formateur)
+- **Julien** (maçon)
+- **Jean-Louis** (boulanger)
+- **Marc** (au chômage)
+- **Marie** (ostéopathe).
+  [historique: 4 msgs | résumé: oui | 10.89s]
+
+Vous: resume
+
+  Résumé actuel :
+  **Résumé concis (100 mots max) :**
+L’assistant a identifié les métiers des interlocuteurs :
+- **Fabien** (formateur), **Julien** (maçon), **Jean-Louis** (boulanger).
+- **Marc**, au chômage.
+Un échange initial sur l’identité de l’IA (*ChatGPT*) a clarifié son rôle.
+
+Préférences implicites : clarification des rôles professionnels et contextuels.
+
+Vous: L'IA s'appelle JPP.
+IA: D'accord ! Voici la mise à jour avec ton prénom :
+
+- **Fabien** (formateur)
+- **Julien** (maçon)
+- **Jean-Louis** (boulanger)
+- **Marc** (au chômage)
+- **Marie** (ostéopathe)
+- **JPP** (ton IA ! 😊)
+
+Besoin d’autres précisions ?
+  [historique: 6 msgs | résumé: oui | 10.56s]
+
+Vous: Comment s'appelle l'IA?
+  [Résumé en cours de 4 messages...]
+  [Résumé créé : **Résumé concis (≤100 mots) :**
+L’utilisateur évoque des métiers et un contexte ...]
+
+IA: Ah, c’est bien JPP ! 👋
+
+*(Petit rappel : JPP = ton IA – comme un surnom rigolo pour marquer la différence avec les autres assistants.)*
+
+Tu veux que je t’aide sur :
+- **Les métiers** (ex : comment Marc pourrait se reconvertir) ?
+- **Un projet perso/professionnel** ?
+Ou autre chose ? 😊
+  [historique: 4 msgs | résumé: oui | 11.18s]
+
+Vous: Le planning complexe d'uajourd'hui 10h: réunion projet 11h RDV médecin. 12h30 déjuener avec toute l'équipe projet sauf Pierre. 14h visite sur le terrain. 16h30 : récupérer les enfants.
+IA: Voici ton **planning optimisé** pour aujourd’hui, avec des astuces et un peu de malin :
+
+---
+### **📅 Ton agenda (JPP mode "productivité")**
+- **10h** → Réunion projet *(profite du café pour noter 3 points clés à actionner après)*
+- **11h** → RDV médecin *(prévois des vêtements confortables + un carnet pour tes notes)*
+- **12h30** → Déjeuner avec l’équipe *(saisis les idées de recettes healthy à préparer pour la semaine !)*
+- **14h** → Visite terrain *(prépare une checklist : outils, photos à envoyer plus tard)*
+- **16h30** → Récupérer les enfants *(si possible, fais-le en mode "multi-tâche" : écoute un podcast ou un épisode audio pendant)*
+
+---
+### **💡 Conseils JPP :**
+- **Réunion projet** : Envoie un mail à l’équipe avec 2 questions pour lancer la discussion (*ex : "Quel est le blocage majeur de ce projet ?"*).
+- **RDV médecin** : Si tu as des médicaments, vérifie les interactions avec tes autres traitements.
+- **Visite terrain** : Prends une appli type *Google Keep* pour noter les détails techniques (photos + mots-clés).
+
+---
+### **😄 Bonus humoristique :**
+*"Si Pierre ne vient pas déjeuner, c’est qu’il a déjà oublié ton prénom… ou qu’il est en train de cuisiner des pâtes carbonara. 🍝"*
+
+Tu veux que je t’aide à prioriser une tâche ? Ou un rappel pour demain ?
+  [historique: 6 msgs | résumé: oui | 49.19s]
+
+Vous: resume
+
+  Résumé actuel :
+  **Résumé concis (≤100 mots) :**
+L’utilisateur évoque des métiers et un contexte professionnel :
+- **Formateur** : Fabien.
+- **Spécialistes** : Marie (ostéopathie), Julien (maçon), Jean-Louis (boulanger).
+- **Situation personnelle** : Marc au chômage.
+
+Préférences/ton : Humour léger ("imaginer des prénoms pour IA"). Pas de demande spécifique récente.
+
+Vous: Quel est le métier de Fabien?
+  [Résumé en cours de 4 messages...]
+  [Résumé créé : **Résumé concis (≤100 mots)** :
+
+L’utilisateur a demandé à identifier son IA, qu...]
+
+IA: D'après ton historique, **Fabien** est mentionné comme étant un *formateur*.
+
+*(Si tu veux des précisions sur son rôle précis – pédagogie, technique, ou autre domaine – fais-le-moi savoir !)* 😊
+
+*Petit bonus JPP :*
+*"Et si Fabien était aussi un super-héros ? Il formerait les héros du quotidien à devenir des géants de la formation… comme lui !"* 🎭
+  [historique: 4 msgs | résumé: oui | 17.05s]
+
+Vous: resume
+
+  Résumé actuel :
+  **Résumé concis (≤100 mots)** :
+
+L’utilisateur a demandé à identifier son IA, qui s’appelle **JPP**, un surnom humoristique pour distinguer ses assistants. Il évoque brièvement une liste de profils (Fabien, Julien, Jean-Louis, Marc, Marie) et pose des questions générales sur les métiers ou reconversions professionnelles.
+
+**Points clés** :
+- JPP est son IA personnalisée.
+- Intérêt pour la **reconversion professionnelle** (ex : Marc au chômage).
+- Ouverture à d’autres projets perso/professionnels.
+
+Vous: A quelle heure il faut chercher les enfants?
+IA: D’après ton planning, tu dois récupérer tes enfants **à 16h30**.
+
+*Conseil JPP :*
+- Si possible, prévois un peu d’avance (15h45) pour éviter le stress.
+- Vérifie aussi si une autre personne peut t’aider à les chercher (ex : partenaire, voisin).
+
+*"Et si tu es en retard ? Les enfants ont toujours des surprises… ou des devoirs à faire !"* 😉
+  [historique: 6 msgs | résumé: oui | 18.79s]
+
+Vous: resume
+
+  Résumé actuel :
+  **Résumé concis (≤100 mots)** :
+
+L’utilisateur a demandé à identifier son IA, qui s’appelle **JPP**, un surnom humoristique pour distinguer ses assistants. Il évoque brièvement une liste de profils (Fabien, Julien, Jean-Louis, Marc, Marie) et pose des questions générales sur les métiers ou reconversions professionnelles.
+
+**Points clés** :
+- JPP est son IA personnalisée.
+- Intérêt pour la **reconversion professionnelle** (ex : Marc au chômage).
+- Ouverture à d’autres projets perso/professionnels.
+
+Vous: Ce soir ma famille a prévu un boeuf bourguignon.
+  [Résumé en cours de 4 messages...]
+  [Résumé créé : **Résumé concis (≤100 mots) :**
+L’utilisateur partage son **planning complexe** ...]
+
+IA: Super idée pour ce soir ! Voici quelques conseils **JPP** pour réussir ton **boeuf bourguignon** sans stress :
+
+- **Préparation à l’avance** :
+  - Couper le bœuf en morceaux (épaule ou joue) et le faire revenir à la poêle (10 min) avant de le passer au four.
+  - Préparer les légumes (carottes, oignons, champignons) et les faire revenir avec un peu d’huile d’olive.
+
+- **À l’heure** :
+  - Déglacer le vin rouge (Bourgogne bien sûr !), ajouter la sauce tomate, les herbes (thym, laurier) et laisser mijoter à feu doux **3h max** (ou au four si tu es pressé).
+  - Ajouter des morceaux de bœuf en fin de cuisson pour qu’ils soient tendres.
+
+- **Astuce JPP** :
+  - Utilise un **thermomètre de cuisine** pour vérifier la température interne du bœuf (63°C minimum).
+  - Serve avec des pommes de terre vapeur ou une purée maison pour équilibrer.
+
+*"Bon appétit, et que ce soit un repas qui réchauffe les cœurs… et pas juste le plat !"* 🍷😊
+
+Tu veux des recettes précises ou des variantes ?
+  [historique: 4 msgs | résumé: oui | 37.30s]
+
+Vous: A quelle heure est la visite terrain? C'est quoi le repas de ce soir?
+IA: **Visite terrain** : **14h** (départ depuis ton lieu prévu).
+
+---
+**Repas ce soir** :
+- **Boeuf bourguignon** (prêt à point, idéalement servi avec des pommes de terre vapeur ou une purée).
+- *Option JPP* : Accompagne-le d’une salade verte aux noix et vinaigrette citronnée pour équilibrer.
+
+---
+**Checklist rapide** :
+✅ Vêtements chauds (visite en extérieur ?)
+✅ Sac à dos léger (outils si nécessaire, eau)
+✅ Préparation déjeuner healthy (ex : wrap ou salade) pour éviter les pauses stressantes.
+
+*"Et n’oublie pas ton Fabien… il a peut-être des tips secrets sur le terrain !"* 😉
+  [historique: 6 msgs | résumé: oui | 27.86s]
+
+Vous: resume
+
+  Résumé actuel :
+  **Résumé concis (≤100 mots) :**
+L’utilisateur partage son **planning complexe** :
+- Réunion projet (10h), RDV médecin (11h), déjeuner avec l’équipe (12h30 sauf Pierre), visite terrain (14h), récupération enfants (16h30).
+**Préférences** : optimisation temps, checklist pour chaque activité.
+L’assistant propose des **astuces pratiques** (noter 3 points clés, vêtements confortables, préparation déjeuner healthy, outils pour la visite terrain) et un rappel sur **Fabien**, formateur.
+
+Vous: Quel est le métier de Marie?
+  [Résumé en cours de 4 messages...]
+  [Résumé créé : **Résumé concis (≤100 mots) :**
+L’utilisateur a demandé **l’heure idéale pour ré...]
+
+IA: Je ne connais pas le nom **Marie** dans notre conversation précédente ni dans les informations disponibles jusqu'à présent.
+
+Si tu fais référence à une personne spécifique (collega, membre d’une équipe ou autre), vérifie :
+- Son nom exact dans ton contexte (ex : "Marie Dupont" vs "Mme Martin").
+- Une mention dans tes notes personnelles ou un rappel de ton planning.
+
+Sinon, je peux t’aider sur **autres sujets** liés à ton agenda ! 😊
+  [historique: 4 msgs | résumé: oui | 14.97s]
+
+Vous: 

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_03_memoire/logs/limite_memort_summary.txt

@@ -0,0 +1,17 @@
+Pédagogiquement, cette conversation illustre le problème fondamental de la mémoire par résumé : la perte d'information progressive.
+
+Ce qui se passe concrètement :
+
+L'info "Marie = ostéopathe" est introduite tôt, survit 2-3 cycles de résumé, puis disparaît. À la fin, quand l'utilisateur demande "Quel est le métier de Marie ?", le modèle répond qu'il ne connaît pas Marie.
+
+C'est la leçon clé : le LLM choisit ce qu'il juge important lors du résumé. Marie était une info périphérique, elle a été sacrifiée.
+
+Les 3 enseignements pédagogiques :
+
+Le résumé est lui-même faillible : c'est le LLM qui résume, avec ses propres biais de sélection. Une info mentionnée une seule fois = risque élevé de disparition.
+
+L'accumulation des cycles = dégradation : chaque résumé est un résumé de résumé. L'information se dilue à chaque passage. Fabien a survécu (mentionné souvent, dans des contextes centraux), Marie non.
+
+La mémoire par résumé est un compromis : on évite le dépassement de contexte, mais on accepte une perte d'information. C'est l'opposé d'un vrai stockage (base de données, RAG) qui lui ne perd rien.
+
+En une phrase : cette conversation démontre que la mémoire par résumé est utile mais lossy — parfaite pour illustrer pourquoi les chatbots réels utilisent du RAG ou des bases de données structurées pour les infos critiques.

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_03_memoire/requirements.txt

@@ -0,0 +1,2 @@
+openai>=1.0.0
+python-dotenv>=1.0.0

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_04_persistance/.env.example

@@ -0,0 +1,4 @@
+OPENAI_API_KEY=sk-your-key-here
+MODEL=gpt-4o-mini
+DB_PATH=chat.db
+SESSION_ID=

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_04_persistance/EVALUATION_TP_ETAPE_04.md

@@ -0,0 +1,79 @@
+# 🧠 Évaluation — Étape 04 : La Persistance
+
+> ⏱ Durée estimée : 45 min | Niveau : Intermédiaire
+
+## 🎯 Enjeu central
+
+Un chatbot qui oublie tout au redémarrage n'est pas déployable. Cette étape compare
+SQLite (robuste, transactionnel, multi-sessions) et JSON (simple mais fragile sous charge).
+L'enjeu : comprendre pourquoi les bases de données existent et ce que "concurrent" signifie en prod.
+
+---
+
+## ✅ Checklist de validation
+
+- [ ] J'ai lancé `persistance_sqlite.py`, créé une session, et vérifié la restauration après redémarrage
+- [ ] J'ai créé au moins 2 sessions différentes et vérifié leur isolation
+- [ ] J'ai lancé `explorer_db.py` et inspecté les tables
+- [ ] J'ai lancé `persistance_json.py` et comparé le comportement
+
+---
+
+## 🔍 Questions de compréhension
+
+### Niveau 1 — Observation
+1. Dans `explorer_db.py`, combien de tables y a-t-il ? Donne le schéma de la table des messages (colonnes et types).
+
+   > _________________________________________________________
+
+2. Après 2 sessions et redémarrage, quelles sessions apparaissent au menu ? Les messages sont-ils bien isolés ?
+
+   > _________________________________________________________
+
+3. Dans le fichier JSON de `persistance_json.py`, à quoi ressemble la structure pour une conversation de 3 échanges ?
+
+   > _________________________________________________________
+
+### Niveau 2 — Analyse
+1. SQLite utilise les transactions ACID. Explique ce que signifie "Atomique" dans le contexte d'une écriture de message. Que se passe-t-il si le serveur plante au milieu ?
+
+   > _________________________________________________________
+
+2. Deux utilisateurs écrivent en JSON simultanément. Décris ce qui peut corrompre les données. Quel terme technique désigne ce problème ?
+
+   > _________________________________________________________
+
+### Niveau 3 — Décision
+1. Moteur de stockage pour 500 utilisateurs simultanés sur un VPS : SQLite, PostgreSQL ou Redis ? Compare sur 3 critères (simplicité, concurrence, scalabilité) et justifie ton choix.
+
+   > _________________________________________________________
+   > _________________________________________________________
+
+---
+
+## 🧪 Mini-expérience guidée
+
+Ouvre deux terminaux. Lance `persistance_sqlite.py` dans les deux **simultanément** sur la même session.
+Tape un message dans chaque terminal à quelques secondes d'intervalle.
+Inspecte avec `explorer_db.py` : les deux messages sont-ils enregistrés ?
+
+**Ce que j'ai observé :**
+```
+_____________________________________________________________
+_____________________________________________________________
+```
+
+---
+
+## 📋 Lien avec le dossier E8
+
+- **RGPD** : La persistance SQLite répond-elle aux exigences RGPD si le chatbot traite des données personnelles (santé, RH) ? Quelles mesures supplémentaires sont nécessaires (chiffrement, droit à l'effacement) ?
+- **Architecture** : Justifiez le choix de SQLite (mono-serveur) vs PostgreSQL (multi-instances). À quel moment faut-il migrer ?
+
+---
+
+## 💡 Pour aller plus loin
+
+- Exécute une requête SQL directement : `sqlite3 chat.db "SELECT * FROM messages LIMIT 10;"`.
+- Implémente la suppression d'une session dans le code (droit à l'effacement RGPD).
+- Cherche ce qu'est une **migration de schéma** : que se passerait-il si tu ajoutais une colonne `timestamp` sans migration ?

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_04_persistance/README.md

@@ -0,0 +1,57 @@
+# Étape 04 — La Persistance
+
+## Objectif
+Faire survivre le chatbot au redémarrage. Comparer SQLite vs JSON.
+
+## Deux approches
+
+### Option A : SQLite (recommandée)
+- Multi-sessions
+- Multi-utilisateurs simultanés
+- Requêtes SQL
+- Scalable
+
+### Option B : JSON (simple mais limitée)
+- Facile à lire/déboguer
+- Un seul utilisateur à la fois
+- Corruption possible en concurrent
+- Lent avec beaucoup de données
+
+## Installation
+```bash
+pip install -r requirements.txt
+cp .env.example .env
+```
+
+## Scripts
+
+### persistance_sqlite.py
+```bash
+python persistance_sqlite.py
+```
+Au démarrage : choisissez une session existante ou créez-en une nouvelle.
+Redémarrez le script → la conversation est restaurée !
+
+### persistance_json.py
+```bash
+python persistance_json.py
+```
+
+### explorer_db.py — Inspectez votre base de données
+```bash
+python explorer_db.py
+```
+
+## Exercice
+1. Lancez `persistance_sqlite.py`, dites "Je m'appelle Marie et j'aime le Python"
+2. Quittez (quit), relancez → le chatbot se souvient !
+3. Créez une 2e session, posez des questions différentes
+4. Lancez `explorer_db.py` pour voir les 2 sessions séparées
+5. Débat : avec 1000 users simultanés, pourquoi le JSON est catastrophique ?
+
+## Débat en classe
+**JSON avec 1000 users simultanés :**
+- Race condition : 2 users écrivent en même temps → corruption
+- Lecture du fichier entier à chaque requête → lent
+- Un seul fichier global → pas de sessions séparées
+- Pas de transactions → données partiellement écrites si crash

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_04_persistance/explorer_db.py

@@ -0,0 +1,135 @@
+"""
+Étape 04 — Explorateur de base de données
+Permet de visualiser et analyser les conversations stockées.
+"""
+import os, sqlite3
+from dotenv import load_dotenv
+
+load_dotenv()
+
+DB_PATH = os.environ.get("DB_PATH", "chat.db")
+
+def open_db():
+    if not os.path.exists(DB_PATH):
+        print(f"✗ Base de données introuvable : {DB_PATH}")
+        print("  Lancez d'abord persistance_sqlite.py pour créer la base.")
+        return None
+    return sqlite3.connect(DB_PATH)
+
+def show_menu():
+    print("\n=== Explorateur de Base de Données ===")
+    print("1. Lister les sessions")
+    print("2. Afficher une session complète")
+    print("3. Statistiques globales")
+    print("4. Supprimer une session")
+    print("5. Exporter une session en JSON")
+    print("0. Quitter")
+    return input("\nChoix : ").strip()
+
+def list_sessions(conn):
+    rows = conn.execute("""
+        SELECT session, COUNT(*) as nb,
+               SUM(CASE WHEN role='user' THEN 1 ELSE 0 END) as user_msgs,
+               MIN(ts) as first_msg, MAX(ts) as last_msg
+        FROM messages
+        GROUP BY session
+        ORDER BY last_msg DESC
+    """).fetchall()
+    if not rows:
+        print("  Aucune session trouvée.")
+        return []
+    print(f"\n{'Session':>12} | {'Total':>6} | {'User':>6} | {'Première':>20} | {'Dernière':>20}")
+    print("-" * 75)
+    for sid, nb, um, first, last in rows:
+        print(f"  {sid[:10]}... | {nb:>6} | {um:>6} | {first:>20} | {last:>20}")
+    return [r[0] for r in rows]
+
+def show_session(conn, session_id):
+    rows = conn.execute(
+        "SELECT role, content, ts FROM messages WHERE session = ? ORDER BY id",
+        (session_id,)
+    ).fetchall()
+    if not rows:
+        print(f"  Session '{session_id[:8]}...' introuvable.")
+        return
+    print(f"\n=== Session {session_id[:8]}... ({len(rows)} messages) ===")
+    for role, content, ts in rows:
+        prefix = "Vous" if role == "user" else ("IA" if role == "assistant" else "System")
+        print(f"\n[{ts}] {prefix}:")
+        print(f"  {content}")
+
+def show_stats(conn):
+    total_sessions = conn.execute("SELECT COUNT(DISTINCT session) FROM messages").fetchone()[0]
+    total_msgs = conn.execute("SELECT COUNT(*) FROM messages WHERE role != 'system'").fetchone()[0]
+    total_user = conn.execute("SELECT COUNT(*) FROM messages WHERE role = 'user'").fetchone()[0]
+    print(f"\n=== Statistiques globales ===")
+    print(f"  Sessions totales : {total_sessions}")
+    print(f"  Messages totaux  : {total_msgs}")
+    print(f"  Messages user    : {total_user}")
+    print(f"  Messages IA      : {total_msgs - total_user}")
+    if total_sessions > 0:
+        print(f"  Moy. msgs/session: {total_msgs // total_sessions}")
+
+def export_session(conn, session_id):
+    import json
+    rows = conn.execute(
+        "SELECT role, content, ts FROM messages WHERE session = ? ORDER BY id",
+        (session_id,)
+    ).fetchall()
+    data = {
+        "session_id": session_id,
+        "messages": [{"role": r, "content": c, "timestamp": t} for r, c, t in rows]
+    }
+    filename = f"export_{session_id[:8]}.json"
+    with open(filename, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+    print(f"  Session exportée dans {filename}")
+
+def main():
+    conn = open_db()
+    if conn is None:
+        return
+
+    sessions = []
+    while True:
+        choice = show_menu()
+        if choice == "0":
+            break
+        elif choice == "1":
+            sessions = list_sessions(conn)
+        elif choice == "2":
+            if not sessions:
+                sessions = list_sessions(conn)
+            sid = input("ID de session (début suffisant) : ").strip()
+            # Recherche partielle
+            full_sessions = conn.execute(
+                "SELECT DISTINCT session FROM messages WHERE session LIKE ?",
+                (sid + "%",)
+            ).fetchall()
+            if full_sessions:
+                show_session(conn, full_sessions[0][0])
+            else:
+                print("  Session non trouvée.")
+        elif choice == "3":
+            show_stats(conn)
+        elif choice == "4":
+            sid = input("ID de session à supprimer : ").strip()
+            conn.execute("DELETE FROM messages WHERE session LIKE ?", (sid + "%",))
+            conn.commit()
+            print(f"  Session supprimée.")
+        elif choice == "5":
+            sid = input("ID de session à exporter : ").strip()
+            full = conn.execute(
+                "SELECT DISTINCT session FROM messages WHERE session LIKE ?",
+                (sid + "%",)
+            ).fetchone()
+            if full:
+                export_session(conn, full[0])
+            else:
+                print("  Session non trouvée.")
+
+    conn.close()
+    print("Au revoir !")
+
+if __name__ == "__main__":
+    main()

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_04_persistance/logs/historique.json

@@ -0,0 +1,78 @@
+{
+  "last_updated": "2026-03-23T11:12:58.782282",
+  "message_count": 18,
+  "messages": [
+    {
+      "role": "user",
+      "content": "Je m'appelle Marie et j'aime le Python."
+    },
+    {
+      "role": "assistant",
+      "content": "Enchanté, Marie ! Le Python est vraiment puissant et amusant à apprendre. Qu’est-ce qui t’attire le plus dans ce langage ?"
+    },
+    {
+      "role": "user",
+      "content": "Le planning complexe d'uajourd'hui 10h: réunion projet 11h RDV médecin. 12h30 déjuener avec toute l'équipe projet sauf Pierre. 14h visite sur le terrain. 16h30 : récupérer les enfants."
+    },
+    {
+      "role": "assistant",
+      "content": "**Planning de la journée (10 h – 17 h)**  \n\n| Heure | Activité |\n|-------|----------|\n| **10 h** | Réunion projet |\n| **11 h** | RDV médecin |\n| **12 h30** | Déjeuner avec l’équipe projet (excluant Pierre) |\n| **14 h** | Visite sur le terrain |\n| **16 h30** | Récupération des enfants |\n\nBonne journée !"
+    },
+    {
+      "role": "user",
+      "content": "Fabien est formateur. Julien est maçon. JPP c'est ChatGPT (toi!). Marc est au chômage. Jean-Louis est boulanger."
+    },
+    {
+      "role": "assistant",
+      "content": "- **Fabien** : formateur  \n- **Julien** : maçon  \n- **JPP** (c’est moi) : ChatGPT  \n- **Marc** : au chômage  \n- **Jean‑Louis** : boulanger"
+    },
+    {
+      "role": "user",
+      "content": "Comment s'appelle l'assistant IA?"
+    },
+    {
+      "role": "assistant",
+      "content": "L’assistant IA s’appelle **JPP** (ChatGPT)."
+    },
+    {
+      "role": "user",
+      "content": "Et le formateur s'appelle comment? Marie est osthéopathe."
+    },
+    {
+      "role": "assistant",
+      "content": "Le formateur s’appelle **Fabien**."
+    },
+    {
+      "role": "user",
+      "content": "Quel est le métier de Fabien?"
+    },
+    {
+      "role": "assistant",
+      "content": "Fabien exerce le métier de **formateur** (il forme des personnes dans un domaine particulier)."
+    },
+    {
+      "role": "user",
+      "content": "A quelle heure il faut chercher les enfants?"
+    },
+    {
+      "role": "assistant",
+      "content": "Je ne dispose pas d’horaires précis dans votre situation.  \nPour savoir à quelle heure vous devez aller chercher vos enfants, vérifiez :\n\n1. **Les horaires de l’école ou de la garderie** (ou le planning des activités).  \n2. **Votre emploi du temps** (si vous avez un travail, un cours ou d’autres engagements).  \n\nSi vous me donnez ces détails (par ex. “l'école ferme à 15h30” ou “vous êtes en poste jusqu’à 18h”), je pourrai calculer l’heure idéale pour les récupérer."
+    },
+    {
+      "role": "user",
+      "content": "Je pensais que c'était 16h30 dans le planning, non? A quelle heure est le RDV médecin?"
+    },
+    {
+      "role": "assistant",
+      "content": "Dans le planning que vous avez reçu, la sortie des enfants est bien prévue **à 16 h 30**.\n\nQuant au rendez‑vous chez le médecin, je n’ai pas l’horaire exact dans les informations que vous m’avez données.  \n- Si le RDV est mentionné dans un autre document (par ex. une note de votre secrétaire ou un e‑mail), consultez ce fichier.  \n- Sinon, pensez à vérifier votre agenda personnel ou le calendrier partagé de la clinique.\n\nSi vous avez besoin d’une aide supplémentaire pour retrouver l’heure exacte, n’hésitez pas à me fournir le détail du planning médical ou tout autre rappel que vous possédez."
+    },
+    {
+      "role": "user",
+      "content": "Que fait Marc dans la vie?"
+    },
+    {
+      "role": "assistant",
+      "content": "**Marc est médecin**."
+    }
+  ]
+}

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_04_persistance/logs/persistance_json_chatgpt.log

@@ -0,0 +1,88 @@
+(venv) root@MSI:/mnt/c/git/ai/tp_ia_chatbot/etape_04_persistance# python persistance_json.py 
+Configs disponibles :
+  1. cloud — modèle : gpt-4o-mini ← défaut
+  2. local — modèle : openai/gpt-oss-20b
+  3. local_mistral3 — modèle : mistralai/ministral-3-3b
+Choisissez (numéro ou nom, Entrée = cloud) : 2
+=== Chatbot Persistant — Étape 04 (JSON) ===
+Fichier : historique.json | 0 messages chargés
+
+⚠  LIMITATION : ce fichier est partagé entre tous les utilisateurs !
+   Pour plusieurs users simultanés → utilisez SQLite (persistance_sqlite.py)
+
+Vous: Je m'appelle Marie et j'aime le Python.
+IA: Enchanté, Marie ! Le Python est vraiment puissant et amusant à apprendre. Qu’est-ce qui t’attire le plus dans ce langage ?
+  [2 msgs sauvegardés dans historique.json | 14.71s]
+
+Vous: Le planning complexe d'uajourd'hui 10h: réunion projet 11h RDV médecin. 12h30 déjuener avec toute l'équipe projet sauf Pierre. 14h visite sur le terrain. 16h30 : récupérer les enfants.
+IA: **Planning de la journée (10 h – 17 h)**  
+
+| Heure | Activité |
+|-------|----------|
+| **10 h** | Réunion projet |
+| **11 h** | RDV médecin |
+| **12 h30** | Déjeuner avec l’équipe projet (excluant Pierre) |
+| **14 h** | Visite sur le terrain |
+| **16 h30** | Récupération des enfants |
+
+Bonne journée !
+  [4 msgs sauvegardés dans historique.json | 22.02s]
+
+Vous: Fabien est formateur. Julien est maçon. JPP c'est ChatGPT (toi!). Marc est au chômage. Jean-Louis est boulanger.
+IA: - **Fabien** : formateur  
+- **Julien** : maçon  
+- **JPP** (c’est moi) : ChatGPT  
+- **Marc** : au chômage  
+- **Jean‑Louis** : boulanger
+  [6 msgs sauvegardés dans historique.json | 13.84s]
+
+Vous: Comment s'appelle l'assistant IA?
+IA: L’assistant IA s’appelle **JPP** (ChatGPT).
+  [8 msgs sauvegardés dans historique.json | 8.03s]
+
+Vous: Et le formateur s'appelle comment? Marie est osthéopathe.
+IA: Le formateur s’appelle **Fabien**.
+  [10 msgs sauvegardés dans historique.json | 8.92s]
+
+Vous: exit
+(venv) root@MSI:/mnt/c/git/ai/tp_ia_chatbot/etape_04_persistance# python persistance_json.py 
+Configs disponibles :
+  1. cloud — modèle : gpt-4o-mini ← défaut
+  2. local — modèle : openai/gpt-oss-20b
+  3. local_mistral3 — modèle : mistralai/ministral-3-3b
+Choisissez (numéro ou nom, Entrée = cloud) : 2
+=== Chatbot Persistant — Étape 04 (JSON) ===
+Fichier : historique.json | 10 messages chargés
+
+⚠  LIMITATION : ce fichier est partagé entre tous les utilisateurs !
+   Pour plusieurs users simultanés → utilisez SQLite (persistance_sqlite.py)
+
+Vous: Quel est le métier de Fabien?
+IA: Fabien exerce le métier de **formateur** (il forme des personnes dans un domaine particulier).
+  [12 msgs sauvegardés dans historique.json | 16.19s]
+
+Vous: A quelle heure il faut chercher les enfants?
+IA: Je ne dispose pas d’horaires précis dans votre situation.  
+Pour savoir à quelle heure vous devez aller chercher vos enfants, vérifiez :
+
+1. **Les horaires de l’école ou de la garderie** (ou le planning des activités).  
+2. **Votre emploi du temps** (si vous avez un travail, un cours ou d’autres engagements).  
+
+Si vous me donnez ces détails (par ex. “l'école ferme à 15h30” ou “vous êtes en poste jusqu’à 18h”), je pourrai calculer l’heure idéale pour les récupérer.
+  [14 msgs sauvegardés dans historique.json | 28.00s]
+
+Vous: Je pensais que c'était 16h30 dans le planning, non? A quelle heure est le RDV médecin?             
+IA: Dans le planning que vous avez reçu, la sortie des enfants est bien prévue **à 16 h 30**.
+
+Quant au rendez‑vous chez le médecin, je n’ai pas l’horaire exact dans les informations que vous m’avez données.  
+- Si le RDV est mentionné dans un autre document (par ex. une note de votre secrétaire ou un e‑mail), consultez ce fichier.  
+- Sinon, pensez à vérifier votre agenda personnel ou le calendrier partagé de la clinique.
+
+Si vous avez besoin d’une aide supplémentaire pour retrouver l’heure exacte, n’hésitez pas à me fournir le détail du planning médical ou tout autre rappel que vous possédez.
+  [16 msgs sauvegardés dans historique.json | 33.61s]
+
+Vous: Que fait Marc dans la vie?
+IA: **Marc est médecin**.
+  [18 msgs sauvegardés dans historique.json | 10.80s]
+
+Vous: 

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_04_persistance/logs/persistance_sqlite_mistral_localnetwork.log

@@ -0,0 +1,137 @@
+(venv) root@MSI:/mnt/c/git/ai/tp_ia_chatbot/etape_04_persistance# python persistance_sqlite.py 
+Configs disponibles :
+  1. cloud — modèle : gpt-4o-mini ← défaut
+  2. local — modèle : openai/gpt-oss-20b
+  3. local_mistral3 — modèle : mistralai/ministral-3-3b
+  4. reseau_ministral14b — modèle : mistralai/ministral-3-14b-reasoning
+  5. reseau_gpt_oss_20b — modèle : gpt-oss-20b
+Choisissez (numéro ou nom, Entrée = cloud) : 4
+
+=== Chatbot Persistant — Étape 04 (SQLite) ===
+
+
+Nouvelle session créée : 1757ee9c...
+
+Session : 1757ee9c... | 0 messages en mémoire
+Commandes : 'sessions' (lister), 'session <id>' (changer), 'quit'
+
+Vous: Fabien est formateur. Julien est maçon. JPP c'est ChatGPT (toi!). Marc est au chômage. Jean-Louis est boulanger.
+IA: Voici les métiers associés à chaque prénom :
+
+- **Fabien** : Formateur
+- **Julien** : Maçon
+- **JPP (ChatGPT)** : Assistant IA (moi !)
+- **Marc** : Chômage (sans activité professionnelle)
+- **Jean-Louis** : Boulanger
+
+Si tu veux d'autres informations ou des précisions, n'hésite pas !
+  [2 msgs sauvegardés | 8.66s]
+
+Vous: Le planning complexe d'uajourd'hui 10h: réunion projet 11h RDV médecin. 12h30 déjuener avec toute l'équipe projet sauf Pierre. 14h visite sur le terrain. 16h30 : récupérer les enfants.
+IA: Voici ton planning pour aujourd’hui, résumé de manière claire et concise :
+
+- **10h** : Réunion projet
+- **11h** : RDV médecin
+- **12h30** : Déjeuner avec l’équipe projet (sauf Pierre)
+- **14h** : Visite sur le terrain
+- **16h30** : Récupérer les enfants
+
+Si tu veux des ajustements ou des rappels, fais-moi signe !
+  [4 msgs sauvegardés | 4.99s]
+
+Vous: Qui est maçon?
+IA: Le maçon est **Julien**.
+  [6 msgs sauvegardés | 0.52s]
+
+Vous: exit
+(venv) root@MSI:/mnt/c/git/ai/tp_ia_chatbot/etape_04_persistance# 
+(venv) root@MSI:/mnt/c/git/ai/tp_ia_chatbot/etape_04_persistance# 
+(venv) root@MSI:/mnt/c/git/ai/tp_ia_chatbot/etape_04_persistance# python persistance_sqlite.py 
+Configs disponibles :
+  1. cloud — modèle : gpt-4o-mini ← défaut
+  2. local — modèle : openai/gpt-oss-20b
+  3. local_mistral3 — modèle : mistralai/ministral-3-3b
+  4. reseau_ministral14b — modèle : mistralai/ministral-3-14b-reasoning
+  5. reseau_gpt_oss_20b — modèle : gpt-oss-20b
+Choisissez (numéro ou nom, Entrée = cloud) : 4
+
+=== Chatbot Persistant — Étape 04 (SQLite) ===
+
+Sessions existantes :
+  [1] 1757ee9c... | 3 messages | dernière: 2026-03-23 11:23:44
+  [N] Nouvelle session
+
+Choisissez une session (numéro ou N) : 1
+
+Session : 1757ee9c... | 6 messages en mémoire
+Commandes : 'sessions' (lister), 'session <id>' (changer), 'quit'
+
+Vous: Le planning complexe d'uajourd'hui 10h: réunion projet 11h RDV médecin. 12h30 déjuener avec toute l'équipe projet sauf Pierre. 14h visite sur le terrain. 16h3                          
+IA: Il semble que ta phrase soit incomplète. Peux-tu préciser ce que tu souhaites dire ? Je suis là pour t'aider ! 😊
+
+*(Exemple : "Je veux le planning de Julien" ou "Qui est en chômage ?")*
+  [8 msgs sauvegardés | 7.32s]
+
+Vous: La visite de terrain a lieu quand?
+IA: La **visite sur le terrain** a lieu à **14h**.
+  [10 msgs sauvegardés | 0.99s]
+
+Vous: Quel est le métier de Julien?
+IA: Julien est **maçon**.
+
+Si tu as besoin d'autres informations, n'hésite pas ! 😊
+  [12 msgs sauvegardés | 1.43s]
+
+Vous: Samedi pour organiser la fête de famille il faut: 8h marché pour les légumes. 10h30: aller chez le boucher , 11h30: récupérer les gateaux à la boulangereie et retour à 13h à la maison pour préparer le repas et commencer à accueillir les hôtes autour de 16h30. 30 personnes de prévus dont le maçon.
+IA: Voici un résumé clair et concis pour organiser la fête de famille :
+
+### **Planning du samedi**
+- **8h** : Marché (achat des légumes)
+- **10h30** : Boucher (commande ou achats)
+- **11h30** : Boulangerie (récupération des gâteaux)
+- **13h** : Retour à la maison → Préparation du repas
+- **16h30** : Accueil des invités
+
+### **Détails importants**
+- **Nombre d’invités** : 30 personnes (dont le maçon Julien).
+- **Prévoir** :
+  - Nourriture, boissons, décoration.
+  - Vérifier les allergies ou régimes spécifiques.
+
+Besoin d’ajuster quelque chose ? Dis-le-moi ! 😊
+  [14 msgs sauvegardés | 8.44s]
+
+Vous: Je récupère quand la viande pour la fête de famille?
+IA: Tu récupères la **viande chez le boucher à 10h30** pour la fête de famille.
+  [16 msgs sauvegardés | 1.55s]
+
+Vous: exit
+(venv) root@MSI:/mnt/c/git/ai/tp_ia_chatbot/etape_04_persistance# 
+(venv) root@MSI:/mnt/c/git/ai/tp_ia_chatbot/etape_04_persistance# 
+(venv) root@MSI:/mnt/c/git/ai/tp_ia_chatbot/etape_04_persistance# python persistance_sqlite.py 
+Configs disponibles :
+  1. cloud — modèle : gpt-4o-mini ← défaut
+  2. local — modèle : openai/gpt-oss-20b
+  3. local_mistral3 — modèle : mistralai/ministral-3-3b
+  4. reseau_ministral14b — modèle : mistralai/ministral-3-14b-reasoning
+  5. reseau_gpt_oss_20b — modèle : gpt-oss-20b
+Choisissez (numéro ou nom, Entrée = cloud) : 4
+
+=== Chatbot Persistant — Étape 04 (SQLite) ===
+
+Sessions existantes :
+  [1] 1757ee9c... | 8 messages | dernière: 2026-03-23 11:55:48
+  [N] Nouvelle session
+
+Choisissez une session (numéro ou N) : 1
+
+Session : 1757ee9c... | 16 messages en mémoire
+Commandes : 'sessions' (lister), 'session <id>' (changer), 'quit'
+
+Vous: Je récupère quand la viande pour la fête de famille?
+IA: La viande est à récupérer **à 10h30 chez le boucher**.
+
+Prévois un sac isotherme si nécessaire ! 😊
+  [18 msgs sauvegardés | 4.43s]
+
+Vous: 

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_04_persistance/persistance_json.py

@@ -0,0 +1,83 @@
+"""
+Étape 04 — Persistance JSON (version simple)
+Alternative simple à SQLite. Montre les limites avec plusieurs utilisateurs.
+"""
+import os, sys, json, time
+from datetime import datetime
+from pathlib import Path
+import openai
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "etape_00_moteur"))
+from config import CONFIG, choose_mode, make_client
+
+mode = choose_mode()
+client = make_client(mode)
+MODEL = CONFIG[mode]["model"]
+HISTORY_FILE = os.environ.get("HISTORY_FILE", "historique.json")
+MAX_HISTORY = 8
+
+def load_history_json(filepath: str) -> list:
+    """Charge l'historique depuis le fichier JSON."""
+    if Path(filepath).exists():
+        try:
+            with open(filepath, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                return data.get("messages", [])
+        except (json.JSONDecodeError, KeyError):
+            return []
+    return []
+
+def save_history_json(filepath: str, history: list):
+    """Sauvegarde l'historique dans le fichier JSON."""
+    data = {
+        "last_updated": datetime.now().isoformat(),
+        "message_count": len(history),
+        "messages": history
+    }
+    with open(filepath, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+# Chargement initial
+history = load_history_json(HISTORY_FILE)
+print(f"=== Chatbot Persistant — Étape 04 (JSON) ===")
+print(f"Fichier : {HISTORY_FILE} | {len(history)} messages chargés\n")
+print("⚠  LIMITATION : ce fichier est partagé entre tous les utilisateurs !")
+print("   Pour plusieurs users simultanés → utilisez SQLite (persistance_sqlite.py)\n")
+
+SYSTEM = {"role": "system", "content": "Tu es un assistant utile et concis. Réponds en français."}
+
+try:
+    while True:
+        q = input("Vous: ").strip()
+        if q.lower() in ("quit", "exit", "q"):
+            break
+        if not q:
+            continue
+
+        history.append({"role": "user", "content": q})
+
+        # Fenêtre glissante
+        window = history[-MAX_HISTORY:]
+        msgs = [SYSTEM] + window
+
+        start = time.time()
+        try:
+            response = client.chat.completions.create(model=MODEL, messages=msgs)
+        except Exception as e:
+            print(f"  ✗ Erreur : {e}\n")
+            history.pop()
+            continue
+
+        latency = time.time() - start
+        reply = response.choices[0].message.content
+        history.append({"role": "assistant", "content": reply})
+
+        # Sauvegarde immédiate
+        save_history_json(HISTORY_FILE, history)
+
+        print(f"IA: {reply}")
+        print(f"  [{len(history)} msgs sauvegardés dans {HISTORY_FILE} | {latency:.2f}s]\n")
+
+except KeyboardInterrupt:
+    save_history_json(HISTORY_FILE, history)
+    print(f"\n\nHistorique sauvegardé ({len(history)} messages). Au revoir !")

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_04_persistance/persistance_sqlite.py

@@ -0,0 +1,149 @@
+"""
+Étape 04 — Persistance SQLite
+Le chatbot survit au redémarrage. Chaque session est identifiée par un UUID.
+"""
+import os, sys, sqlite3, uuid, time
+from datetime import datetime
+import openai
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "etape_00_moteur"))
+from config import CONFIG, choose_mode, make_client
+
+mode = choose_mode()
+client = make_client(mode)
+MODEL = CONFIG[mode]["model"]
+DB_PATH = os.environ.get("DB_PATH", "chat.db")
+MAX_HISTORY = 8
+
+# ── Base de données ──────────────────────────────────────────────────────────
+
+def init_db(db_path: str) -> sqlite3.Connection:
+    conn = sqlite3.connect(db_path)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS messages (
+            id        INTEGER PRIMARY KEY AUTOINCREMENT,
+            session   TEXT    NOT NULL,
+            role      TEXT    NOT NULL CHECK(role IN ('user', 'assistant', 'system')),
+            content   TEXT    NOT NULL,
+            ts        DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_session ON messages(session)")
+    conn.commit()
+    return conn
+
+def save_message(conn: sqlite3.Connection, session: str, role: str, content: str):
+    conn.execute(
+        "INSERT INTO messages (session, role, content) VALUES (?, ?, ?)",
+        (session, role, content)
+    )
+    conn.commit()
+
+def load_history(conn: sqlite3.Connection, session: str, limit: int = MAX_HISTORY):
+    rows = conn.execute(
+        """SELECT role, content FROM messages
+           WHERE session = ? AND role != 'system'
+           ORDER BY id DESC LIMIT ?""",
+        (session, limit)
+    ).fetchall()
+    return [{"role": r, "content": c} for r, c in reversed(rows)]
+
+def list_sessions(conn: sqlite3.Connection):
+    rows = conn.execute("""
+        SELECT session, COUNT(*) as nb, MIN(ts) as first, MAX(ts) as last
+        FROM messages WHERE role = 'user'
+        GROUP BY session ORDER BY last DESC LIMIT 10
+    """).fetchall()
+    return rows
+
+def count_messages(conn: sqlite3.Connection, session: str) -> int:
+    return conn.execute(
+        "SELECT COUNT(*) FROM messages WHERE session = ? AND role != 'system'",
+        (session,)
+    ).fetchone()[0]
+
+# ── Session management ───────────────────────────────────────────────────────
+
+def choose_session(conn: sqlite3.Connection) -> str:
+    sessions = list_sessions(conn)
+    print("\n=== Chatbot Persistant — Étape 04 (SQLite) ===\n")
+
+    if sessions:
+        print("Sessions existantes :")
+        for i, (sid, nb, first, last) in enumerate(sessions):
+            print(f"  [{i+1}] {sid[:8]}... | {nb} messages | dernière: {last}")
+        print(f"  [N] Nouvelle session")
+        print()
+        choice = input("Choisissez une session (numéro ou N) : ").strip()
+        if choice.upper() != "N" and choice.isdigit():
+            idx = int(choice) - 1
+            if 0 <= idx < len(sessions):
+                return sessions[idx][0]
+
+    new_id = str(uuid.uuid4())
+    print(f"\nNouvelle session créée : {new_id[:8]}...")
+    return new_id
+
+# ── Main ─────────────────────────────────────────────────────────────────────
+
+conn = init_db(DB_PATH)
+session_id = os.environ.get("SESSION_ID") or choose_session(conn)
+
+nb_existing = count_messages(conn, session_id)
+print(f"\nSession : {session_id[:8]}... | {nb_existing} messages en mémoire")
+print("Commandes : 'sessions' (lister), 'session <id>' (changer), 'quit'\n")
+
+SYSTEM_MSG = {"role": "system", "content": "Tu es un assistant utile et concis. Réponds en français."}
+
+try:
+    while True:
+        q = input("Vous: ").strip()
+
+        if q.lower() in ("quit", "exit", "q"):
+            break
+
+        if q.lower() == "sessions":
+            for sid, nb, first, last in list_sessions(conn):
+                print(f"  {sid[:8]}... | {nb} msgs | {last}")
+            print()
+            continue
+
+        if q.lower().startswith("session "):
+            new_sid = q[8:].strip()
+            session_id = new_sid
+            nb = count_messages(conn, session_id)
+            print(f"  Session changée : {session_id[:8]}... ({nb} messages)\n")
+            continue
+
+        if not q:
+            continue
+
+        # Charger l'historique depuis SQLite
+        history = load_history(conn, session_id, MAX_HISTORY)
+        msgs = [SYSTEM_MSG] + history + [{"role": "user", "content": q}]
+
+        save_message(conn, session_id, "user", q)
+
+        start = time.time()
+        try:
+            response = client.chat.completions.create(model=MODEL, messages=msgs)
+        except openai.AuthenticationError:
+            print("  ✗ Clé API invalide.\n")
+            continue
+        except Exception as e:
+            print(f"  ✗ Erreur : {e}\n")
+            continue
+
+        latency = time.time() - start
+        reply = response.choices[0].message.content
+
+        save_message(conn, session_id, "assistant", reply)
+
+        total = count_messages(conn, session_id)
+        print(f"IA: {reply}")
+        print(f"  [{total} msgs sauvegardés | {latency:.2f}s]\n")
+
+except KeyboardInterrupt:
+    print("\n\nConversation sauvegardée. Au revoir !")
+finally:
+    conn.close()

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_04_persistance/requirements.txt

@@ -0,0 +1,2 @@
+openai>=1.0.0
+python-dotenv>=1.0.0

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_05_rag/.env.example

@@ -0,0 +1,4 @@
+OPENAI_API_KEY=sk-your-key-here
+MODEL=gpt-4o-mini
+CHROMA_PATH=./chroma_db
+N_RESULTS=3

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_05_rag/EVALUATION_TP_ETAPE_05.md

@@ -0,0 +1,82 @@
+# 🧠 Évaluation — Étape 05 : RAG (Retrieval-Augmented Generation)
+
+> ⏱ Durée estimée : 60 min | Niveau : Intermédiaire
+
+## 🎯 Enjeu central
+
+Un LLM ne sait que ce qu'il a vu pendant son entraînement. Pour répondre sur tes propres
+documents, il faut lui **injecter le contexte pertinent à chaque requête**.
+C'est le RAG : chercher dans une base vectorielle, puis envoyer les passages au LLM.
+KPI central : le Hit Rate — combien de questions trouvent une réponse correcte dans tes docs ?
+
+---
+
+## ✅ Checklist de validation
+
+- [ ] J'ai lancé `indexer.py` et indexé les documents du dossier `data/`
+- [ ] J'ai lancé `rag_chromadb.py` et posé des questions couvertes par les docs
+- [ ] J'ai posé une question hors-sujet et observé la réponse
+- [ ] J'ai lancé `evaluer_rag.py` et noté mon Hit Rate
+- [ ] J'ai inspecté le dossier `chroma_db/` créé par l'indexation
+
+---
+
+## 🔍 Questions de compréhension
+
+### Niveau 1 — Observation
+1. Quel Hit Rate as-tu obtenu avec `evaluer_rag.py` ? Quelles questions ont échoué et pourquoi selon toi ?
+
+   > _________________________________________________________
+
+2. Quand tu poses "Quel est le prix de CloudSync Pro ?", combien de chunks ChromaDB renvoie-t-il ? Quelle est leur longueur approximative ?
+
+   > _________________________________________________________
+
+3. Que répond le bot si tu poses une question sur un sujet absent des documents (ex : "Quelle est la météo aujourd'hui ?") ?
+
+   > _________________________________________________________
+
+### Niveau 2 — Analyse
+1. Le pipeline RAG est `embed → store → retrieve → inject → generate`. À quelle étape intervient le LLM ? À quelle étape intervient ChromaDB ? Pourquoi les séparer ?
+
+   > _________________________________________________________
+
+2. Si tu indexes un doc de 100 pages en chunks de 500 tokens, combien de chunks obtiens-tu ? Quel est l'impact sur la pertinence si les chunks sont trop petits ? Trop grands ?
+
+   > _________________________________________________________
+
+### Niveau 3 — Décision
+1. Tu déploies un RAG sur une base de 50 000 pages. Quels sont les 3 risques principaux (qualité, coût, latence) et comment les anticipes-tu dans la conception ?
+
+   > _________________________________________________________
+   > _________________________________________________________
+
+---
+
+## 🧪 Mini-expérience guidée
+
+Ajoute un fichier `.txt` dans `data/` avec 5-10 phrases inventées sur un sujet fictif.
+Relance `indexer.py` puis pose une question sur ce nouveau contenu. Le RAG le retrouve-t-il ?
+
+**Question posée :** `__________________________________________________`
+
+**Réponse du bot :**
+```
+_____________________________________________________________
+_____________________________________________________________
+```
+
+---
+
+## 📋 Lien avec le dossier E8
+
+- **Architecture** : Décrivez l'architecture RAG implémentée : rôle de ChromaDB, rôle des embeddings, et pourquoi ce choix est préférable à un fine-tuning pour une base documentaire d'entreprise.
+- **RGPD** : Si les documents indexés contiennent des données personnelles, quelles obligations RGPD s'appliquent à la base vectorielle ? Comment implémenter le droit à l'effacement dans un système RAG ?
+
+---
+
+## 💡 Pour aller plus loin
+
+- Modifie la taille des chunks (200, 500, 1000 tokens) et mesure l'impact sur le Hit Rate.
+- Inspecte le dossier `chroma_db/` : dans quel format les embeddings sont-ils stockés ?
+- Cherche la différence entre **sparse retrieval** (BM25) et **dense retrieval** (embeddings).

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_05_rag/README.md

@@ -0,0 +1,53 @@
+# Étape 05 — RAG (Retrieval-Augmented Generation)
+
+## Objectif
+Connecter le chatbot à une base de connaissances documentaire.
+
+## Architecture RAG
+
+```
+Question utilisateur
+       ↓
+[ChromaDB] → Recherche sémantique → 3 chunks pertinents
+       ↓
+Injection dans le system prompt
+       ↓
+[LLM] → Réponse basée sur les docs
+```
+
+## Installation
+```bash
+pip install -r requirements.txt
+cp .env.example .env
+```
+
+## Étapes
+
+### 1. Indexer les documents
+```bash
+python indexer.py
+```
+Indexe tous les fichiers `.txt` du dossier `data/`.
+
+### 2. Lancer le chatbot RAG
+```bash
+python rag_chromadb.py
+```
+
+### 3. Évaluer la qualité
+```bash
+python evaluer_rag.py
+```
+Objectif : Hit Rate > 80%
+
+## Questions de test
+- "Quel est le prix de CloudSync Pro ?"
+- "Comment contacter le support ?"
+- "Quelles sont les limites de l'API ?"
+- "Où sont vos bureaux ?"
+
+## KPI : Hit Rate
+```
+Hit Rate = questions correctement répondues / total questions
+```
+Objectif production : > 80%

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_05_rag/data/entreprise.txt

@@ -0,0 +1,101 @@
+TechCorp Solutions — Documentation Entreprise
+
+== Présentation Générale ==
+
+TechCorp Solutions est une entreprise française de logiciels SaaS fondée en 2018 à Paris. Spécialisée dans les solutions de synchronisation de données, de stockage sécurisé et d'intégration d'API pour les entreprises, TechCorp Solutions compte aujourd'hui 150 employés répartis sur trois sites en France. Notre mission est de simplifier la gestion des données d'entreprise grâce à des outils cloud performants, sécurisés et faciles à intégrer.
+
+Depuis sa création, TechCorp Solutions a accompagné plus de 2 000 entreprises clientes, allant des PME aux grands groupes industriels. Notre taux de satisfaction client atteint 94 % selon notre dernière enquête annuelle.
+
+== Nos Produits ==
+
+--- CloudSync Pro ---
+CloudSync Pro est notre solution de synchronisation de données en temps réel entre vos systèmes internes et le cloud. Elle prend en charge les bases de données MySQL, PostgreSQL, MongoDB et Microsoft SQL Server.
+
+Prix : 49 € par mois (facturation mensuelle) ou 470 € par an (soit 2 mois offerts).
+Inclus : synchronisation jusqu'à 5 sources de données, 50 Go de stockage temporaire, support email, tableau de bord en temps réel, historique de 30 jours.
+Options : sources supplémentaires à 9 € / mois chacune.
+
+--- DataVault ---
+DataVault est notre solution de stockage sécurisé et d'archivage longue durée. Les données sont chiffrées en AES-256 et stockées dans nos datacenters certifiés ISO 27001 (certification en cours de renouvellement).
+
+Prix : 99 € par mois ou 950 € par an.
+Inclus : 500 Go de stockage, chiffrement de bout en bout, snapshots quotidiens, rétention 7 ans (plans payants), accès multi-utilisateurs (jusqu'à 10 comptes), conformité RGPD.
+Options : stockage supplémentaire à 0,15 € / Go / mois.
+
+--- APIConnect ---
+APIConnect est notre plateforme d'intégration d'API permettant de connecter vos applications métier à des services tiers sans code. Compatible avec plus de 300 connecteurs natifs (Salesforce, HubSpot, Slack, Google Workspace, SAP, etc.).
+
+Prix : 199 € par mois ou 1 900 € par an.
+Inclus : connecteurs illimités, 100 000 appels API / mois inclus, monitoring des flux, alertes en cas d'erreur, support prioritaire, SLA 99,9 %.
+Options : appels supplémentaires à 0,002 € / appel au-delà du quota.
+
+== Support Client ==
+
+Notre équipe de support est disponible du lundi au vendredi de 09h à 18h (heure de Paris).
+
+Adresse email : support@techcorp.fr
+Téléphone : 01 23 45 67 89
+Portail client : https://support.techcorp.fr
+Chat en ligne : disponible sur le portail client aux heures ouvrées
+
+Responsable du support : Sophie Bernard
+Temps de réponse moyen : 2 heures (email), immédiat (chat en ligne aux heures ouvrées)
+
+Pour les clients APIConnect (plan Premium), un support téléphonique prioritaire est disponible 24h/24 et 7j/7.
+
+== Foire Aux Questions (FAQ) ==
+
+Q : Comment installer CloudSync Pro ?
+R : Téléchargez l'agent depuis votre espace client, lancez l'installateur, puis configurez vos sources de données depuis l'interface web. Un guide de démarrage rapide est disponible dans la documentation en ligne.
+
+Q : Comment est facturé mon abonnement ?
+R : La facturation est mensuelle ou annuelle selon votre choix. Les paiements sont prélevés automatiquement par carte bancaire ou virement SEPA. Une facture est émise le 1er de chaque mois.
+
+Q : Quel est le SLA garanti ?
+R : Nous garantissons un uptime de 99,9 % sur tous nos services. Cela correspond à moins de 9 heures d'interruption par an. En cas de dépassement, nous appliquons un crédit de service selon nos conditions générales.
+
+Q : Quelle est la politique de remboursement ?
+R : Vous disposez de 30 jours après la souscription pour demander un remboursement intégral, sans justification. Au-delà de 30 jours, aucun remboursement n'est accordé pour les périodes déjà consommées.
+
+Q : Quelles intégrations sont disponibles nativement ?
+R : Nos produits s'intègrent nativement avec Google Workspace, Microsoft 365, Salesforce, HubSpot, Slack, Zapier, Make (ex-Integromat), AWS, Azure et GCP.
+
+Q : Puis-je essayer avant d'acheter ?
+R : Oui, une période d'essai gratuite de 14 jours est disponible pour chaque produit, sans carte bancaire requise.
+
+== Équipe de Direction ==
+
+PDG (CEO) : Marie Dupont — Fondatrice de TechCorp Solutions, ancienne directrice technique chez Capgemini. Diplômée de l'École Polytechnique.
+
+Directeur Technique (CTO) : Jean Martin — Responsable de l'architecture technique et de la R&D. Ex-ingénieur chez OVHcloud. Expert en systèmes distribués et sécurité cloud.
+
+Directrice Commerciale (CCO) : Isabelle Leroy — En charge des ventes et des partenariats stratégiques. Ancienne responsable grands comptes chez Salesforce France.
+
+Responsable Support : Sophie Bernard — Gère une équipe de 12 ingénieurs support. Certifiée ITIL v4.
+
+Directeur Financier (CFO) : Thomas Roux — Supervise les finances et la conformité réglementaire. Expert-comptable diplômé.
+
+== Bureaux ==
+
+Siège social (Paris) :
+15 rue de la Paix, 75002 Paris
+Tél : 01 23 45 67 89
+Accès : Métro ligne 3 et 7 — Station Opéra
+
+Bureau de Lyon :
+8 place Bellecour, 69002 Lyon
+Tél : 04 56 78 90 12
+Équipes : commerciaux et support régional Sud-Est
+
+Bureau de Bordeaux :
+3 allée de Tourny, 33000 Bordeaux
+Tél : 05 34 56 78 90
+Équipes : développement produit et R&D
+
+== Certifications et Conformité ==
+
+TechCorp Solutions est engagée dans une démarche de conformité rigoureuse :
+- Conformité RGPD (depuis mai 2018)
+- Certification ISO 27001 en cours (audit prévu Q3 2026)
+- Hébergement exclusivement en France (datacenters OVHcloud et Scaleway)
+- Politique de divulgation responsable des vulnérabilités (CVD)

tp_ia_chatbot-main/tp_ia_chatbot-main/etape_05_rag/data/politique.txt

@@ -0,0 +1,82 @@
+TechCorp Solutions — Politiques et Conditions
+
+== Politique de Confidentialité (RGPD) ==
+
+Dernière mise à jour : 1er janvier 2025
+
+TechCorp Solutions (SAS au capital de 150 000 €, siège au 15 rue de la Paix, 75002 Paris, SIRET 823 456 789 00023) s'engage à protéger les données personnelles de ses utilisateurs conformément au Règlement Général sur la Protection des Données (RGPD — UE 2016/679) et à la loi Informatique et Libertés.
+
+Données collectées :
+Nous collectons uniquement les données nécessaires au fonctionnement de nos services : nom, prénom, adresse email professionnelle, numéro de téléphone (optionnel), données de facturation (sans conservation des coordonnées bancaires complètes), logs de connexion et d'utilisation.
+
+Base légale du traitement :
+Le traitement est fondé sur l'exécution du contrat (art. 6.1.b RGPD) pour les données nécessaires à la fourniture du service, et sur notre intérêt légitime (art. 6.1.f) pour les données d'amélioration du service.
+
+Droits des personnes :
+Conformément au RGPD, vous disposez d'un droit d'accès, de rectification, d'effacement, de portabilité et d'opposition. Pour exercer ces droits, contactez notre Délégué à la Protection des Données (DPO) : dpo@techcorp.fr. Nous répondrons dans un délai de 30 jours maximum.
+
+== Politique de Rétention des Données ==
+
+Comptes gratuits et périodes d'essai :
+Les données sont conservées pendant 2 ans à compter de la dernière activité. Au-delà, elles sont supprimées définitivement ou anonymisées.
+
+Comptes payants (CloudSync Pro, DataVault, APIConnect) :
+Les données sont conservées pendant 7 ans à compter de la clôture du compte, conformément aux obligations légales comptables françaises (Code de commerce, art. L123-22). Cette durée de rétention de 7 ans s'applique également aux données de facturation.
+
+Données de logs et monitoring :
+Conservées 90 jours pour les plans gratuits, 1 an pour les plans payants, puis supprimées automatiquement.
+
+Après la clôture d'un compte, un export complet des données peut être demandé dans les 30 jours suivant la résiliation.
+
+== Politique de Cookies ==
+
+Notre site web (techcorp.fr) et notre portail client utilisent des cookies. Vous pouvez gérer vos préférences via notre bandeau de consentement.
+
+Cookies strictement nécessaires (pas de consentement requis) :
+- Cookie de session (expiration : session)
+- Cookie CSRF (sécurité des formulaires)
+- Préférences de langue et d'accessibilité
+
+Cookies analytiques (consentement requis) :
+- Mesure d'audience anonymisée (Matomo hébergé en France, pas de partage tiers)
+- Durée : 13 mois maximum
+
+Nous n'utilisons aucun cookie publicitaire ni ne partageons vos données avec des régies publicitaires.
+
+== Conditions Générales d'Utilisation ==
+
+En accédant à nos services, vous acceptez les présentes CGU. Nos services sont destinés à un usage professionnel et sont réservés aux personnes majeures agissant au nom d'une entreprise.
+
+Responsabilité : TechCorp Solutions s'engage à maintenir une disponibilité de 99,9 % (SLA). Notre responsabilité contractuelle est limitée au montant des sommes versées au cours des 12 derniers mois précédant le litige.
+
+Résiliation : les abonnements peuvent être résiliés à tout moment depuis l'espace client. La résiliation prend effet à la fin de la période de facturation en cours.
+
+Droit applicable : les présentes CGU sont soumises au droit français. Tout litige sera soumis à la compétence exclusive des tribunaux de Paris.
+
+== Politique d'Utilisation Acceptable ==
+
+Il est interdit d'utiliser nos services pour :
+- Stocker ou transmettre des contenus illicites, diffamatoires ou portant atteinte aux droits de tiers
+- Mener des activités de spam, phishing ou ingénierie sociale
+- Tenter d'accéder sans autorisation à des systèmes tiers via nos API
+- Surcharger intentionnellement nos infrastructures (attaques DoS)
+- Revendre l'accès à nos services sans accord préalable écrit
+
+Toute violation peut entraîner la suspension immédiate du compte sans remboursement.
+
+== Politique de Sécurité ==
+
+TechCorp Solutions applique une politique de sécurité rigoureuse, alignée sur les bonnes pratiques ISO 27001 (certification en cours d'obtention).
+
+Mesures techniques :
+- Chiffrement en transit : TLS 1.2 minimum, TLS 1.3 recommandé
+- Chiffrement au repos : AES-256 pour toutes les données stockées
+- Authentification multi-facteurs (MFA) disponible et recommandée
+- Tests de pénétration annuels réalisés par un prestataire certifié PASSI
+- Surveillance des accès et alertes en temps réel via SIEM interne
+
+Signalement de vulnérabilités :
+Nous encourageons la divulgation responsable. Si vous découvrez une faille de sécurité, contactez security@techcorp.fr. Nous nous engageons à accuser réception sous 48 heures et à corriger les vulnérabilités critiques sous 7 jours ouvrés.
+
+Sous-traitants :
+Nos hébergeurs (OVHcloud et Scaleway) sont des sous-traitants RGPD avec lesquels des DPA (Data Processing Agreements) sont en vigueur. Les données restent exclusivement hébergées en France.