Posted on

Guide : Creer un dashboard web pour surveiller votre agent IA

Un agent IA autonome a besoin d un tableau de bord pour visualiser son activite, ses logs et ses alertes. Voici comment construire un dashboard web minimaliste avec Flask en moins de 100 lignes de code.

Le setup minimal

pip install flask

# dashboard.py
from flask import Flask, render_template_string, jsonify
import datetime, json, os

app = Flask(__name__)
LOG_FILE = "agent_logs.json"

def get_logs():
    try:
        with open(LOG_FILE) as f:
            return json.load(f)
    except:
        return []

@app.route("/")
def index():
    logs = get_logs()[-50:]  # 50 derniers
    html = """
    <html>
    <head><title>Agent IA Dashboard</title>
    <meta http-equiv='refresh' content='30'>
    <style>
    body{font-family:sans-serif;max-width:900px;margin:0 auto;padding:20px;background:#1a1a2e;color:#eee}
    h1{color:#e94560}
    .log{padding:10px;margin:5px 0;border-radius:8px;background:#16213e}
    .info{border-left:4px solid #0f3460}
    .warning{border-left:4px solid #e94560}
    .error{border-left:4px solid #ff0000}
    .time{color:#888;font-size:12px}
    .status{display:flex;gap:20px;margin:20px 0}
    .card{background:#16213e;padding:20px;border-radius:10px;flex:1;text-align:center}
    .card h3{margin:0;color:#e94560}
    </style></head>
    <body>
    <h1>Agent IA Dashboard</h1>
    <div class='status'>
      <div class='card'><h3>{{ logs|length }}</h3>Actions</div>
      <div class='card'><h3>{{ warnings }}</h3>Alertes</div>
      <div class='card'><h3>{{ uptime }}</h3>Uptime</div>
    </div>
    {% for log in logs|reverse %}
    <div class='log {{ log.level }}'>
      <span class='time'>{{ log.time }}</span> {{ log.message }}
    </div>
    {% endfor %}
    </body></html>
    """
    warnings = len([l for l in logs if l.get('level') == 'warning'])
    return render_template_string(html, logs=logs, warnings=warnings, uptime="24h")

if __name__ == "__main__":
    app.run(host="127.0.0.1", port=8080)

Ajouter des logs depuis l agent

import json, datetime

def log_action(message, level="info"):
    entry = {
        "time": datetime.datetime.now().strftime("%d/%m %H:%M:%S"),
        "message": message,
        "level": level
    }
    try:
        with open("agent_logs.json") as f:
            logs = json.load(f)
    except:
        logs = []
    logs.append(entry)
    logs = logs[-500:]  # garder les 500 derniers
    with open("agent_logs.json", "w") as f:
        json.dump(logs, f)

# Dans votre agent :
log_action("Rapport matinal envoye", "info")
log_action("Stock bas detecte sur OldPatoun", "warning")
log_action("Backup IONOS termine — 4 sites", "info")

Acceder a distance

Pour acceder au dashboard depuis votre telephone, utilisez un tunnel Cloudflare (gratuit) :

# Installer cloudflared
# Puis :
cloudflared tunnel --url http://localhost:8080

Vous obtenez une URL publique type https://random-name.trycloudflare.com accessible de partout.

Materiel

Le dashboard tourne sur n importe quoi — meme un Raspberry Pi 5. Pour un setup complet agent + dashboard, un mini PC avec un ecran 4K est ideal.

Posted on

Guide : Planifier les executions automatiques de votre agent IA

Un agent IA n est vraiment utile que s il travaille sans que vous ayez a le lancer manuellement. Voici comment planifier des taches automatiques : rapport matinal, surveillance de sites, backup nocturne, veille concurrentielle.

Methode 1 — Python schedule (la plus simple)

La bibliotheque schedule est parfaite pour planifier des taches dans votre script Python :

pip install schedule

import schedule, time, threading

def rapport_matinal():
    print("Rapport du matin...")
    # Votre logique agent ici

def check_emails():
    print("Verification emails...")

def backup_nocturne():
    print("Backup en cours...")

# Planification
schedule.every().day.at("08:00").do(rapport_matinal)
schedule.every(10).minutes.do(check_emails)
schedule.every().day.at("02:00").do(backup_nocturne)
schedule.every().monday.at("09:00").do(lambda: print("Rapport hebdo"))

# Boucle principale
while True:
    schedule.run_pending()
    time.sleep(60)

Methode 2 — Taches planifiees Windows

Pour que l agent demarre automatiquement au boot :

# PowerShell (en administrateur)
$action = New-ScheduledTaskAction -Execute "C:\chemin\python.exe" -Argument "-m app.main" -WorkingDirectory "C:\chemin\agent"
$trigger = New-ScheduledTaskTrigger -AtLogon
$settings = New-ScheduledTaskSettingsSet -StartWhenAvailable -DontStopOnIdleEnd
Register-ScheduledTask -TaskName "MonAgentIA" -Action $action -Trigger $trigger -Settings $settings

Methode 3 — Cron (Linux/Mac)

# Editer le crontab
crontab -e

# Ajouter :
@reboot cd /home/user/agent && python -m app.main &
0 8 * * * cd /home/user/agent && python rapport.py
*/10 * * * * cd /home/user/agent && python check_emails.py

Methode 4 — Systemd (Linux, le plus robuste)

# Creer /etc/systemd/system/agent-ia.service
[Unit]
Description=Agent IA Autonome
After=network.target

[Service]
Type=simple
User=votre_user
WorkingDirectory=/home/user/agent
ExecStart=/usr/bin/python3 -m app.main
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

# Activer
sudo systemctl enable agent-ia
sudo systemctl start agent-ia
sudo systemctl status agent-ia

Architecture autopilot

Notre agent AgentBMax utilise un systeme d autopilot qui combine schedule + threading :

AUTOPILOT_TASKS = {
    "briefing": {"schedule": "08:00", "action": rapport_matinal},
    "email_check": {"interval_min": 10, "action": check_emails},
    "site_monitoring": {"interval_min": 60, "action": check_sites},
    "backup": {"schedule": "02:00", "action": backup},
    "crypto_watch": {"interval_min": 30, "action": check_crypto},
}

for name, task in AUTOPILOT_TASKS.items():
    if "schedule" in task:
        schedule.every().day.at(task["schedule"]).do(task["action"])
    elif "interval_min" in task:
        schedule.every(task["interval_min"]).minutes.do(task["action"])

Materiel recommande

Un agent qui tourne 24/7 doit etre sur une machine fiable et econome : un mini PC Intel Core Ultra consomme 15W et suffit largement. Ajoutez un NAS pour le stockage des logs et backups.

Posted on

Guide : Recevoir les alertes de votre agent IA sur WhatsApp et Signal

Votre agent IA detecte un probleme sur votre site, recoit une commande ou termine un backup — comment etre prevenu instantanement sur votre telephone ? Voici comment connecter votre agent a WhatsApp et Signal.

Option 1 — Signal (le plus prive)

Signal est open source et chiffre de bout en bout. Parfait pour des alertes contenant des infos sensibles.

Installation de signal-cli

# Linux
sudo apt install signal-cli

# Windows — telecharger depuis github.com/AsamK/signal-cli
# Extraire dans C:\signal-cli\

# Enregistrer votre numero
signal-cli -a +33612345678 register
# Verifier avec le code SMS recu
signal-cli -a +33612345678 verify CODE

Envoyer un message depuis Python

import subprocess

def send_signal(message, recipient="+33612345678"):
    try:
        result = subprocess.run(
            ["signal-cli", "-a", "+33612345678", 
             "send", "-m", message, recipient],
            capture_output=True, timeout=30, text=True
        )
        return result.returncode == 0
    except Exception as e:
        print(f"Erreur Signal: {e}")
        return False

# Utilisation
send_signal("Backup termine — 4 sites sauvegardes")

Option 2 — WhatsApp via Twilio

Twilio offre une API WhatsApp Business. Cout : environ 0.005 euros par message.

Setup

pip install twilio

from twilio.rest import Client

TWILIO_SID = "votre_account_sid"
TWILIO_TOKEN = "votre_auth_token"
TWILIO_WHATSAPP = "whatsapp:+14155238886"  # numero Twilio
MY_WHATSAPP = "whatsapp:+33612345678"

def send_whatsapp(message):
    client = Client(TWILIO_SID, TWILIO_TOKEN)
    msg = client.messages.create(
        body=message,
        from_=TWILIO_WHATSAPP,
        to=MY_WHATSAPP
    )
    return msg.sid


Option 3 — Telegram (gratuit et simple)

Telegram est l option la plus simple — pas besoin de Twilio ni de signal-cli.

import requests

BOT_TOKEN = "votre_bot_token"  # depuis @BotFather
CHAT_ID = "votre_chat_id"

def send_telegram(message):
    url = f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage"
    requests.post(url, json={"chat_id": CHAT_ID, "text": message})

send_telegram("Rapport quotidien : 0 commandes, tout OK")

Option 4 — Email (le backup fiable)

import smtplib
from email.mime.text import MIMEText

def send_email(subject, body, to="Nous contacter"):
    msg = MIMEText(body)
    msg["Subject"] = subject
    msg["From"] = "Nous contacter"
    msg["To"] = to
    
    with smtplib.SMTP_SSL("smtp.gmail.com", 465) as server:
        server.login("Nous contacter", "app_password_ici")
        server.send_message(msg)

Combiner les canaux

def alert(message, level="info"):
    # Toujours par email
    send_email(f"[{level.upper()}] Agent IA", message)
    
    # Urgent → Signal + WhatsApp
    if level == "critical":
        send_signal(message)
        send_whatsapp(message)
    
    # Normal → Telegram seulement
    elif level == "warning":
        send_telegram(message)

# Exemples
alert("Nouvelle commande 89.90 euros", "warning")
alert("Backup quotidien termine", "info")

👉 Mini PC pour heberger votre agent 24/7 | Raspberry Pi 5 pour un agent ultra-economique

Posted on

Guide : Creer votre premier agent IA autonome en Python

Un agent IA est un programme qui utilise un LLM pour raisonner et executer des actions de facon autonome. Contrairement a un chatbot qui repond passivement, un agent peut envoyer des emails, naviguer sur le web, executer du code et gerer des fichiers. Voici comment en construire un from scratch.

Architecture d un agent

Un agent se compose de 4 elements :

  • Le cerveau — un LLM (Llama, Qwen, Mistral) qui raisonne
  • Les outils — des fonctions Python que l agent peut appeler (envoyer un email, lire un fichier, faire une recherche web)
  • La memoire — l historique des actions et resultats
  • La boucle — observer, reflechir, agir, evaluer, repeter

Etape 1 — Le LLM local

Installez llama-cpp-python et telechargez un modele :

pip install llama-cpp-python

# Telecharger Qwen 2.5 3B (leger, bon en francais)
# depuis huggingface.co/Qwen/Qwen2.5-3B-Instruct-GGUF

Etape 2 — Definir les outils

import subprocess, datetime, os

TOOLS = {
    "datetime": lambda arg: datetime.datetime.now().strftime("%d/%m/%Y %H:%M"),
    "shell": lambda arg: subprocess.run(arg, shell=True, capture_output=True, text=True).stdout[:500],
    "file_read": lambda arg: open(arg).read()[:2000],
    "file_write": lambda arg: open(arg.split('|')[0],'w').write(arg.split('|',1)[1]),
    "web_search": lambda arg: "Resultat de recherche pour: " + arg,
}

TOOL_DESC = """
Tu as acces aux outils suivants :
- datetime : donne la date et l heure
- shell  : execute une commande systeme
- file_read  : lit un fichier
- file_write | : ecrit dans un fichier
- web_search  : recherche sur le web
Pour utiliser un outil, reponds : TOOL: nom_outil argument
"""

Etape 3 — La boucle agent

from llama_cpp import Llama

llm = Llama(model_path="qwen2.5-3b-instruct-q4_k_m.gguf", n_ctx=2048)

def run_agent(task, max_steps=5):
    history = []
    system = f"Tu es un agent IA autonome. {TOOL_DESC}"
    
    for step in range(max_steps):
        prompt = f"[SYSTEM] {system}\n[TASK] {task}\n"
        for h in history:
            prompt += f"[STEP {h['step']}] {h['action']}\n[RESULT] {h['result']}\n"
        prompt += f"[STEP {step+1}] Que fais-tu ?\n"
        
        response = llm(prompt, max_tokens=256, stop=["\n[STEP"])
        text = response["choices"][0]["text"].strip()
        
        if text.startswith("TOOL:"):
            tool_line = text[5:].strip()
            tool_name = tool_line.split()[0]
            tool_arg = tool_line[len(tool_name):].strip()
            if tool_name in TOOLS:
                result = TOOLS[tool_name](tool_arg)
            else:
                result = f"Outil {tool_name} inconnu"
        elif "DONE" in text or "termine" in text.lower():
            return text
        else:
            result = text
        
        history.append({"step": step+1, "action": text, "result": str(result)[:500]})
    
    return "Agent termine apres " + str(max_steps) + " etapes"

# Test
print(run_agent("Quelle heure est-il et cree un fichier rapport.txt avec la date"))

Etape 4 — Ajouter des vrais outils

Gmail, calendrier, Slack, base de donnees — chaque outil est une simple fonction Python. L agent apprend a les utiliser grace aux descriptions dans le prompt systeme. Plus vous ajoutez d outils, plus l agent devient capable.

Notre experience : AgentBMax

Nous avons construit AgentBMax avec exactement cette architecture. Il tourne sur un mini PC a 300 euros avec 8 Go de RAM, sans GPU, et gere nos 5 sites e-commerce au quotidien. Preuve que l IA autonome est accessible a tous.

👉 Mini PC pour votre agent | RAM 32 Go pour plus d outils | SSD rapide pour les donnees

Posted on

Guide : Installer Llama 3 en local pas a pas (Windows et Linux)

Ce guide vous accompagne de A a Z pour installer et faire tourner Llama 3 sur votre propre machine. Aucune experience requise — suivez simplement les etapes.

Prerequis materiel

Minimum : 16 Go de RAM et un processeur recent (Intel 12e gen+ ou AMD Ryzen 5000+). Recommande : une carte graphique NVIDIA RTX 4070 ou superieure pour des performances optimales. Sans GPU, ca fonctionne sur CPU mais 10x plus lentement.

Etape 1 — Installer Ollama (methode la plus simple)

Windows : Telechargez Ollama depuis ollama.com. Lancez l installeur. C est tout.

Linux : Ouvrez un terminal et tapez :

curl -fsSL https://ollama.com/install.sh | sh

Ollama s installe et demarre automatiquement en arriere-plan.

Etape 2 — Telecharger Llama 3

Dans votre terminal (PowerShell sur Windows, Terminal sur Linux) :

ollama pull llama3.1:8b

Le modele fait environ 4.7 Go. Le telechargement prend 5 a 15 minutes selon votre connexion. Pour la version plus performante (necessite 16+ Go de VRAM) :

ollama pull llama3.1:70b

Etape 3 — Discuter avec Llama

Tapez simplement :

ollama run llama3.1:8b

Vous etes maintenant en conversation avec Llama 3 ! Tapez vos questions, le modele repond. Tapez /bye pour quitter.

Etape 4 — Interface graphique (optionnel)

Pour une interface type ChatGPT, installez Open WebUI :

docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway ghcr.io/open-webui/open-webui:main

Ouvrez votre navigateur sur http://localhost:3000. Vous avez votre propre ChatGPT prive.

Methode alternative — llama.cpp (plus de controle)

Pour les utilisateurs avances qui veulent un controle total :

# Cloner le repo
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# Compiler (Linux/Mac)
make -j

# Ou avec support GPU CUDA (NVIDIA)
make -j GGML_CUDA=1

# Telecharger un modele GGUF depuis huggingface.co
# Lancer
./llama-cli -m votre-modele.gguf -p "Bonjour, comment vas-tu ?" -n 256

Methode Python — llama-cpp-python

Pour integrer dans vos scripts Python :

pip install llama-cpp-python

# Dans votre script :
from llama_cpp import Llama
llm = Llama(model_path="./modele.gguf", n_ctx=2048, n_gpu_layers=0)
response = llm("Explique-moi le machine learning", max_tokens=512)
print(response["choices"][0]["text"])

Performances attendues

Sur CPU (pas de GPU) : 5-10 tokens/seconde — utilisable mais lent. Sur RTX 4070 : 40-60 tokens/seconde — fluide. Sur RTX 5090 : 120+ tokens/seconde — instantane.

Quel modele choisir

Llama 3.1 8B : le meilleur rapport taille/qualite, tourne sur n importe quel PC recent. Qwen 2.5 7B : excellent en francais. Mistral 7B : rapide et polyvalent. Pour essayer : ollama pull qwen2.5:7b

👉 GPU recommande : RTX 4070 Ti | SSD pour stocker les modeles | RAM 32 Go DDR5