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.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

---

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

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.

---

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

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

# 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

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

ssh root@<server-ip> -p <ssh-port>

Étape 3 — Installer les dépendances

# 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

# 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

# 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

# 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

# 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

# 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 :

# 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://<server-ip>:8000/run \
  -H "Content-Type: application/json" \
  -d '{"language": "python", "code": "import os; print(os.listdir(\\".\\"))"}'

# Point de terminaison chat
curl -X POST http://<server-ip>: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 :

# Sur votre machine locale
ssh -L 8000:localhost:8000 root@<server-ip> -p <ssh-port> -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]

# 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 :

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)

# /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

systemctl daemon-reload
systemctl enable open-interpreter
systemctl start open-interpreter
systemctl status open-interpreter

---

Dépannage

interpreter commande introuvable

# 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é

# 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

# 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

# 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

# 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

# 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é

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

---

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

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.

---

Liens utiles

• GitHub: https://github.com/OpenInterpreter/open-interpreter ⭐ 57K+

• Documentation: https://docs.openinterpreter.com

• Discord: https://discord.gg/Hvz9Axh84z

• Clore.ai Marketplace: https://clore.ai/marketplace

• Modèles Ollama: https://ollama.ai/library

• Modèles GGUF HuggingFace: https://huggingface.co/TheBloke