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.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

---

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

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.

---

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

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

# 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

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

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

Étape 3 — Installer les dépendances

# 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

# 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

# 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

# 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

# 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

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

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

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

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

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)

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

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

---

Dépannage

interpreter commande introuvable

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

# 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

# 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

# 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émarrez le service
systemctl restart open-interpreter

Limites de débit de l'API

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

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

---

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

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.

---

Liens utiles

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

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

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

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

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

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