Suna AI : l'agent d'IA généraliste open source

Le domaine de l'intelligence artificielle évolue de plus en plus vers des agents capables de faire plus que simplement traiter l'information – ils peuvent agir. Suna AI émerge dans cet espace en tant qu'agent d'IA généraliste open-source convaincant, conçu pour fonctionner comme un compagnon numérique capable de comprendre les instructions en langage naturel et d'exécuter des tâches complexes et réelles directement en votre nom. Développé par Kortix AI et publié sous la licence permissive Apache 2.0, Suna se différencie en combinant une puissante suite d'outils avec une interface conversationnelle, dans le but de combler le fossé entre l'intention de l'utilisateur et l'action numérique tangible.

Contrairement aux outils d'IA spécialisés, la force de Suna réside dans sa polyvalence. Il est conçu pour orchestrer diverses capacités – de la navigation sur le web et la gestion de fichiers à l'exécution de code et à l'interaction avec les API – le tout piloté par vos invites conversationnelles. Cet article fournit un aperçu des principales capacités et de l'architecture de Suna, suivi d'un tutoriel détaillé, étape par étape, sur la façon de configurer et d'exécuter votre propre instance localement, vous permettant de tirer parti de ce puissant agent d'IA dans votre propre environnement.

💡

Vous voulez un excellent outil de test d'API qui génère une belle documentation d'API ?

Vous voulez une plateforme intégrée, tout-en-un, pour que votre équipe de développeurs travaille ensemble avec une productivité maximale ?

Apidog répond à toutes vos demandes et remplace Postman à un prix beaucoup plus abordable !

button

Qu'est-ce que Suna AI et comment fonctionne Suna AI ?

Pour comprendre ce que Suna peut faire, il est essentiel de saisir les outils qu'il utilise. Ces capacités lui permettent d'interagir avec le monde numérique comme un utilisateur humain, mais de manière automatisée et pilotée par l'IA.

Automatisation du navigateur (via Playwright) : Suna peut lancer et contrôler une instance de navigateur web dans son environnement sécurisé. Cela signifie qu'il peut naviguer vers des URL spécifiques, se connecter à des sites web (si les informations d'identification sont fournies en toute sécurité), cliquer sur des boutons, remplir des formulaires, faire défiler des pages et, surtout, extraire des données directement du contenu des pages web. Cette capacité déverrouille la vaste quantité d'informations et de fonctionnalités disponibles sur le web pour l'automatisation.
Gestion des fichiers : L'agent ne se limite pas aux données web. Il a la capacité d'interagir avec un système de fichiers dans son environnement sandboxé. Cela inclut la création de nouveaux fichiers (comme des rapports ou des exportations de données), la lecture de documents existants, la modification de leur contenu et l'organisation des fichiers en répertoires. Ceci est essentiel pour les tâches qui impliquent la génération de sorties ou le traitement de données locales.
Exploration web et recherche améliorée : Au-delà de la navigation sur une seule page, Suna peut explorer systématiquement des sites web (en suivant les liens) pour collecter des informations complètes. Il peut également s'intégrer à des API de recherche dédiées (comme l'intégration Tavily facultative) pour effectuer une récupération d'informations plus sophistiquée et ciblée que l'utilisation standard des moteurs de recherche, ce qui permet des capacités de recherche plus approfondies.
Exécution en ligne de commande : Dans son conteneur Docker sécurisé, Suna a la possibilité d'exécuter des commandes shell. Cette fonctionnalité puissante lui permet d'exécuter des scripts, d'utiliser d'autres utilitaires de ligne de commande, d'interagir avec les ressources système (dans les limites du conteneur) et potentiellement d'automatiser des tâches telles que les compilations ou les déploiements de logiciels si configuré de manière appropriée. La sécurité est primordiale ici, gérée par l'environnement isolé.
Intégration d'API (via RapidAPI et appels directs) : Suna peut effectuer des appels vers des interfaces de programmation d'applications (API) externes. Cela lui permet de se connecter à un vaste écosystème de services tiers. La documentation met en évidence l'intégration RapidAPI facultative, permettant l'accès à divers fournisseurs de données (par exemple, pour les données LinkedIn, les informations financières, etc.), mais elle peut également être configurée pour interagir directement avec d'autres API RESTful, étendant considérablement son potentiel de collecte de données et de prise d'actions.
Interprétation du code : Suna inclut la possibilité d'exécuter des extraits de code (principalement Python) dans son environnement sécurisé. Ce n'est pas seulement pour exécuter des scripts existants, mais cela permet à l'agent de générer et d'exécuter dynamiquement du code pour effectuer des calculs complexes, des analyses de données, un traitement logique personnalisé ou des transformations qui dépassent les capacités de ses autres outils.

La véritable puissance de Suna réside dans la capacité de l'IA à sélectionner et à séquencer ces outils de manière appropriée en fonction de la demande de l'utilisateur. Une seule instruction peut déclencher un flux de travail impliquant la recherche sur le web, l'extraction de données, leur traitement avec du code interprété, la mise en forme du résultat dans un fichier et sa sauvegarde – le tout géré par l'agent.

L'architecture de Suna : les composants impliqués

Comprendre le processus de configuration nécessite une compréhension de base des principaux composants architecturaux de Suna :

API backend (Python/FastAPI) : La logique de base réside ici. Il gère les demandes des utilisateurs, maintient l'état de la conversation, orchestre l'utilisation des outils de l'agent et gère la communication avec le modèle linguistique volumineux (LLM) choisi via LiteLLM (offrant une flexibilité avec des fournisseurs comme OpenAI et Anthropic).
Frontend (Next.js/React) : Il s'agit de l'application web orientée utilisateur. Il fournit l'interface de chat pour interagir avec Suna, affiche les résultats et comprend des éléments de tableau de bord pour surveiller l'activité de l'agent.
Environnement Docker de l'agent (via Daytona) : La sécurité et l'isolement sont essentiels. Chaque tâche de l'agent s'exécute dans un conteneur Docker dédié géré par Daytona. Ce bac à sable contient tous les outils nécessaires (navigateur, interpréteur de code, accès au système de fichiers) et empêche l'agent d'interférer avec le système hôte.
Base de données Supabase (PostgreSQL) : Gère tous les besoins de persistance des données, y compris les comptes d'utilisateurs et l'authentification, l'historique des conversations, le stockage des fichiers générés par l'agent, le suivi de l'état de l'agent et potentiellement l'analyse.

Ces composants fonctionnent ensemble, communiquant via des API, pour offrir l'expérience Suna. La configuration auto-hébergée implique la configuration et l'exécution de ces parties interconnectées.

Comment configurer Suna AI

Exécuter Suna vous-même offre un contrôle et une confidentialité maximum. Les étapes suivantes vous guident tout au long du processus de configuration :

Phase 1 : Rassembler les prérequis

Avant d'installer Suna, vous avez besoin de plusieurs services et informations d'identification externes :

Projet Supabase :

Inscrivez-vous ou connectez-vous sur supabase.com et créez un nouveau projet.
Accédez aux Paramètres > API de votre projet. Copiez soigneusement votre URL du projet, votre clé publique anon et votre clé secrète service_role.
Installez l'interface de ligne de commande Supabase : Suivez les instructions sur supabase.com/docs/guides/cli.

Base de données Redis :

Option 1 (Cloud - Recommandé) : Utilisez un service comme Upstash (offre une version gratuite). Créez une base de données et enregistrez son hôte/point de terminaison, son port, son mot de passe et notez si SSL/TLS est requis (généralement oui).
Option 2 (Local) : Installez Redis localement (par exemple, brew install redis sur macOS, sudo apt install redis-server sur Debian/Ubuntu, ou via Docker/WSL sur Windows). Notez l'hôte (localhost), le port (généralement 6379), le mot de passe (généralement aucun) et le paramètre SSL (False).

Compte Daytona et configuration de l'image :

Inscrivez-vous sur daytona.io.
Accédez à Paramètres > Clés API et générez une nouvelle clé API. Copiez-la.
Accédez à la section Images. Cliquez sur Ajouter une image.
Nom de l'image : adamcohenhillel/kortix-suna:0.0.20
Point d'entrée : /usr/bin/supervisord -n -c /etc/supervisor/conf.d/supervisord.conf
Enregistrez cette configuration d'image.

Clé API LLM :

Choisissez entre OpenAI (platform.openai.com) ou Anthropic (console.anthropic.com). Obtenez une clé API auprès du fournisseur choisi.
Notez l'identifiant de modèle spécifique que vous prévoyez d'utiliser (par exemple, gpt-4o, anthropic/claude-3-5-sonnet-latest).

(Facultatif) Clé API Tavily : Pour de meilleurs résultats de recherche. Obtenez une clé auprès de Tavily AI.

(Facultatif) Clé RapidAPI : Si vous avez l'intention d'utiliser des intégrations pré-construites en ayant besoin (comme des extracteurs web spécifiques).

Obtenez une clé auprès de rapidapi.com.
N'oubliez pas de vous abonner aux API spécifiques (par exemple, l'extracteur LinkedIn) sur le marché RapidAPI que les outils Suna pourraient utiliser. Vérifiez le répertoire backend/agent/tools/data_providers/ pour le code de l'outil pertinent et les URL de base d'API requises.

Phase 2 : Installation et configuration

Maintenant, configurez les composants de l'application Suna :

Clonez le référentiel :

git clone https://github.com/kortix-ai/suna.git
cd suna

Configurez le backend (.env) :

cd backend
cp .env.example .env (ou créez .env si l'exemple est manquant).
Modifiez .env avec les informations d'identification de la phase 1 :

NEXT_PUBLIC_URL="http://localhost:3000" # Ou votre URL frontend si différente

# Supabase
SUPABASE_URL=YOUR_SUPABASE_URL
SUPABASE_ANON_KEY=YOUR_SUPABASE_ANON_KEY
SUPABASE_SERVICE_ROLE_KEY=YOUR_SUPABASE_SERVICE_ROLE_KEY

# Redis
REDIS_HOST=YOUR_REDIS_HOST
REDIS_PORT=YOUR_REDIS_PORT
REDIS_PASSWORD=YOUR_REDIS_PASSWORD # Laissez vide si aucun
REDIS_SSL=True # Ou False pour Redis local non-SSL

# Daytona
DAYTONA_API_KEY=YOUR_DAYTONA_API_KEY
DAYTONA_SERVER_URL="https://app.daytona.io/api"
DAYTONA_TARGET="us" # Ou votre région

# --- Configuration LLM (REMPLISSEZ UN SEUL ENSEMBLE) ---
# Exemple Anthropic :
ANTHROPIC_API_KEY=YOUR_ANTHROPIC_API_KEY
MODEL_TO_USE="anthropic/claude-3-5-sonnet-latest" # Ou autre modèle Claude
OPENAI_API_KEY=
# Exemple OpenAI :
# ANTHROPIC_API_KEY=
# OPENAI_API_KEY=YOUR_OPENAI_API_KEY
# MODEL_TO_USE="gpt-4o" # Ou autre modèle OpenAI
# -----------------------------------------

# Facultatif
TAVILY_API_KEY=YOUR_TAVILY_API_KEY # Facultatif
RAPID_API_KEY=YOUR_RAPID_API_KEY # Facultatif

Important : Fournissez uniquement les clés d'un fournisseur LLM (soit Anthropic, soit OpenAI).

Configurez le schéma de la base de données Supabase :

Assurez-vous d'être dans le répertoire backend.
Connectez-vous : supabase login
Liez le projet : supabase link --project-ref YOUR_PROJECT_REF_ID (Obtenez l'ID à partir du tableau de bord Supabase).
Appliquez les migrations : supabase db push
Vérifiez le schéma : Accédez au tableau de bord de votre projet Supabase -> Paramètres du projet -> API -> section Schéma sous "Config". Assurez-vous que basejump est répertorié dans "Schémas exposés". Ajoutez-le s'il est manquant et enregistrez.

Configurez le frontend (.env.local) :

cd ../frontend
cp .env.example .env.local (ou créez .env.local).
Modifiez .env.local :

NEXT_PUBLIC_SUPABASE_URL=YOUR_SUPABASE_URL # Identique à backend .env
NEXT_PUBLIC_SUPABASE_ANON_KEY=YOUR_SUPABASE_ANON_KEY # Identique à backend .env
NEXT_PUBLIC_BACKEND_URL="http://localhost:8000/api" # Emplacement backend par défaut
NEXT_PUBLIC_URL="http://localhost:3000" # Emplacement frontend par défaut

Installez les dépendances :

Frontend (Node.js/npm) :

# Dans le répertoire frontend
npm install

Backend (Python 3.11) :

# Dans le répertoire backend (utilisez un environnement virtuel !)
# python -m venv venv
# source venv/bin/activate  OU .\venv\Scripts\activate (Windows)
pip install -r requirements.txt

Phase 3 : Exécution de Suna

Démarrer le service backend :

Ouvrez un terminal.
Accédez à path/to/suna/backend.
Si vous utilisez un environnement virtuel, activez-le (source venv/bin/activate).
Exécutez : python api.py
Recherchez la confirmation que le serveur est en cours d'exécution (probablement sur le port 8000).

Démarrer le service frontend :

Ouvrez un deuxième terminal.
Accédez à path/to/suna/frontend.
Exécutez : npm run dev
Recherchez la confirmation que le serveur est en cours d'exécution (probablement sur le port 3000).

Accédez à votre instance Suna :

Ouvrez un navigateur web et accédez à http://localhost:3000.
Utilisez l'option Inscription pour créer votre compte utilisateur (alimenté par Supabase Auth).
Connectez-vous et commencez à donner des instructions à votre agent Suna auto-hébergé.

Conclusion

Suna AI représente une étape pratique vers des agents d'IA autonomes capables d'exécuter des tâches dans le domaine numérique. Sa nature open-source, combinée à une boîte à outils puissante et à une architecture modulaire, en fait une option attrayante pour les développeurs et les utilisateurs à la recherche d'un assistant d'IA personnalisable et auto-hébergeable. En suivant le processus de configuration détaillé décrit ci-dessus, vous pouvez déployer votre propre instance de Suna, vous accordant une interface conversationnelle pour automatiser la navigation, la manipulation de fichiers, la collecte de données, l'exécution de code, et plus encore, le tout dans un environnement que vous contrôlez. Bien que sa configuration nécessite une attention particulière à ses multiples composants, le résultat est un agent d'IA polyvalent prêt à agir en votre nom.

💡

button