# 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](/ai/model-runner/ide-integrations/get-started/#enable-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:
     ```console
     $ docker desktop enable model-runner --tcp 12434
     ```
   - Docker Engine: TCP está habilitado por defecto en el puerto 12434.
3. Descarga un modelo:
   ```console
   $ 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:
>
> ```console
> $ 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](https://github.com/cline/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:

| Ajuste   | Valor                                                    |
| -------- | -------------------------------------------------------- |
| Base URL | `http://localhost:12434/engines/v1`                      |
| API Key  | `not-needed` (o cualquier valor de marcador de posición) |
| Model ID | `ai/qwen2.5-coder` (o tu modelo preferido)               |

> [!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:

   ```console
   $ docker model status
   ```

2. Prueba el endpoint directamente:

   ```console
   $ 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](https://continue.dev) 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`):

```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:

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

## Cursor

[Cursor](https://cursor.sh) 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](https://zed.dev) 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`):

```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](https://github.com/open-webui/open-webui) proporciona una interfaz similar a ChatGPT para modelos locales.

Consulta [Integración de Open WebUI](/ai/model-runner/ide-integrations/openwebui-integration/) para obtener instrucciones detalladas de configuración.

## Aider

[Aider](https://aider.chat) 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:

```bash
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:

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

## LangChain

### Python

```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

```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

```python
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](https://opencode.ai/) 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](/../guides/opencode-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](https://opencode.ai/docs/#install))
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:
   ```json
   {
     "$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](https://www.docker.com/blog/opencode-docker-model-runner-private-ai-coding/).

## Claude Code

[Claude Code](https://claude.com/product/claude-code) es la herramienta de línea de comandos de [Anthropic](https://www.anthropic.com/) 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](/../guides/claude-code-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](/../guides/claude-code-sandbox-model-runner/).

### Configuración

1. Instala Claude Code (consulta las [instrucciones](https://code.claude.com/docs/en/quickstart#step-1-install-claude-code)).
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`:
   ```bash
   ANTHROPIC_BASE_URL=http://localhost:12434 claude --model qwen2.5-coder
   ```
   En Windows (PowerShell) puedes hacerlo así:
   ```powershell
   $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):
>
> ```shell
> export ANTHROPIC_BASE_URL=http://localhost:12434
> ```

Puedes encontrar más detalles en [esta publicación del blog de Docker](https://www.docker.com/blog/run-claude-code-locally-docker-model-runner/).

> [!NOTE]
>
> Mientras que las otras integraciones en esta página utilizan la [API compatible con OpenAI](/ai/model-runner/api-reference/#openai-compatible-api), DMR también expone una [API compatible con Anthropic](/ai/model-runner/api-reference/#anthropic-compatible-api) utilizada aquí.

## Problemas comunes

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

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

   ```console
   $ docker model status
   ```

2. Verifica que el acceso TCP esté habilitado:

   ```console
   $ 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](https://learn.microsoft.com/en-us/windows/wsl/networking#mirrored-mode-networking) puede resolver esto.

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

1. Verifica que el modelo esté descargado:

   ```console
   $ 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:

   ```console
   $ 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

| Caso de uso                    | Modelo recomendado    | Notas                                                                     |
| ------------------------------ | --------------------- | ------------------------------------------------------------------------- |
| Completado de código           | `ai/qwen3-coder`      | Optimizado para tareas de programación con una ventana de contexto grande |
| Programación basada en agentes | `ai/devstral-small-2` | Buena opción para herramientas como Claude Code y OpenCode                |
| Asistente general              | `ai/llama3.2`         | Buen equilibrio de capacidades                                            |
| Pequeño/rápido                 | `ai/smollm2`          | Bajo uso de recursos                                                      |
| Embeddings                     | `ai/all-minilm`       | Para RAG y búsqueda semántica                                             |

## Qué sigue

- [Referencia de la API](/ai/model-runner/ide-integrations/api-reference/) - Documentación completa de la API
- [Opciones de configuración](/ai/model-runner/ide-integrations/configuration/) - Ajusta el comportamiento del modelo
- [Integración de Open WebUI](/ai/model-runner/ide-integrations/openwebui-integration/) - Configura una interfaz web