Intégrer le dashboard de données

Section 11.5.9 : Intégrer le dashboard de données

🎯 Objectif pédagogique

Créer un dashboard de données intégré à votre application : métriques d'usage, visualisations, et analytics. Vous serez capable de construire un tableau de bord professionnel qui montre l'impact de votre chatbot.

Les données comme preuve de valeur

Marc veut montrer que son chatbot est utile. Les métriques, c'est la preuve : combien de conversations ? quels sujets ? quel taux de satisfaction ? Un dashboard transforme des données brutes en insights actionnables.

Dashboard Streamlit intégré

# pages/dashboard.py — Page analytics (Streamlit multi-page)

import streamlit as st
import json
from pathlib import Path
from datetime import datetime, timedelta
import random  # Pour les données de démo

st.set_page_config(page_title="CareerBot — Analytics", page_icon="📊")
st.title("📊 Dashboard Analytics")

# ═══ Données (en production : base de données) ═══
def load_analytics():
    """Charger les données analytics (mock pour le MVP)."""
    # En production : requête SQL ou API
    return \{
        "total_conversations": 347,
        "total_messages": 2184,
        "avg_messages_per_convo": 6.3,
        "satisfaction_rate": 87,
        "top_questions": [
            ("Salaires Data Analyst", 89),
            ("Formations recommandées", 76),
            ("Compétences à apprendre", 64),
            ("Préparation entretien", 52),
            ("Analyse de CV", 38),
        ],
        "tools_usage": \{
            "search_knowledge": 412,
            "analyze_profile": 156,
            "create_action_plan": 89,
        \},
        "daily_conversations": [
            (datetime.now() - timedelta(days=i), random.randint(20, 60))
            for i in range(30, 0, -1)
        ]
    \}

data = load_analytics()

# ═══ KPIs en haut ═══
col1, col2, col3, col4 = st.columns(4)

with col1:
    st.metric("Conversations", data["total_conversations"], delta="+23 cette semaine")
with col2:
    st.metric("Messages", data["total_messages"], delta="+142")
with col3:
    st.metric("Moy. msg/convo", f"\{data['avg_messages_per_convo']:.1f\}")
with col4:
    st.metric("Satisfaction", f"\{data['satisfaction_rate']\}%", delta="+2%")

st.divider()

# ═══ Graphiques ═══
col_left, col_right = st.columns(2)

with col_left:
    st.subheader("📈 Conversations par jour")
    chart_data = \{
        "Date": [d[0].strftime("%d/%m") for d in data["daily_conversations"]],
        "Conversations": [d[1] for d in data["daily_conversations"]]
    \}
    st.bar_chart(chart_data, x="Date", y="Conversations")

with col_right:
    st.subheader("🔧 Outils les plus utilisés")
    for tool, count in data["tools_usage"].items():
        st.progress(count / max(data["tools_usage"].values()), text=f"\{tool\}: \{count\}")

st.divider()

# ═══ Top questions ═══
st.subheader("❓ Questions les plus fréquentes")
for question, count in data["top_questions"]:
    col_q, col_c = st.columns([4, 1])
    with col_q:
        st.write(f"**\{question\}**")
    with col_c:
        st.write(f"\{count\} fois")

# ═══ Base de connaissances ═══
st.divider()
st.subheader("📚 Base de connaissances")

from knowledge import KnowledgeBase
kb = KnowledgeBase()
kb_stats = kb.get_stats()
st.write(f"Documents indexés : **\{kb_stats['total_documents']\}**")
st.write(f"Collection : **\{kb_stats['collection_name']\}**")

Tracker simple pour le MVP

# analytics.py — Tracking minimaliste

import json
from pathlib import Path
from datetime import datetime

class Analytics:
    """Tracking analytics simple (fichier JSON)."""
    
    def __init__(self, filepath="data/analytics.json"):
        self.filepath = Path(filepath)
        self.filepath.parent.mkdir(parents=True, exist_ok=True)
        self.data = self._load()
    
    def _load(self):
        if self.filepath.exists():
            return json.loads(self.filepath.read_text(encoding="utf-8"))
        return \{"conversations": [], "events": []\}
    
    def _save(self):
        self.filepath.write_text(
            json.dumps(self.data, ensure_ascii=False, indent=2),
            encoding="utf-8"
        )
    
    def log_message(self, role, content, tools_used=None):
        """Logger un message de conversation."""
        self.data["events"].append(\{
            "type": "message",
            "role": role,
            "content_length": len(content),
            "tools_used": tools_used or [],
            "timestamp": datetime.now().isoformat()
        \})
        self._save()
    
    def log_conversation_end(self, message_count):
        """Logger la fin d'une conversation."""
        self.data["conversations"].append(\{
            "messages": message_count,
            "timestamp": datetime.now().isoformat()
        \})
        self._save()
    
    def get_summary(self):
        """Résumé des analytics."""
        return \{
            "total_conversations": len(self.data["conversations"]),
            "total_events": len(self.data["events"]),
            "avg_messages": (
                sum(c["messages"] for c in self.data["conversations"]) / 
                len(self.data["conversations"])
                if self.data["conversations"] else 0
            )
        \}

🏋️ Exercice pratique (25 minutes)

1. →Implémentez analytics.py avec le tracking basique
2. →Intégrez le tracking dans votre agent (log_message après chaque échange)
3. →Créez la page dashboard dans Streamlit
4. →Générez des données de test et vérifiez le dashboard