# Open Interpreter **Open Interpreter** permite que los modelos de lenguaje ejecuten código, naveguen por la web y editen archivos en tu máquina a través de una interfaz de chat en lenguaje natural. Con más de 57K estrellas en GitHub, es la alternativa de código abierto líder al Code Interpreter de ChatGPT — pero sin límites de sandbox. {% hint style="success" %} Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace). {% endhint %} *** ## ¿Qué es Open Interpreter? Open Interpreter lleva el poder de un asistente de codificación IA directamente a tu terminal. En lugar de copiar y pegar entre ChatGPT y tu shell, chateas de forma natural y el modelo ejecuta código en tiempo real: * **Ejecuta Python, JS, shell, R, AppleScript** — directamente en tu servidor * **Navega por la web** — obtiene páginas, rellena formularios, extrae datos * **Edita archivos** — crea, modifica y gestiona cualquier archivo en el disco * **Estado persistente** — variables, importaciones y resultados sobreviven entre mensajes * **Múltiples backends de LLM** — OpenAI, Anthropic, modelos locales vía Ollama/LlamaCpp {% hint style="info" %} Open Interpreter está diseñado para desarrolladores e investigadores que desean una interfaz conversacional con todo su entorno de cómputo. En un servidor GPU de Clore.ai, obtienes una máquina potente con acceso completo a Internet y sin límites de ejecución. {% endhint %} *** ## Requisitos del servidor | Componente | Mínimo | Recomendado | | -------------- | -------------------------------- | ------------------------------------- | | GPU | Cualquiera (modo CPU disponible) | RTX 3090 / A100 para LLMs locales | | VRAM | — | 24 GB+ para modelos locales de 13B | | RAM | 8 GB | 16 GB+ | | CPU | 4 núcleos | 8+ núcleos | | Almacenamiento | 20 GB | 50 GB+ | | SO | Ubuntu 20.04+ | Ubuntu 22.04 | | Python | 3.10+ | 3.11 | | Red | Requerido | Alta velocidad para la navegación web | *** ## Puertos | Puerto | Servicio | Notas | | ------ | ------------------------- | --------------------------------------------- | | 22 | SSH | Acceso a terminal, túnel para la interfaz web | | 8000 | Servidor Open Interpreter | REST API y UI web opcional | *** ## Inicio rápido con Docker Open Interpreter no tiene una imagen Docker oficial, así que construimos una limpia. Este enfoque te da un entorno reproducible e aislado en cualquier servidor de Clore.ai. ### Dockerfile ```dockerfile FROM python:3.11-slim # Dependencias del sistema RUN apt-get update && apt-get install -y \ git \ curl \ wget \ build-essential \ nodejs \ npm \ chromium \ chromium-driver \ && rm -rf /var/lib/apt/lists/* # Instala Open Interpreter con todos los extras RUN pip install --no-cache-dir \ open-interpreter \ 'open-interpreter[local]' \ playwright \ jupyter # Instala los navegadores de Playwright RUN playwright install chromium WORKDIR /workspace # Exponer puerto del servidor EXPOSE 8000 # Predeterminado: terminal interactivo CMD ["interpreter"] ``` ### Construir y ejecutar ```bash # Construir la imagen docker build -t open-interpreter:latest . # Ejecutar en modo interactivo (chat en terminal) docker run -it --rm \ -e OPENAI_API_KEY=sk-... \ -v $(pwd)/workspace:/workspace \ open-interpreter:latest # Ejecutar como servidor REST API 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 ``` *** ## Instalación en Clore.ai (Bare Metal) Si prefieres ejecutar directamente en un servidor Clore.ai sin Docker: ### Paso 1 — Alquila un servidor 1. Ve a [Mercado de Clore.ai](https://clore.ai/marketplace) 2. Filtrar por **RAM ≥ 16 GB**, **GPU** (opcional pero útil para modelos locales) 3. Elige un servidor con **Imagen base PyTorch** o **Ubuntu** imagen base 4. Abierto **Puerto SSH 22** y opcionalmente **8000** en tu pedido ### Paso 2 — Conéctate vía SSH ```bash ssh root@ -p ``` ### Paso 3 — Instalar dependencias ```bash # Actualizar el sistema apt-get update && apt-get upgrade -y # Instalar Python 3.11 apt-get install -y python3.11 python3.11-venv python3.11-pip nodejs npm curl # Crear entorno virtual python3.11 -m venv /opt/open-interpreter source /opt/open-interpreter/bin/activate ``` ### Paso 4 — Instalar Open Interpreter ```bash # Instalación básica pip install open-interpreter # Con soporte para LLM local (Ollama, LlamaCpp) pip install 'open-interpreter[local]' # Con soporte de navegador/web pip install playwright playwright install chromium ``` ### Paso 5 — Configurar la clave API ```bash # Establecer variable de entorno (añadir a ~/.bashrc para persistencia) export OPENAI_API_KEY=sk-your-key-here export ANTHROPIC_API_KEY=sk-ant-your-key-here # O usar un archivo .env cat > /workspace/.env << 'EOF' OPENAI_API_KEY=sk-your-key-here ANTHROPIC_API_KEY=sk-ant-your-key-here EOF ``` ### Paso 6 — Primer inicio ```bash # Activar entorno source /opt/open-interpreter/bin/activate # Iniciar chat interactivo interpreter # O con modelo específico interpreter --model gpt-4o interpreter --model claude-3-5-sonnet-20241022 ``` *** ## Uso de LLMs locales (no se requiere clave API) Una de las funciones destacadas de Open Interpreter en servidores GPU de Clore.ai es ejecutar modelos completamente locales: ### Opción A: Backend Ollama ```bash # Instalar Ollama curl -fsSL https://ollama.ai/install.sh | sh # Descargar un modelo con capacidad de código ollama pull codellama:13b ollama pull deepseek-coder:6.7b ollama pull mistral:7b # Ejecutar Open Interpreter con Ollama interpreter --model ollama/codellama:13b ``` ### Opción B: Backend LlamaCpp ```bash # Instalar llama-cpp-python con soporte CUDA pip install 'llama-cpp-python[server]' --extra-index-url https://jllllll.github.io/llama-cpp-python-cuBLAS-wheels/AVX2/cu121 # Descargar un modelo GGUF wget https://huggingface.co/TheBloke/CodeLlama-13B-GGUF/resolve/main/codellama-13b.Q4_K_M.gguf # Ejecutar con el modelo local interpreter --local --model /path/to/codellama-13b.Q4_K_M.gguf ``` *** ## Ejecutando como servidor (REST API) Open Interpreter 0.2+ incluye un servidor HTTP incorporado para acceso programático: ```bash # Iniciar el servidor interpreter --server --port 8000 --host 0.0.0.0 # En otro terminal o cliente, enviar solicitudes: curl -X POST http://:8000/run \ -H "Content-Type: application/json" \ -d '{"language": "python", "code": "import os; print(os.listdir(\\".\\"))"}' # Endpoint de chat curl -X POST http://:8000/chat \ -H "Content-Type: application/json" \ -d '{"message": "List all Python files in /workspace and count lines of code"}' ``` ### Túnel SSH para acceso local Si el puerto 8000 no está expuesto públicamente, usa tunelización SSH: ```bash # En tu máquina local ssh -L 8000:localhost:8000 root@ -p -N # Luego abre http://localhost:8000 ``` *** ## Ejemplos prácticos ### Ejemplo 1: Canal de análisis de datos ``` Usuario: Descarga el conjunto de datos MNIST, entrena una CNN simple y grafica las curvas de precisión. Guarda la gráfica como mnist_results.png Open Interpreter: ¡Claro! Haré esto paso a paso... [ejecuta código Python en tiempo real] ``` ```python # Open Interpreter genera y ejecuta: 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() # ... entrena el modelo, grafica resultados, guarda PNG ``` ### Ejemplo 2: Web scraping ``` Usuario: Extrae los 10 repositorios de GitHub con más tendencia hoy y guárdalos en un CSV con nombre, estrellas y descripción. ``` ### Ejemplo 3: Gestión de archivos ``` Usuario: Encuentra todos los archivos .log en /var/log con más de 7 días y comprímelos en un tarball en /backup/logs-$(date).tar.gz ``` ### Ejemplo 4: Script de monitorización del sistema ``` Usuario: Escríbeme un script en Python que supervise el uso de memoria GPU cada 5 segundos y alerte si supera el 90%. Ejecútalo en segundo plano. ``` *** ## Archivo de configuración Crear `~/.interpreter/config.yaml` para establecer valores predeterminados: ```yaml model: gpt-4o temperature: 0 system_message: | Eres un asistente IA útil que se ejecuta en un servidor GPU de Clore.ai. Prefiere siempre código eficiente y listo para producción. Guarda salidas importantes en /workspace/. safe_mode: false auto_run: true verbose: false ``` *** ## Ejecución con systemd (servicio persistente) ```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 ``` *** ## Solución de problemas ### `interpreter` comando no encontrado ```bash # Asegúrate de que el venv esté activado source /opt/open-interpreter/bin/activate # O instala globalmente pip install open-interpreter # Comprueba PATH which interpreter echo $PATH ``` ### La ejecución de código está bloqueada / modo seguro ```bash # Desactivar modo seguro (usar con precaución en servidores de confianza) interpreter --safe_mode false # O en config.yaml: # safe_mode: false # auto_run: true ``` ### Errores de Playwright / navegador ```bash # Instalar dependencias del sistema para 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 ``` ### Falta de memoria con LLMs locales ```bash # Usa un modelo cuantizado más pequeño ollama pull codellama:7b # en lugar de 13b # O reduce la ventana de contexto interpreter --model ollama/codellama:7b --context_window 4096 ``` ### Conexión rechazada en el puerto 8000 ```bash # Comprueba si el servidor está en ejecución ss -tlnp | grep 8000 # Comprueba el firewall ufw allow 8000/tcp # Reiniciar servicio systemctl restart open-interpreter ``` ### Límites de tasa de la API ```bash # Cambiar a Anthropic Claude para límites más altos export ANTHROPIC_API_KEY=sk-ant-... interpreter --model claude-3-5-sonnet-20241022 # O usa un modelo local para evitar por completo los límites de la API interpreter --model ollama/codellama:13b ``` *** ## Consideraciones de seguridad {% hint style="warning" %} Open Interpreter ejecuta código directamente en tu servidor. Siempre: * Ejecuta en un contenedor Docker o VM para uso en producción * Nunca expongas el puerto 8000 públicamente sin autenticación * Usa tunelización SSH para acceso remoto * Audita el código antes de habilitarlo `auto_run: true` para entradas no confiables {% endhint %} *** ## Recomendaciones de GPU en Clore.ai Open Interpreter en sí es ligero — la necesidad de GPU la impulsa el **modelo local** que ejecutes como backend. | GPU | VRAM | Precio en Clore.ai | Recomendación de modelo local | | --------- | ----- | ------------------ | --------------------------------------------------------------------------------- | | RTX 3090 | 24 GB | \~$0.12/h | CodeLlama 13B Q8, Llama 3 8B, Mistral 7B — buena calidad de codificación | | RTX 4090 | 24 GB | \~$0.70/h | CodeLlama 34B Q4, DeepSeek Coder 33B Q4 — calidad de codificación cercana a GPT-4 | | A100 40GB | 40 GB | \~$1.20/h | Llama 3 70B Q4 — agente de codificación autónomo de nivel de producción | | Solo CPU | — | \~$0.02/hr | Cualquier modelo vía API de OpenAI/Anthropic — no se necesita GPU local | {% hint style="info" %} **Si usas la API de OpenAI/Anthropic:** Solo necesitas una instancia con CPU (\~$0.02/hr) — la GPU es irrelevante ya que la inferencia se ejecuta en la nube. Elige instancias GPU solo al ejecutar **modelos locales** para evitar los costes por token de la API. **Mejor configuración local de modelo:** RTX 3090 + Ollama ejecutando `codellama:13b` te brinda un agente de codificación totalmente autónomo y preservador de privacidad sin costes de API por \~$0.12/hr. {% endhint %} *** ## Enlaces útiles * **GitHub**: ⭐ 57K+ * **Documentación**: * **Discord**: * **Mercado de Clore.ai**: * **Modelos de Ollama**: * **Modelos GGUF de HuggingFace**: --- # Agent Instructions: 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: ``` GET https://docs.clore.ai/guides/guides_v2-es/plataformas-y-agentes-de-ia/open-interpreter.md?ask= ``` The question should be specific, self-contained, and written in natural language. 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.