> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/plateformes-et-agents-ia/open-interpreter.md). # Open Interpreter **Open Interpreter** permet aux modèles linguistiques d'exécuter du code, de naviguer sur le web et de modifier des fichiers sur votre machine via une interface de chat en langage naturel. Avec plus de 57K étoiles sur GitHub, c'est l'alternative open-source principale à Code Interpreter de ChatGPT — mais sans limites de sandbox. {% hint style="success" %} Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace). {% endhint %} *** ## Qu'est-ce que Open Interpreter ? Open Interpreter apporte la puissance d'un assistant de codage IA directement à votre terminal. Au lieu de copier-coller entre ChatGPT et votre shell, vous discutez naturellement et le modèle exécute du code en temps réel : * **Exécuter Python, JS, shell, R, AppleScript** — directement sur votre serveur * **Parcourir le web** — récupérer des pages, remplir des formulaires, extraire des données * **Modifier des fichiers** — créer, modifier et gérer n'importe quel fichier sur le disque * **État persistant** — les variables, importations et résultats survivent entre les messages * **Plusieurs backends LLM** — OpenAI, Anthropic, modèles locaux via Ollama/LlamaCpp {% hint style="info" %} Open Interpreter est conçu pour les développeurs et chercheurs qui souhaitent une interface conversationnelle vers l'ensemble de leur environnement de calcul. Sur un serveur GPU Clore.ai, vous disposez d'une machine puissante avec un accès Internet complet et sans limites d'exécution. {% endhint %} *** ## Exigences serveur | Composant | Minimum | Recommandé | | --------- | -------------------------------------- | --------------------------------- | | GPU | N'importe lequel (mode CPU disponible) | RTX 3090 / A100 pour LLM locaux | | VRAM | — | 24 Go+ pour modèles locaux 13B | | RAM | 8 Go | 16 Go+ | | CPU | 4 cœurs | 8+ cœurs | | Stockage | 20 Go | 50 Go+ | | OS | Ubuntu 20.04+ | Ubuntu 22.04 | | Python | 3.10+ | 3.11 | | Réseau | Requis | Haut débit pour la navigation web | *** ## Ports | Port | Service | Remarques | | ---- | ------------------------ | ------------------------------------ | | 22 | SSH | Accès terminal, tunnel pour l'UI web | | 8000 | Serveur Open Interpreter | API REST & interface web optionnelle | *** ## Démarrage rapide avec Docker Open Interpreter n'a pas d'image Docker officielle, donc nous en construisons une propre. Cette approche vous offre un environnement isolé et reproductible sur n'importe quel serveur Clore.ai. ### Dockerfile ```dockerfile FROM python:3.11-slim # Dépendances système RUN apt-get update && apt-get install -y \ git \ curl \ wget \ build-essential \ nodejs \ npm \ chromium \ chromium-driver \ && rm -rf /var/lib/apt/lists/* # Installer Open Interpreter avec toutes les options RUN pip install --no-cache-dir \ open-interpreter \ 'open-interpreter[local]' \ playwright \ jupyter # Installer les navigateurs Playwright RUN playwright install chromium WORKDIR /workspace # Exposer le port du serveur EXPOSE 8000 # Par défaut : terminal interactif CMD ["interpreter"] ``` ### Construire & Exécuter ```bash # Construire l'image docker build -t open-interpreter:latest . # Exécuter en mode interactif (chat terminal) docker run -it --rm \ -e OPENAI_API_KEY=sk-... \ -v $(pwd)/workspace:/workspace \ open-interpreter:latest # Exécuter comme serveur API REST docker run -d \ --name open-interpreter \ -p 8000:8000 \ -e OPENAI_API_KEY=sk-... \ -v $(pwd)/workspace:/workspace \ open-interpreter:latest \ interpreter --server --port 8000 --host 0.0.0.0 ``` *** ## Installation sur Clore.ai (Bare Metal) Si vous préférez exécuter directement sur un serveur Clore.ai sans Docker : ### Étape 1 — Louer un serveur 1. Aller à [Clore.ai Marketplace](https://clore.ai/marketplace) 2. Filtrer par **RAM ≥ 16 Go**, **GPU** (optionnel mais utile pour les modèles locaux) 3. Choisissez un serveur avec un **PyTorch** ou **Ubuntu** image de base 4. Ouvert **Port SSH 22** et éventuellement **8000** dans votre commande ### Étape 2 — Se connecter via SSH ```bash ssh root@ -p ``` ### Étape 3 — Installer les dépendances ```bash # Mettre le système à jour apt-get update && apt-get upgrade -y # Installer Python 3.11 apt-get install -y python3.11 python3.11-venv python3.11-pip nodejs npm curl # Créer un environnement virtuel python3.11 -m venv /opt/open-interpreter source /opt/open-interpreter/bin/activate ``` ### Étape 4 — Installer Open Interpreter ```bash # Installation de base pip install open-interpreter # Avec support des LLM locaux (Ollama, LlamaCpp) pip install 'open-interpreter[local]' # Avec support navigateur/web pip install playwright playwright install chromium ``` ### Étape 5 — Configurer la clé API ```bash # Définir la variable d'environnement (ajouter à ~/.bashrc pour la persistance) export OPENAI_API_KEY=sk-your-key-here export ANTHROPIC_API_KEY=sk-ant-your-key-here # Ou utiliser un fichier .env cat > /workspace/.env << 'EOF' OPENAI_API_KEY=sk-your-key-here ANTHROPIC_API_KEY=sk-ant-your-key-here EOF ``` ### Étape 6 — Premier lancement ```bash # Activer l'environnement source /opt/open-interpreter/bin/activate # Démarrer le chat interactif interpreter # Ou avec un modèle spécifique interpreter --model gpt-4o interpreter --model claude-3-5-sonnet-20241022 ``` *** ## Utilisation de LLM locaux (clé API non requise) L'une des fonctionnalités phares d'Open Interpreter sur les serveurs GPU Clore.ai est d'exécuter entièrement des modèles locaux : ### Option A : Backend Ollama ```bash # Installer Ollama curl -fsSL https://ollama.ai/install.sh | sh # Récupérer un modèle adapté au code ollama pull codellama:13b ollama pull deepseek-coder:6.7b ollama pull mistral:7b # Exécuter Open Interpreter avec Ollama interpreter --model ollama/codellama:13b ``` ### Option B : Backend LlamaCpp ```bash # Installer llama-cpp-python avec support CUDA pip install 'llama-cpp-python[server]' --extra-index-url https://jllllll.github.io/llama-cpp-python-cuBLAS-wheels/AVX2/cu121 # Télécharger un modèle GGUF wget https://huggingface.co/TheBloke/CodeLlama-13B-GGUF/resolve/main/codellama-13b.Q4_K_M.gguf # Exécuter avec le modèle local interpreter --local --model /path/to/codellama-13b.Q4_K_M.gguf ``` *** ## Exécution en tant que serveur (API REST) Open Interpreter 0.2+ inclut un serveur HTTP intégré pour un accès programmatique : ```bash # Démarrer le serveur interpreter --server --port 8000 --host 0.0.0.0 # Dans un autre terminal ou client, envoyer des requêtes : curl -X POST http://:8000/run \ -H "Content-Type: application/json" \ -d '{"language": "python", "code": "import os; print(os.listdir(\\".\\"))"}' # Point de terminaison chat curl -X POST http://:8000/chat \ -H "Content-Type: application/json" \ -d '{"message": "List all Python files in /workspace and count lines of code"}' ``` ### Tunnel SSH pour accès local Si le port 8000 n'est pas exposé publiquement, utilisez le tunneling SSH : ```bash # Sur votre machine locale ssh -L 8000:localhost:8000 root@ -p -N # Puis ouvrez http://localhost:8000 ``` *** ## Exemples pratiques ### Exemple 1 : Pipeline d'analyse de données ``` Utilisateur : Télécharge le jeu de données MNIST, entraîne un CNN simple et trace les courbes de précision. Sauvegarde le graphique sous mnist_results.png Open Interpreter : D'accord ! Je vais procéder étape par étape... [exécute du code Python en temps réel] ``` ```python # Open Interpreter génère et exécute : import tensorflow as tf import matplotlib.pyplot as plt import numpy as np (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data() # ... entraîne le modèle, trace les résultats, sauvegarde le PNG ``` ### Exemple 2 : Scraping web ``` Utilisateur : Récupère les 10 dépôts GitHub les plus en vogue aujourd'hui et sauvegarde-les dans un CSV avec nom, étoiles et description. ``` ### Exemple 3 : Gestion de fichiers ``` Utilisateur : Trouve tous les fichiers .log dans /var/log datant de plus de 7 jours et compresse-les dans une archive tar à /backup/logs-$(date).tar.gz ``` ### Exemple 4 : Script de surveillance système ``` Utilisateur : Écris-moi un script Python qui surveille l'utilisation mémoire GPU toutes les 5 secondes et alerte si elle dépasse 90%. Exécute-le en arrière-plan. ``` *** ## Fichier de configuration Créer `~/.interpreter/config.yaml` pour définir les valeurs par défaut : ```yaml model: gpt-4o temperature: 0 system_message: | Vous êtes un assistant IA utile exécuté sur un serveur GPU Clore.ai. Privilégiez toujours du code efficace et prêt pour la production. Enregistrez les sorties importantes dans /workspace/. safe_mode: false auto_run: true verbose: false ``` *** ## Exécution avec systemd (service persistant) ```ini # /etc/systemd/system/open-interpreter.service [Unit] Description=Open Interpreter Server After=network.target [Service] Type=simple User=root WorkingDirectory=/workspace Environment=OPENAI_API_KEY=sk-your-key ExecStart=/opt/open-interpreter/bin/interpreter --server --port 8000 --host 0.0.0.0 Restart=on-failure RestartSec=10 [Install] WantedBy=multi-user.target ``` ```bash systemctl daemon-reload systemctl enable open-interpreter systemctl start open-interpreter systemctl status open-interpreter ``` *** ## Dépannage ### `interpreter` commande introuvable ```bash # Assurez-vous que le venv est activé source /opt/open-interpreter/bin/activate # Ou installez globalement pip install open-interpreter # Vérifiez le PATH which interpreter echo $PATH ``` ### L'exécution de code est bloquée / mode sécurité ```bash # Désactiver le mode sûr (à utiliser avec prudence sur des serveurs de confiance) interpreter --safe_mode false # Ou dans config.yaml : # safe_mode: false # auto_run: true ``` ### Erreurs Playwright / navigateur ```bash # Installer les dépendances système pour Chromium apt-get install -y \ libnss3 libatk1.0-0 libatk-bridge2.0-0 \ libcups2 libxcomposite1 libxdamage1 \ libxrandr2 libgbm1 libxkbcommon0 playwright install chromium playwright install-deps ``` ### Manque de mémoire avec des LLM locaux ```bash # Utilisez un modèle quantifié plus petit ollama pull codellama:7b # au lieu de 13b # Ou réduisez la fenêtre de contexte interpreter --model ollama/codellama:7b --context_window 4096 ``` ### Connexion refusée sur le port 8000 ```bash # Vérifiez si le serveur est en cours d'exécution ss -tlnp | grep 8000 # Vérifiez le pare-feu ufw allow 8000/tcp # Redémarrer le service systemctl restart open-interpreter ``` ### Limites de taux API ```bash # Passez à Anthropic Claude pour des limites supérieures export ANTHROPIC_API_KEY=sk-ant-... interpreter --model claude-3-5-sonnet-20241022 # Ou utilisez un modèle local pour éviter complètement les limites d'API interpreter --model ollama/codellama:13b ``` *** ## Considérations de sécurité {% hint style="warning" %} Open Interpreter exécute du code directement sur votre serveur. Toujours : * Exécuter dans un conteneur Docker ou une VM pour un usage en production * Ne jamais exposer le port 8000 publiquement sans authentification * Utiliser le tunneling SSH pour l'accès à distance * Auditer le code avant d'activer `auto_run: true` pour les entrées non fiables {% endhint %} *** ## Recommandations GPU Clore.ai Open Interpreter lui-même est léger — le besoin en GPU dépend du modèle **local** que vous exécutez en backend. | GPU | VRAM | Prix Clore.ai | Recommandation de modèle local | | -------------- | ----- | ------------- | --------------------------------------------------------------------------- | | RTX 3090 | 24 Go | \~0,12 $/h | CodeLlama 13B Q8, Llama 3 8B, Mistral 7B — bonne qualité de codage | | RTX 4090 | 24 Go | \~0,70 $/h | CodeLlama 34B Q4, DeepSeek Coder 33B Q4 — qualité de codage proche de GPT-4 | | A100 40GB | 40 Go | \~1,20 $/h | Llama 3 70B Q4 — agent de codage autonome de niveau production | | CPU uniquement | — | \~0,02$/h | N'importe quel modèle via l'API OpenAI/Anthropic — pas de GPU local requis | {% hint style="info" %} **Si vous utilisez l'API OpenAI/Anthropic :** Vous n'avez besoin que d'une instance CPU (\~0,02$/h) — le GPU est sans importance puisque l'inférence s'exécute dans le cloud. Choisissez des instances GPU uniquement lorsque vous exécutez **des modèles locaux** pour éviter les coûts par token de l'API. **Meilleure configuration locale :** RTX 3090 + Ollama exécutant `codellama:13b` vous offre un agent de codage pleinement autonome et respectueux de la vie privée sans coûts d'API pour environ 0,12$/h. {% endhint %} *** ## Liens utiles * **GitHub**: ⭐ 57K+ * **Documentation**: * **Discord**: * **Clore.ai Marketplace**: * **Modèles Ollama**: * **Modèles GGUF HuggingFace**: --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-fr/plateformes-et-agents-ia/open-interpreter.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.