> 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-ia-et-agents/open-interpreter.md). # Open Interpreter **Open Interpreter** permet aux modèles de langage 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 57 k étoiles GitHub, c'est la principale alternative open source à Code Interpreter de ChatGPT — mais sans les limites du sandbox. {% hint style="success" %} Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [la place de marché CLORE.AI](https://clore.ai/marketplace). {% endhint %} *** ## Qu'est-ce qu'Open Interpreter ? Open Interpreter apporte la puissance d'un assistant de codage IA directement dans votre terminal. Au lieu de copier-coller entre ChatGPT et votre shell, vous discutez naturellement et le modèle exécute le code en temps réel : * **Exécuter Python, JS, shell, R, AppleScript** — directement sur votre serveur * **Naviguer sur 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, les imports et les résultats persistent d'un message à l'autre * **Plusieurs backends de LLM** — OpenAI, Anthropic, modèles locaux via Ollama/LlamaCpp {% hint style="info" %} Open Interpreter est conçu pour les développeurs et les chercheurs qui veulent une interface conversationnelle avec l'ensemble de leur environnement de calcul. Sur un serveur GPU Clore.ai, vous obtenez une machine puissante avec un accès Internet complet et sans limites d'exécution. {% endhint %} *** ## Exigences du serveur | Composant | Minimum | Recommandé | | ---------------------- | -------------------------------------- | ------------------------------------ | | GPU | N'importe lequel (mode CPU disponible) | RTX 3090 / A100 pour les LLM locaux | | VRAM | — | 24 Go+ pour les modèles locaux 13B | | RAM | 8 Go | 16 Go+ | | CPU | 4 cœurs | 8 cœurs ou plus | | Stockage | 20 Go | 50 Go+ | | Système d'exploitation | Ubuntu 20.04+ | Ubuntu 22.04 | | Python | 3.10+ | 3.11 | | Réseau | Requis | Haute vitesse pour la navigation web | *** ## Ports | Port | Service | Remarques | | ---- | ------------------------ | ---------------------------------------------- | | 22 | SSH | Accès au terminal, tunnel pour l'interface web | | 8000 | Serveur Open Interpreter | API REST et interface web facultative | *** ## Démarrage rapide avec Docker Open Interpreter n'a pas d'image Docker officielle, alors nous en construisons une propre. Cette approche vous offre un environnement reproductible et isolé 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 tous les extras 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 et exécuter ```bash # Construisez l'image docker build -t open-interpreter:latest . # Exécuter en mode interactif (chat dans le terminal) docker run -it --rm \\ -e OPENAI_API_KEY=sk-... \\ -v $(pwd)/workspace:/workspace \\ open-interpreter:latest # Exécuter comme serveur d'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 l'exécuter directement sur un serveur Clore.ai sans Docker : ### Étape 1 — Louer un serveur 1. Accédez à [Marketplace Clore.ai](https://clore.ai/marketplace) 2. Filtrer par **RAM ≥ 16 Go**, **GPU** (facultatif mais utile pour les modèles locaux) 3. Choisissez un serveur avec un **PyTorch** ou **Ubuntu** image de base 4. Ouvrez **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 à jour le système 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 prise en charge des LLM locaux (Ollama, LlamaCpp) pip install 'open-interpreter[local]' # Avec prise en charge du navigateur/web pip install playwright playwright install chromium ``` ### Étape 5 — Configurer la clé API ```bash # Définir la variable d'environnement (ajoutez-la à ~/.bashrc pour la conserver) 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 — Première exécution ```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 (aucune clé API requise) L'une des fonctionnalités phares d'Open Interpreter sur les serveurs GPU Clore.ai est l'exécution entièrement locale de modèles : ### Option A : Backend Ollama ```bash # Installer Ollama curl -fsSL https://ollama.ai/install.sh | sh # Télécharger un modèle capable de coder 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 la prise en charge 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 de chat curl -X POST http://:8000/chat \\ -H "Content-Type: application/json" \ -d '{"message": "Lister tous les fichiers Python dans /workspace et compter les lignes de code"}' ``` ### Tunnel SSH pour un 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échargez le jeu de données MNIST, entraînez un CNN simple et tracez les courbes de précision. Enregistrez le graphique sous mnist_results.png Open Interpreter : Bien sûr ! Je vais faire cela é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, enregistre le PNG ``` ### Exemple 2 : Extraction web ``` Utilisateur : Récupérez les 10 principaux dépôts GitHub tendance du jour et enregistrez-les dans un CSV avec le nom, les étoiles et la description. ``` ### Exemple 3 : Gestion de fichiers ``` Utilisateur : Trouvez tous les fichiers .log dans /var/log datant de plus de 7 jours et compressez-les dans une archive tar à /backup/logs-$(date).tar.gz ``` ### Exemple 4 : Script de surveillance du système ``` Utilisateur : Écrivez-moi un script Python qui surveille l'utilisation de la mémoire GPU toutes les 5 secondes et alerte si elle dépasse 90 %. Exécutez-le en arrière-plan. ``` *** ## Fichier de configuration Créez un fichier `~/.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 un 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=Serveur Open Interpreter 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 # Vérifiez que l'environnement virtuel 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 du code est bloquée / mode sécurité ```bash # Désactivez le mode sécurisé (à utiliser avec prudence sur les 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 ``` ### Mémoire insuffisante avec les 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émarrez le service systemctl restart open-interpreter ``` ### Limites de débit de l'API ```bash # Passez à Anthropic Claude pour des limites plus élevées 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 de l'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écutez-le dans un conteneur Docker ou une VM pour un usage en production * N'exposez jamais publiquement le port 8000 sans authentification * Utilisez le tunneling SSH pour l'accès à distance * Auditez le code avant de l'activer `auto_run: true` pour des entrées non fiables {% endhint %} *** ## Recommandations GPU Clore.ai Open Interpreter lui-même est léger — le besoin en GPU est déterminé par le **modèle local** que vous utilisez comme backend. | GPU | VRAM | Prix Clore.ai | Recommandation de modèle local | | -------------- | ----- | ----------------------------------------- | ------------------------------------------------------------------------------------ | | RTX 3090 | 24 Go | 0,07–0,21 $/h | CodeLlama 13B Q8, Llama 3 8B, Mistral 7B — qualité de codage solide | | RTX 4090 | 24 Go | 0,14–0,42 $/h | CodeLlama 34B Q4, DeepSeek Coder 33B Q4 — qualité de codage proche de celle de GPT-4 | | A100 40 Go | 40 Go | [bare metal](https://clore.ai/bare-metal) | 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 — aucun GPU local nécessaire | {% 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** afin d'éviter les coûts de l'API par jeton. **Meilleure configuration de modèle local :** RTX 3090 + Ollama en cours d'exécution `codellama:13b` vous offre un agent de codage entièrement autonome et respectueux de la vie privée, sans coûts d'API, pour 0,07–0,21 $/h. {% endhint %} *** ## Liens utiles * **GitHub**: ⭐ 57 k+ * **Documentation**: * **Discord**: * **Marketplace Clore.ai**: * **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, and the optional `goal` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-fr/plateformes-ia-et-agents/open-interpreter.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. 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.