> 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-zh/ai-ping-tai-yu-zhi-neng-ti/continue-dev.md).

# Continue.dev AI 编程

用 Clore.ai GPU 为 Continue.dev 提供算力——在便宜的 GPU 租赁上本地运行 CodeLlama 34B、DeepSeek Coder 和 Qwen2.5-Coder，用于私有 AI 编程辅助。

Continue.dev 是一款面向 VS Code 和 JetBrains 的开源 AI 编码助手，拥有 2.5 万+ GitHub stars。该 **扩展运行在你的本地机器上** （或在你的 IDE 中），但它会连接到一个用于推理的后端模型服务器。将 Continue.dev 指向从 Clore.ai 租用的强大 GPU 后，你将获得：

* **顶级编码模型** （34B+ 参数），你的笔记本电脑无法承载
* **完全隐私** —— 代码保留在你可控的基础设施上
* **灵活成本** —— 只在你编码时付费（约 $0.20–0.50/小时，而 Copilot 为 $19/月）
* **兼容 OpenAI 的 API** —— Continue.dev 可无缝连接到 Ollama、vLLM 或 TabbyML

本指南重点介绍如何设置 **Clore.ai GPU 后端** （Ollama 或 vLLM），你的本地 Continue.dev 扩展会连接到它。

{% hint style="success" %}
所有 GPU 服务器示例都使用通过 [CLORE.AI 市场](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
**架构**：你的 IDE（安装 Continue.dev 扩展）→ 互联网 → Clore.ai GPU 服务器（运行 Ollama / vLLM / TabbyML）→ 本地模型推理。代码从不接触第三方 API。
{% endhint %}

## 概览

| 属性            | 详情                                                              |
| ------------- | --------------------------------------------------------------- |
| **项目**        | [continuedev/continue](https://github.com/continuedev/continue) |
| **许可证**       | Apache 2.0                                                      |
| **GitHub 星标** | 25K+                                                            |
| **IDE 支持**    | VS Code、JetBrains（IntelliJ、PyCharm、WebStorm、GoLand 等）           |
| **配置文件**      | `~/.continue/config.json`                                       |
| **后端选项**      | Ollama、vLLM、TabbyML、LM Studio、llama.cpp、兼容 OpenAI 的 API         |
| **难度**        | 简单（安装扩展）/ 中等（自托管后端）                                             |
| **需要 GPU？**   | 在 Clore.ai 服务器上（是）；在你的笔记本电脑上（否）                                 |
| **主要特性**      | 自动补全、聊天、编辑模式、代码库上下文（RAG）、自定义斜杠命令                                |

### 推荐的编码模型

| 模型                    | 显存      | 强项              | 备注                 |
| --------------------- | ------- | --------------- | ------------------ |
| `codellama:7b`        | \~6 GB  | 快速自动补全          | 不错的起点              |
| `codellama:13b`       | 约 10 GB | 均衡              | 自动补全的最佳质量/速度平衡     |
| `codellama:34b`       | \~22 GB | 最佳 CodeLlama 质量 | 需要 RTX 3090 / A100 |
| `deepseek-coder:6.7b` | \~5 GB  | Python/JS 专家    | 非常适合 Web 开发        |
| `deepseek-coder:33b`  | \~22 GB | 顶级开源模型          | 在代码方面可与 GPT-4 匹敌   |
| `qwen2.5-coder:7b`    | \~6 GB  | 多语言代码           | 在 40+ 种语言上表现强劲     |
| `qwen2.5-coder:32b`   | \~22 GB | 最先进             | 2024 年最佳开源编码模型     |
| `starcoder2:15b`      | \~12 GB | 代码补全专家          | 支持 FIM（中间填充）       |

## 需求

### Clore.ai 服务器要求

| 层级      | GPU       | 显存    | 内存    | 磁盘     | 价格                                | 模型                                           |
| ------- | --------- | ----- | ----- | ------ | --------------------------------- | -------------------------------------------- |
| **预算**  | RTX 3060  | 12 GB | 16 GB | 40 GB  | $0.03–0.07/小时                     | CodeLlama 7B、DeepSeek 6.7B、Qwen2.5-Coder 7B  |
| **推荐**  | RTX 3090  | 24 GB | 32 GB | 80 GB  | $0.07–0.21/小时                     | CodeLlama 34B、DeepSeek 33B、Qwen2.5-Coder 32B |
| **性能**  | RTX 4090  | 24 GB | 32 GB | 80 GB  | $0.14–0.42/小时                     | 与上面相同的模型，更快的推理                               |
| **性能**  | A100 40GB | 40 GB | 64 GB | 120 GB | [裸机](https://clore.ai/bare-metal) | 可同时运行多个 34B 模型                               |
| **最大值** | A100 80GB | 80 GB | 80 GB | 200 GB | [裸机](https://clore.ai/bare-metal) | 70B 模型（CodeLlama 70B）                        |

### 本地要求（你的机器）

* VS Code 或任意 JetBrains IDE
* 已安装 Continue.dev 扩展
* 到你的 Clore.ai 服务器的稳定互联网连接
* **无需本地 GPU** —— 所有推理都发生在 Clore.ai 上

## 快速开始

### 第 1 部分：设置 Clore.ai 后端

#### 选项 A —— Ollama 后端（适合大多数用户）

Ollama 是 Continue.dev 最容易上手的后端——设置简单、模型管理优秀、兼容 OpenAI 的 API。

```bash
# 1. SSH 登录你的 Clore.ai 服务器
ssh root@<clore-server-ip> -p <port>

# 2. 启动带 GPU 支持的 Ollama
docker run -d \\
  --name ollama \\
  --gpus all \\
  -p 11434:11434 \
  -v /workspace/ollama:/root/.ollama \
  --restart unless-stopped \
  ollama/ollama

# 3. 验证 Ollama 是否正在运行
curl http://localhost:11434/

# 4. 拉取你的编码模型（根据你的 VRAM 选择）
# 对于 12GB VRAM（RTX 3060）：
docker exec ollama ollama pull codellama:13b

# 对于 24GB VRAM（RTX 3090 / RTX 4090）：
docker exec ollama ollama pull qwen2.5-coder:32b
# 或：
docker exec ollama ollama pull deepseek-coder:33b

# 5. 拉取一个快速自动补全模型（与聊天模型分开）
docker exec ollama ollama pull starcoder2:3b   # 非常快，非常适合 FIM 自动补全

# 6. 验证模型是否可用
docker exec ollama ollama list

# 7. 测试推理
docker exec ollama ollama run qwen2.5-coder:32b "Write a Python function to binary search a sorted list"
```

要将 Ollama 暴露到外部（这样你的本地 IDE 才能连接）：

```bash
# 以启用外部访问的方式重启 Ollama
docker stop ollama && docker rm ollama

docker run -d \\
  --name ollama \\
  --gpus all \\
  -p 11434:11434 \
  -v /workspace/ollama:/root/.ollama \
  -e OLLAMA_HOST=0.0.0.0 \
  --restart unless-stopped \
  ollama/ollama

# 在你的本地机器上测试：
curl http://<clore-server-ip>:11434/api/tags
```

{% hint style="warning" %}
默认公开暴露 11434 端口没有认证。生产环境请改为设置 SSH 隧道（见 [提示与最佳实践](#tips--best-practices)).
{% endhint %}

#### 选项 B —— vLLM 后端（高吞吐 / 兼容 OpenAI）

vLLM 提供更快的推理和多用户支持。如果多个开发者共享一台 Clore.ai 服务器，这非常理想。

```bash
# 使用兼容 OpenAI 的 API 启动 vLLM
docker run -d \\
  --name vllm \\
  --gpus all \\
  -p 8000:8000 \
  -v /workspace/hf-models:/root/.cache/huggingface \
  -e HF_TOKEN="your-huggingface-token" \
  --restart unless-stopped \
  vllm/vllm-openai:latest \
  --model Qwen/Qwen2.5-Coder-32B-Instruct \
  --dtype auto \
  --max-model-len 32768 \\
  --tensor-parallel-size 1 \\
  --gpu-memory-utilization 0.90 \\
  --served-model-name qwen2.5-coder-32b

# 对于多 GPU（例如两张 RTX 3090）：
docker run -d \\
  --name vllm \\
  --gpus all \\
  -p 8000:8000 \
  -v /workspace/hf-models:/root/.cache/huggingface \
  -e HF_TOKEN="your-huggingface-token" \
  vllm/vllm-openai:latest \
  --model deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct \
  --tensor-parallel-size 2 \\
  --dtype auto \
  --max-model-len 65536 \\
  --served-model-name deepseek-coder-v2

# 测试 API
curl http://localhost:8000/v1/models
curl http://localhost:8000/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "qwen2.5-coder-32b",
    "messages": [{"role": "user", "content": "在 Rust 中写一个 hello world"}],
    "max_tokens": 200
  }'
```

#### 选项 C —— TabbyML 后端（FIM 自动补全专家）

TabbyML 提供更出色的中间填充（FIM）自动补全——也就是行内幽灵文本建议。请参阅 [TabbyML 文档](https://tabby.tabbyml.com/) 了解完整设置细节。

```bash
# 为 Continue.dev 自动补全快速设置 TabbyML
docker run -d \\
  --name tabby \
  --gpus all \\
  -p 8080:8080 \\
  -v /workspace/tabby-data:/data \
  --restart unless-stopped \
  tabbyml/tabby serve \
  --model StarCoder2-7B \
  --chat-model Mistral-7B \
  --device cuda

# 验证
curl http://localhost:8080/v1/health
```

### 第 2 部分：安装 Continue.dev 扩展

**VS Code：**

1. 打开扩展面板（`Ctrl+Shift+X` / `Cmd+Shift+X`)
2. 搜索 **"Continue"** —— 安装 Continue（continuedev）提供的官方扩展
3. 点击侧边栏中的 Continue 图标（或 `Ctrl+Shift+I`)

**JetBrains（IntelliJ、PyCharm、WebStorm、GoLand）：**

1. `文件 → 设置 → 插件 → Marketplace`
2. 搜索 **"Continue"** 然后安装
3. 重启 IDE；Continue 面板会出现在右侧边栏

### 第 3 部分：配置 Continue.dev 使用 Clore.ai

编辑 `~/.continue/config.json` 在你的 **本地机器上**:

```json
{
  "models": [
    {
      "title": "Clore.ai —— Qwen2.5-Coder 32B",
      "provider": "ollama",
      "model": "qwen2.5-coder:32b",
      "apiBase": "http://<clore-server-ip>:11434",
      "contextLength": 32768,
      "completionOptions": {
        "temperature": 0.1,
        "topP": 0.95,
        "maxTokens": 4096
      }
    },
    {
      "title": "Clore.ai —— CodeLlama 13B（快速）",
      "provider": "ollama",
      "model": "codellama:7b",
      "apiBase": "http://<clore-server-ip>:11434",
      "contextLength": 16384
    }
  ],
  "tabAutocompleteModel": {
    "title": "StarCoder2 3B（自动补全）",
    "provider": "ollama",
    "model": "starcoder2:3b",
    "apiBase": "http://<clore-server-ip>:11434"
  },
  "embeddingsProvider": {
    "provider": "ollama",
    "model": "nomic-embed-text",
    "apiBase": "http://<clore-server-ip>:11434"
  },
  "contextProviders": [
    { "name": "code" },
    { "name": "docs" },
    { "name": "diff" },
    { "name": "terminal" },
    { "name": "problems" },
    { "name": "folder" },
    { "name": "codebase" }
  ],
  "slashCommands": [
    { "name": "edit", "description": "编辑选中的代码" },
    { "name": "comment", "description": "为代码添加注释" },
    { "name": "share", "description": "将对话导出为 markdown" },
    { "name": "cmd", "description": "生成终端命令" },
    { "name": "commit", "description": "生成 git 提交信息" }
  ]
}
```

对于 **vLLM 后端** 而不是 Ollama：

```json
{
  "models": [
    {
      "title": "Clore.ai —— DeepSeek Coder 33B（vLLM）",
      "provider": "openai",
      "model": "deepseek-coder-v2",
      "apiBase": "http://<clore-server-ip>:8000/v1",
      "apiKey": "如果已设置则填入令牌",
      "contextLength": 65536,
      "completionOptions": {
        "temperature": 0.0,
        "maxTokens": 8192
      }
    }
  ]
}
```

对于 **TabbyML 后端** （仅自动补全）：

```json
{
  "tabAutocompleteModel": {
    "title": "Clore.ai —— TabbyML StarCoder2",
    "provider": "openai",
    "model": "StarCoder2-7B",
    "apiBase": "http://<clore-server-ip>:8080/v1",
    "apiKey": "若已设置则使用认证令牌"
  }
}
```

## 配置

### SSH 隧道设置（安全远程访问）

不要公开暴露端口，而是从你的本地机器使用 SSH 隧道：

```bash
# 打开 SSH 隧道：本地 11434 端口 → Clore.ai 服务器 11434 端口
ssh -N -L 11434:localhost:11434 root@<clore-server-ip> -p <clore-ssh-port>

# 保持隧道常驻（添加到 ~/.ssh/config）：
Host clore-coding
  HostName <clore-server-ip>
  Port <clore-ssh-port>
  User root
  LocalForward 11434 localhost:11434
  LocalForward 8000 localhost:8000
  ServerAliveInterval 60
  ServerAliveCountMax 3

# 连接方式：
ssh -N clore-coding

# 然后在 config.json 中使用 localhost：
# "apiBase": "http://localhost:11434"
```

### 使用 autossh 的持久隧道

```bash
# 在你的本地机器上安装 autossh（Linux/macOS）
sudo apt install autossh   # Ubuntu/Debian
brew install autossh       # macOS

# 运行可自动重连的持久隧道
autossh -M 0 -N \
  -o "ServerAliveInterval 30" \
  -o "ServerAliveCountMax 3" \
  -L 11434:localhost:11434 \
  root@<clore-server-ip> -p <clore-ssh-port>

# 添加到 systemd 以便开机自动启动（Linux）
cat > ~/.config/systemd/user/clore-tunnel.service << 'EOF'
[Unit]
Description=SSH tunnel to Clore.ai coding server
After=network.target

[Service]
ExecStart=autossh -M 0 -N \
  -o StrictHostKeyChecking=accept-new \
  -o ServerAliveInterval=30 \
  -o ServerAliveCountMax=3 \
  -L 11434:localhost:11434 \
  root@CLORE_IP -p CLORE_PORT
Restart=always
RestartSec=10

[Install]
WantedBy=default.target
EOF

systemctl --user enable clore-tunnel
systemctl --user start clore-tunnel
```

### 为不同任务加载多个模型

对于 RTX 3090（24 GB），你可以同时运行一个大型聊天模型和一个小型自动补全模型：

```bash
# 在 Clore.ai 服务器上：

# 拉取模型
docker exec ollama ollama pull qwen2.5-coder:32b      # 聊天（22 GB）
docker exec ollama ollama pull starcoder2:3b           # 自动补全（2 GB）
docker exec ollama ollama pull nomic-embed-text        # 向量嵌入（0.5 GB）

# Ollama 会自动处理模型切换
# 通过智能缓存，这三者都能装进 24 GB VRAM

# 监控 VRAM 使用情况
nvidia-smi --query-gpu=memory.used,memory.free --format=csv -l 5
```

### 代码库索引（为你的仓库做 RAG）

Continue.dev 可以为你的代码库建立索引，从而提供上下文感知建议。拉取一个嵌入模型：

```bash
# 在 Clore.ai 服务器上——将嵌入模型添加到 Ollama
docker exec ollama ollama pull nomic-embed-text

# 在 config.json（本地）中，嵌入功能已经在上面配置好了。
# Continue.dev 会自动为你打开的工作区建立索引。
# 手动触发重新索引：Ctrl+Shift+P → "Continue: Index Codebase"
```

## GPU 加速

### 监控推理性能

```bash
# 在你的 Clore.ai 服务器上——在编码会话期间观察 GPU
watch -n 1 nvidia-smi

# 查看每秒 token 数（Ollama 日志）
docker logs ollama --tail 20 -f

# 详细 GPU 状态
nvidia-smi dmon -s u -d 2

# 内存分布
nvidia-smi --query-gpu=name,memory.used,memory.free,utilization.gpu \
  --format=csv,noheader -l 5
```

### 不同 GPU 的预期性能

| GPU           | 模型                      | 上下文 | 每秒 token 数（约） |
| ------------- | ----------------------- | --- | ------------- |
| RTX 3060 12GB | CodeLlama 7B            | 8K  | 约 40–60 t/s   |
| RTX 3060 12GB | DeepSeek-Coder 6.7B     | 8K  | 约 45–65 t/s   |
| RTX 3090 24GB | Qwen2.5-Coder 32B（Q4）   | 16K | 约 15–25 t/s   |
| RTX 3090 24GB | DeepSeek-Coder 33B（Q4）  | 16K | 约 15–22 t/s   |
| RTX 4090 24GB | Qwen2.5-Coder 32B（Q4）   | 16K | 约 25–40 t/s   |
| A100 40GB     | Qwen2.5-Coder 32B（FP16） | 32K | 约 35–50 t/s   |
| A100 80GB     | CodeLlama 70B（Q4）       | 32K | 约 20–30 t/s   |

对于自动补全（中间填充）， **starcoder2:3b** 或 **codellama:7b** 可达到 50–100 t/s —— 快到在 IDE 中几乎像是即时出现。

### 调优 Ollama 以获得更好性能

```bash
# 在 Clore.ai 服务器上——优化 Ollama 设置
docker stop ollama && docker rm ollama

docker run -d \\
  --name ollama \\
  --gpus all \\
  -p 11434:11434 \
  -v /workspace/ollama:/root/.ollama \
  -e OLLAMA_HOST=0.0.0.0 \
  -e OLLAMA_NUM_PARALLEL=2 \
  -e OLLAMA_MAX_LOADED_MODELS=2 \
  -e OLLAMA_FLASH_ATTENTION=1 \
  --restart unless-stopped \
  ollama/ollama

# OLLAMA_NUM_PARALLEL=2：同时处理 2 个请求
# OLLAMA_MAX_LOADED_MODELS=2：在 GPU 内存中保留 2 个模型
# OLLAMA_FLASH_ATTENTION=1：启用 flash attention（更快、更省内存）
```

## 提示与最佳实践

### 针对不同任务使用不同模型

按任务类型为 Continue.dev 配置专门模型——界面允许你在对话过程中切换模型：

```json
{
  "models": [
    {
      "title": "聊天 —— Qwen2.5-Coder 32B",
      "provider": "ollama",
      "model": "qwen2.5-coder:32b",
      "apiBase": "http://localhost:11434",
      "contextLength": 32768,
      "description": "最适合复杂问题、代码审查、架构决策"
    },
    {
      "title": "快速 —— CodeLlama 7B",
      "provider": "ollama",
      "model": "codellama:7b",
      "apiBase": "http://localhost:11434",
      "contextLength": 8192,
      "description": "快速回答、简单补全、低延迟"
    },
    {
      "title": "自动补全 —— StarCoder2 3B",
      "provider": "ollama",
      "model": "starcoder2:3b",
      "apiBase": "http://localhost:11434",
      "contextLength": 4096,
      "description": "行内幽灵文本建议"
    }
  ]
}
```

### 成本对比

| 解决方案                  | 月度成本（每天使用 8 小时） | 隐私          | 模型质量              |
| --------------------- | --------------- | ----------- | ----------------- |
| GitHub Copilot        | $19/用户/月        | ❌ 微软云       | GPT-4o（闭源）        |
| Cursor 专业版            | $20/用户/月        | ❌ Cursor 云端 | Claude 3.5（闭源）    |
| Clore.ai 上的 RTX 3060  | 约 $24/月         | ✅ 你的服务器     | CodeLlama 13B     |
| Clore.ai 上的 RTX 3090  | 约 $48/月         | ✅ 你的服务器     | Qwen2.5-Coder 32B |
| Clore.ai 上的 RTX 4090  | 约 $84/月         | ✅ 你的服务器     | Qwen2.5-Coder 32B |
| Clore.ai 上的 A100 80GB | 约 $264/月        | ✅ 你的服务器     | CodeLlama 70B     |

对于 3 名或以上开发者共用一台 Clore.ai RTX 3090（总计约 $48/月）的小组来说，人均成本低于 Copilot，同时还能获得更大、私有的模型。

### 不编码时关闭

Clore.ai 按小时计费。使用一个简单脚本来启动/停止服务器：

```bash
# 将这些保存为本地脚本

# start-coding-server.sh
#!/bin/bash
echo "正在打开到 Clore.ai 的 SSH 隧道..."
ssh -N -f -L 11434:localhost:11434 clore-coding
echo "隧道已打开。Continue.dev 已就绪。"

# stop-coding-server.sh
#!/bin/bash
echo "正在关闭 SSH 隧道..."
pkill -f "ssh.*clore-coding"
echo "隧道已关闭。记得停止你的 Clore.ai 订单以停止计费！"
```

### 使用 Continue.dev 自定义命令

将自定义斜杠命令添加到 `config.json` 以支持常见的编码工作流：

```json
{
  "customCommands": [
    {
      "name": "review",
      "prompt": "检查这段代码是否存在错误、安全问题和性能问题。请给出具体且可执行的建议。",
      "description": "代码审查"
    },
    {
      "name": "test",
      "prompt": "为这段代码编写全面的单元测试。包含边界情况。使用与代码相同的语言/框架。",
      "description": "生成测试"
    },
    {
      "name": "docstring",
      "prompt": "按照该语言的最佳实践，为这段代码添加清晰、全面的文档字符串/注释。",
      "description": "添加文档"
    },
    {
      "name": "optimize",
      "prompt": "优化这段代码的性能。解释你改了什么以及为什么。",
      "description": "优化代码"
    }
  ]
}
```

## 故障排查

| 问题                      | 可能原因             | 解决方案                                                                    |
| ----------------------- | ---------------- | ----------------------------------------------------------------------- |
| Continue.dev 显示“连接被拒绝”  | 无法连接到 Ollama     | 检查 SSH 隧道是否处于活动状态；验证 `curl http://localhost:11434/` 正常工作                |
| 自动补全未触发                 | 未设置 Tab 自动补全模型   | 在 `tabAutocompleteModel` 添加到 config.json；并在 Continue 设置中启用              |
| 响应非常慢（首个 token 超过 30 秒） | 模型从磁盘加载          | 首次请求会将模型加载到 VRAM 中——后续请求就会很快                                            |
| “未找到模型”错误               | 模型尚未拉取           | 运行 `docker exec ollama ollama pull <model-name>` 在 Clore.ai 服务器上        |
| token 之间延迟很高            | 网络延迟或模型过大        | 使用 SSH 隧道；切换到更小的模型；检查服务器 GPU 利用率                                        |
| 代码库上下文不起作用              | 缺少 embeddings 模型 | 拉取 `nomic-embed-text` 通过 Ollama；检查 `embeddingsProvider` 在 config.json 中 |
| SSH 隧道频繁断开              | 连接不稳定            | 使用 `autossh` 以实现持续重连；添加 `ServerAliveInterval 30`                        |
| 超出上下文窗口                 | 长文件/长对话          | 减少 `contextLength` 在 config.json 中；使用上下文更长的模型                           |
| JetBrains 插件未加载         | IDE 版本不兼容        | 将 JetBrains IDE 更新到最新版本；检查 Continue.dev 插件兼容性矩阵                         |
| 加载期间 vLLM 内存不足（OOM）     | VRAM 不足          | 在 `--gpu-memory-utilization 0.85`；使用更小的模型或量化版本                          |

### 调试命令

```bash
# 在你的本地机器上——测试连接
curl http://localhost:11434/api/tags          # if using SSH tunnel
curl http://<clore-ip>:11434/api/tags        # if port is open directly

# 在 CLORE.AI 服务器上——检查 Ollama
docker logs ollama --tail 30 -f
docker exec ollama ollama list
docker exec ollama ollama ps                  # show currently loaded models

# 测试模型响应时间
time curl http://localhost:11434/api/generate \
  -d '{"model": "codellama:7b", "prompt": "def hello():", "stream": false}'

# 检查 GPU 内存
nvidia-smi --query-gpu=memory.used,memory.free --format=csv

# 检查 vLLM 日志
docker logs vllm --tail 50 -f

# 重启 Ollama 而不丢失模型
docker restart ollama
```

### Continue.dev 配置验证

```bash
# 在你的本地机器上验证 config.json 语法
python3 -c "
import json, sys
try:
    config = json.load(open(sys.argv[1]))
    print('✅ 配置是有效的 JSON')
    print(f'模型：{[m[\"title\"] for m in config.get(\"models\", [])]}')
except Exception as e:
    print(f'❌ 错误：{e}')
" ~/.continue/config.json
```

## 延伸阅读

* [Continue.dev 文档](https://docs.continue.dev/) — 所有 IDE 集成和配置选项的官方文档
* [Continue.dev GitHub](https://github.com/continuedev/continue) — 源代码、问题、模型兼容性
* [Continue.dev 配置参考](https://docs.continue.dev/reference) — 完整 `config.json` 架构
* [Clore.ai 上的 Ollama](/guides/guides_v2-zh/yu-yan-mo-xing/ollama.md) — 详细的 Ollama 设置指南（推荐后端）
* [Clore.ai 上的 vLLM](/guides/guides_v2-zh/yu-yan-mo-xing/vllm.md) — 面向团队的高性能替代后端
* [TabbyML](https://tabby.tabbyml.com/) — 具有 FIM 优化的专用自动补全后端
* [GPU 比较指南](/guides/guides_v2-zh/ru-men-zhi-nan/gpu-comparison.md) — 为你的编码工作负载选择合适的 GPU
* [模型兼容性](/guides/guides_v2-zh/ru-men-zhi-nan/model-compatibility.md) — 哪些模型适合哪些 VRAM 容量
* [Qwen2.5-Coder](https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct) — 目前最好的开源编码模型
* [DeepSeek-Coder-V2](https://huggingface.co/deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct) — 具有长上下文能力的强力替代方案
* [CLORE.AI 市场](https://clore.ai/marketplace) — 租用 GPU 服务器


---

# 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-zh/ai-ping-tai-yu-zhi-neng-ti/continue-dev.md?ask=<question>&goal=<endgoal>
```

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