Integraciones de IDE y herramientas

Docker Model Runner puede servir como backend local para asistentes de codificación de IA y herramientas de desarrollo populares. Esta guía muestra cómo configurar herramientas comunes para utilizar modelos ejecutándose en DMR.

Requisitos previos

Antes de configurar cualquier herramienta:

1. Habilita Docker Model Runner en Docker Desktop o Docker Engine.
2. Habilita el acceso TCP del host:
   • Docker Desktop: habilita el host-side TCP support en Settings > AI, o ejecuta:

     $ docker desktop enable model-runner --tcp 12434
     

   • Docker Engine: TCP está habilitado por defecto en el puerto 12434.
3. Descarga un modelo:

   $ docker model pull ai/qwen2.5-coder
   

Tip

El tamaño de contexto predeterminado para muchos modelos (como gpt-oss) es de 4,096 tokens, lo cual es limitante para tareas de programación. Puedes volver a empaquetarlo con una ventana de contexto más grande:

$ docker model pull gpt-oss
$ docker model package --from ai/gpt-oss --context-size 32000 gpt-oss:32k

Alternativamente, modelos como ai/glm-4.7-flash, ai/qwen2.5-coder y ai/devstral-small-2 vienen con un contexto de 128K por defecto y funcionan sin necesidad de volver a empaquetarlos.

Cline (VS Code)

Cline es un asistente de codificación de IA para VS Code.

Configuración

1. Abre VS Code y ve a la configuración de la extensión Cline.
2. Selecciona OpenAI Compatible como proveedor de API.
3. Configura los siguientes ajustes:

Important

La URL base debe incluir /engines/v1 al final. No incluyas una barra diagonal final.

Resolución de problemas de Cline

Si Cline no logra conectarse:

1. Verifica que DMR se esté ejecutando:

   $ docker model status
   

2. Prueba el endpoint directamente:

   $ curl http://localhost:12434/engines/v1/models
   

3. Comprueba que CORS esté configurado si ejecutas una versión basada en web:

   • En Docker Desktop Settings > AI, añade tu origen a CORS Allowed Origins

Continue (VS Code / JetBrains)

Continue es un asistente de código de IA de código abierto que funciona con VS Code y los IDE de JetBrains.

Configuración

Edita tu archivo de configuración de Continue (~/.continue/config.json):

{
  "models": [
    {
      "title": "Docker Model Runner",
      "provider": "openai",
      "model": "ai/qwen2.5-coder",
      "apiBase": "http://localhost:12434/engines/v1",
      "apiKey": "not-needed"
    }
  ]
}

Usar el proveedor de Ollama

Continue también es compatible con el proveedor de Ollama, que funciona con DMR:

{
  "models": [
    {
      "title": "Docker Model Runner (Ollama)",
      "provider": "ollama",
      "model": "ai/qwen2.5-coder",
      "apiBase": "http://localhost:12434"
    }
  ]
}

Cursor

Cursor es un editor de código potenciado por IA.

Configuración

1. Abre la configuración de Cursor (CMD/Ctrl + ,).

2. Navega a Models > OpenAI API Key.

3. Configura:

   Ajuste	Valor
   OpenAI API Key	not-needed
   Override OpenAI Base URL	http://localhost:12434/engines/v1

4. En el menú desplegable de modelos, introduce el nombre de tu modelo: ai/qwen2.5-coder

Note

Algunas características de Cursor pueden requerir modelos con capacidades específicas (por ejemplo, llamada a funciones). Utiliza modelos capaces como ai/qwen2.5-coder o ai/llama3.2 para obtener los mejores resultados.

Zed

Zed es un editor de código de alto rendimiento con características de IA.

Configuración

Edita la configuración de tu Zed (~/.config/zed/settings.json):

{
  "language_models": {
    "openai": {
      "api_url": "http://localhost:12434/engines/v1",
      "available_models": [
        {
          "name": "ai/qwen2.5-coder",
          "display_name": "Qwen 2.5 Coder (DMR)",
          "max_tokens": 8192
        }
      ]
    }
  }
}

Open WebUI

Open WebUI proporciona una interfaz similar a ChatGPT para modelos locales.

Consulta Integración de Open WebUI para obtener instrucciones detalladas de configuración.

Aider

Aider es una herramienta de programación en pareja con IA para la terminal.

Configuración

Establece las variables de entorno o utiliza banderas de la línea de comandos:

export OPENAI_API_BASE=http://localhost:12434/engines/v1
export OPENAI_API_KEY=not-needed

aider --model openai/ai/qwen2.5-coder

Or en un solo comando:

$ aider --openai-api-base http://localhost:12434/engines/v1 \
        --openai-api-key not-needed \
        --model openai/ai/qwen2.5-coder

LangChain

Python

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    base_url="http://localhost:12434/engines/v1",
    api_key="not-needed",
    model="ai/qwen2.5-coder"
)

response = llm.invoke("Write a hello world function in Python")
print(response.content)

JavaScript/TypeScript

import { ChatOpenAI } from "@langchain/openai";

const model = new ChatOpenAI({
  configuration: {
    baseURL: "http://localhost:12434/engines/v1",
  },
  apiKey: "not-needed",
  modelName: "ai/qwen2.5-coder",
});

const response = await model.invoke("Write a hello world function");
console.log(response.content);

LlamaIndex

from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(
    api_base="http://localhost:12434/engines/v1",
    api_key="not-needed",
    model="ai/qwen2.5-coder"
)

response = llm.complete("Write a hello world function")
print(response.text)

OpenCode

OpenCode es un asistente de codificación de código abierto diseñado para integrarse directamente en los flujos de trabajo de los desarrolladores. Es compatible con múltiples proveedores de modelos y expone un sistema de configuración flexible que facilita el cambio entre ellos.

Consulta Usar OpenCode con Docker Model Runner para obtener una guía orientada a tareas que describe la configuración, los ajustes y la resolución de problemas de los modelos.

Configuración

1. Instala OpenCode (consulta las instrucciones)
2. Haz referencia a DMR en tu configuración de OpenCode, ya sea globalmente en ~/.config/opencode/opencode.json o de forma específica del proyecto con un archivo opencode.json en la raíz de tu proyecto:

   {
     "$schema": "https://opencode.ai/config.json",
     "provider": {
       "dmr": {
         "npm": "@ai-sdk/openai-compatible",
         "name": "Docker Model Runner",
         "options": {
           "baseURL": "http://localhost:12434/v1"
         },
         "models": {
           "ai/qwen2.5-coder": {
             "name": "ai/qwen2.5-coder"
           },
           "ai/llama3.2": {
             "name": "ai/llama3.2"
           }
         }
       }
     }
   }

3. Selecciona el modelo que deseas en OpenCode.

Puedes encontrar más detalles en esta publicación del blog de Docker.

Claude Code

Claude Code es la herramienta de línea de comandos de Anthropic para la codificación basada en agentes. Reside en tu terminal, comprende tu base de código y ejecuta tareas rutinarias, explica código complejo y gestiona flujos de trabajo de Git a través de comandos en lenguaje natural.

Consulta Usar Claude Code con Docker Model Runner para obtener una guía orientada a tareas que describe la configuración de modelos, ajustes e inspección de solicitudes. Para ejecutar Claude Code en un entorno de pruebas de Docker (Sandbox) aislado contra un modelo local, consulta Ejecutar Claude Code en un Docker Sandbox con Docker Model Runner.

Configuración

1. Instala Claude Code (consulta las instrucciones).
2. Usa la variable de entorno ANTHROPIC_BASE_URL para apuntar Claude Code a DMR. En Mac o Linux, puedes hacer esto, por ejemplo si deseas usar el modelo gpt-oss:32k:

   ANTHROPIC_BASE_URL=http://localhost:12434 claude --model qwen2.5-coder

   En Windows (PowerShell) puedes hacerlo así:

   $env:ANTHROPIC_BASE_URL="http://localhost:12434"
   claude --model gpt-oss:32k

Tip

Para evitar configurar la variable cada vez, añádela a tu perfil de shell (~/.bashrc, ~/.zshrc o equivalente):

export ANTHROPIC_BASE_URL=http://localhost:12434

Puedes encontrar más detalles en esta publicación del blog de Docker.

Note

Mientras que las otras integraciones en esta página utilizan la API compatible con OpenAI, DMR también expone una API compatible con Anthropic utilizada aquí.

Problemas comunes

Errores de "Conexión rechazada" (Connection refused)

1. Asegúrate de que Docker Model Runner esté habilitado y ejecutándose:

   $ docker model status
   

2. Verifica que el acceso TCP esté habilitado:

   $ curl http://localhost:12434/engines/v1/models
   

3. Comprueba si otro servicio está utilizando el puerto 12434.

4. Si ejecutas tu herramienta en WSL y deseas conectarte a DMR en el host a través de localhost, es posible que esto no funcione directamente. Configurar WSL para usar redes duplicadas puede resolver esto.

Errores de "Modelo no encontrado" (Model not found)

1. Verifica que el modelo esté descargado:

   $ docker model list
   

2. Usa el nombre completo del modelo, incluyendo el espacio de nombres (por ejemplo, ai/qwen2.5-coder, no solo qwen2.5-coder).

Respuestas lentas o tiempos de espera agotados (timeouts)

1. Para las primeras solicitudes, los modelos deben cargarse en memoria. Las solicitudes posteriores serán más rápidas.

2. Considera utilizar un modelo más pequeño o ajustar el tamaño del contexto:

   $ docker model configure --context-size 4096 ai/qwen2.5-coder
   

3. Comprueba los recursos disponibles del sistema (RAM, memoria de GPU).

Errores de CORS (herramientas basadas en web)

Si usas herramientas basadas en navegador, añade el origen a los orígenes permitidos por CORS:

1. Docker Desktop: Settings > AI > CORS Allowed Origins.
2. Añade la URL de tu herramienta (por ejemplo, http://localhost:3000).

Modelos recomendados por caso de uso

Qué sigue

• Referencia de la API - Documentación completa de la API
• Opciones de configuración - Ajusta el comportamiento del modelo
• Integración de Open WebUI - Configura una interfaz web