Include fingerprint carbon

.gitignore

@@ -1,4 +1,6 @@
 /__pycache__/*
+*/__pycache__/*
 /.qodo/*
 
-.env
+.env
+emissions.csv

app.py

@@ -9,6 +9,8 @@ from langchain_core.messages import AIMessageChunk
 from typing import Literal
 import re
 
+from carbon.empreinte_carbone import initCarbon, traceImpact, display_cf_comparison
+
 
 # Charger les variables d'environnement
 load_dotenv()
@@ -54,6 +56,8 @@ def process_query(query, architecture: Literal["A", "B", "C"]):
         st.markdown(query)
 
     full_response = ""
+    usages = None
+    start_time = time.time()  # Start timing
 
     events = agent.stream(initial_state, config=config, stream_mode="messages")
     
@@ -64,17 +68,44 @@ def process_query(query, architecture: Literal["A", "B", "C"]):
 
         for event in events:
             for message in event:
-                if isinstance(message, AIMessageChunk) and hasattr(message, 'content'):
-                    full_response += message.content  # Accumuler les morceaux
-        # 🛑 Vérification si la réponse contient une requête Cypher
-        if re.search(r"(?i)(MATCH|CREATE|MERGE|DELETE|CALL)[\s\S]+;", full_response):
+                if isinstance(message, AIMessageChunk):
+                    # Vérifiez le type de message et affichez son contenu
+                    if hasattr(message, 'content'):
+                        full_response += message.content
+                        response_placeholder.markdown(full_response)
+
+                    if hasattr(message, 'usage_metadata'):
+                        usages = message.usage_metadata
+
+        latency = time.time() - start_time  # Calculate elapsed time
+
+        #         if isinstance(message, AIMessageChunk) and hasattr(message, 'content'):
+        #             full_response += message.content  # Accumuler les morceaux
+        # # 🛑 Vérification si la réponse contient une requête Cypher
+        # if re.search(r"(?i)(MATCH|CREATE|MERGE|DELETE|CALL)[\s\S]+;", full_response):
             
-            full_response = full_response = re.sub(r"(?i)(MATCH|CREATE|MERGE|DELETE|CALL)[\s\S]+?;", "", full_response).strip()
+        #     full_response = full_response = re.sub(r"(?i)(MATCH|CREATE|MERGE|DELETE|CALL)[\s\S]+?;", "", full_response).strip()
 
 
         # 🔄 Affichage final
-        response_placeholder.markdown(full_response)
+        # response_placeholder.markdown(full_response)
         st.session_state.chat_history.append({"role": "assistant", "content": full_response})
+
+        traceImpact(
+            st.session_state.current_model,
+            trace={
+                'completion_tokens' : usages.get('output_tokens', None),
+                'latency' : latency  # Use the measured latency
+            }
+        )
+        
+        # Mise à jour des tokens + coût
+        st.session_state['tokens_metrics']['input_tokens'] += usages.get('input_tokens', 0)
+        st.session_state['tokens_metrics']['output_tokens'] += usages.get('output_tokens', 0)
+        st.session_state['tokens_metrics']['total_tokens'] += usages.get('total_tokens', 0)
+        calculate_tokens_cost()
+
+        st.rerun()
         
     
 
@@ -84,11 +115,35 @@ def display_sidebar():
         lien_ressource = "https://www.fnac.com/livre-numerique/a21290809/Gaspard-Boreal-La-Confession-muette"
         #st.title("📄 La confession muette")
         #st.write("Posez vos questions sur le document.")
-        st.image(agent_B.get_graph().draw_mermaid_png(), caption="Workflow Graph")
         st.markdown("Document de référence 📄 : \nLa confession muette (2025)")
         st.markdown("Avec l'aimable autorisation de Gaspard Boréal: \n[Récit d'origine]({})".format(lien_ressource))
 
 
+        # Token metrics containers
+        st.sidebar.markdown("### Tokens")
+
+        # HTML pour le tableau sans index ni colonnes inutiles
+        table_html = f"""
+            <table style="width:100%">
+                <tr><td>Input Tokens</td><td style="text-align: right;"><b>{st.session_state['tokens_metrics'].get('input_tokens', 0)}</b></td></tr>
+                <tr><td>Output Tokens</td><td style="text-align: right;"><b>{st.session_state['tokens_metrics'].get('output_tokens', 0)}</b></td></tr>
+                <tr><td>Total Tokens</td><td style="text-align: right;"><b>{st.session_state['tokens_metrics'].get('total_tokens', 0)}</b></td></tr>
+                <tr><td>Coût</td><td style="text-align: right;"><b>{st.session_state['tokens_cost']} €</b></td></tr>
+            </table>
+        """
+
+        st.sidebar.markdown(table_html, unsafe_allow_html=True)
+        
+        st.sidebar.markdown("### Empreinte Carbone")
+        
+        display_cf_comparison(st.sidebar)
+        
+        st.sidebar.markdown("---")
+        st.sidebar.image("./assets/bziiit.png", width=100)
+        st.sidebar.markdown("2025 : Open source en Licence MIT")
+        st.sidebar.markdown("info@bziiit.com")
+
+
 def display_chat_history():
     """Affiche l'historique de chat."""
     for message in st.session_state.chat_history:
@@ -100,11 +155,21 @@ def display_chat_history():
                 st.markdown(message["content"])
 
 def main():
-    """Point d'entrée de l'application."""
+
+    initCarbon()
+
+    st.session_state['current_model'] = "mistral-large-latest"
+
+    if "tokens_metrics" not in st.session_state or "chat_history" not in st.session_state :
+        initialize_conversation()
+
+
+    # """Point d'entrée de l'application."""
     # Vérifier que les index Pinecone sont prêts
     if not check_indexes_ready():
         return
 
+
     st.title("RAG architectures")
     st.markdown(
         """
@@ -124,6 +189,9 @@ def main():
     )        
 
     display_sidebar()
+
+    if(st.session_state.chat_history):
+        display_chat_history()
     
     query = st.chat_input("Posez votre question ici:")
     if query:
@@ -136,5 +204,27 @@ def main():
 
         process_query(query, architecture)
 
+           
+def calculate_tokens_cost():
+    input_tokens = st.session_state['tokens_metrics'].get('input_tokens', 0)
+    output_tokens = st.session_state['tokens_metrics'].get('output_tokens', 0)
+    cost_input = (input_tokens / 1_000_000) * 1.80
+    cost_output = (output_tokens / 1_000_000) * 5.40
+    total_cost = round(cost_input + cost_output, 3)
+    st.session_state['tokens_cost'] = total_cost
+            
+def initialize_conversation():
+    # st.session_state["messages"] = []
+    st.session_state["chat_history"] = []
+    st.session_state["tokens_cost"] = 0
+    st.session_state['tokens_metrics'] = {
+        'input_tokens': 0,
+        'output_tokens': 0,
+        'total_tokens': 0
+    }
+    calculate_tokens_cost()
+
+
+
 if __name__ == "__main__":
     main()

carbon/comparateur.py

@@ -0,0 +1,54 @@
+
+import streamlit as st
+import pandas as pd
+
+dict_comparaison_1kgCO2 = {
+    "eau en litre":[374/100,"https://impactco2.fr/icons/eauenbouteille.svg"],
+    "smartphones": [1.16/100,"https://impactco2.fr/icons/smartphone.svg"],
+    "voiture en km": [460/100,"https://impactco2.fr/icons/voiturethermique.svg"],
+    "tgv en km":[34130/100,"https://impactco2.fr/icons/tgv.svg"],
+}
+
+def compare(value_init, ratio_equivalent):
+    return ratio_equivalent * value_init if ratio_equivalent else None
+
+def display_comparaison(container,value_init, ratio_equivalent,icon, unit):
+    #value_init must be in kgCO2
+    link_url = f"https://impactco2.fr/outils/comparateur?value={value_init}&comparisons=tgv,eauenbouteille,voiturethermique"
+    container.markdown(f"<div style='text-align: center;'><a href='{link_url}' target='_blank'><img src='{icon}' alt='{unit}' width='50'></div>", unsafe_allow_html=True)
+    container.markdown(f"<div style='text-align: center;'><b>{compare(value_init, ratio_equivalent):.2f}</b> {unit}</div>", unsafe_allow_html=True)
+
+def custom_cumsum(ecologits_series, codecarbon_series):
+    cumsum = 0
+    result = []
+    for eco, code in zip(ecologits_series, codecarbon_series):
+        if code == 0:
+            result.append(0)
+        else:
+            cumsum += eco
+            result.append(cumsum)
+    return pd.Series(result, index=ecologits_series.index)
+
+
+def get_table_empreintes_detailed() -> pd.DataFrame:
+    emissions_data = st.session_state["partial_emissions"]
+    emissions_df = pd.DataFrame(emissions_data).T  # Transpose to match the desired format
+
+    # Rename columns and index values
+    emissions_df = emissions_df.rename(columns={"cc": "CodeCarbon (Cumulative)", "el": "EcoLogits (par requete)"})
+    emissions_df = emissions_df.applymap(lambda x: x * 1000)
+    emissions_df = emissions_df.round(2)
+    emissions_df = emissions_df.rename(index={
+        "Scrapping": "Collecte de documents et scrapping",
+        "extraction_pp": "Extraction des parties prenantes (serveur et IA)",
+        "cartographie": "Sauvegarde de la cartographie",
+        "chatbot": "Dialogue avec chatBot IA",
+        "download_rapport": "Téléchargement cartographie"
+    })
+
+    # Make Ecologits column cumulative
+    emissions_df["EcoLogits (Cumulative)"] = custom_cumsum(emissions_df["EcoLogits (par requete)"], emissions_df["CodeCarbon (Cumulative)"])
+
+    emissions_df['Consommation Totale'] = emissions_df["CodeCarbon (Cumulative)"] + emissions_df["EcoLogits (Cumulative)"]
+    emissions_df = emissions_df.round(2)
+    return emissions_df

carbon/empreinte_carbone.py

@@ -0,0 +1,158 @@
+import base64
+import pandas as pd
+import altair as alt
+
+import streamlit as st
+from codecarbon import EmissionsTracker
+from ecologits.tracers.utils import compute_llm_impacts
+
+from .comparateur import get_table_empreintes_detailed, display_comparaison, dict_comparaison_1kgCO2
+
+
+def initCarbon():
+        
+    if "emission" not in st.session_state:
+        tracker = EmissionsTracker()
+        tracker.start()
+        st.session_state["emission"] = tracker
+    
+    if "partial_emissions" not in st.session_state:
+        st.session_state["partial_emissions"] = {
+            "chatbot": {"cc": 0, "el": 0} #cc for codecarbon , el for ecologits
+        }
+
+def traceImpact(model_name, trace):
+
+    print(trace)
+    impact = compute_llm_impacts(
+        provider="mistralai",
+        model_name=model_name,
+        output_token_count=trace['completion_tokens'],
+        request_latency=trace['latency'],
+    )
+
+    if impact.gwp and impact.gwp.value:
+        st.session_state["partial_emissions"]["chatbot"]["el"] += impact.gwp.value
+
+# Function to read and encode an SVG file to Base64
+def load_svg_as_base64(file_path):
+    with open(file_path, "rb") as f:
+        svg_data = f.read()
+    return base64.b64encode(svg_data).decode()
+
+def color_scale(val):
+    if val == '-':
+        return 'background-color: {color}'
+    elif val <= 1:
+        color = '#008571' #'rgba(0,238,0,0.5)'  # green with opacity
+    elif val <= 10:
+        color = '#83c2b8'  # light green with opacity
+    elif val <= 50:
+        color = '#efcd82'  # light yellow with opacity
+    elif val <= 100:
+        color = '#f2aa56'  # light orange with opacity
+    else:
+        color = '#e87a58'  # light red with opacity
+    return f'background-color: {color};color:white'
+
+def display_cf_comparison(stm: st):
+    # svg_file_path = "feuille.svg"
+    # svg_base64 = load_svg_as_base64(svg_file_path)
+    # stm.markdown(
+    # f"""
+    # **Votre consommation carbone**
+    #     <img src='data:image/svg+xml;base64,{svg_base64}' alt='svg' width='15' height='15' style='margin-left: 10px;'>
+    # """,
+    # unsafe_allow_html=True
+    # )
+
+    serveur_emission = st.session_state['emission'].stop()
+    emission_api = sum([value["el"] for value in st.session_state["partial_emissions"].values()])
+
+    if serveur_emission is None :
+        serveur_emission = 0
+    if emission_api is None :
+        emission_api = 0
+    total_emission = serveur_emission + emission_api
+
+    if total_emission == 0:
+        pourcentage_api = 0
+        pourcentage_serveur = 0
+    else:
+        pourcentage_api = emission_api / total_emission
+        pourcentage_serveur = serveur_emission / total_emission
+    
+    
+    # HTML pour le tableau sans index ni colonnes inutiles
+    table_html = f"""
+        <table style="width:100%">
+            <tr><td colspan="2" style="text-align: center;"><b>{total_emission*1000:.2f}</b> g eq. CO2</td></tr>
+            <tr><td style="text-align: center;">Empreinte serveur (via CodeCarbon)</td><td style="text-align: right;"><b>{serveur_emission*1000:.2f}</b> ({pourcentage_serveur:.2%})</td></tr>
+            <tr><td style="text-align: center;">Empreinte IA (via EcoLogits)</td><td style="text-align: right;"><b>{emission_api*1000:.2f}</b> ({pourcentage_api:.2%})</td></tr>
+        </table>
+    """
+
+    st.sidebar.markdown(table_html, unsafe_allow_html=True)
+    
+
+    c1,c2,c3 = stm.columns([1,1,1])
+
+    c2.write("---")
+
+    stm.markdown("**Votre équivalence**")
+    col1,col2,col3 = stm.columns([1,1,1])
+    display_comparaison(col1,total_emission,dict_comparaison_1kgCO2["eau en litre"][0]*1000,dict_comparaison_1kgCO2["eau en litre"][1],"ml")
+    display_comparaison(col2,total_emission,dict_comparaison_1kgCO2["tgv en km"][0],dict_comparaison_1kgCO2["tgv en km"][1],"km")
+    display_comparaison(col3,total_emission,dict_comparaison_1kgCO2["voiture en km"][0]*1000,dict_comparaison_1kgCO2["voiture en km"][1],"m")
+    stm.markdown("\n")
+    stm.markdown(
+    f"""
+    Fournis par **ADEME**
+        <a href='https://www.ademe.fr' target='_blank'><img src='https://www.ademe.fr/wp-content/uploads/2022/11/ademe-logo-2022-1.svg' alt='svg' width='30' height='30' style='margin-left: 10px;'>
+    """,
+    unsafe_allow_html=True
+    )
+
+def display_carbon_footprint():
+    st.title("EMPREINTE ÉNERGÉTIQUE DE L'APPLICATION IA CARTO RSE")
+    display_cf_comparison(st)
+    table = get_table_empreintes_detailed()
+    # table[['Consommation Totale']] = table[['Consommation Totale']].map('${:,.2f}'.format)
+   
+    table.replace({0.00: '-'}, inplace=True)
+    #just 2 digits after the comma
+    styled_df = table[['Consommation Totale']].rename(columns={'Consommation Totale': 'Consommation totale (g eqCo2)'})
+    styled_df = styled_df.round(2)
+    
+    styled_df = styled_df.style.applymap(color_scale, subset=['Consommation totale (g eqCo2)'])
+    st.markdown("---")
+    st.markdown("### DÉTAIL PAR TÂCHE")
+    st.table(styled_df)
+    with st.expander("Plus de détails"):
+        st.table(table)
+    
+    st.markdown("### SYNTHESE (Dialogue IA et non IA)")
+
+    serveur_emission = st.session_state['emission'].stop()
+    emission_api = sum([value["el"] for value in st.session_state["partial_emissions"].values()])
+    print(serveur_emission, emission_api)
+    total_emission = serveur_emission + emission_api
+
+    pourcentage_api = emission_api / total_emission
+    pourcentage_serveur = serveur_emission / total_emission
+
+    df = pd.DataFrame({"Catégorie": ["Identification + dessin","IA (extraction pp + dialogue)"], "valeur": [pourcentage_serveur, pourcentage_api]})
+    color_scale_alt = alt.Scale(domain=['Identification + dessin', 'IA (extraction pp + dialogue)'], range=['#011166', '#63abdf'])
+
+    base=alt.Chart(df).encode(
+    theta=alt.Theta(field="valeur", type="quantitative", stack=True),
+    color=alt.Color(field="Catégorie", type="nominal", scale=color_scale_alt),
+)
+
+
+    pie = base.mark_arc(outerRadius=100)
+    text = base.mark_text(radius=150,fill= "black",align='center', baseline='middle',fontSize=20).encode(alt.Text(field="valeur", type="quantitative", format=".2%"))
+
+    chart = alt.layer(pie, text, data=df).resolve_scale(theta="independent")
+    st.altair_chart(chart, use_container_width=True)
+

langchain-neo4j.ipynb

@@ -240,7 +240,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.10.16 ('python_env')",
+   "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
@@ -254,12 +254,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.16"
-  },
-  "vscode": {
-   "interpreter": {
-    "hash": "61b9aa377fb83f63bad7741d096e61bd539c2bb481b5373a09d4b308f1781ad2"
-   }
+   "version": "3.12.2"
   }
  },
  "nbformat": 4,