Open Interpreter

Open Interpreter Lässt Sprachmodelle Code ausführen, im Web surfen und Dateien auf deinem Rechner über eine Chat-Oberfläche in natürlicher Sprache bearbeiten. Mit über 57.000 GitHub-Sternen ist es die führende Open-Source-Alternative zu ChatGPTs Code Interpreter — aber ohne Sandbox-Beschränkungen.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

---

Was ist Open Interpreter?

Open Interpreter bringt die Leistung eines KI-Coding-Assistenten direkt in dein Terminal. Statt zwischen ChatGPT und deiner Shell hin- und herzukopieren, chattest du natürlich und das Modell führt Code in Echtzeit aus:

• Führe Python, JS, Shell, R, AppleScript aus — direkt auf deinem Server

• Im Web surfen — Seiten abrufen, Formulare ausfüllen, Daten extrahieren

• Dateien bearbeiten — jede Datei auf der Festplatte erstellen, ändern und verwalten

• Persistenter Zustand — Variablen, Imports und Ergebnisse bleiben über Nachrichten hinweg erhalten

• Mehrere LLM-Backends — OpenAI, Anthropic, lokale Modelle über Ollama/LlamaCpp

Open Interpreter ist für Entwickler und Forscher konzipiert, die eine dialogbasierte Oberfläche für ihre gesamte Computerumgebung wollen. Auf einem Clore.ai-GPU-Server erhältst du eine leistungsstarke Maschine mit vollem Internetzugang und ohne Ausführungslimits.

---

Serveranforderungen

Komponente	Minimum	Empfohlen
GPU	Beliebig (CPU-Modus verfügbar)	RTX 3090 / A100 für lokale LLMs
VRAM	—	24 GB+ für lokale 13B-Modelle
RAM	8 GB	16 GB+
CPU	4 Kerne	8+ Kerne
Speicher	20 GB	50 GB+
Betriebssystem	Ubuntu 20.04+	Ubuntu 22.04
Python	3.10+	3.11
Netzwerk	Erforderlich	Hochgeschwindigkeit fürs Surfen im Web

---

Ports

Port	Dienst	Hinweise
22	SSH	Terminalzugriff, Tunnel für Web-UI
8000	Open-Interpreter-Server	REST-API & optionale Web-UI

---

Schnellstart mit Docker

Open Interpreter hat kein offizielles Docker-Image, deshalb bauen wir ein sauberes. Dieser Ansatz bietet dir eine reproduzierbare, isolierte Umgebung auf jedem Clore.ai-Server.

Dockerfile

FROM python:3.11-slim

# Systemabhängigkeiten
RUN apt-get update && apt-get install -y \
    git \
    curl \
    wget \
    build-essential \
    nodejs \\
    npm \\
    chromium \\
    chromium-driver \\
    && rm -rf /var/lib/apt/lists/*

# Installiere Open Interpreter mit allen Extras
RUN pip install --no-cache-dir \
    open-interpreter \\
    'open-interpreter[local]' \\
    playwright \\
    jupyter

# Installiere Playwright-Browser
RUN playwright install chromium

WORKDIR /workspace

# Server-Port freigeben
EXPOSE 8000

# Standard: interaktives Terminal
CMD ["interpreter"]

Bauen & Ausführen

# Das Image bauen
docker build -t open-interpreter:latest .

# Interaktiven Modus ausführen (Terminal-Chat)
docker run -it --rm \\
  -e OPENAI_API_KEY=sk-... \\
  -v $(pwd)/workspace:/workspace \\
  open-interpreter:latest

# Als REST-API-Server ausführen
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 auf Clore.ai (Bare Metal)

Wenn du es lieber direkt auf einem Clore.ai-Server ohne Docker ausführst:

Schritt 1 — Einen Server mieten

1. Gehe zu Clore.ai-Marktplatz

2. Filtern nach RAM ≥ 16 GB, GPU (optional, aber nützlich für lokale Modelle)

3. Wähle einen Server mit einem PyTorch oder Ubuntu Basis-Image

4. Öffnen SSH-Port 22 und optional 8000 in deiner Bestellung

Schritt 2 — Per SSH verbinden

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

Schritt 3 — Abhängigkeiten installieren

# System aktualisieren
apt-get update && apt-get upgrade -y

# Python 3.11 installieren
apt-get install -y python3.11 python3.11-venv python3.11-pip nodejs npm curl

# Virtuelle Umgebung erstellen
python3.11 -m venv /opt/open-interpreter
source /opt/open-interpreter/bin/activate

Schritt 4 — Open Interpreter installieren

# Basisinstallation
pip install open-interpreter

# Mit Unterstützung für lokale LLMs (Ollama, LlamaCpp)
pip install 'open-interpreter[local]'

# Mit Browser-/Web-Unterstützung
pip install playwright
playwright install chromium

Schritt 5 — API-Schlüssel konfigurieren

# Umgebungsvariable setzen (für Persistenz zu ~/.bashrc hinzufügen)
export OPENAI_API_KEY=sk-your-key-here
export ANTHROPIC_API_KEY=sk-ant-your-key-here

# Oder eine .env-Datei verwenden
cat > /workspace/.env << 'EOF'
OPENAI_API_KEY=sk-your-key-here
ANTHROPIC_API_KEY=sk-ant-your-key-here
EOF

Schritt 6 — Erster Start

# Umgebung aktivieren
source /opt/open-interpreter/bin/activate

# Interaktiven Chat starten
interpreter

# Oder mit einem bestimmten Modell
interpreter --model gpt-4o
interpreter --model claude-3-5-sonnet-20241022

---

Lokale LLMs verwenden (kein API-Schlüssel erforderlich)

Eine der herausragenden Funktionen von Open Interpreter auf Clore.ai-GPU-Servern ist, dass es vollständig lokale Modelle ausführt:

Option A: Ollama-Backend

# Ollama installieren
curl -fsSL https://ollama.ai/install.sh | sh

# Ein codefähiges Modell herunterladen
ollama pull codellama:13b
ollama pull deepseek-coder:6.7b
ollama pull mistral:7b

# Open Interpreter mit Ollama ausführen
interpreter --model ollama/codellama:13b

Option B: LlamaCpp-Backend

# llama-cpp-python mit CUDA-Unterstützung installieren
pip install 'llama-cpp-python[server]' --extra-index-url https://jllllll.github.io/llama-cpp-python-cuBLAS-wheels/AVX2/cu121

# Ein GGUF-Modell herunterladen
wget https://huggingface.co/TheBloke/CodeLlama-13B-GGUF/resolve/main/codellama-13b.Q4_K_M.gguf

# Mit dem lokalen Modell ausführen
interpreter --local --model /path/to/codellama-13b.Q4_K_M.gguf

---

Als Server ausführen (REST-API)

Open Interpreter 0.2+ enthält einen integrierten HTTP-Server für den programmgesteuerten Zugriff:

# Server starten
interpreter --server --port 8000 --host 0.0.0.0

# In einem anderen Terminal oder Client Anfragen senden:
curl -X POST http://<server-ip>:8000/run \\
  -H "Content-Type: application/json" \\
  -d '{"language": "python", "code": "import os; print(os.listdir(\".\"))"}'

# Chat-Endpunkt
curl -X POST http://<server-ip>:8000/chat \\
  -H "Content-Type: application/json" \\
  -d '{"message": "Liste alle Python-Dateien in /workspace auf und zähle die Codezeilen"}'

SSH-Tunnel für lokalen Zugriff

Wenn Port 8000 nicht öffentlich freigegeben ist, verwende SSH-Tunneling:

# Auf deinem lokalen Rechner
ssh -L 8000:localhost:8000 root@<server-ip> -p <ssh-port> -N
# Dann http://localhost:8000 öffnen

---

Praktische Beispiele

Beispiel 1: Datenanalyse-Pipeline

Benutzer: Lade den MNIST-Datensatz herunter, trainiere ein einfaches CNN und zeichne Genauigkeitskurven. Speichere die Grafik als mnist_results.png

Open Interpreter: Sicher! Ich mache das Schritt für Schritt...
[führt Python-Code in Echtzeit aus]

# Open Interpreter erzeugt und führt aus:
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()
# ... trainiert das Modell, zeichnet Ergebnisse, speichert PNG

Beispiel 2: Web-Scraping

Benutzer: Scrape heute die 10 angesagtesten GitHub-Repositories und speichere sie in einer CSV mit Name, Sternen und Beschreibung.

Beispiel 3: Dateiverwaltung

Benutzer: Finde alle .log-Dateien in /var/log, die älter als 7 Tage sind, und komprimiere sie in ein Tarball unter /backup/logs-$(date).tar.gz

Beispiel 4: Systemüberwachungs-Skript

Benutzer: Schreibe mir ein Python-Skript, das alle 5 Sekunden die GPU-Speichernutzung überwacht und alarmiert, wenn sie 90 % überschreitet. Führe es im Hintergrund aus.

---

Konfigurationsdatei

Erstelle ~/.interpreter/config.yaml um Standardwerte festzulegen:

model: gpt-4o
temperature: 0
system_message: |
  Du bist ein hilfreicher KI-Assistent, der auf einem Clore.ai-GPU-Server läuft.
  Verwende stets effizienten, produktionsreifen Code.
  Speichere wichtige Ausgaben in /workspace/.
safe_mode: false
auto_run: true
verbose: false

---

Ausführung mit systemd (persistenter Dienst)

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

---

Fehlerbehebung

interpreter Befehl nicht gefunden

# Stelle sicher, dass die venv aktiviert ist
source /opt/open-interpreter/bin/activate

# Oder global installieren
pip install open-interpreter

# PATH überprüfen
which interpreter
echo $PATH

Codeausführung ist blockiert / Sicherheitsmodus

# Sicherheitsmodus deaktivieren (auf vertrauenswürdigen Servern mit Vorsicht verwenden)
interpreter --safe_mode false

# Oder in config.yaml:
# safe_mode: false
# auto_run: true

Playwright-/Browser-Fehler

# Systemabhängigkeiten für Chromium installieren
apt-get install -y \\
    libnss3 libatk1.0-0 libatk-bridge2.0-0 \\
    libcups2 libxcomposite1 libxdamage1 \\
    libxrandr2 libgbm1 libxkbcommon0

playwright install chromium
playwright install-deps

Zu wenig Speicher bei lokalen LLMs

# Ein kleineres quantisiertes Modell verwenden
ollama pull codellama:7b  # statt 13b

# Oder das Kontextfenster verkleinern
interpreter --model ollama/codellama:7b --context_window 4096

Verbindung auf Port 8000 abgelehnt

# Prüfen, ob der Server läuft
ss -tlnp | grep 8000

# Firewall prüfen
ufw allow 8000/tcp

# Dienst neu starten
systemctl restart open-interpreter

API-Rate-Limits

# Zu Anthropic Claude mit höheren Limits wechseln
export ANTHROPIC_API_KEY=sk-ant-...
interpreter --model claude-3-5-sonnet-20241022

# Oder ein lokales Modell verwenden, um API-Limits vollständig zu umgehen
interpreter --model ollama/codellama:13b

---

Sicherheitsaspekte

Open Interpreter führt Code direkt auf deinem Server aus. Immer:

• Für den produktiven Einsatz in einem Docker-Container oder einer VM ausführen

• Port 8000 niemals ohne Authentifizierung öffentlich freigeben

• Für den Fernzugriff SSH-Tunneling verwenden

• Den Code vor dem Aktivieren prüfen auto_run: true für nicht vertrauenswürdige Eingaben

---

GPU-Empfehlungen für Clore.ai

Open Interpreter selbst ist leichtgewichtig — der GPU-Bedarf wird von dem jeweiligen lokalen Modell bestimmt, das du als Backend ausführst.

GPU	VRAM	Clore.ai-Preis	Empfehlung für lokale Modelle
RTX 3090	24 GB	ca. 0,07–0,21 $/h	CodeLlama 13B Q8, Llama 3 8B, Mistral 7B — solide Codequalität
RTX 4090	24 GB	ca. 0,14–0,42 $/h	CodeLlama 34B Q4, DeepSeek Coder 33B Q4 — Codequalität fast auf GPT-4-Niveau
A100 40GB	40 GB	Bare Metal	Llama 3 70B Q4 — autonomer Coding-Agent in Produktionsqualität
Nur CPU	—	~$0,02/Stunde	Beliebiges Modell über die OpenAI-/Anthropic-API — keine lokale GPU erforderlich

Wenn du die OpenAI-/Anthropic-API verwendest: Du benötigst nur eine CPU-Instanz (~$0,02/Stunde) — die GPU ist irrelevant, da die Inferenz in der Cloud läuft. Wähle GPU-Instanzen nur, wenn du lokale Modelle ausführst, um Kosten pro Token für die API zu vermeiden.

Beste lokale Modellkonfiguration: RTX 3090 + laufendes Ollama codellama:13b bietet dir für 0,07–0,21 $/Stunde einen vollständig autonomen, datenschutzfreundlichen Coding-Agenten ohne API-Kosten.

---

Nützliche Links

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

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

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

• Clore.ai-Marktplatz: https://clore.ai/marketplace

• Ollama-Modelle: https://ollama.ai/library

• HuggingFace-GGUF-Modelle: https://huggingface.co/TheBloke