MCP Server ADEME Environnement - Initial release

Serveur MCP exposant les données environnementales ADEME:
- AGRIBALYSE: impacts alimentaires (2500+ produits)
- Base Carbone: facteurs d'émission (20000+ FE)

9 outils MCP:
- search_emission_factors: recherche unifiée 2 bases
- get_emission_factor_details: détails méthodologiques
- compare_emission_factors: comparaison avec sensibilité
- search_food, get_transport/energy/waste/equipment_factors
- get_categories

Co-authored-by: Cursor <cursoragent@cursor.com>

.env.example

@@ -0,0 +1,5 @@
+# Configuration MCP Server ADEME Environnement
+# Pas de clé API requise - les APIs ADEME sont publiques
+
+# Optionnel : timeout des requêtes HTTP (secondes)
+# HTTP_TIMEOUT=30

.gitignore

@@ -0,0 +1,4 @@
+.env
+venv/
+__pycache__/
+*.pyc

README.md

@@ -1,13 +1,154 @@
 ---
-title: MCP CO2
-emoji: 📚
-colorFrom: yellow
-colorTo: yellow
+title: MCP Server ADEME Environnement
+emoji: 🌱
+colorFrom: green
+colorTo: blue
 sdk: gradio
-sdk_version: 6.5.1
+sdk_version: 5.29.0
 app_file: app.py
 pinned: false
-short_description: MCP to acces api of ADEME Base Carbone et la Base Agribalyse
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🌱 MCP Server ADEME Environnement
+
+Serveur MCP (Model Context Protocol) pour accéder aux données environnementales de l'ADEME.
+
+## 📊 Sources de données
+
+| Base | Description | Données |
+|------|-------------|---------|
+| **AGRIBALYSE** | Impacts environnementaux alimentaires | 2500+ produits, 16 indicateurs |
+| **Base Carbone** | Facteurs d'émission GES | 20000+ FE (transport, énergie, déchets, équipements) |
+
+## 🛠️ Outils MCP disponibles
+
+### Recherche
+
+| Outil | Description |
+|-------|-------------|
+| `search_emission_factors` | Recherche unifiée dans AGRIBALYSE + Base Carbone |
+| `get_emission_factor_details` | Détails méthodologiques complets d'un FE |
+| `compare_emission_factors` | Comparaison de 2 FE avec analyse de sensibilité |
+| `get_categories` | Liste des catégories disponibles |
+
+### Par domaine
+
+| Outil | Source | Description |
+|-------|--------|-------------|
+| `search_food` | AGRIBALYSE | Recherche d'aliments avec impacts environnementaux |
+| `get_transport_factors` | Base Carbone | FE transport (véhicule, carburant) |
+| `get_energy_factors` | Base Carbone | FE énergie (gaz, électricité, fioul) |
+| `get_waste_factors` | Base Carbone | FE déchets (par type et traitement) |
+| `get_equipment_factors` | Base Carbone | FE équipements (informatique, électroménager) |
+
+## 🔌 Connexion MCP
+
+### Configuration Claude Desktop
+
+Ajouter dans `claude_desktop_config.json` :
+
+```json
+{
+  "mcpServers": {
+    "ademe-environnement": {
+      "url": "https://VOTRE-USERNAME-mcp-ademe-environnement.hf.space/gradio_api/mcp/sse"
+    }
+  }
+}
+```
+
+### Configuration Cursor
+
+Ajouter dans les paramètres MCP :
+
+```json
+{
+  "ademe-environnement": {
+    "url": "https://VOTRE-USERNAME-mcp-ademe-environnement.hf.space/gradio_api/mcp/sse"
+  }
+}
+```
+
+## 📖 Exemples d'utilisation
+
+### Recherche unifiée
+
+```
+search_emission_factors("boeuf")
+→ Résultats AGRIBALYSE (viande) + Base Carbone (élevage)
+```
+
+### Analyse de sensibilité transport
+
+```
+# Trouver les FE
+get_transport_factors("VUL", "diesel")
+get_transport_factors("VUL", "électrique")
+
+# Comparer
+compare_emission_factors("28022", "28024")
+→ Écart, incertitude, recommandation
+```
+
+### Bilan repas cantine
+
+```
+# Aliments
+search_food("poulet rôti")
+search_food("haricots verts")
+
+# Transport
+get_transport_factors("VUL", "diesel")
+
+# Énergie cuisson
+get_energy_factors("gaz naturel")
+
+# Déchets
+get_waste_factors("alimentaire", "compost")
+```
+
+## 📁 Structure du projet
+
+```
+mcp-ademe-environnement/
+├── app.py                 # Point d'entrée Gradio + MCP
+├── requirements.txt       # Dépendances
+├── README.md             # Ce fichier
+└── src/
+    ├── __init__.py
+    ├── models.py          # Modèles Pydantic
+    ├── tools.py           # Outils MCP
+    └── clients/
+        ├── __init__.py
+        ├── agribalyse.py  # Client API AGRIBALYSE
+        └── base_carbone.py # Client API Base Carbone
+```
+
+## 🚀 Déploiement
+
+### Local
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+### HuggingFace Spaces
+
+1. Créer un nouveau Space (SDK: Gradio)
+2. Pousser le code
+3. Le Space démarre automatiquement
+
+## 📚 Documentation des APIs
+
+- [AGRIBALYSE](https://agribalyse.ademe.fr/) - Documentation officielle
+- [Base Carbone](https://base-empreinte.ademe.fr/) - Base Empreinte ADEME
+- [data.ademe.fr](https://data.ademe.fr/) - Portail open data ADEME
+
+## 📄 Licence
+
+Données sous [Licence Ouverte / Open Licence](https://www.etalab.gouv.fr/licence-ouverte-open-licence/)
+
+---
+
+Développé avec ❤️ pour faciliter l'accès aux données environnementales

app.py

@@ -0,0 +1,163 @@
+"""MCP Server ADEME Environnement - Point d'entrée Gradio.
+
+Ce serveur MCP expose les données environnementales de l'ADEME :
+- AGRIBALYSE : impacts environnementaux de 2500+ aliments
+- Base Carbone : 20000+ facteurs d'émission (transport, énergie, déchets, équipements)
+
+Utilisation :
+- Déployer sur HuggingFace Spaces
+- Connecter depuis un client MCP (Claude, etc.)
+"""
+
+import gradio as gr
+
+from src.tools import (
+    search_emission_factors,
+    get_emission_factor_details,
+    compare_emission_factors,
+    search_food,
+    get_transport_factors,
+    get_energy_factors,
+    get_waste_factors,
+    get_equipment_factors,
+    get_categories,
+)
+
+
+# Créer les interfaces pour chaque outil MCP
+# Chaque gr.Interface expose la fonction comme outil MCP
+
+search_interface = gr.Interface(
+    fn=search_emission_factors,
+    inputs=[
+        gr.Textbox(label="query", info="Terme de recherche (ex: boeuf, camion diesel)"),
+        gr.Dropdown(choices=["all", "agribalyse", "base_carbone"], value="all", label="source"),
+        gr.Number(value=10, label="size", info="Nombre de résultats"),
+    ],
+    outputs=gr.JSON(label="Résultats"),
+    title="search_emission_factors",
+    description="Recherche unifiée de facteurs d'émission dans AGRIBALYSE et Base Carbone",
+)
+
+details_interface = gr.Interface(
+    fn=get_emission_factor_details,
+    inputs=[
+        gr.Textbox(label="identifier", info="ID du facteur d'émission"),
+        gr.Dropdown(choices=["base_carbone", "agribalyse"], value="base_carbone", label="source"),
+    ],
+    outputs=gr.JSON(label="Détails"),
+    title="get_emission_factor_details",
+    description="Détails méthodologiques complets d'un facteur d'émission",
+)
+
+compare_interface = gr.Interface(
+    fn=compare_emission_factors,
+    inputs=[
+        gr.Textbox(label="id1", info="ID du premier FE"),
+        gr.Textbox(label="id2", info="ID du second FE"),
+        gr.Dropdown(choices=["base_carbone", "agribalyse"], value="base_carbone", label="source1"),
+        gr.Dropdown(choices=["base_carbone", "agribalyse"], value="base_carbone", label="source2"),
+    ],
+    outputs=gr.JSON(label="Comparaison"),
+    title="compare_emission_factors",
+    description="Compare deux facteurs d'émission avec analyse de sensibilité",
+)
+
+food_interface = gr.Interface(
+    fn=search_food,
+    inputs=[
+        gr.Textbox(label="query", info="Terme de recherche (ex: steak, yaourt)"),
+        gr.Textbox(label="group", info="Groupe d'aliment (optionnel)"),
+        gr.Number(value=10, label="size"),
+    ],
+    outputs=gr.JSON(label="Résultats"),
+    title="search_food",
+    description="Recherche d'aliments dans la base AGRIBALYSE",
+)
+
+transport_interface = gr.Interface(
+    fn=get_transport_factors,
+    inputs=[
+        gr.Textbox(label="vehicle_type", info="Type de véhicule (ex: VUL, poids lourd)"),
+        gr.Textbox(label="fuel_type", info="Carburant (ex: diesel, électrique)"),
+        gr.Number(value=20, label="size"),
+    ],
+    outputs=gr.JSON(label="Résultats"),
+    title="get_transport_factors",
+    description="Recherche de facteurs d'émission pour le transport",
+)
+
+energy_interface = gr.Interface(
+    fn=get_energy_factors,
+    inputs=[
+        gr.Textbox(label="energy_type", info="Type d'énergie (ex: gaz naturel, électricité)"),
+        gr.Number(value=20, label="size"),
+    ],
+    outputs=gr.JSON(label="Résultats"),
+    title="get_energy_factors",
+    description="Recherche de facteurs d'émission pour l'énergie",
+)
+
+waste_interface = gr.Interface(
+    fn=get_waste_factors,
+    inputs=[
+        gr.Textbox(label="waste_type", info="Type de déchet (ex: alimentaire, plastique)"),
+        gr.Textbox(label="treatment", info="Traitement (ex: compost, incinération)"),
+        gr.Number(value=20, label="size"),
+    ],
+    outputs=gr.JSON(label="Résultats"),
+    title="get_waste_factors",
+    description="Recherche de facteurs d'émission pour les déchets",
+)
+
+equipment_interface = gr.Interface(
+    fn=get_equipment_factors,
+    inputs=[
+        gr.Textbox(label="equipment_type", info="Type d'équipement (ex: ordinateur, smartphone)"),
+        gr.Number(value=20, label="size"),
+    ],
+    outputs=gr.JSON(label="Résultats"),
+    title="get_equipment_factors",
+    description="Recherche de facteurs d'émission pour les équipements",
+)
+
+categories_interface = gr.Interface(
+    fn=get_categories,
+    inputs=[
+        gr.Dropdown(choices=["all", "agribalyse", "base_carbone"], value="all", label="source"),
+    ],
+    outputs=gr.JSON(label="Catégories"),
+    title="get_categories",
+    description="Liste les catégories disponibles dans les bases de données",
+)
+
+# Combiner toutes les interfaces dans des onglets
+demo = gr.TabbedInterface(
+    interface_list=[
+        search_interface,
+        food_interface,
+        transport_interface,
+        energy_interface,
+        waste_interface,
+        equipment_interface,
+        compare_interface,
+        details_interface,
+        categories_interface,
+    ],
+    tab_names=[
+        "🔍 Recherche",
+        "🍎 Alimentation",
+        "🚗 Transport",
+        "⚡ Énergie",
+        "🗑️ Déchets",
+        "💻 Équipements",
+        "⚖️ Comparer",
+        "📋 Détails",
+        "📂 Catégories",
+    ],
+    title="🌱 MCP Server ADEME Environnement",
+)
+
+# Lancement avec MCP activé
+if __name__ == "__main__":
+    demo.launch(mcp_server=True)

requirements.txt

@@ -0,0 +1,5 @@
+gradio[mcp]>=5.27.1
+httpx>=0.27.0
+pydantic>=2.0.0
+python-dotenv>=1.0.0
+anyio>=4.0.0

src/__init__.py

@@ -0,0 +1,4 @@
+# MCP Server ADEME Environnement
+# Intégration AGRIBALYSE + Base Carbone
+
+__version__ = "1.0.0"

src/clients/__init__.py

@@ -0,0 +1,4 @@
+from .agribalyse import AgribalyseClient
+from .base_carbone import BaseCarboneClient
+
+__all__ = ["AgribalyseClient", "BaseCarboneClient"]

src/clients/agribalyse.py

@@ -0,0 +1,166 @@
+"""Client API AGRIBALYSE - Données environnementales alimentaires."""
+
+import httpx
+from typing import Any
+
+BASE_URL = "https://data.ademe.fr/data-fair/api/v1/datasets/agribalyse-31-synthese"
+
+
+class AgribalyseClient:
+    """Client async pour l'API AGRIBALYSE."""
+
+    def __init__(self, timeout: float = 30.0):
+        self.timeout = timeout
+        self._client: httpx.AsyncClient | None = None
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(timeout=self.timeout)
+        return self._client
+
+    async def close(self):
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    async def search(
+        self,
+        query: str,
+        size: int = 10,
+        select: list[str] | None = None
+    ) -> dict[str, Any]:
+        """Recherche d'aliments dans AGRIBALYSE.
+        
+        Args:
+            query: Terme de recherche (ex: "boeuf", "pomme")
+            size: Nombre de résultats (max 100)
+            select: Champs à retourner (None = tous)
+        
+        Returns:
+            Dict avec total et results
+        """
+        client = await self._get_client()
+        
+        params = {
+            "q": query,
+            "size": min(size, 100)
+        }
+        
+        if select:
+            params["select"] = ",".join(select)
+        
+        response = await client.get(f"{BASE_URL}/lines", params=params)
+        response.raise_for_status()
+        return response.json()
+
+    async def get_by_code(self, code_ciqual: int) -> dict[str, Any] | None:
+        """Récupère un aliment par son code CIQUAL.
+        
+        Args:
+            code_ciqual: Code CIQUAL de l'aliment
+        
+        Returns:
+            Données de l'aliment ou None
+        """
+        client = await self._get_client()
+        
+        params = {
+            "qs": f"Code_CIQUAL:{code_ciqual}",
+            "size": 1
+        }
+        
+        response = await client.get(f"{BASE_URL}/lines", params=params)
+        response.raise_for_status()
+        data = response.json()
+        
+        if data.get("results"):
+            return data["results"][0]
+        return None
+
+    async def get_categories(self) -> list[str]:
+        """Liste les groupes d'aliments disponibles.
+        
+        Returns:
+            Liste des groupes d'aliments uniques
+        """
+        client = await self._get_client()
+        
+        response = await client.get(
+            f"{BASE_URL}/values_agg",
+            params={"field": "Groupe_d'aliment", "size": 100}
+        )
+        response.raise_for_status()
+        data = response.json()
+        
+        return [item["value"] for item in data.get("aggs", [])]
+
+    async def get_subcategories(self, group: str) -> list[str]:
+        """Liste les sous-groupes d'un groupe d'aliments.
+        
+        Args:
+            group: Nom du groupe d'aliments
+        
+        Returns:
+            Liste des sous-groupes
+        """
+        client = await self._get_client()
+        
+        response = await client.get(
+            f"{BASE_URL}/values_agg",
+            params={
+                "field": "Sous-groupe_d'aliment",
+                "size": 100,
+                "qs": f"Groupe_d'aliment:\"{group}\""
+            }
+        )
+        response.raise_for_status()
+        data = response.json()
+        
+        return [item["value"] for item in data.get("aggs", [])]
+
+
+# Champs principaux AGRIBALYSE pour référence
+AGRIBALYSE_FIELDS = {
+    "identite": [
+        "Code_CIQUAL",
+        "Code_AGB",
+        "Nom_du_Produit_en_Français",
+        "LCI_Name",
+        "Groupe_d'aliment",
+        "Sous-groupe_d'aliment",
+    ],
+    "impact_climatique": [
+        "Changement_climatique",
+        "Changement_climatique_-_émissions_fossiles",
+        "Changement_climatique_-_émissions_biogéniques",
+        "Changement_climatique_-_émissions_liées_au_changement_d'affectation_des_sols",
+    ],
+    "autres_impacts": [
+        "Score_unique_EF",
+        "Acidification_terrestre_et_eaux_douces",
+        "Eutrophisation_marine",
+        "Eutrophisation_eaux_douces",
+        "Eutrophisation_terrestre",
+        "Utilisation_du_sol",
+        "Épuisement_des_ressources_eau",
+        "Épuisement_des_ressources_énergétiques",
+        "Épuisement_des_ressources_minéraux",
+        "Particules_fines",
+        "Formation_photochimique_d'ozone",
+        "Appauvrissement_de_la_couche_d'ozone",
+        "Rayonnements_ionisants",
+        "Écotoxicité_pour_écosystèmes_aquatiques_d'eau_douce",
+        "Effets_toxicologiques_sur_la_santé_humaine___substances_cancérogènes",
+        "Effets_toxicologiques_sur_la_santé_humaine___substances_non-cancérogènes",
+    ],
+    "qualite": [
+        "DQR",
+    ],
+    "contexte": [
+        "Livraison",
+        "Préparation",
+        "Approche_emballage_",
+        "code_avion",
+        "code_saison",
+    ],
+}

src/clients/base_carbone.py

@@ -0,0 +1,278 @@
+"""Client API Base Carbone - Facteurs d'émission ADEME."""
+
+import httpx
+from typing import Any
+
+BASE_URL = "https://data.ademe.fr/data-fair/api/v1/datasets/base-carboner"
+
+
+class BaseCarboneClient:
+    """Client async pour l'API Base Carbone."""
+
+    def __init__(self, timeout: float = 30.0):
+        self.timeout = timeout
+        self._client: httpx.AsyncClient | None = None
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(timeout=self.timeout)
+        return self._client
+
+    async def close(self):
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    async def search(
+        self,
+        query: str,
+        size: int = 10,
+        type_ligne: str = "Elément",
+        statut: str | None = None,
+        category: str | None = None
+    ) -> dict[str, Any]:
+        """Recherche de facteurs d'émission dans Base Carbone.
+        
+        Args:
+            query: Terme de recherche
+            size: Nombre de résultats (max 100)
+            type_ligne: "Elément" ou "Poste" (défaut: Elément)
+            statut: Filtrer par statut ("Valide générique", "Archivé", etc.)
+            category: Filtrer par catégorie (chemin partiel)
+        
+        Returns:
+            Dict avec total et results
+        """
+        client = await self._get_client()
+        
+        params = {
+            "q": query,
+            "size": min(size, 100)
+        }
+        
+        # Construire les filtres
+        filters = []
+        if type_ligne:
+            filters.append(f"Type_Ligne:{type_ligne}")
+        if statut:
+            filters.append(f"Statut_de_l'élément:\"{statut}\"")
+        if category:
+            filters.append(f"Code_de_la_catégorie:*{category}*")
+        
+        if filters:
+            params["qs"] = " AND ".join(filters)
+        
+        response = await client.get(f"{BASE_URL}/lines", params=params)
+        response.raise_for_status()
+        return response.json()
+
+    async def get_by_id(self, element_id: str) -> dict[str, Any] | None:
+        """Récupère un facteur d'émission par son identifiant.
+        
+        Args:
+            element_id: Identifiant de l'élément
+        
+        Returns:
+            Données du FE ou None
+        """
+        client = await self._get_client()
+        
+        params = {
+            "qs": f"Identifiant_de_l'élément:{element_id}",
+            "size": 10  # Peut avoir plusieurs lignes (postes)
+        }
+        
+        response = await client.get(f"{BASE_URL}/lines", params=params)
+        response.raise_for_status()
+        data = response.json()
+        
+        if data.get("results"):
+            return data["results"]
+        return None
+
+    async def get_categories(self, parent: str | None = None) -> list[dict[str, Any]]:
+        """Liste les catégories disponibles.
+        
+        Args:
+            parent: Chemin de catégorie parent pour filtrer
+        
+        Returns:
+            Liste des catégories avec leur compte
+        """
+        client = await self._get_client()
+        
+        params = {
+            "field": "Code_de_la_catégorie",
+            "size": 200
+        }
+        
+        if parent:
+            params["qs"] = f"Code_de_la_catégorie:*{parent}*"
+        
+        response = await client.get(f"{BASE_URL}/values_agg", params=params)
+        response.raise_for_status()
+        data = response.json()
+        
+        return [
+            {"category": item["value"], "count": item["total"]}
+            for item in data.get("aggs", [])
+        ]
+
+    async def search_transport(
+        self,
+        vehicle_type: str | None = None,
+        fuel_type: str | None = None,
+        size: int = 20
+    ) -> dict[str, Any]:
+        """Recherche de FE transport.
+        
+        Args:
+            vehicle_type: Type de véhicule (VUL, Poids lourd, Voiture, etc.)
+            fuel_type: Type de carburant (Diesel, Essence, Électrique, etc.)
+            size: Nombre de résultats
+        
+        Returns:
+            Facteurs d'émission transport
+        """
+        query_parts = ["transport"]
+        if vehicle_type:
+            query_parts.append(vehicle_type)
+        if fuel_type:
+            query_parts.append(fuel_type)
+        
+        return await self.search(
+            query=" ".join(query_parts),
+            size=size,
+            category="Transport"
+        )
+
+    async def search_energy(
+        self,
+        energy_type: str | None = None,
+        size: int = 20
+    ) -> dict[str, Any]:
+        """Recherche de FE énergie.
+        
+        Args:
+            energy_type: Type d'énergie (Gaz naturel, Électricité, Fioul, etc.)
+            size: Nombre de résultats
+        
+        Returns:
+            Facteurs d'émission énergie
+        """
+        query = energy_type or "énergie"
+        
+        return await self.search(
+            query=query,
+            size=size,
+            category="Combustibles"
+        )
+
+    async def search_waste(
+        self,
+        waste_type: str | None = None,
+        treatment: str | None = None,
+        size: int = 20
+    ) -> dict[str, Any]:
+        """Recherche de FE déchets.
+        
+        Args:
+            waste_type: Type de déchet (alimentaire, plastique, etc.)
+            treatment: Traitement (compost, incinération, stockage, etc.)
+            size: Nombre de résultats
+        
+        Returns:
+            Facteurs d'émission déchets
+        """
+        query_parts = ["déchet"]
+        if waste_type:
+            query_parts.append(waste_type)
+        if treatment:
+            query_parts.append(treatment)
+        
+        return await self.search(
+            query=" ".join(query_parts),
+            size=size,
+            category="Traitement des déchets"
+        )
+
+    async def search_equipment(
+        self,
+        equipment_type: str | None = None,
+        size: int = 20
+    ) -> dict[str, Any]:
+        """Recherche de FE équipements.
+        
+        Args:
+            equipment_type: Type d'équipement (ordinateur, téléphone, etc.)
+            size: Nombre de résultats
+        
+        Returns:
+            Facteurs d'émission équipements
+        """
+        query = equipment_type or "équipement informatique"
+        
+        return await self.search(
+            query=query,
+            size=size,
+            category="Achats de biens"
+        )
+
+
+# Champs principaux Base Carbone pour référence
+BASE_CARBONE_FIELDS = {
+    "identite": [
+        "Identifiant_de_l'élément",
+        "Nom_base_français",
+        "Nom_base_anglais",
+        "Nom_attribut_français",
+        "Nom_frontière_français",
+        "Code_de_la_catégorie",
+        "Type_de_l'élément",
+        "Type_Ligne",
+    ],
+    "valeurs": [
+        "Total_poste_non_décomposé",
+        "Unité_français",
+        "Unité_anglais",
+    ],
+    "decomposition_gaz": [
+        "CO2f",
+        "CO2b",
+        "CH4f",
+        "CH4b",
+        "N2O",
+        "Autres_GES",
+    ],
+    "qualite": [
+        "Incertitude",
+        "Qualité",
+        "Qualité_M",
+        "Qualité_TeR",
+        "Qualité_C",
+        "Qualité_TiR",
+        "Qualité_GR",
+        "Qualité_P",
+        "Transparence",
+    ],
+    "methodologie": [
+        "Source",
+        "Programme",
+        "Url_du_programme",
+        "Contributeur",
+        "Autres_Contributeurs",
+        "Structure",
+        "Commentaire_français",
+        "Réglementations",
+    ],
+    "validite": [
+        "Statut_de_l'élément",
+        "Date_de_création",
+        "Date_de_modification",
+        "Période_de_validité",
+    ],
+    "localisation": [
+        "Localisation_géographique",
+        "Sous-localisation_géographique_français",
+    ],
+}

src/models.py

@@ -0,0 +1,143 @@
+"""Modèles Pydantic pour le MCP Server ADEME."""
+
+from pydantic import BaseModel, Field
+from typing import Any
+
+
+class EmissionFactor(BaseModel):
+    """Facteur d'émission unifié (AGRIBALYSE ou Base Carbone)."""
+    
+    source: str = Field(description="Source: 'agribalyse' ou 'base_carbone'")
+    id: str = Field(description="Identifiant unique")
+    name: str = Field(description="Nom en français")
+    value: float = Field(description="Valeur du FE en kgCO2e")
+    unit: str = Field(description="Unité (kgCO2e/kg, kgCO2e/km, etc.)")
+    category: str = Field(description="Catégorie")
+    
+    # Qualité
+    uncertainty: float | None = Field(default=None, description="Incertitude en %")
+    dqr: float | None = Field(default=None, description="Data Quality Rating (1-5)")
+    
+    # Métadonnées
+    methodology_source: str | None = Field(default=None, description="Source méthodologique")
+    validity_period: str | None = Field(default=None, description="Période de validité")
+    status: str | None = Field(default=None, description="Statut (Valide, Archivé)")
+
+
+class FoodItem(BaseModel):
+    """Aliment AGRIBALYSE avec impacts environnementaux."""
+    
+    code_ciqual: int = Field(description="Code CIQUAL")
+    code_agb: str = Field(description="Code AGRIBALYSE")
+    name_fr: str = Field(description="Nom en français")
+    name_en: str | None = Field(default=None, description="Nom en anglais")
+    
+    group: str = Field(description="Groupe d'aliment")
+    subgroup: str = Field(description="Sous-groupe d'aliment")
+    
+    # Impact climatique
+    climate_change: float = Field(description="Impact changement climatique (kgCO2e/kg)")
+    climate_change_fossil: float | None = Field(default=None, description="Émissions fossiles")
+    climate_change_biogenic: float | None = Field(default=None, description="Émissions biogéniques")
+    climate_change_land_use: float | None = Field(default=None, description="Changement d'affectation des sols")
+    
+    # Score global
+    ef_score: float | None = Field(default=None, description="Score unique EF")
+    dqr: float | None = Field(default=None, description="Data Quality Rating")
+    
+    # Contexte
+    delivery: str | None = Field(default=None, description="Mode de livraison")
+    preparation: str | None = Field(default=None, description="Mode de préparation")
+    packaging: str | None = Field(default=None, description="Type d'emballage")
+    by_plane: bool = Field(default=False, description="Transport par avion")
+
+
+class TransportFactor(BaseModel):
+    """Facteur d'émission transport."""
+    
+    id: str
+    vehicle_type: str = Field(description="Type de véhicule")
+    fuel_type: str | None = Field(default=None, description="Type de carburant")
+    attribute: str | None = Field(default=None, description="Attribut (tonnage, etc.)")
+    
+    value: float = Field(description="Valeur en kgCO2e")
+    unit: str = Field(description="Unité (kgCO2e/km, kgCO2e/t.km, etc.)")
+    
+    uncertainty: float | None = Field(default=None, description="Incertitude %")
+    source: str | None = Field(default=None, description="Source")
+    status: str | None = Field(default=None, description="Statut")
+
+
+class EnergyFactor(BaseModel):
+    """Facteur d'émission énergie."""
+    
+    id: str
+    energy_type: str = Field(description="Type d'énergie")
+    specification: str | None = Field(default=None, description="Spécification")
+    
+    value: float = Field(description="Valeur en kgCO2e")
+    unit: str = Field(description="Unité (kgCO2e/kWh, kgCO2e/kg, etc.)")
+    
+    # Décomposition par gaz
+    co2_fossil: float | None = Field(default=None, description="CO2 fossile")
+    co2_biogenic: float | None = Field(default=None, description="CO2 biogénique")
+    ch4: float | None = Field(default=None, description="Méthane")
+    n2o: float | None = Field(default=None, description="Protoxyde d'azote")
+    
+    uncertainty: float | None = Field(default=None, description="Incertitude %")
+    source: str | None = Field(default=None, description="Source")
+
+
+class WasteFactor(BaseModel):
+    """Facteur d'émission déchets."""
+    
+    id: str
+    waste_type: str = Field(description="Type de déchet")
+    treatment: str = Field(description="Traitement (compost, incinération, etc.)")
+    
+    value: float = Field(description="Valeur en kgCO2e/tonne")
+    unit: str = Field(default="kgCO2e/tonne", description="Unité")
+    
+    # Décomposition par gaz
+    co2_fossil: float | None = None
+    co2_biogenic: float | None = None
+    ch4: float | None = None
+    n2o: float | None = None
+    
+    uncertainty: float | None = None
+    source: str | None = None
+
+
+class ComparisonResult(BaseModel):
+    """Résultat de comparaison entre 2 facteurs d'émission."""
+    
+    factor1: EmissionFactor
+    factor2: EmissionFactor
+    
+    absolute_difference: float = Field(description="Différence absolue (FE2 - FE1)")
+    relative_difference: float = Field(description="Différence relative en %")
+    
+    # Analyse
+    lower_bound_diff: float | None = Field(
+        default=None,
+        description="Différence min compte tenu des incertitudes"
+    )
+    upper_bound_diff: float | None = Field(
+        default=None,
+        description="Différence max compte tenu des incertitudes"
+    )
+    
+    recommendation: str | None = Field(
+        default=None,
+        description="Recommandation d'usage"
+    )
+
+
+class SearchResult(BaseModel):
+    """Résultat de recherche unifiée."""
+    
+    total: int = Field(description="Nombre total de résultats")
+    results: list[EmissionFactor] = Field(description="Facteurs d'émission trouvés")
+    sources: dict[str, int] = Field(
+        description="Nombre de résultats par source"
+    )

src/tools.py

@@ -0,0 +1,644 @@
+"""Outils MCP pour l'API ADEME (AGRIBALYSE + Base Carbone)."""
+
+import json
+from typing import Any
+
+from .clients import AgribalyseClient, BaseCarboneClient
+
+# Clients globaux (initialisés au premier appel)
+_agribalyse_client: AgribalyseClient | None = None
+_base_carbone_client: BaseCarboneClient | None = None
+
+
+def _get_agribalyse() -> AgribalyseClient:
+    global _agribalyse_client
+    if _agribalyse_client is None:
+        _agribalyse_client = AgribalyseClient()
+    return _agribalyse_client
+
+
+def _get_base_carbone() -> BaseCarboneClient:
+    global _base_carbone_client
+    if _base_carbone_client is None:
+        _base_carbone_client = BaseCarboneClient()
+    return _base_carbone_client
+
+
+def _format_agribalyse_result(item: dict[str, Any]) -> dict[str, Any]:
+    """Formate un résultat AGRIBALYSE en format unifié."""
+    return {
+        "source": "agribalyse",
+        "id": str(item.get("Code_CIQUAL", "")),
+        "name": item.get("Nom_du_Produit_en_Français", ""),
+        "name_en": item.get("LCI_Name", ""),
+        "value": item.get("Changement_climatique", 0),
+        "unit": "kgCO2e/kg",
+        "category": item.get("Groupe_d'aliment", ""),
+        "subcategory": item.get("Sous-groupe_d'aliment", ""),
+        "dqr": item.get("DQR"),
+        "ef_score": item.get("Score_unique_EF"),
+        "climate_fossil": item.get("Changement_climatique_-_émissions_fossiles"),
+        "climate_biogenic": item.get("Changement_climatique_-_émissions_biogéniques"),
+        "climate_land_use": item.get("Changement_climatique_-_émissions_liées_au_changement_d'affectation_des_sols"),
+        "delivery": item.get("Livraison"),
+        "preparation": item.get("Préparation"),
+        "packaging": item.get("Approche_emballage_"),
+        "by_plane": item.get("code_avion", False),
+    }
+
+
+def _format_base_carbone_result(item: dict[str, Any]) -> dict[str, Any]:
+    """Formate un résultat Base Carbone en format unifié."""
+    # Construire le nom complet
+    name_parts = [item.get("Nom_base_français", "")]
+    if item.get("Nom_attribut_français"):
+        name_parts.append(item.get("Nom_attribut_français"))
+    if item.get("Nom_frontière_français"):
+        name_parts.append(f"({item.get('Nom_frontière_français')})")
+    
+    return {
+        "source": "base_carbone",
+        "id": item.get("Identifiant_de_l'élément", ""),
+        "name": " - ".join(filter(None, name_parts)),
+        "name_en": item.get("Nom_base_anglais", ""),
+        "value": item.get("Total_poste_non_décomposé", 0),
+        "unit": item.get("Unité_français", ""),
+        "category": item.get("Code_de_la_catégorie", ""),
+        "uncertainty": item.get("Incertitude"),
+        "dqr": item.get("Qualité"),
+        "status": item.get("Statut_de_l'élément"),
+        "validity": item.get("Période_de_validité"),
+        "methodology": {
+            "source": item.get("Source"),
+            "program": item.get("Programme"),
+            "url": item.get("Url_du_programme"),
+            "contributor": item.get("Contributeur"),
+            "structure": item.get("Structure"),
+            "comment": item.get("Commentaire_français"),
+            "regulations": item.get("Réglementations"),
+        },
+        "decomposition_gas": {
+            "co2_fossil": item.get("CO2f"),
+            "co2_biogenic": item.get("CO2b"),
+            "ch4_fossil": item.get("CH4f"),
+            "ch4_biogenic": item.get("CH4b"),
+            "n2o": item.get("N2O"),
+            "other_ghg": item.get("Autres_GES"),
+        },
+        "quality_indicators": {
+            "M": item.get("Qualité_M"),
+            "TeR": item.get("Qualité_TeR"),
+            "C": item.get("Qualité_C"),
+            "TiR": item.get("Qualité_TiR"),
+            "GR": item.get("Qualité_GR"),
+            "P": item.get("Qualité_P"),
+            "transparency": item.get("Transparence"),
+        },
+        "location": item.get("Localisation_géographique"),
+    }
+
+
+# ============================================================================
+# OUTILS MCP
+# ============================================================================
+
+async def search_emission_factors(
+    query: str,
+    source: str = "all",
+    size: int = 10
+) -> str:
+    """Recherche unifiée de facteurs d'émission dans AGRIBALYSE et Base Carbone.
+    
+    Permet de trouver des facteurs d'émission (FE) pour calculer l'impact carbone
+    de différentes activités : alimentation, transport, énergie, déchets, équipements.
+    
+    Args:
+        query: Terme de recherche (ex: "boeuf", "camion diesel", "gaz naturel").
+        source: Source à interroger - "all" (les deux), "agribalyse" (alimentation), 
+                ou "base_carbone" (transport, énergie, déchets, équipements).
+        size: Nombre de résultats par source (défaut: 10, max: 50).
+    
+    Returns:
+        JSON avec les résultats unifiés des deux bases, incluant :
+        - id, name, value (kgCO2e), unit, category
+        - source d'origine (agribalyse/base_carbone)
+        - métadonnées de qualité (DQR, incertitude)
+    
+    Example:
+        search_emission_factors("poulet", source="agribalyse")
+        search_emission_factors("camion", source="base_carbone")
+        search_emission_factors("électricité")
+    """
+    results = []
+    sources_count = {"agribalyse": 0, "base_carbone": 0}
+    size = min(size, 50)
+    
+    try:
+        # Recherche AGRIBALYSE
+        if source in ["all", "agribalyse"]:
+            client = _get_agribalyse()
+            agri_data = await client.search(query, size=size)
+            for item in agri_data.get("results", []):
+                results.append(_format_agribalyse_result(item))
+                sources_count["agribalyse"] += 1
+        
+        # Recherche Base Carbone
+        if source in ["all", "base_carbone"]:
+            client = _get_base_carbone()
+            bc_data = await client.search(query, size=size)
+            for item in bc_data.get("results", []):
+                if item.get("Type_Ligne") == "Elément":
+                    results.append(_format_base_carbone_result(item))
+                    sources_count["base_carbone"] += 1
+        
+        return json.dumps({
+            "total": len(results),
+            "sources": sources_count,
+            "results": results
+        }, ensure_ascii=False, indent=2)
+    
+    except Exception as e:
+        return json.dumps({"error": str(e)}, ensure_ascii=False)
+
+
+async def get_emission_factor_details(
+    identifier: str,
+    source: str = "base_carbone"
+) -> str:
+    """Obtient les détails méthodologiques complets d'un facteur d'émission.
+    
+    Retourne toutes les informations disponibles sur un FE : valeur, incertitude,
+    source méthodologique, décomposition par gaz, indicateurs de qualité, etc.
+    Essentiel pour comprendre comment le FE a été calculé et sa fiabilité.
+    
+    Args:
+        identifier: Identifiant du FE (Code_CIQUAL pour AGRIBALYSE, 
+                   Identifiant_de_l'élément pour Base Carbone).
+        source: "agribalyse" ou "base_carbone".
+    
+    Returns:
+        JSON avec tous les détails méthodologiques :
+        - Valeur et unité
+        - Incertitude et indicateurs de qualité (DQR, M, TeR, C, TiR, GR, P)
+        - Source, programme, contributeur
+        - Décomposition par gaz (CO2f, CO2b, CH4, N2O)
+        - Commentaires méthodologiques
+        - Période de validité et statut
+    
+    Example:
+        get_emission_factor_details("27002", source="base_carbone")
+        get_emission_factor_details("13050", source="agribalyse")
+    """
+    try:
+        if source == "agribalyse":
+            client = _get_agribalyse()
+            item = await client.get_by_code(int(identifier))
+            if item:
+                result = _format_agribalyse_result(item)
+                # Ajouter tous les impacts environnementaux
+                result["all_impacts"] = {
+                    "climate_change": item.get("Changement_climatique"),
+                    "acidification": item.get("Acidification_terrestre_et_eaux_douces"),
+                    "eutrophication_marine": item.get("Eutrophisation_marine"),
+                    "eutrophication_freshwater": item.get("Eutrophisation_eaux_douces"),
+                    "eutrophication_terrestrial": item.get("Eutrophisation_terrestre"),
+                    "land_use": item.get("Utilisation_du_sol"),
+                    "water_depletion": item.get("Épuisement_des_ressources_eau"),
+                    "energy_depletion": item.get("Épuisement_des_ressources_énergétiques"),
+                    "mineral_depletion": item.get("Épuisement_des_ressources_minéraux"),
+                    "particulate_matter": item.get("Particules_fines"),
+                    "ozone_formation": item.get("Formation_photochimique_d'ozone"),
+                    "ozone_depletion": item.get("Appauvrissement_de_la_couche_d'ozone"),
+                    "ionizing_radiation": item.get("Rayonnements_ionisants"),
+                    "ecotoxicity": item.get("Écotoxicité_pour_écosystèmes_aquatiques_d'eau_douce"),
+                    "toxicity_cancer": item.get("Effets_toxicologiques_sur_la_santé_humaine___substances_cancérogènes"),
+                    "toxicity_non_cancer": item.get("Effets_toxicologiques_sur_la_santé_humaine___substances_non-cancérogènes"),
+                }
+                return json.dumps(result, ensure_ascii=False, indent=2)
+            return json.dumps({"error": f"Aliment {identifier} non trouvé"})
+        
+        else:  # base_carbone
+            client = _get_base_carbone()
+            items = await client.get_by_id(identifier)
+            if items:
+                # Récupérer l'élément principal et ses postes
+                main_element = None
+                posts = []
+                for item in items:
+                    if item.get("Type_Ligne") == "Elément":
+                        main_element = _format_base_carbone_result(item)
+                    elif item.get("Type_Ligne") == "Poste":
+                        posts.append({
+                            "post_name": item.get("Nom_poste_français"),
+                            "post_type": item.get("Type_poste"),
+                            "value": item.get("Total_poste_non_décomposé"),
+                        })
+                
+                if main_element:
+                    main_element["decomposition_posts"] = posts
+                    return json.dumps(main_element, ensure_ascii=False, indent=2)
+            
+            return json.dumps({"error": f"FE {identifier} non trouvé"})
+    
+    except Exception as e:
+        return json.dumps({"error": str(e)}, ensure_ascii=False)
+
+
+async def compare_emission_factors(
+    id1: str,
+    id2: str,
+    source1: str = "base_carbone",
+    source2: str = "base_carbone"
+) -> str:
+    """Compare deux facteurs d'émission avec analyse méthodologique.
+    
+    Permet de comparer deux FE pour une analyse de sensibilité : écart de valeur,
+    comparaison des incertitudes, différences de périmètre méthodologique.
+    Utile pour choisir entre deux options (ex: diesel vs électrique).
+    
+    Args:
+        id1: Identifiant du premier FE.
+        id2: Identifiant du second FE.
+        source1: Source du premier FE ("agribalyse" ou "base_carbone").
+        source2: Source du second FE ("agribalyse" ou "base_carbone").
+    
+    Returns:
+        JSON avec la comparaison détaillée :
+        - Valeurs des deux FE
+        - Différence absolue et relative (%)
+        - Plage de différence compte tenu des incertitudes
+        - Comparaison des qualités de données
+        - Recommandation d'usage
+    
+    Example:
+        compare_emission_factors("28022", "28024")  # VUL diesel vs électrique
+        compare_emission_factors("13050", "13029", "agribalyse", "agribalyse")  # Boeuf vs poulet
+    """
+    try:
+        # Récupérer les détails des deux FE
+        details1_json = await get_emission_factor_details(id1, source1)
+        details2_json = await get_emission_factor_details(id2, source2)
+        
+        details1 = json.loads(details1_json)
+        details2 = json.loads(details2_json)
+        
+        if "error" in details1:
+            return json.dumps({"error": f"FE1: {details1['error']}"})
+        if "error" in details2:
+            return json.dumps({"error": f"FE2: {details2['error']}"})
+        
+        # Calculs de comparaison
+        val1 = details1.get("value", 0)
+        val2 = details2.get("value", 0)
+        
+        abs_diff = val2 - val1
+        rel_diff = ((val2 - val1) / val1 * 100) if val1 != 0 else None
+        
+        # Calcul avec incertitudes
+        unc1 = details1.get("uncertainty", 0) or 0
+        unc2 = details2.get("uncertainty", 0) or 0
+        
+        lower_bound = None
+        upper_bound = None
+        if unc1 > 0 or unc2 > 0:
+            val1_min = val1 * (1 - unc1/100)
+            val1_max = val1 * (1 + unc1/100)
+            val2_min = val2 * (1 - unc2/100)
+            val2_max = val2 * (1 + unc2/100)
+            
+            if val1 > 0:
+                lower_bound = (val2_min - val1_max) / val1 * 100
+                upper_bound = (val2_max - val1_min) / val1 * 100
+        
+        # Recommandation
+        recommendation = None
+        if rel_diff is not None:
+            if abs(rel_diff) < 10:
+                recommendation = "Écart faible (<10%), les deux options sont équivalentes."
+            elif rel_diff < -20:
+                recommendation = f"Option 2 ({details2['name']}) significativement meilleure (-{abs(rel_diff):.0f}%)."
+            elif rel_diff > 20:
+                recommendation = f"Option 1 ({details1['name']}) significativement meilleure (+{rel_diff:.0f}%)."
+            else:
+                recommendation = "Écart modéré, considérer d'autres critères (coût, faisabilité)."
+        
+        return json.dumps({
+            "factor1": {
+                "id": id1,
+                "source": source1,
+                "name": details1.get("name"),
+                "value": val1,
+                "unit": details1.get("unit"),
+                "uncertainty": unc1,
+                "dqr": details1.get("dqr"),
+            },
+            "factor2": {
+                "id": id2,
+                "source": source2,
+                "name": details2.get("name"),
+                "value": val2,
+                "unit": details2.get("unit"),
+                "uncertainty": unc2,
+                "dqr": details2.get("dqr"),
+            },
+            "comparison": {
+                "absolute_difference": round(abs_diff, 4),
+                "relative_difference_percent": round(rel_diff, 1) if rel_diff else None,
+                "range_with_uncertainty": {
+                    "lower_bound_percent": round(lower_bound, 1) if lower_bound else None,
+                    "upper_bound_percent": round(upper_bound, 1) if upper_bound else None,
+                },
+                "recommendation": recommendation,
+            }
+        }, ensure_ascii=False, indent=2)
+    
+    except Exception as e:
+        return json.dumps({"error": str(e)}, ensure_ascii=False)
+
+
+async def search_food(
+    query: str,
+    group: str = "",
+    size: int = 10
+) -> str:
+    """Recherche d'aliments dans la base AGRIBALYSE.
+    
+    AGRIBALYSE contient les impacts environnementaux de 2500+ produits alimentaires
+    français, calculés sur tout le cycle de vie (du champ à l'assiette).
+    
+    Args:
+        query: Terme de recherche (ex: "steak", "yaourt", "pain").
+        group: Filtrer par groupe d'aliment (ex: "viandes", "produits laitiers").
+               Laisser vide pour chercher dans tous les groupes.
+        size: Nombre de résultats (défaut: 10, max: 50).
+    
+    Returns:
+        JSON avec les aliments trouvés :
+        - Nom, code CIQUAL, groupe/sous-groupe
+        - Impact climatique (kgCO2e/kg)
+        - Décomposition (fossile, biogénique, changement d'affectation)
+        - Score environnemental global (EF Score)
+        - Qualité des données (DQR)
+    
+    Example:
+        search_food("boeuf")
+        search_food("fromage", group="produits laitiers")
+    """
+    try:
+        client = _get_agribalyse()
+        data = await client.search(query, size=min(size, 50))
+        
+        results = []
+        for item in data.get("results", []):
+            # Filtrer par groupe si spécifié
+            if group and group.lower() not in item.get("Groupe_d'aliment", "").lower():
+                continue
+            results.append(_format_agribalyse_result(item))
+        
+        return json.dumps({
+            "total": len(results),
+            "results": results
+        }, ensure_ascii=False, indent=2)
+    
+    except Exception as e:
+        return json.dumps({"error": str(e)}, ensure_ascii=False)
+
+
+async def get_transport_factors(
+    vehicle_type: str = "",
+    fuel_type: str = "",
+    size: int = 20
+) -> str:
+    """Recherche de facteurs d'émission pour le transport.
+    
+    Permet de trouver les FE de différents modes de transport : routier (voiture,
+    VUL, poids lourd), ferroviaire, maritime, aérien. Inclut différentes motorisations
+    (diesel, essence, électrique, hybride, GNV).
+    
+    Args:
+        vehicle_type: Type de véhicule (ex: "voiture", "VUL", "poids lourd", "train").
+        fuel_type: Type de carburant (ex: "diesel", "essence", "électrique", "hybride").
+        size: Nombre de résultats (défaut: 20).
+    
+    Returns:
+        JSON avec les FE transport :
+        - Nom du véhicule et motorisation
+        - Valeur (kgCO2e/km ou kgCO2e/t.km)
+        - Incertitude
+        - Source méthodologique
+    
+    Example:
+        get_transport_factors("VUL", "diesel")
+        get_transport_factors("poids lourd")
+        get_transport_factors(fuel_type="électrique")
+    """
+    try:
+        client = _get_base_carbone()
+        data = await client.search_transport(vehicle_type or None, fuel_type or None, size)
+        
+        results = []
+        for item in data.get("results", []):
+            if item.get("Type_Ligne") == "Elément":
+                results.append(_format_base_carbone_result(item))
+        
+        return json.dumps({
+            "total": len(results),
+            "results": results
+        }, ensure_ascii=False, indent=2)
+    
+    except Exception as e:
+        return json.dumps({"error": str(e)}, ensure_ascii=False)
+
+
+async def get_energy_factors(
+    energy_type: str = "",
+    size: int = 20
+) -> str:
+    """Recherche de facteurs d'émission pour l'énergie.
+    
+    Permet de trouver les FE des différentes sources d'énergie : gaz naturel,
+    électricité, fioul, charbon, bois, etc. Utile pour calculer l'impact
+    du chauffage, de la cuisson, ou de la consommation électrique.
+    
+    Args:
+        energy_type: Type d'énergie (ex: "gaz naturel", "électricité", "fioul").
+        size: Nombre de résultats (défaut: 20).
+    
+    Returns:
+        JSON avec les FE énergie :
+        - Type d'énergie
+        - Valeur (kgCO2e/kWh ou kgCO2e/kg)
+        - Décomposition par gaz (CO2, CH4, N2O)
+        - Incertitude
+    
+    Example:
+        get_energy_factors("gaz naturel")
+        get_energy_factors("électricité")
+    """
+    try:
+        client = _get_base_carbone()
+        data = await client.search_energy(energy_type or None, size)
+        
+        results = []
+        for item in data.get("results", []):
+            if item.get("Type_Ligne") == "Elément":
+                results.append(_format_base_carbone_result(item))
+        
+        return json.dumps({
+            "total": len(results),
+            "results": results
+        }, ensure_ascii=False, indent=2)
+    
+    except Exception as e:
+        return json.dumps({"error": str(e)}, ensure_ascii=False)
+
+
+async def get_waste_factors(
+    waste_type: str = "",
+    treatment: str = "",
+    size: int = 20
+) -> str:
+    """Recherche de facteurs d'émission pour les déchets.
+    
+    Permet de trouver les FE des différents types de déchets selon leur
+    traitement : compostage, incinération, stockage (décharge), méthanisation.
+    
+    Args:
+        waste_type: Type de déchet (ex: "alimentaire", "plastique", "papier").
+        treatment: Mode de traitement (ex: "compost", "incinération", "stockage").
+        size: Nombre de résultats (défaut: 20).
+    
+    Returns:
+        JSON avec les FE déchets :
+        - Type de déchet et traitement
+        - Valeur (kgCO2e/tonne)
+        - Décomposition par gaz
+        - Incertitude
+    
+    Example:
+        get_waste_factors("alimentaire", "compost")
+        get_waste_factors("plastique", "incinération")
+    """
+    try:
+        client = _get_base_carbone()
+        data = await client.search_waste(waste_type or None, treatment or None, size)
+        
+        results = []
+        for item in data.get("results", []):
+            if item.get("Type_Ligne") == "Elément":
+                results.append(_format_base_carbone_result(item))
+        
+        return json.dumps({
+            "total": len(results),
+            "results": results
+        }, ensure_ascii=False, indent=2)
+    
+    except Exception as e:
+        return json.dumps({"error": str(e)}, ensure_ascii=False)
+
+
+async def get_equipment_factors(
+    equipment_type: str = "",
+    size: int = 20
+) -> str:
+    """Recherche de facteurs d'émission pour les équipements.
+    
+    Permet de trouver les FE des équipements informatiques et électroménagers :
+    ordinateurs, téléphones, télévisions, réfrigérateurs, etc.
+    Inclut la décomposition par poste (matières premières, fabrication, transport).
+    
+    Args:
+        equipment_type: Type d'équipement (ex: "ordinateur", "téléphone", "télévision").
+        size: Nombre de résultats (défaut: 20).
+    
+    Returns:
+        JSON avec les FE équipements :
+        - Type d'équipement
+        - Valeur (kgCO2e/unité)
+        - Décomposition par poste (si disponible)
+        - Incertitude
+    
+    Example:
+        get_equipment_factors("ordinateur portable")
+        get_equipment_factors("smartphone")
+    """
+    try:
+        client = _get_base_carbone()
+        data = await client.search_equipment(equipment_type or None, size)
+        
+        results = []
+        for item in data.get("results", []):
+            if item.get("Type_Ligne") == "Elément":
+                results.append(_format_base_carbone_result(item))
+        
+        return json.dumps({
+            "total": len(results),
+            "results": results
+        }, ensure_ascii=False, indent=2)
+    
+    except Exception as e:
+        return json.dumps({"error": str(e)}, ensure_ascii=False)
+
+
+async def get_categories(
+    source: str = "all"
+) -> str:
+    """Liste les catégories disponibles dans les bases de données.
+    
+    Permet de découvrir les catégories de facteurs d'émission disponibles
+    pour orienter les recherches.
+    
+    Args:
+        source: "agribalyse" (groupes d'aliments), "base_carbone" (catégories FE),
+                ou "all" (les deux).
+    
+    Returns:
+        JSON avec les catégories par source.
+    
+    Example:
+        get_categories("agribalyse")
+        get_categories("base_carbone")
+    """
+    try:
+        result = {}
+        
+        if source in ["all", "agribalyse"]:
+            client = _get_agribalyse()
+            categories = await client.get_categories()
+            result["agribalyse"] = {
+                "description": "Groupes d'aliments AGRIBALYSE",
+                "categories": categories
+            }
+        
+        if source in ["all", "base_carbone"]:
+            client = _get_base_carbone()
+            categories = await client.get_categories()
+            # Extraire les catégories racines
+            root_categories = set()
+            for cat in categories:
+                root = cat["category"].split(" > ")[0]
+                root_categories.add(root)
+            
+            result["base_carbone"] = {
+                "description": "Catégories principales Base Carbone",
+                "categories": sorted(list(root_categories))
+            }
+        
+        return json.dumps(result, ensure_ascii=False, indent=2)
+    
+    except Exception as e:
+        return json.dumps({"error": str(e)}, ensure_ascii=False)
+
+
+# Liste des outils pour export
+ALL_TOOLS = [
+    search_emission_factors,
+    get_emission_factor_details,
+    compare_emission_factors,
+    search_food,
+    get_transport_factors,
+    get_energy_factors,
+    get_waste_factors,
+    get_equipment_factors,
+    get_categories,
+]