> 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-de/ki-plattformen-and-agenten/open-interpreter.md). # 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. {% hint style="success" %} Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über [CLORE.AI-Marktplatz](https://clore.ai/marketplace). {% endhint %} *** ## 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 {% hint style="info" %} 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. {% endhint %} *** ## 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 ```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 ```bash # 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](https://clore.ai/marketplace) 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 ```bash ssh root@ -p ``` ### Schritt 3 — Abhängigkeiten installieren ```bash # 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 ```bash # 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 ```bash # 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 ```bash # 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 ```bash # 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 ```bash # 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: ```bash # Server starten interpreter --server --port 8000 --host 0.0.0.0 # In einem anderen Terminal oder Client Anfragen senden: curl -X POST http://:8000/run \\ -H "Content-Type: application/json" \\ -d '{"language": "python", "code": "import os; print(os.listdir(\".\"))"}' # Chat-Endpunkt curl -X POST http://: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: ```bash # Auf deinem lokalen Rechner ssh -L 8000:localhost:8000 root@ -p -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] ``` ```python # 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: ```yaml 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) ```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 ``` *** ## Fehlerbehebung ### `interpreter` Befehl nicht gefunden ```bash # 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 ```bash # 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 ```bash # 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 ```bash # 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 ```bash # 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 ```bash # 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 {% hint style="warning" %} 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 {% endhint %} *** ## 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](https://clore.ai/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 | {% hint style="info" %} **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. {% endhint %} *** ## Nützliche Links * **GitHub**: ⭐ 57K+ * **Dokumentation**: * **Discord**: * **Clore.ai-Marktplatz**: * **Ollama-Modelle**: * **HuggingFace-GGUF-Modelle**: --- # 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-de/ki-plattformen-and-agenten/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.