> 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-es/plataformas-y-agentes-de-ia/open-interpreter.md). # 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 principal alternativa de código abierto 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 [Marketplace de CLORE.AI](https://clore.ai/marketplace). {% endhint %} *** ## ¿Qué es Open Interpreter? Open Interpreter lleva el poder de un asistente de programación con 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 administra cualquier archivo en el disco * **Estado persistente** — las variables, importaciones y resultados sobreviven entre mensajes * **Múltiples backends LLM** — OpenAI, Anthropic, modelos locales vía Ollama/LlamaCpp {% hint style="info" %} Open Interpreter está diseñado para desarrolladores e investigadores que quieren una interfaz conversacional para 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 navegar por la web | *** ## Puertos | Puerto | Servicio | Notas | | ------ | ---------------------------- | ------------------------------------------- | | 22 | SSH | Acceso al terminal, túnel para interfaz web | | 8000 | Servidor de Open Interpreter | API REST y UI web opcional | *** ## Inicio rápido con Docker Open Interpreter no tiene una imagen oficial de Docker, así que construimos una limpia. Este enfoque te brinda un entorno reproducible y 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 el puerto del servidor EXPOSE 8000 # Predeterminado: terminal interactiva CMD ["interpreter"] ``` ### Compilar y ejecutar ```bash # Compila 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 de 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 ``` *** ## Instalación en Clore.ai (Bare Metal) Si prefieres ejecutarlo directamente en un servidor de Clore.ai sin Docker: ### Paso 1 — Alquilar un servidor 1. Ve a [Marketplace 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 **PyTorch** o **Ubuntu** base 4. Abre **puerto SSH 22** y opcionalmente **8000** en tu pedido ### Paso 2 — Conectarse vía SSH ```bash ssh root@ -p ``` ### Paso 3 — Instalar dependencias ```bash # Actualiza el sistema apt-get update && apt-get upgrade -y # Instala Python 3.11 apt-get install -y python3.11 python3.11-venv python3.11-pip nodejs npm curl # Crea un 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 locales (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 # Define la variable de entorno (añádela a ~/.bashrc para que persista) export OPENAI_API_KEY=sk-your-key-here export ANTHROPIC_API_KEY=sk-ant-your-key-here # O usa 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 — Primera ejecución ```bash # Activa el entorno source /opt/open-interpreter/bin/activate # Inicia el chat interactivo interpreter # O con un modelo específico interpreter --model gpt-4o interpreter --model claude-3-5-sonnet-20241022 ``` *** ## Uso de LLM locales (no requiere clave API) Una de las funciones estrella de Open Interpreter en los servidores GPU de Clore.ai es ejecutar modelos completamente locales: ### Opción A: backend de Ollama ```bash # Instalar Ollama curl -fsSL https://ollama.ai/install.sh | sh # Descarga un modelo capaz de programar ollama pull codellama:13b ollama pull deepseek-coder:6.7b ollama pull mistral:7b # Ejecuta Open Interpreter con Ollama interpreter --model ollama/codellama:13b ``` ### Opción B: backend de LlamaCpp ```bash # Instala 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 # Descarga un modelo GGUF wget https://huggingface.co/TheBloke/CodeLlama-13B-GGUF/resolve/main/codellama-13b.Q4_K_M.gguf # Ejecuta con el modelo local interpreter --local --model /path/to/codellama-13b.Q4_K_M.gguf ``` *** ## Ejecutándolo como servidor (API REST) Open Interpreter 0.2+ incluye un servidor HTTP integrado para acceso programático: ```bash # Inicia el servidor interpreter --server --port 8000 --host 0.0.0.0 # En otra terminal o cliente, envía 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": "Lista todos los archivos de Python en /workspace y cuenta las líneas de código"}' ``` ### Túnel SSH para acceso local Si el puerto 8000 no está expuesto públicamente, usa túnel 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: canalización de análisis de datos ``` Usuario: Descarga el conjunto de datos MNIST, entrena una CNN sencilla y traza curvas de precisión. Guarda la gráfica como mnist_results.png Open Interpreter: ¡Claro! Lo haré 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, traza resultados, guarda PNG ``` ### Ejemplo 2: raspado web ``` Usuario: Extrae hoy los 10 principales repositorios de GitHub en tendencia 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 de Python que monitorice el uso de memoria de la 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 de IA útil que se ejecuta en un servidor GPU de Clore.ai. Prioriza siempre código eficiente y listo para producción. Guarda los resultados importantes en /workspace/. safe_mode: false auto_run: true verbose: false ``` *** ## Ejecutándolo con systemd (servicio persistente) ```ini # /etc/systemd/system/open-interpreter.service [Unit] Description=Servidor de 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 ``` ```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 instálalo globalmente pip install open-interpreter # Comprueba PATH which interpreter echo $PATH ``` ### La ejecución de código está bloqueada / modo de seguridad ```bash # Desactiva el modo de seguridad (úsalo 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 # Instala las 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 memoria con LLM 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 # Reinicia el servicio systemctl restart open-interpreter ``` ### Límites de tasa de la API ```bash # Cambia 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 una VM para uso en producción * Nunca expongas el puerto 8000 públicamente sin autenticación * Usa túnel SSH para acceso remoto * Audita el código antes de habilitarlo `auto_run: true` para entradas no confiables {% endhint %} *** ## Recomendaciones de GPU para Clore.ai Open Interpreter en sí es liviano — la necesidad de GPU está determinada por el **modelo local** que ejecutes como backend. | GPU | VRAM | Precio de Clore.ai | Recomendación de modelo local | | --------- | ----- | ----------------------------------------- | ---------------------------------------------------------------------------------------- | | RTX 3090 | 24 GB | $0.07–0.21/h | CodeLlama 13B Q8, Llama 3 8B, Mistral 7B — calidad de programación sólida | | RTX 4090 | 24 GB | $0.14–0.42/h | CodeLlama 34B Q4, DeepSeek Coder 33B Q4 — calidad de programación casi al nivel de GPT-4 | | A100 40GB | 40 GB | [bare metal](https://clore.ai/bare-metal) | 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 estás usando la API de OpenAI/Anthropic:** Solo necesitas una instancia CPU (\~$0.02/hr) — la GPU es irrelevante, ya que la inferencia se ejecuta en la nube. Elige instancias GPU solo cuando ejecutes **modelos locales** para evitar costos de API por token. **Mejor configuración de modelo local:** RTX 3090 + Ollama ejecutando `codellama:13b` te brinda un agente de codificación totalmente autónomo, que preserva la privacidad y sin costos de API por $0.07–0.21/hr. {% endhint %} *** ## Enlaces útiles * **GitHub**: ⭐ 57K+ * **Documentación**: * **Discord**: * **Marketplace de Clore.ai**: * **Modelos de Ollama**: * **Modelos GGUF de HuggingFace**: --- # 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-es/plataformas-y-agentes-de-ia/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.