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 扩展会连接到它。

所有 GPU 服务器示例都使用通过 CLORE.AI 市场.

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

概览

属性	详情
项目	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	裸机	可同时运行多个 34B 模型
最大值	A100 80GB	80 GB	80 GB	200 GB	裸机	70B 模型（CodeLlama 70B）

本地要求（你的机器）

• VS Code 或任意 JetBrains IDE

• 已安装 Continue.dev 扩展

• 到你的 Clore.ai 服务器的稳定互联网连接

• 无需本地 GPU —— 所有推理都发生在 Clore.ai 上

快速开始

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

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

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

# 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 才能连接）：

# 以启用外部访问的方式重启 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

默认公开暴露 11434 端口没有认证。生产环境请改为设置 SSH 隧道（见 提示与最佳实践).

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

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

# 使用兼容 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 文档 了解完整设置细节。

# 为 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 在你的 本地机器上:

{
  "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：

{
  "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 后端 （仅自动补全）：

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

配置

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

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

# 打开 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 的持久隧道

# 在你的本地机器上安装 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），你可以同时运行一个大型聊天模型和一个小型自动补全模型：

# 在 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 可以为你的代码库建立索引，从而提供上下文感知建议。拉取一个嵌入模型：

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

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

GPU 加速

监控推理性能

# 在你的 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 以获得更好性能

# 在 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 配置专门模型——界面允许你在对话过程中切换模型：

{
  "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 按小时计费。使用一个简单脚本来启动/停止服务器：

# 将这些保存为本地脚本

# 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 以支持常见的编码工作流：

{
  "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；使用更小的模型或量化版本

调试命令

# 在你的本地机器上——测试连接
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 配置验证

# 在你的本地机器上验证 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 文档 — 所有 IDE 集成和配置选项的官方文档

• Continue.dev GitHub — 源代码、问题、模型兼容性

• Continue.dev 配置参考 — 完整 config.json 架构

• Clore.ai 上的 Ollama — 详细的 Ollama 设置指南（推荐后端）

• Clore.ai 上的 vLLM — 面向团队的高性能替代后端

• TabbyML — 具有 FIM 优化的专用自动补全后端

• GPU 比较指南 — 为你的编码工作负载选择合适的 GPU

• 模型兼容性 — 哪些模型适合哪些 VRAM 容量

• Qwen2.5-Coder — 目前最好的开源编码模型

• DeepSeek-Coder-V2 — 具有长上下文能力的强力替代方案

• CLORE.AI 市场 — 租用 GPU 服务器