Upload 14 files

.env.example

@@ -0,0 +1,8 @@
+# Example environment variables
+# Copy this file to .env and fill in your actual values
+
+# Mistral AI API Key
+MISTRAL_API_KEY=your_mistral_api_key_here
+
+# Optional: Default model
+DEFAULT_MODEL=mistral-tiny

.gitignore

@@ -0,0 +1,73 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Environment variables
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Gradio
+gradio_cached_examples/
+flagged/
+gradio.db
+
+# Logs
+*.log
+logs/
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# Temporary files
+*.tmp
+*.temp

DEPLOY_INSTRUCTIONS.md

@@ -0,0 +1,80 @@
+# Instructions pour déployer sur Hugging Face Spaces
+
+## Prérequis
+1. Compte Hugging Face : [huggingface.co](https://huggingface.co)
+2. Git installé sur votre machine
+
+## Étapes de déploiement
+
+### 1. Créer un nouveau Space
+1. Allez sur [huggingface.co/new-space](https://huggingface.co/new-space)
+2. Donnez un nom à votre Space (ex: `ecologits-chat`)
+3. Choisissez `Gradio` comme SDK
+4. Sélectionnez `Public` ou `Private` selon vos préférences
+5. Cliquez sur "Create Space"
+
+### 2. Cloner le repository
+```bash
+git clone https://huggingface.co/spaces/VOTRE_USERNAME/VOTRE_SPACE_NAME
+cd VOTRE_SPACE_NAME
+```
+
+### 3. Copier les fichiers
+Copiez tous ces fichiers dans le dossier de votre Space :
+- `app.py`
+- `chat_interface.py`
+- `mistral_client.py`
+- `impacts_tracker.py`
+- `config.py`
+- `requirements.txt`
+- `README.md` (ou renommez `README_HF.md` en `README.md`)
+
+### 4. Créer le fichier de configuration Hugging Face
+Créez un fichier `README.md` avec les métadonnées Hugging Face :
+
+```yaml
+---
+title: EcoLogits Chat
+emoji: 🌱
+colorFrom: green
+colorTo: blue
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# 🌱 EcoLogits Chat
+
+[Contenu de votre README...]
+```
+
+### 5. Pousser sur Hugging Face
+```bash
+git add .
+git commit -m "Initial commit - EcoLogits Chat"
+git push
+```
+
+### 6. Configurer l'application (optionnel)
+Si vous voulez utiliser votre propre clé API par défaut :
+1. Allez dans les Settings de votre Space
+2. Ajoutez une variable d'environnement : `MISTRAL_API_KEY`
+3. Mettez votre clé API comme valeur
+4. Redémarrez le Space
+
+## ✅ Résultat
+Votre application sera disponible à l'adresse :
+`https://huggingface.co/spaces/VOTRE_USERNAME/VOTRE_SPACE_NAME`
+
+Les utilisateurs pourront :
+- Utiliser l'app directement sans fork
+- Fournir leur propre clé API Mistral
+- Voir l'impact environnemental de leurs conversations
+- Choisir parmi tous les modèles Mistral disponibles
+
+## 🔒 Sécurité
+- Les clés API des utilisateurs ne sont jamais stockées
+- Elles n'existent que pendant la session active
+- Aucune donnée n'est partagée avec des tiers

README.md

@@ -1,13 +1,235 @@
----
-title: Ecologits Chat
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
-sdk: gradio
-sdk_version: 5.0.1
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+# EcoLogits - AI Environmental Impact Tracker
+
+A clean, modular chat application that tracks the environmental impact of AI model usage using **EcoLogits** library and **Mistral AI** models.
+
+## 🌱 Overview
+
+This application provides a user-friendly interface to chat with Mistral AI models while tracking their environmental impact in real-time. It displays energy consumption and carbon footprint for each conversation, promoting awareness of AI's environmental costs.
+
+## ✨ Features
+
+- **Clean Chat Interface**: Simple Gradio-based web interface with tabbed impact tracking
+- **Environmental Tracking**: Real-time tracking of energy usage and carbon emissions using EcoLogits
+- **Smart Model Filtering**: Automatically filters to show only text-to-text capable models (excludes OCR, embedding, vision models)
+- **Tabbed Impact Visualization**: 
+  - 🎯 **Last Message**: Impact of the specific last request with warnings/errors
+  - 📈 **Total Session**: Cumulative environmental metrics across the entire session
+- **Warning System**: Shows EcoLogits warnings and errors conditionally in the UI
+- **Modular Architecture**: Clean separation of concerns across multiple files
+- **Session Management**: Clear conversation and reset impacts with the "Effacer tout" button
+
+## 🏗️ Architecture
+
+The application is organized into focused, reusable modules:
+
+```
+├── app.py                 # Main application entry point
+├── config.py             # Configuration and environment variables
+├── mistral_client.py     # Mistral API wrapper with EcoLogits integration
+├── impacts_tracker.py    # Environmental impact tracking and calculations
+├── chat_interface.py     # Gradio UI components and user interaction
+└── app_original.py       # Backup of original monolithic version
+```
+
+### Module Responsibilities
+
+- **`config.py`**: Centralized configuration management, environment variables, fallback models
+- **`mistral_client.py`**: Handles Mistral API communication, intelligent model filtering, EcoLogits integration
+- **`impacts_tracker.py`**: Tracks and calculates cumulative environmental impacts
+- **`chat_interface.py`**: Manages the Gradio web interface with tabbed impact display
+- **`app.py`**: Simple entry point that ties everything together
+
+## 🚀 Setup
+
+### Prerequisites
+
+- Python 3.8+
+- Mistral AI API key
+
+### Installation
+
+1. **Clone or download the project files**
+
+2. **Create a virtual environment:**
+   ```bash
+   python -m venv .venv
+   ```
+
+3. **Activate the virtual environment:**
+   ```bash
+   # Windows
+   .venv\Scripts\Activate.ps1
+   
+   # Linux/Mac
+   source .venv/bin/activate
+   ```
+
+4. **Install dependencies:**
+   ```bash
+   pip install gradio mistralai ecologits python-dotenv
+   ```
+
+5. **Set up environment variables:**
+   
+   Create a `.env` file in the project root:
+   ```env
+   MISTRAL_API_KEY=your_mistral_api_key_here
+   ```
+   
+   Or set the environment variable directly:
+   ```bash
+   # Windows
+   $env:MISTRAL_API_KEY="your_mistral_api_key_here"
+   
+   # Linux/Mac
+   export MISTRAL_API_KEY="your_mistral_api_key_here"
+   ```
+
+### Getting a Mistral API Key
+
+1. Visit [Mistral AI Console](https://console.mistral.ai/)
+2. Create an account or sign in
+3. Navigate to API Keys section
+4. Create a new API key
+5. Copy the key and add it to your `.env` file
+
+## 🎯 Usage
+
+### Running the Application
+
+1. **Activate your virtual environment:**
+   ```bash
+   .venv\Scripts\Activate.ps1
+   ```
+
+2. **Run the application:**
+   ```bash
+   python app.py
+   ```
+
+3. **Open your browser** to the displayed URL (typically `http://127.0.0.1:7860`)
+
+### Using the Interface
+
+1. **Select a Model**: Choose from available text-to-text Mistral models (automatically filtered)
+2. **Start Chatting**: Enter your message and click Send
+3. **Monitor Impact**: Use the tabs to view different impact metrics:
+   - **🎯 Dernier message**: Impact of your last request + any EcoLogits warnings/errors
+   - **📈 Session totale**: Cumulative impact across the entire conversation
+4. **Track Progress**: See real-time energy and carbon consumption updates
+5. **Clear Session**: Use "🗑️ Effacer tout" to start fresh and reset all impacts
+
+## 📊 Environmental Metrics
+
+The application tracks and displays:
+
+- **Energy Consumption**: Measured in kilowatt-hours (kWh)
+- **Carbon Emissions**: CO2 equivalent emissions in grams
+- **Cumulative Totals**: Running totals across the entire session
+- **Per-Message Impact**: Individual impact of each AI response
+
+## 🔧 Configuration
+
+### Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `MISTRAL_API_KEY` | Your Mistral AI API key | *Required* |
+
+### Model Selection
+
+The application automatically:
+- Fetches available models from Mistral API
+- Filters to only show text-to-text capable models (using `completion_chat` capability)
+- Falls back to predefined models if API is unavailable
+
+### Fallback Models
+
+If the Mistral API is unavailable, the application uses these models:
+- `mistral-small-latest`
+- `mistral-large-latest`
+- `open-mistral-nemo`
+
+## 🛠️ Development
+
+### Code Structure
+
+The codebase follows clean architecture principles:
+
+```python
+# Clean separation of concerns
+config.py           # Configuration management
+mistral_client.py   # External API integration
+impacts_tracker.py  # Business logic for tracking
+chat_interface.py   # UI presentation layer
+app.py             # Application composition
+```
+
+### Key Design Decisions
+
+1. **Model Filtering**: Only shows models with `completion_chat: true` capability
+2. **Error Handling**: Graceful degradation when APIs are unavailable
+3. **Environmental Focus**: EcoLogits warnings displayed prominently in UI
+4. **Modular Design**: Each file has a single, clear responsibility
+
+### Adding New Features
+
+The modular structure makes it easy to extend:
+
+- **New Providers**: Add to `mistral_client.py` or create similar modules
+- **UI Changes**: Modify `chat_interface.py` 
+- **Tracking Logic**: Extend `impacts_tracker.py`
+- **Configuration**: Add to `config.py`
+
+## 🌍 About EcoLogits
+
+[EcoLogits](https://ecologits.ai/) is a Python library that tracks the environmental impact of AI model usage. It provides:
+
+- Real-time energy consumption tracking
+- Carbon footprint calculations
+- Support for multiple AI providers
+- Detailed impact reporting
+
+This application demonstrates responsible AI usage by making environmental costs visible and measurable.
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+1. **"Invalid model" errors**: 
+   - Fixed! The app now filters out incompatible models automatically
+   - Check the console output to see which models are included/excluded
+
+2. **Clear button not working**: 
+   - Fixed! The "Effacer tout" button now properly resets conversation and impacts
+
+3. **Missing tabs**: 
+   - Fixed! Tabbed interface restored with "Dernier message" and "Session totale"
+
+4. **API connection issues**:
+   - Check your `MISTRAL_API_KEY` in the `.env` file
+   - The app will fall back to predefined models if the API is unavailable
+
+### Recent Improvements
+
+- ✅ **Fixed Model Filtering**: No more "Invalid model" errors from OCR/specialized models
+- ✅ **Restored Tabbed Interface**: Full impact tracking with organized tabs
+- ✅ **Fixed Clear Button**: "Effacer tout" now properly resets conversation and impacts
+- ✅ **Enhanced Debugging**: Visible model filtering process with inclusion/exclusion lists
+
+## 📄 License
+
+This project is provided as-is for educational and development purposes.
+
+## 🤝 Contributing
+
+Feel free to fork, modify, and improve this application. The modular structure makes it easy to:
+
+- Add new AI providers
+- Enhance the UI
+- Improve environmental tracking
+- Add new features
+
+---
+
+**Made with 🌱 for sustainable AI development**

README_HF.md

@@ -0,0 +1,48 @@
+# 🌱 EcoLogits Chat - Chat Écologique avec Mistral
+
+Une application de chat qui utilise l'API Mistral AI tout en surveillant l'impact environnemental de chaque génération grâce à [EcoLogits](https://ecologits.ai/).
+
+## 🚀 Utilisation sur Hugging Face
+
+### 1. Obtenez votre clé API Mistral
+1. Créez un compte sur [console.mistral.ai](https://console.mistral.ai)
+2. Générez une nouvelle clé API dans votre tableau de bord
+3. Copiez votre clé API
+
+### 2. Utilisez l'application
+1. Collez votre clé API dans le champ prévu à cet effet
+2. Choisissez votre modèle Mistral préféré
+3. Commencez à chatter tout en surveillant votre impact environnemental !
+
+## 📊 Fonctionnalités
+
+- **Chat intelligent** : Discutez avec les modèles Mistral AI
+- **Suivi environnemental** : Mesurez la consommation d'énergie et l'empreinte carbone de chaque message
+- **Interface intuitive** : Interface Gradio simple et conviviale
+- **Sécurisé** : Votre clé API n'est jamais stockée, elle n'existe que pendant votre session
+
+## 🔒 Sécurité
+
+- Vos clés API ne sont jamais sauvegardées
+- Les clés API sont uniquement utilisées pendant votre session active
+- Aucune donnée n'est partagée avec des tiers
+
+## 💚 Impact Environnemental
+
+Cette application utilise [EcoLogits](https://ecologits.ai/) pour traquer :
+- **Consommation d'énergie** (kWh) par message et cumulée
+- **Empreinte carbone** (kgCO2eq) par message et cumulée
+- **Avertissements** sur l'impact environnemental
+
+## 🛠️ Installation Locale
+
+Si vous voulez exécuter l'application localement :
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+## 📝 License
+
+MIT License - Voir le fichier LICENSE pour plus de détails.

README_HUGGINGFACE.md

@@ -0,0 +1,92 @@
+---
+title: EcoLogits Chat
+emoji: 🌱
+colorFrom: green
+colorTo: blue
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+tags:
+  - mistral
+  - ecologits
+  - environment
+  - sustainability
+  - ai-chat
+---
+
+# 🌱 EcoLogits Chat - Chat Écologique avec Mistral
+
+Une application de chat qui utilise l'API Mistral AI tout en surveillant l'impact environnemental de chaque génération grâce à [EcoLogits](https://ecologits.ai/).
+
+## 🚀 Utilisation
+
+### 🔑 Obtenez votre clé API Mistral
+1. Créez un compte sur [console.mistral.ai](https://console.mistral.ai)
+2. Générez une nouvelle clé API dans votre tableau de bord
+3. Copiez votre clé API
+4. Collez-la dans le champ prévu dans l'application
+
+### 💬 Commencez à chatter
+1. Choisissez votre modèle Mistral préféré
+2. Tapez votre message
+3. Surveillez l'impact environnemental en temps réel !
+
+## 📊 Fonctionnalités
+
+- **Chat intelligent** : Discutez avec les modèles Mistral AI (50+ modèles disponibles)
+- **Suivi environnemental** : Mesurez la consommation d'énergie et l'empreinte carbone
+- **Interface intuitive** : Interface Gradio simple et conviviale
+- **Sécurisé** : Votre clé API n'est jamais stockée
+- **Temps réel** : Impact affiché pour chaque message et en cumul
+
+## 🔒 Sécurité & Confidentialité
+
+- ✅ **Aucun stockage** : Vos clés API ne sont jamais sauvegardées
+- ✅ **Session uniquement** : Les clés API n'existent que pendant votre session
+- ✅ **Pas de partage** : Aucune donnée partagée avec des tiers
+- ✅ **Code ouvert** : Code source entièrement visible et auditable
+
+## 💚 Impact Environnemental Tracké
+
+Cette application utilise [EcoLogits](https://ecologits.ai/) pour mesurer :
+
+### Par message :
+- **Consommation d'énergie** (kWh)
+- **Empreinte carbone** (kgCO2eq)
+
+### Cumul session :
+- **Énergie totale** consommée
+- **Carbone total** émis
+- **Nombre de générations**
+
+### Alertes :
+- **Avertissements** sur l'impact
+- **Erreurs** de mesure (si applicable)
+
+## 🤖 Modèles Supportés
+
+L'application détecte automatiquement tous les modèles Mistral disponibles, incluant :
+- mistral-tiny, mistral-small, mistral-medium
+- mistral-large (dernières versions)
+- codestral (pour le code)
+- pixtral (multimodal)
+- Et beaucoup d'autres !
+
+## 🛠️ Installation Locale
+
+```bash
+git clone <ce-repo>
+cd ecologitets
+pip install -r requirements.txt
+python app.py
+```
+
+## 📄 License
+
+MIT License - Libre d'utilisation et de modification.
+
+---
+
+💡 **Astuce** : Utilisez des modèles plus petits (comme mistral-tiny) pour réduire votre impact environnemental !

app.py

@@ -1,64 +1,18 @@
-import gradio as gr
-from huggingface_hub import InferenceClient
-
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-
-if __name__ == "__main__":
-    demo.launch()
+from chat_interface import ChatInterface
+
+def main():
+    """Launch the chat application"""
+    # Create and launch the interface
+    chat_app = ChatInterface()
+    interface = chat_app.create_interface()
+    
+    print("🌱 Launching EcoLogits Chat...")
+    interface.launch(
+        share=False,
+        server_name="0.0.0.0",  # Allow external connections for Hugging Face
+        server_port=7860,       # Standard Hugging Face port
+        inbrowser=False         # Don't auto-open browser on server
+    )
+
+if __name__ == "__main__":
+    main()

app_config.py

@@ -0,0 +1,26 @@
+import os
+
+# Hugging Face Spaces configuration
+TITLE = "🌱 EcoLogits Chat - Chat Écologique avec Mistral"
+DESCRIPTION = """
+# 🌱 Chat Écologique avec Mistral
+
+💬 Discutez avec l'IA tout en surveillant l'impact environnemental de vos conversations.
+
+⚠️ **Important** : Vous devez fournir votre propre clé API Mistral pour utiliser cette application.
+
+## 🔑 Comment obtenir votre clé API :
+1. Créez un compte sur [console.mistral.ai](https://console.mistral.ai)
+2. Générez une clé API dans votre tableau de bord
+3. Collez votre clé dans le champ ci-dessous
+
+## 📊 Fonctionnalités :
+- ✅ Chat avec les modèles Mistral AI
+- ✅ Suivi de la consommation d'énergie (kWh)
+- ✅ Mesure de l'empreinte carbone (kgCO2eq)
+- ✅ Interface sécurisée (clé API non stockée)
+"""
+
+# For Hugging Face Spaces metadata
+TAGS = ["mistral", "ecologits", "environment", "chat", "ai"]
+THUMBNAIL = None  # Add a thumbnail URL if you have one

app_original.py

@@ -0,0 +1,534 @@
+import os 
+from dotenv import load_dotenv
+from ecologits import EcoLogits
+from mistralai import Mistral
+import gradio as gr
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Initialize EcoLogits
+EcoLogits.init(providers=["mistralai"])
+
+client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
+
+# Initialize cumulative impacts storage
+class CumulativeImpacts:
+    def __init__(self):
+        self.reset()
+    
+    def reset(self):
+        self.energy_min = 0.0
+        self.energy_max = 0.0
+        self.energy_unit = "kWh"
+        self.gwp_min = 0.0
+        self.gwp_max = 0.0
+        self.gwp_unit = "kgCO2eq"
+        self.adpe_min = 0.0
+        self.adpe_max = 0.0
+        self.adpe_unit = "kgSbeq"
+        self.pe_min = 0.0
+        self.pe_max = 0.0
+        self.pe_unit = "kWh"
+        self.usage_energy_min = 0.0
+        self.usage_energy_max = 0.0
+        self.usage_gwp_min = 0.0
+        self.usage_gwp_max = 0.0
+        self.embodied_gwp = 0.0
+        self.embodied_gwp_unit = "kgCO2eq"
+        self.embodied_adpe = 0.0
+        self.embodied_adpe_unit = "kgSbeq"
+        self.embodied_pe = 0.0
+        self.embodied_pe_unit = "kWh"
+        self.generation_count = 0
+        
+        # Store previous values for delta calculation
+        self.prev_energy_min = 0.0
+        self.prev_energy_max = 0.0
+        self.prev_gwp_min = 0.0
+        self.prev_gwp_max = 0.0
+        self.prev_adpe_min = 0.0
+        self.prev_adpe_max = 0.0
+        self.prev_pe_min = 0.0
+        self.prev_pe_max = 0.0
+        self.prev_usage_energy_min = 0.0
+        self.prev_usage_energy_max = 0.0
+        self.prev_usage_gwp_min = 0.0
+        self.prev_usage_gwp_max = 0.0
+        self.prev_embodied_gwp = 0.0
+        self.prev_embodied_adpe = 0.0
+        self.prev_embodied_pe = 0.0
+
+    def get_generation_delta(self):
+        """Get the delta between current and previous totals (impact of last generation)"""
+        return {
+            'energy_min': self.energy_min - self.prev_energy_min,
+            'energy_max': self.energy_max - self.prev_energy_max,
+            'energy_unit': self.energy_unit,
+            'gwp_min': self.gwp_min - self.prev_gwp_min,
+            'gwp_max': self.gwp_max - self.prev_gwp_max,
+            'gwp_unit': self.gwp_unit,
+            'adpe_min': self.adpe_min - self.prev_adpe_min,
+            'adpe_max': self.adpe_max - self.prev_adpe_max,
+            'adpe_unit': self.adpe_unit,
+            'pe_min': self.pe_min - self.prev_pe_min,
+            'pe_max': self.pe_max - self.prev_pe_max,
+            'pe_unit': self.pe_unit,
+            'usage_energy_min': self.usage_energy_min - self.prev_usage_energy_min,
+            'usage_energy_max': self.usage_energy_max - self.prev_usage_energy_max,
+            'usage_gwp_min': self.usage_gwp_min - self.prev_usage_gwp_min,
+            'usage_gwp_max': self.usage_gwp_max - self.prev_usage_gwp_max,
+            'embodied_gwp': float(self.embodied_gwp) - float(self.prev_embodied_gwp),
+            'embodied_gwp_unit': self.embodied_gwp_unit,
+            'embodied_adpe': float(self.embodied_adpe) - float(self.prev_embodied_adpe),
+            'embodied_adpe_unit': self.embodied_adpe_unit,
+            'embodied_pe': float(self.embodied_pe) - float(self.prev_embodied_pe),
+            'embodied_pe_unit': self.embodied_pe_unit
+        }
+
+    def add_impacts(self, impacts):
+        # Store previous values before updating
+        self.prev_energy_min = self.energy_min
+        self.prev_energy_max = self.energy_max
+        self.prev_gwp_min = self.gwp_min
+        self.prev_gwp_max = self.gwp_max
+        self.prev_adpe_min = self.adpe_min
+        self.prev_adpe_max = self.adpe_max
+        self.prev_pe_min = self.pe_min
+        self.prev_pe_max = self.pe_max
+        self.prev_usage_energy_min = self.usage_energy_min
+        self.prev_usage_energy_max = self.usage_energy_max
+        self.prev_usage_gwp_min = self.usage_gwp_min
+        self.prev_usage_gwp_max = self.usage_gwp_max
+        # Convert values to float to avoid type issues
+        self.prev_embodied_gwp = float(self.embodied_gwp) if self.embodied_gwp is not None else 0.0
+        self.prev_embodied_adpe = float(self.embodied_adpe) if self.embodied_adpe is not None else 0.0
+        self.prev_embodied_pe = float(self.embodied_pe) if self.embodied_pe is not None else 0.0
+        
+        # Update current values
+        self.energy_min += impacts.energy.value.min
+        self.energy_max += impacts.energy.value.max
+        self.energy_unit = impacts.energy.unit
+        
+        self.gwp_min += impacts.gwp.value.min
+        self.gwp_max += impacts.gwp.value.max
+        self.gwp_unit = impacts.gwp.unit
+        
+        self.adpe_min += impacts.adpe.value.min
+        self.adpe_max += impacts.adpe.value.max
+        self.adpe_unit = impacts.adpe.unit
+        
+        self.pe_min += impacts.pe.value.min
+        self.pe_max += impacts.pe.value.max
+        self.pe_unit = impacts.pe.unit
+        
+        self.usage_energy_min += impacts.usage.energy.value.min
+        self.usage_energy_max += impacts.usage.energy.value.max
+        self.usage_gwp_min += impacts.usage.gwp.value.min
+        self.usage_gwp_max += impacts.usage.gwp.value.max
+        
+        # Handle embodied impacts - they might be RangeValue objects or simple floats
+        if hasattr(impacts.embodied.gwp.value, 'min'):
+            self.embodied_gwp += impacts.embodied.gwp.value.min  # Use min if it's a RangeValue
+        else:
+            self.embodied_gwp += impacts.embodied.gwp.value  # Use direct value if it's a float
+        self.embodied_gwp_unit = impacts.embodied.gwp.unit
+        
+        if hasattr(impacts.embodied.adpe.value, 'min'):
+            self.embodied_adpe += impacts.embodied.adpe.value.min
+        else:
+            self.embodied_adpe += impacts.embodied.adpe.value
+        self.embodied_adpe_unit = impacts.embodied.adpe.unit
+        
+        if hasattr(impacts.embodied.pe.value, 'min'):
+            self.embodied_pe += impacts.embodied.pe.value.min
+        else:
+            self.embodied_pe += impacts.embodied.pe.value
+        self.embodied_pe_unit = impacts.embodied.pe.unit
+        
+        self.generation_count += 1
+
+# Global cumulative impacts instance
+cumulative_impacts = CumulativeImpacts()
+def get_response(message, history, model):
+    message_aggregate = []
+    if history:
+        message_aggregate.extend(history)
+    message_aggregate.append({"role": "user", "content": message})
+    print(message_aggregate)
+    
+    # Use the selected model or default to mistral-tiny
+    if not model:
+        model = "mistral-tiny"
+    
+    print(f"Using model: {model}")
+    response = client.chat.complete(
+        messages=message_aggregate,
+        model=model
+    )
+    if response.impacts.has_warnings: # type: ignore
+        for w in response.impacts.warnings: # type: ignore
+            print(w)
+
+    if response.impacts.has_errors: # type: ignore
+        for e in response.impacts.errors: # type: ignore
+            print(e)
+
+    # Get the impacts and format them
+    impacts = response.impacts # type: ignore
+    
+    # Add impacts to cumulative total
+    cumulative_impacts.add_impacts(impacts)
+    
+    # Get the delta for this generation
+    generation_delta = cumulative_impacts.get_generation_delta()
+    
+    message_aggregate.append({
+        "role": "assistant", 
+        "content": response.choices[0].message.content
+    })
+    
+    # Return current generation impacts, generation delta, and cumulative totals
+    return (
+        message_aggregate,
+        # Current generation impacts (raw from API)
+        impacts.energy.value.min,
+        impacts.energy.value.max,
+        impacts.energy.unit,
+        impacts.gwp.value.min,
+        impacts.gwp.value.max,
+        impacts.gwp.unit,
+        f"{impacts.adpe.value.min:.2e}",
+        f"{impacts.adpe.value.max:.2e}",
+        impacts.adpe.unit,
+        impacts.pe.value.min,
+        impacts.pe.value.max,
+        impacts.pe.unit,
+        impacts.usage.energy.value.min,
+        impacts.usage.energy.value.max,
+        impacts.usage.gwp.value.min,
+        impacts.usage.gwp.value.max,
+        f"{impacts.embodied.gwp.value:.2e}",
+        impacts.embodied.gwp.unit,
+        f"{impacts.embodied.adpe.value:.2e}",
+        impacts.embodied.adpe.unit,
+        f"{impacts.embodied.pe.value:.2e}",
+        impacts.embodied.pe.unit,
+        # Generation delta (calculated difference)
+        generation_delta['energy_min'],
+        generation_delta['energy_max'],
+        generation_delta['energy_unit'],
+        generation_delta['gwp_min'],
+        generation_delta['gwp_max'],
+        generation_delta['gwp_unit'],
+        f"{generation_delta['adpe_min']:.2e}",
+        f"{generation_delta['adpe_max']:.2e}",
+        generation_delta['adpe_unit'],
+        generation_delta['pe_min'],
+        generation_delta['pe_max'],
+        generation_delta['pe_unit'],
+        generation_delta['usage_energy_min'],
+        generation_delta['usage_energy_max'],
+        generation_delta['usage_gwp_min'],
+        generation_delta['usage_gwp_max'],
+        f"{generation_delta['embodied_gwp']:.2e}",
+        generation_delta['embodied_gwp_unit'],
+        f"{generation_delta['embodied_adpe']:.2e}",
+        generation_delta['embodied_adpe_unit'],
+        f"{generation_delta['embodied_pe']:.2e}",
+        generation_delta['embodied_pe_unit'],
+        # Cumulative impacts
+        cumulative_impacts.energy_min,
+        cumulative_impacts.energy_max,
+        cumulative_impacts.energy_unit,
+        cumulative_impacts.gwp_min,
+        cumulative_impacts.gwp_max,
+        cumulative_impacts.gwp_unit,
+        f"{cumulative_impacts.adpe_min:.2e}",
+        f"{cumulative_impacts.adpe_max:.2e}",
+        cumulative_impacts.adpe_unit,
+        cumulative_impacts.pe_min,
+        cumulative_impacts.pe_max,
+        cumulative_impacts.pe_unit,
+        cumulative_impacts.usage_energy_min,
+        cumulative_impacts.usage_energy_max,
+        cumulative_impacts.usage_gwp_min,
+        cumulative_impacts.usage_gwp_max,
+        f"{cumulative_impacts.embodied_gwp:.2e}",
+        cumulative_impacts.embodied_gwp_unit,
+        f"{cumulative_impacts.embodied_adpe:.2e}",
+        cumulative_impacts.embodied_adpe_unit,
+        f"{cumulative_impacts.embodied_pe:.2e}",
+        cumulative_impacts.embodied_pe_unit,
+        cumulative_impacts.generation_count
+    )
+
+with gr.Blocks() as demo:
+    gr.Markdown("# 🌱 EcoLogits Chat - Chat écologique avec Mistral")
+    gr.Markdown("Discutez avec l'IA tout en surveillant l'impact environnemental de chaque requête")
+    
+    with gr.Row():
+        with gr.Column(scale=3):
+            chatbot = gr.Chatbot(
+            type="messages", 
+            height=600,
+            show_label=False
+            )
+            with gr.Row():
+                prompt = gr.Textbox(
+                    placeholder="Tapez votre message ici...", 
+                    scale=4,
+                    show_label=False,
+                    max_lines=3
+                )
+            send_btn = gr.Button("Envoyer", variant="primary", scale=1)
+            with gr.Row():
+                # Get available models from Mistral API
+                try:
+                    available_models = client.models.list()
+                    model_choices = [model.id for model in available_models.data] if available_models.data else []
+                except Exception as e:
+                    print(f"Warning: Could not fetch models from API: {e}")
+                    model_choices = ["mistral-tiny", "mistral-small", "mistral-medium"]
+                
+                if not model_choices:
+                    model_choices = ["mistral-tiny", "mistral-small", "mistral-medium"]
+                
+                model = gr.Dropdown(
+                    choices=model_choices,
+                    value=model_choices[0] if model_choices else "mistral-tiny",
+                    label="Modèle Mistral",
+                    scale=1
+                )
+        
+        with gr.Column(scale=2):
+            gr.Markdown("## 📊 Impact Environnemental")
+            
+            # Generation counter
+            generation_counter = gr.Number(label="🔢 Nombre de générations", precision=0, interactive=False)
+            
+            # Tabs for current vs cumulative impacts
+            with gr.Tabs():
+                with gr.TabItem("🎯 Dernier message"):
+                    gr.Markdown("### � **Coût calculé de cette requête spécifique**")
+                    gr.Markdown("*Différence entre le total avant et après cette génération*")
+                    
+                    with gr.Accordion("⚡ Consommation d'énergie", open=True):
+                        with gr.Row():
+                            delta_energy_min = gr.Number(label="Min", precision=8, interactive=False)
+                            delta_energy_max = gr.Number(label="Max", precision=8, interactive=False)
+                        delta_energy_unit = gr.Textbox(label="Unité", interactive=False)
+                    
+                    with gr.Accordion("🌍 Empreinte carbone (GWP)", open=True):
+                        with gr.Row():
+                            delta_gwp_min = gr.Number(label="Min", precision=8, interactive=False)
+                            delta_gwp_max = gr.Number(label="Max", precision=8, interactive=False)
+                        delta_gwp_unit = gr.Textbox(label="Unité", interactive=False)
+                    
+                    with gr.Accordion("⛏️ Épuisement des ressources (ADPe)", open=False):
+                        with gr.Row():
+                            delta_adpe_min = gr.Textbox(label="Min", interactive=False)
+                            delta_adpe_max = gr.Textbox(label="Max", interactive=False)
+                        delta_adpe_unit = gr.Textbox(label="Unité", interactive=False)
+                    
+                    with gr.Accordion("🔋 Énergie primaire (PE)", open=False):
+                        with gr.Row():
+                            delta_pe_min = gr.Number(label="Min", precision=8, interactive=False)
+                            delta_pe_max = gr.Number(label="Max", precision=8, interactive=False)
+                        delta_pe_unit = gr.Textbox(label="Unité", interactive=False)
+                    
+                    with gr.Accordion("💻 Impact d'usage", open=False):
+                        gr.Markdown("**Énergie**")
+                        with gr.Row():
+                            delta_usage_energy_min = gr.Number(label="Min", precision=8, interactive=False)
+                            delta_usage_energy_max = gr.Number(label="Max", precision=8, interactive=False)
+                        gr.Markdown("**GWP**")
+                        with gr.Row():
+                            delta_usage_gwp_min = gr.Number(label="Min", precision=8, interactive=False)
+                            delta_usage_gwp_max = gr.Number(label="Max", precision=8, interactive=False)
+                    
+                    with gr.Accordion("🏭 Impact incorporé", open=False):
+                        delta_embodied_gwp = gr.Textbox(label="GWP", interactive=False)
+                        delta_embodied_gwp_unit = gr.Textbox(label="Unité GWP", interactive=False)
+                        delta_embodied_adpe = gr.Textbox(label="ADPe", interactive=False)
+                        delta_embodied_adpe_unit = gr.Textbox(label="Unité ADPe", interactive=False)
+                        delta_embodied_pe = gr.Textbox(label="PE", interactive=False)
+                        delta_embodied_pe_unit = gr.Textbox(label="Unité PE", interactive=False)
+                
+                with gr.TabItem("📈 Chat complet"):
+                    gr.Markdown("### 🔧 **Données directes de l'API EcoLogits**")
+                    
+                    with gr.Accordion("⚡ Consommation d'énergie", open=True):
+                        with gr.Row():
+                            energy_min = gr.Number(label="Min", precision=6, interactive=False)
+                            energy_max = gr.Number(label="Max", precision=6, interactive=False)
+                        energy_unit = gr.Textbox(label="Unité", interactive=False)
+                    
+                    with gr.Accordion("🌍 Empreinte carbone (GWP)", open=True):
+                        with gr.Row():
+                            gwp_min = gr.Number(label="Min", precision=6, interactive=False)
+                            gwp_max = gr.Number(label="Max", precision=6, interactive=False)
+                        gwp_unit = gr.Textbox(label="Unité", interactive=False)
+                    
+                    with gr.Accordion("⛏️ Épuisement des ressources (ADPe)", open=False):
+                        with gr.Row():
+                            adpe_min = gr.Textbox(label="Min", interactive=False)
+                            adpe_max = gr.Textbox(label="Max", interactive=False)
+                        adpe_unit = gr.Textbox(label="Unité", interactive=False)
+                    
+                    with gr.Accordion("🔋 Énergie primaire (PE)", open=False):
+                        with gr.Row():
+                            pe_min = gr.Number(label="Min", precision=6, interactive=False)
+                            pe_max = gr.Number(label="Max", precision=6, interactive=False)
+                        pe_unit = gr.Textbox(label="Unité", interactive=False)
+                    
+                    with gr.Accordion("💻 Impact d'usage", open=False):
+                        gr.Markdown("**Énergie**")
+                        with gr.Row():
+                            usage_energy_min = gr.Number(label="Min", precision=6, interactive=False)
+                            usage_energy_max = gr.Number(label="Max", precision=6, interactive=False)
+                        gr.Markdown("**GWP**")
+                        with gr.Row():
+                            usage_gwp_min = gr.Number(label="Min", precision=6, interactive=False)
+                            usage_gwp_max = gr.Number(label="Max", precision=6, interactive=False)
+                    
+                    with gr.Accordion("🏭 Impact incorporé", open=False):
+                        embodied_gwp = gr.Textbox(label="GWP", interactive=False)
+                        embodied_gwp_unit = gr.Textbox(label="Unité GWP", interactive=False)
+                        embodied_adpe = gr.Textbox(label="ADPe", interactive=False)
+                        embodied_adpe_unit = gr.Textbox(label="Unité ADPe", interactive=False)
+                        embodied_pe = gr.Textbox(label="PE", interactive=False)
+                        embodied_pe_unit = gr.Textbox(label="Unité PE", interactive=False)
+                
+                with gr.TabItem("📊 Total session"):
+                    with gr.Accordion("⚡ Consommation d'énergie totale", open=True):
+                        with gr.Row():
+                            total_energy_min = gr.Number(label="Min", precision=6, interactive=False)
+                            total_energy_max = gr.Number(label="Max", precision=6, interactive=False)
+                        total_energy_unit = gr.Textbox(label="Unité", interactive=False)
+                    
+                    with gr.Accordion("🌍 Empreinte carbone totale (GWP)", open=True):
+                        with gr.Row():
+                            total_gwp_min = gr.Number(label="Min", precision=6, interactive=False)
+                            total_gwp_max = gr.Number(label="Max", precision=6, interactive=False)
+                        total_gwp_unit = gr.Textbox(label="Unité", interactive=False)
+                    
+                    with gr.Accordion("⛏️ Épuisement des ressources totale (ADPe)", open=False):
+                        with gr.Row():
+                            total_adpe_min = gr.Textbox(label="Min", interactive=False)
+                            total_adpe_max = gr.Textbox(label="Max", interactive=False)
+                        total_adpe_unit = gr.Textbox(label="Unité", interactive=False)
+                    
+                    with gr.Accordion("🔋 Énergie primaire totale (PE)", open=False):
+                        with gr.Row():
+                            total_pe_min = gr.Number(label="Min", precision=6, interactive=False)
+                            total_pe_max = gr.Number(label="Max", precision=6, interactive=False)
+                        total_pe_unit = gr.Textbox(label="Unité", interactive=False)
+                    
+                    with gr.Accordion("💻 Impact d'usage total", open=False):
+                        gr.Markdown("**Énergie**")
+                        with gr.Row():
+                            total_usage_energy_min = gr.Number(label="Min", precision=6, interactive=False)
+                            total_usage_energy_max = gr.Number(label="Max", precision=6, interactive=False)
+                        gr.Markdown("**GWP**")
+                        with gr.Row():
+                            total_usage_gwp_min = gr.Number(label="Min", precision=6, interactive=False)
+                            total_usage_gwp_max = gr.Number(label="Max", precision=6, interactive=False)
+                    
+                    with gr.Accordion("🏭 Impact incorporé total", open=False):
+                        total_embodied_gwp = gr.Textbox(label="GWP", interactive=False)
+                        total_embodied_gwp_unit = gr.Textbox(label="Unité GWP", interactive=False)
+                        total_embodied_adpe = gr.Textbox(label="ADPe", interactive=False)
+                        total_embodied_adpe_unit = gr.Textbox(label="Unité ADPe", interactive=False)
+                        total_embodied_pe = gr.Textbox(label="PE", interactive=False)
+                        total_embodied_pe_unit = gr.Textbox(label="Unité PE", interactive=False)
+    
+    def handle_message(message, history, model):
+        if not message.strip():
+            return history, "", *([None]*68)  # Updated for new output count with delta values
+        
+        result = get_response(message, history, model)
+        return result[0], "", *result[1:]
+    
+    def clear_chat():
+        """Clear the chat and reset cumulative impacts"""
+        cumulative_impacts.reset()
+        return [], *([None]*68)  # Clear chatbot and all impact displays
+    
+    # Connect both prompt submit and button click
+    for trigger in [prompt.submit, send_btn.click]:
+        trigger(
+            handle_message,
+            inputs=[prompt, chatbot, model],
+            outputs=[chatbot, prompt, 
+                    # Current generation impacts (raw API data)
+                    energy_min, energy_max, energy_unit,
+                    gwp_min, gwp_max, gwp_unit,
+                    adpe_min, adpe_max, adpe_unit,
+                    pe_min, pe_max, pe_unit,
+                    usage_energy_min, usage_energy_max,
+                    usage_gwp_min, usage_gwp_max,
+                    embodied_gwp, embodied_gwp_unit,
+                    embodied_adpe, embodied_adpe_unit,
+                    embodied_pe, embodied_pe_unit,
+                    # Generation delta (calculated difference)
+                    delta_energy_min, delta_energy_max, delta_energy_unit,
+                    delta_gwp_min, delta_gwp_max, delta_gwp_unit,
+                    delta_adpe_min, delta_adpe_max, delta_adpe_unit,
+                    delta_pe_min, delta_pe_max, delta_pe_unit,
+                    delta_usage_energy_min, delta_usage_energy_max,
+                    delta_usage_gwp_min, delta_usage_gwp_max,
+                    delta_embodied_gwp, delta_embodied_gwp_unit,
+                    delta_embodied_adpe, delta_embodied_adpe_unit,
+                    delta_embodied_pe, delta_embodied_pe_unit,
+                    # Cumulative impacts
+                    total_energy_min, total_energy_max, total_energy_unit,
+                    total_gwp_min, total_gwp_max, total_gwp_unit,
+                    total_adpe_min, total_adpe_max, total_adpe_unit,
+                    total_pe_min, total_pe_max, total_pe_unit,
+                    total_usage_energy_min, total_usage_energy_max,
+                    total_usage_gwp_min, total_usage_gwp_max,
+                    total_embodied_gwp, total_embodied_gwp_unit,
+                    total_embodied_adpe, total_embodied_adpe_unit,
+                    total_embodied_pe, total_embodied_pe_unit,
+                    generation_counter]
+        )
+    
+    # Connect clear button
+    chatbot.clear(
+        clear_chat,
+        outputs=[chatbot,
+                # Current generation impacts (raw API data)
+                energy_min, energy_max, energy_unit,
+                gwp_min, gwp_max, gwp_unit,
+                adpe_min, adpe_max, adpe_unit,
+                pe_min, pe_max, pe_unit,
+                usage_energy_min, usage_energy_max,
+                usage_gwp_min, usage_gwp_max,
+                embodied_gwp, embodied_gwp_unit,
+                embodied_adpe, embodied_adpe_unit,
+                embodied_pe, embodied_pe_unit,
+                # Generation delta (calculated difference)
+                delta_energy_min, delta_energy_max, delta_energy_unit,
+                delta_gwp_min, delta_gwp_max, delta_gwp_unit,
+                delta_adpe_min, delta_adpe_max, delta_adpe_unit,
+                delta_pe_min, delta_pe_max, delta_pe_unit,
+                delta_usage_energy_min, delta_usage_energy_max,
+                delta_usage_gwp_min, delta_usage_gwp_max,
+                delta_embodied_gwp, delta_embodied_gwp_unit,
+                delta_embodied_adpe, delta_embodied_adpe_unit,
+                delta_embodied_pe, delta_embodied_pe_unit,
+                # Cumulative impacts
+                total_energy_min, total_energy_max, total_energy_unit,
+                total_gwp_min, total_gwp_max, total_gwp_unit,
+                total_adpe_min, total_adpe_max, total_adpe_unit,
+                total_pe_min, total_pe_max, total_pe_unit,
+                total_usage_energy_min, total_usage_energy_max,
+                total_usage_gwp_min, total_usage_gwp_max,
+                total_embodied_gwp, total_embodied_gwp_unit,
+                total_embodied_adpe, total_embodied_adpe_unit,
+                total_embodied_pe, total_embodied_pe_unit,
+                generation_counter]
+    )
+
+demo.launch()

chat_interface.py

@@ -0,0 +1,288 @@
+import gradio as gr
+from mistral_client import MistralChatClient
+from impacts_tracker import ImpactsTracker
+from config import DEFAULT_MODEL, MISTRAL_API_KEY, ALLOW_USER_API_KEY
+
+class ChatInterface:
+    """Simple chat interface with environmental impact tracking"""
+    
+    def __init__(self):
+        # Try to initialize with default API key
+        self.client = None
+        self.tracker = ImpactsTracker()
+        self.user_api_key = None
+        
+        # Initialize client if we have a default API key
+        if MISTRAL_API_KEY:
+            try:
+                self.client = MistralChatClient()
+            except Exception as e:
+                print(f"Warning: Could not initialize with default API key: {e}")
+    
+    def update_api_key(self, api_key):
+        """Update or set the API key"""
+        if not api_key or not api_key.strip():
+            return "❌ Veuillez fournir une clé API valide"
+        
+        try:
+            if self.client:
+                self.client.update_api_key(api_key.strip())
+            else:
+                self.client = MistralChatClient(api_key=api_key.strip())
+            
+            self.user_api_key = api_key.strip()
+            return "✅ Clé API mise à jour avec succès"
+        except Exception as e:
+            return f"❌ Erreur lors de la mise à jour de la clé API: {str(e)}"
+    
+    def process_message(self, message, history, model, api_key_input=None):
+        """Process a chat message and return updated conversation with impacts"""
+        # Check if we need to update the API key
+        if api_key_input and api_key_input.strip():
+            if not self.client or self.user_api_key != api_key_input.strip():
+                update_result = self.update_api_key(api_key_input.strip())
+                if "❌" in update_result:
+                    return history, "", *self._get_empty_impacts(), update_result
+        
+        # Check if we have a client initialized
+        if not self.client:
+            error_msg = "❌ Veuillez fournir votre clé API Mistral ci-dessus pour commencer."
+            return history, "", *self._get_empty_impacts(), error_msg
+        
+        if not message.strip():
+            current_status = "✅ Clé API valide" if self.client else "❌ Clé API requise"
+            return history, "", *self._get_empty_impacts(), current_status
+        
+        # Build message history
+        messages = []
+        if history:
+            messages.extend(history)
+        messages.append({"role": "user", "content": message})
+        
+        # Get response from Mistral
+        result = self.client.chat(messages, model or DEFAULT_MODEL)
+        
+        # Update conversation history
+        messages.append({
+            "role": "assistant", 
+            "content": result['content']
+        })
+        
+        # Track environmental impacts
+        if result['impacts']:
+            self.tracker.add_impact(result['impacts'])
+        
+        # Get impact summary
+        impacts = self.tracker.get_summary()
+        
+        # Format warnings and errors for display
+        warnings_text = ""
+        errors_text = ""
+        
+        if result['warnings']:
+            warnings_text = "\n".join([f"⚠️ {w}" for w in result['warnings']])
+        
+        if result['errors']:
+            errors_text = "\n".join([f"❌ {e}" for e in result['errors']])
+        
+        return (
+            messages,  # Updated conversation
+            "",        # Clear input
+            f"{impacts['last_energy']:.6f}",     # Last message energy
+            f"{impacts['last_carbon']:.6f}",     # Last message carbon
+            f"{impacts['total_energy']:.6f}",    # Total energy
+            f"{impacts['total_carbon']:.6f}",    # Total carbon
+            impacts['generation_count'],          # Message count
+            warnings_text,                        # Warnings
+            errors_text,                          # Errors
+            "✅ Clé API valide"                  # API key status
+        )
+    
+    def clear_conversation(self):
+        """Clear conversation and reset impacts"""
+        self.tracker.reset()
+        return (
+            [],           # Empty conversation
+            "",           # Clear input
+            "0.000000",   # Last energy
+            "0.000000",   # Last carbon
+            "0.000000",   # Total energy
+            "0.000000",   # Total carbon
+            0,            # Message count
+            "",           # Clear warnings
+            ""            # Clear errors
+        )
+    
+    def _get_empty_impacts(self):
+        """Return empty values for impact displays"""
+        return [
+            "0.000000",   # Last energy
+            "0.000000",   # Last carbon
+            "0.000000",   # Total energy
+            "0.000000",   # Total carbon
+            0,            # Message count
+            "",           # Clear warnings
+            ""            # Clear errors
+        ]
+    
+    def create_interface(self):
+        """Create and configure the Gradio interface"""
+        with gr.Blocks(title="🌱 EcoLogits Chat") as interface:
+            gr.Markdown("# 🌱 Chat Écologique avec Mistral")
+            gr.Markdown("💬 Discutez avec l'IA en surveillant l'impact environnemental")
+            
+            # API Key input section (always visible for Hugging Face users)
+            with gr.Group(visible=True):
+                gr.Markdown("## 🔑 Configuration de la clé API")
+                gr.Markdown("Pour utiliser cette application, vous devez fournir votre propre clé API Mistral:")
+                gr.Markdown("1. 📝 Créez un compte sur [console.mistral.ai](https://console.mistral.ai)")
+                gr.Markdown("2. 🔑 Générez une clé API dans votre tableau de bord")
+                gr.Markdown("3. 📋 Collez votre clé ci-dessous")
+                
+                with gr.Row():
+                    api_key_input = gr.Textbox(
+                        label="🔐 Clé API Mistral",
+                        type="password",
+                        placeholder="Collez votre clé API Mistral ici...",
+                        scale=4
+                    )
+                    api_key_status = gr.Textbox(
+                        label="Status",
+                        value="❌ Clé API requise",
+                        interactive=False,
+                        scale=2
+                    )
+            
+            with gr.Row():
+                # Chat section
+                with gr.Column(scale=3):
+                    chatbot = gr.Chatbot(
+                        type="messages",
+                        height=600,
+                        show_label=False,
+                        placeholder="💬 Votre conversation apparaîtra ici..."
+                    )
+                    
+                    with gr.Row():
+                        message_input = gr.Textbox(
+                            placeholder="✍️ Tapez votre message...",
+                            scale=4,
+                            show_label=False,
+                            max_lines=3
+                        )
+                        send_button = gr.Button("📤 Envoyer", variant="primary", scale=1)
+                    
+                    # Get available models or use fallback
+                    available_models = []
+                    if self.client and hasattr(self.client, 'available_models'):
+                        available_models = self.client.available_models
+                    else:
+                        from config import FALLBACK_MODELS
+                        available_models = FALLBACK_MODELS
+                    
+                    model_selector = gr.Dropdown(
+                        choices=available_models,
+                        value=available_models[0] if available_models else DEFAULT_MODEL,
+                        label="🤖 Modèle Mistral",
+                        info="Choisissez le modèle à utiliser"
+                    )
+                
+                # Impact tracking section with tabs
+                with gr.Column(scale=2):
+                    gr.Markdown("## 📊 Impact Environnemental")
+                    
+                    # Generation counter
+                    message_count = gr.Number(
+                        label="� Nombre de générations",
+                        value=0,
+                        interactive=False,
+                        precision=0
+                    )
+                    
+                    # Tabs for different impact views
+                    with gr.Tabs():
+                        with gr.TabItem("🎯 Dernier message"):
+                            gr.Markdown("### ⚡ **Impact de cette requête spécifique**")
+                            
+                            # Warnings and Errors section
+                            with gr.Group():
+                                warnings_display = gr.Textbox(
+                                    label="⚠️ Avertissements EcoLogits",
+                                    value="",
+                                    interactive=False,
+                                    max_lines=3,
+                                    placeholder="Aucun avertissement"
+                                )
+                                errors_display = gr.Textbox(
+                                    label="❌ Erreurs EcoLogits", 
+                                    value="",
+                                    interactive=False,
+                                    max_lines=3,
+                                    placeholder="Aucune erreur"
+                                )
+                            
+                            with gr.Accordion("⚡ Consommation d'énergie", open=True):
+                                last_energy = gr.Textbox(
+                                    label="Énergie (kWh)",
+                                    value="0.000000",
+                                    interactive=False
+                                )
+                            
+                            with gr.Accordion("🌍 Empreinte carbone", open=True):
+                                last_carbon = gr.Textbox(
+                                    label="Carbone (kgCO2eq)",
+                                    value="0.000000",
+                                    interactive=False
+                                )
+                        
+                        with gr.TabItem("📈 Session totale"):
+                            gr.Markdown("### � **Cumul de toute la session**")
+                            
+                            with gr.Accordion("⚡ Consommation d'énergie totale", open=True):
+                                total_energy = gr.Textbox(
+                                    label="Énergie totale (kWh)",
+                                    value="0.000000",
+                                    interactive=False
+                                )
+                            
+                            with gr.Accordion("🌍 Empreinte carbone totale", open=True):
+                                total_carbon = gr.Textbox(
+                                    label="Carbone total (kgCO2eq)",
+                                    value="0.000000",
+                                    interactive=False
+                                )
+                    
+                    clear_button = gr.Button("🗑️ Effacer tout", variant="secondary")
+                    
+                    # Add some visual feedback
+                    gr.Markdown("💡 *Utilisez le bouton 'Effacer tout' pour recommencer une nouvelle session*")
+            
+            # Event handlers - Make sure output order matches exactly
+            outputs = [
+                chatbot,          # 0: conversation
+                message_input,    # 1: input field
+                last_energy,      # 2: last energy
+                last_carbon,      # 3: last carbon
+                total_energy,     # 4: total energy
+                total_carbon,     # 5: total carbon
+                message_count,    # 6: message count
+                warnings_display, # 7: warnings
+                errors_display,   # 8: errors
+                api_key_status    # 9: API key status
+            ]
+            
+            # Send message events
+            for trigger in [message_input.submit, send_button.click]:
+                trigger(
+                    self.process_message,
+                    inputs=[message_input, chatbot, model_selector, api_key_input],
+                    outputs=outputs
+                )
+            
+            # Clear conversation event
+            clear_button.click(
+                self.clear_conversation,
+                outputs=outputs[:-1]  # Exclude API key status from clear
+            )
+        
+        return interface

config.py

@@ -0,0 +1,16 @@
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Configuration
+MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY")
+DEFAULT_MODEL = "mistral-tiny"
+
+# Available models fallback
+FALLBACK_MODELS = ["mistral-tiny", "mistral-small", "mistral-medium"]
+
+# App configuration - Always allow user API keys for Hugging Face deployment
+REQUIRE_API_KEY = True  # Always require API key for public deployment
+ALLOW_USER_API_KEY = True  # Always allow users to provide their own key

impacts_tracker.py

@@ -0,0 +1,40 @@
+class ImpactsTracker:
+    """Simple tracker for environmental impacts"""
+    
+    def __init__(self):
+        self.reset()
+    
+    def reset(self):
+        """Reset all counters to zero"""
+        self.total_energy = 0.0
+        self.total_carbon = 0.0  # GWP in CO2 equivalent
+        self.generation_count = 0
+        self.last_energy = 0.0
+        self.last_carbon = 0.0
+    
+    def add_impact(self, impacts):
+        """Add new impact data from API response"""
+        # Calculate energy impact (use average of min/max)
+        energy_impact = (impacts.energy.value.min + impacts.energy.value.max) / 2
+        
+        # Calculate carbon impact (use average of min/max)
+        carbon_impact = (impacts.gwp.value.min + impacts.gwp.value.max) / 2
+        
+        # Store last impact for display
+        self.last_energy = energy_impact
+        self.last_carbon = carbon_impact
+        
+        # Add to totals
+        self.total_energy += energy_impact
+        self.total_carbon += carbon_impact
+        self.generation_count += 1
+    
+    def get_summary(self):
+        """Get a simple summary of impacts"""
+        return {
+            'last_energy': self.last_energy,
+            'last_carbon': self.last_carbon,
+            'total_energy': self.total_energy,
+            'total_carbon': self.total_carbon,
+            'generation_count': self.generation_count
+        }

mistral_client.py

@@ -0,0 +1,116 @@
+from mistralai import Mistral
+from ecologits import EcoLogits
+from config import MISTRAL_API_KEY, FALLBACK_MODELS
+
+class MistralChatClient:
+    """Simple wrapper for Mistral API with EcoLogits tracking"""
+    
+    def __init__(self, api_key=None):
+        # Initialize EcoLogits tracking
+        EcoLogits.init(providers=["mistralai"])
+        
+        # Use provided API key or fall back to config
+        self.api_key = api_key or MISTRAL_API_KEY
+        
+        if not self.api_key:
+            raise ValueError("Mistral API key is required. Please provide it via parameter or environment variable.")
+        
+        # Initialize Mistral client
+        self.client = Mistral(api_key=self.api_key)
+        
+        # Get available models
+        self.available_models = self._get_available_models()
+    
+    def update_api_key(self, new_api_key):
+        """Update the API key and reinitialize the client"""
+        if not new_api_key:
+            raise ValueError("API key cannot be empty")
+        
+        self.api_key = new_api_key
+        self.client = Mistral(api_key=self.api_key)
+        self.available_models = self._get_available_models()
+        return True
+    
+    def _get_available_models(self):
+        """Get list of available text-to-text models from API"""
+        try:
+            models_response = self.client.models.list()
+            if models_response.data:
+                models = []
+                excluded_models = []
+                
+                for model in models_response.data:
+                    model_id = model.id
+                    
+                    # Check if model has capabilities and supports completion_chat
+                    if (hasattr(model, 'capabilities') and 
+                        hasattr(model.capabilities, 'completion_chat') and 
+                        model.capabilities.completion_chat):
+                        
+                        # Exclude specialized models that aren't suitable for general chat
+                        model_id_lower = model_id.lower()
+                        excluded_terms = ['ocr', 'embed', 'vision', 'classifier', 'moderation']
+                        
+                        if any(term in model_id_lower for term in excluded_terms):
+                            excluded_models.append(f"{model_id} (specialized model)")
+                        else:
+                            models.append(model_id)
+                    else:
+                        excluded_models.append(f"{model_id} (no chat completion capability)")
+                
+                # Debug output
+                if models:
+                    print(f"✅ Found {len(models)} suitable chat models: {models}")
+                if excluded_models:
+                    print(f"⚠️ Excluded {len(excluded_models)} models: {excluded_models[:5]}")  # Show first 5
+                
+                return models if models else FALLBACK_MODELS
+                
+        except Exception as e:
+            print(f"Warning: Could not fetch models: {e}")
+        
+        # Return fallback models if API call fails
+        print(f"📋 Using fallback models: {FALLBACK_MODELS}")
+        return FALLBACK_MODELS
+    
+    def chat(self, messages, model):
+        """Send chat request and return response with impacts"""
+        try:
+            response = self.client.chat.complete(
+                messages=messages,
+                model=model
+            )
+            
+            # Collect warnings and errors
+            warnings = []
+            errors = []
+            
+            # Type none becausse Ecologits does not run in runtime, errors is not a real error.
+            # Source: Trust me :)
+            if response.impacts.has_warnings:  # type: ignore
+                for warning in response.impacts.warnings:  # type: ignore
+                    warnings.append(str(warning))
+                    print(f"Warning: {warning}")  # type: ignore
+            
+            if response.impacts.has_errors:  # type: ignore
+                for error in response.impacts.errors:  # type: ignore
+                    errors.append(str(error))
+                    print(f"Error: {error}")  # type: ignore
+            
+            # Type none becausse Ecologits does not run in runtime, errors is not a real error.
+            # Source: Trust me :)
+            return {
+                'content': response.choices[0].message.content,
+                'impacts': response.impacts,  # type: ignore
+                'warnings': warnings,
+                'errors': errors
+            }
+            
+        except Exception as e:
+            print(f"Error during chat completion: {e}")
+            return {
+                'content': f"Erreur: {str(e)}",
+                'impacts': None,
+                'warnings': [],
+                'errors': [str(e)]
+            }

requirements.txt

@@ -1 +1,4 @@
-huggingface_hub==0.25.2
+gradio>=4.0.0
+mistralai
+ecologits
+python-dotenv