Construisez et exécutez votre propre agent IA dans le cloud

Construisez et exécutez votre propre agent IA dans le cloud

L'ère des agents IA est arrivée. Les outils présentés sur OpenAI News et le blog Microsoft AI montrent que les agents autonomes ne sont plus de simples projets de recherche : ce sont des outils pratiques pour automatiser des workflows, analyser des données et interagir avec des API. Mais vous n'avez pas besoin d'un budget colossal pour en construire un. Grâce au cloud computing et aux frameworks open source, vous pouvez déployer votre propre agent IA en quelques minutes.

Cet article vous guide pas à pas pour construire un agent IA léger et personnalisable en utilisant Python, l'API OpenAI et un serveur cloud (comme un droplet DigitalOcean ou une instance AWS EC2). Vous découvrirez les prérequis, l'installation étape par étape et des exemples d'utilisation concrets. À la fin, vous aurez un agent capable d'exécuter des tâches, de mémoriser le contexte et de répondre à des requêtes, le tout fonctionnant dans le cloud.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

• **Un serveur cloud** (par exemple, un droplet DigitalOcean à 10$/mois avec Ubuntu 22.04, ou une instance AWS EC2 t2.micro). Vous devez avoir un accès SSH.
• **Python 3.10+** installé sur le serveur.
• **Une clé API OpenAI** (ou une clé API d'Anthropic si vous utilisez Claude). Obtenez-en une sur [platform.openai.com](https://platform.openai.com) ou [anthropic.com](https://www.anthropic.com).
• **Une familiarité de base avec la ligne de commande et Python.** Aucune connaissance avancée en IA n'est requise.

Installation étape par étape

Nous allons construire un agent qui utilise l'API OpenAI pour répondre aux requêtes des utilisateurs, exécuter du code Python et récupérer des données sur le web. Nous utiliserons la bibliothèque Python `openai` et une interface en ligne de commande simple.

1. Connectez-vous à votre serveur cloud

Ouvrez un terminal et connectez-vous en SSH à votre serveur. Remplacez `votre-ip-serveur` par l'adresse IP de votre serveur.

ssh root@votre-ip-serveur

Si vous utilisez un utilisateur non root, adaptez la commande (ex : `ssh ubuntu@votre-ip-serveur`).

2. Mettez à jour les paquets système

Mettez à jour la liste des paquets et les paquets existants.

sudo apt update && sudo apt upgrade -y

Cela garantit que vous disposez des derniers correctifs de sécurité et versions de bibliothèques.

3. Installez Python et pip

Ubuntu 22.04 est livré avec Python 3.10. Installez pip s'il est manquant.

sudo apt install python3 python3-pip -y

Vérifiez l'installation :

python3 --version
pip3 --version

Vous devriez voir Python 3.10+ et pip 22+.

4. Créez un répertoire de projet

Créez un dossier dédié pour votre agent.

mkdir ~/ai-agent && cd ~/ai-agent

5. Configurez un environnement virtuel

Isolez les dépendances pour éviter les conflits.

python3 -m venv venv
source venv/bin/activate

Votre invite de commande devrait maintenant afficher `(venv)`.

6. Installez les bibliothèques Python requises

Installez le client OpenAI et quelques bibliothèques utilitaires.

pip install openai requests python-dotenv

• `openai` : Client officiel pour l'API OpenAI.
• `requests` : Pour effectuer des appels HTTP (ex : récupération de données web).
• `python-dotenv` : Pour charger la clé API depuis un fichier `.env`.

7. Stockez votre clé API en toute sécurité

Créez un fichier `.env` dans le répertoire du projet. Ne codez jamais les clés en dur dans les scripts.

echo "OPENAI_API_KEY=votre-clé-api-ici" > .env

Remplacez `votre-clé-api-ici` par votre vraie clé. Le fichier doit avoir des permissions restrictives :

chmod 600 .env

8. Écrivez le script de l'agent

Créez un fichier nommé `agent.py`. Ce script sera le cœur de votre agent IA.

#!/usr/bin/env python3
import os
import json
import requests
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def ask_agent(prompt, conversation_history=None):
    if conversation_history is None:
        conversation_history = []
    
    # Ajouter un message système pour définir le comportement de l'agent
    messages = [
        {"role": "system", "content": "Vous êtes un agent IA serviable. Vous pouvez répondre aux questions, exécuter du code et récupérer des données web. Gardez les réponses claires et concises."}
    ]
    messages.extend(conversation_history)
    messages.append({"role": "user", "content": prompt})
    
    response = client.chat.completions.create(
        model="gpt-4o-mini",  # Modèle économique
        messages=messages,
        temperature=0.7,
        max_tokens=1000
    )
    
    return response.choices[0].message.content

def main():
    print("Agent IA (tapez 'quit' pour quitter)")
    history = []
    
    while True:
        user_input = input("\nVous : ").strip()
        if user_input.lower() in ['quit', 'exit']:
            print("Au revoir !")
            break
        
        response = ask_agent(user_input, history)
        print(f"Agent : {response}")
        
        # Stocker le contexte de la conversation
        history.append({"role": "user", "content": user_input})
        history.append({"role": "assistant", "content": response})
        
        # Conserver seulement les 10 derniers échanges pour gérer les limites de tokens
        if len(history) > 20:
            history = history[-20:]

if __name__ == "__main__":
    main()

Ce script charge la clé API, définit une fonction `ask_agent()` qui envoie des requêtes à OpenAI, et exécute une boucle en ligne de commande qui conserve l'historique de la conversation. Le message système définit la personnalité de l'agent.

9. Rendez le script exécutable

chmod +x agent.py

10. Exécutez l'agent

python3 agent.py

Vous verrez une invite. Tapez une question. Par exemple :

Vous : Quelle est la capitale de la France ?
Agent : La capitale de la France est Paris.

Appuyez sur Ctrl+C ou tapez `quit` pour quitter.

Exemples d'utilisation

Maintenant que votre agent fonctionne, explorons des cas d'utilisation pratiques. L'agent peut être étendu pour exécuter du code, récupérer des données en direct et s'intégrer à des API.

Exemple 1 : Exécution de code

Modifiez l'agent pour exécuter du code Python. Ajoutez cette fonction à `agent.py` :

def execute_code(code):
    """Exécute du code Python et renvoie le résultat."""
    try:
        local_vars = {}
        exec(code, {}, local_vars)
        return str(local_vars.get('result', 'Code exécuté avec succès.'))
    except Exception as e:
        return f"Erreur : {str(e)}"

Ensuite, dans la fonction `ask_agent()`, détectez si l'utilisateur demande une exécution de code. Pour simplifier, nous ajouterons un mot-clé spécial. Mettez à jour la boucle `main()` :

if user_input.startswith("!code"):
    code = user_input[6:].strip()
    output = execute_code(code)
    print(f"Agent : {output}")
else:
    response = ask_agent(user_input, history)
    print(f"Agent : {response}")

Vous pouvez maintenant exécuter du code :

Vous : !code result = 5 + 3
Agent : 8

Exemple 2 : Récupération de données web

Ajoutez une fonction pour récupérer et résumer du contenu web.

def fetch_url(url):
    """Récupère le contenu d'une URL."""
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()
        # Renvoyer les 2000 premiers caractères
        return response.text[:2000]
    except Exception as e:
        return f"Erreur lors de la récupération de l'URL : {str(e)}"

Ensuite, dans la boucle principale :

elif user_input.startswith("!fetch"):
    url = user_input[7:].strip()
    content = fetch_url(url)
    summary = ask_agent(f"Résumez ce contenu : {content}", history)
    print(f"Agent : {summary}")

Vous pouvez maintenant demander à l'agent de récupérer des actualités :

Vous : !fetch https://openai.com/news
Agent : La page Actualités d'OpenAI montre les annonces récentes concernant les nouveaux modèles et fonctionnalités...

Exemple 3 : Mémoire persistante avec un fichier

Pour donner à votre agent une mémoire à long terme, sauvegardez l'historique des conversations dans un fichier JSON.

import json

SAVE_FILE = "memory.json"

def save_memory(history):
    with open(SAVE_FILE, "w") as f:
        json.dump(history, f)

def load_memory():
    try:
        with open(SAVE_FILE, "r") as f:
            return json.load(f)
    except FileNotFoundError:
        return []

Ajoutez `save_memory(history)` après chaque réponse et `history = load_memory()` au début de `main()`. Maintenant, votre agent se souvient des conversations passées même après un redémarrage.

Exemple 4 : Exécution en tant que service d'arrière-plan

Pour que votre agent fonctionne en permanence, utilisez `systemd`. Créez un fichier de service :

sudo nano /etc/systemd/system/ai-agent.service

Ajoutez :

[Unit]
Description=Service Agent IA
After=network.target

[Service]
Type=simple
User=root
WorkingDirectory=/root/ai-agent
ExecStart=/root/ai-agent/venv/bin/python /root/ai-agent/agent.py
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Ensuite, activez et démarrez :

sudo systemctl daemon-reload
sudo systemctl enable ai-agent
sudo systemctl start ai-agent

Vérifiez le statut :

sudo systemctl status ai-agent

Maintenant, votre agent s'exécute automatiquement au démarrage et redémarre en cas de panne. Vous pouvez consulter les logs avec `journalctl -u ai-agent -f`.

Exemple 5 : Intégration avec Slack ou Discord

Pour un cas d'utilisation plus avancé, vous pouvez exposer votre agent comme un point de terminaison HTTP en utilisant Flask ou FastAPI, puis le connecter à Slack via des webhooks. Cela transforme votre agent en un bot qui répond aux messages en temps réel.

Installez Flask :

pip install flask

Créez un serveur web simple (`web_agent.py`) :

from flask import Flask, request, jsonify
from agent import ask_agent

app = Flask(__name__)

@app.route("/chat", methods=["POST"])
def chat():
    data = request.json
    prompt = data.get("message", "")
    response = ask_agent(prompt)
    return jsonify({"response": response})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

Exécutez-le :

python3 web_agent.py &

Vous pouvez maintenant envoyer des requêtes POST à `http://votre-ip-serveur:5000/chat` avec un corps JSON `{"message": "Bonjour"}`. Connectez ce point de terminaison à Slack en utilisant l'API Slack Events.

Conclusion

Vous avez construit et déployé votre propre agent IA dans le cloud. En partant d'un serveur nu, vous avez installé Python, configuré l'API OpenAI, écrit un agent conversationnel et l'avez étendu avec l'exécution de code, la récupération web et la mémoire persistante. Vous avez également appris à l'exécuter en tant que service d'arrière-plan et à l'exposer comme une API.

Cette base peut être étendue dans de nombreuses directions :

• Ajoutez la prise en charge de Claude d'Anthropic (consultez Anthropic News pour les détails de l'API).
• Intégrez les services Azure AI de Microsoft pour des fonctionnalités d'entreprise.
• Implémentez des modèles d'utilisation d'outils où l'agent décide quelle fonction appeler.
• Ajoutez une interface web avec Gradio ou Streamlit.

Le point essentiel à retenir : construire un agent IA n'est pas magique. C'est un processus structuré qui consiste à connecter des API, gérer l'état et traiter les cas particuliers. Avec l'hébergement cloud, vous obtenez fiabilité et évolutivité. Commencez avec le script simple ci-dessus, puis itérez. Votre agent grandira avec vos besoins.

Alors, lancez-vous maintenant : déployez votre agent et laissez-le travailler pour vous.