Cách chạy Qwen3.5-27B cục bộ cho Agentic Coding

Trong hướng dẫn này, bạn sẽ thiết lập một máy H100 SXM từ xa trên Vast.ai, phục vụ Qwen3.5-27B bằng vLLM, kết nối nó với OpenCode và kiểm thử khả năng agentic coding của mô hình trên một dự án FastAPI thực tế.

Chúng tôi cố ý không sử dụng llama.cpp ở đây. Dù llama.cpp rất phù hợp cho nhiều thiết lập suy luận cục bộ, chạy một mô hình 27B đã lượng tử hóa qua nó thường đi kèm đánh đổi: chất lượng đầu ra thấp hơn, hiệu năng viết mã giảm và nhiều bước cấu hình rườm rà hơn. 

Với các mô hình lớn như Qwen3.5-27B, lượng tử hóa có thể ảnh hưởng rõ rệt đến độ tin cậy, và triển khai cục bộ qua llama.cpp có thể trở nên khó quản lý nếu bạn muốn hành vi agent mượt mà như môi trường sản xuất.

Thay vào đó, hướng dẫn này sử dụng vLLM trên GPU H100 SXM thuê ngoài. Cách này mang lại endpoint tương thích OpenAI ổn định hơn, khai thác hiệu năng tốt hơn từ mô hình đầy đủ và thiết lập gọn gàng hơn cho quy trình agentic coding.

Bạn có thể xem hướng dẫn riêng của chúng tôi về chạy Qwen3.5-397B-A17B cục bộ. 

Điều kiện tiên quyết

Trước khi bắt đầu, hãy đảm bảo bạn có:

• tài khoản Vast.ai
• ít nhất $5 tín dụng để thuê một phiên bản GPU
• kiến thức cơ bản về terminal Linux

Một H100 SXM là lựa chọn mạnh cho thiết lập này vì Qwen3.5-27B cần nhiều bộ nhớ và thông lượng cao, đặc biệt cho cửa sổ ngữ cảnh dài và suy luận tập trung vào viết mã mượt mà.

Bước 1: Khởi chạy và truy cập phiên bản Vast.ai của bạn

Chúng tôi sử dụng Vast.ai vì đây là một chợ GPU thường cho bạn linh hoạt hơn nhiều về giá và phần cứng so với đám mây một nhà cung cấp truyền thống. 

Bạn có thể thuê từ máy do cộng đồng cung cấp đến các gói Secure Cloud / datacenter, được Vast đánh dấu bằng nhãn trung tâm dữ liệu màu xanh. Với thiết lập như thế này, tôi khuyến nghị mạnh mẽ chọn các máy có nhãn xanh để có độ tin cậy cao hơn và trải nghiệm mượt mà hơn.

Bắt đầu bằng cách tạo tài khoản Vast.ai và nạp đủ tín dụng cho phiên làm việc. Sau đó mở trang tìm kiếm, chọn mẫu PyTorch có bật Jupyter, và tìm gói 1x H100 SXM. 

Giá trên Vast.ai thay đổi liên tục vì là chợ thời gian thực, nên hãy coi mọi mức phí theo giờ là xấp xỉ, không cố định.

Sau khi thuê máy, vào thẻ Instances. Khi trạng thái chuyển sang Open, nhấn nút Open để mở cổng quản trị của phiên bản trong trình duyệt. 

Từ đây, bạn có thể mở Jupyter và bắt đầu một phiên terminal trực tiếp trên máy từ xa.

Trong hướng dẫn này, hãy mở hai terminal:

• Một terminal để phục vụ Qwen3.5-27B với vLLM
• Một terminal để cài đặt và chạy OpenCode

Giữ các tác vụ này tách biệt giúp quy trình dễ quản lý hơn khi máy chủ mô hình đang chạy.

Bước 2: Cài đặt vLLM và phục vụ Qwen3.5

Ở bước này, bạn sẽ tạo môi trường Python tách biệt, cài đặt vLLM và khởi chạy Qwen3.5-27B như một API tương thích OpenAI để OpenCode có thể kết nối. 

vLLM là động cơ suy luận thông lượng cao cho các mô hình ngôn ngữ lớn, được thiết kế để phục vụ mô hình hiệu quả qua API.

Tạo không gian làm việc và môi trường ảo

Trong terminal đầu tiên, tạo một không gian sạch cho máy chủ mô hình:

mkdir qwen-servercd qwen-server/uv venv --python 3.12source .venv/bin/activate

Điều này tạo môi trường Python 3.12 riêng để các phụ thuộc của máy chủ mô hình được cô lập khỏi phần còn lại của máy.

Cài đặt vLLM

Bây giờ cài đặt vLLM:

uv pip install vllm --torch-backend=auto --extra-index-url https://wheels.vllm.ai/nightly

Thao tác này cài động cơ suy luận sẽ phơi bày Qwen3.5 qua một API tương thích OpenAI.

Lưu ý: Bạn có thể không cần các wheels nightly cho thiết lập này, vì vLLM hiện tại hỗ trợ Qwen3.5 thường hoạt động tốt với cài đặt chuẩn.

Khởi động máy chủ Qwen3.5

Khi vLLM đã cài xong, khởi động máy chủ mô hình với:

vllm serve Qwen/Qwen3.5-27B \
 --host 127.0.0.1 \
 --port 8000 \
 --api-key local-dev-key \
 --served-model-name qwen3.5-27b-local \
 --tensor-parallel-size 1 \
 --max-model-len 64000 \
 --enable-auto-tool-choice \
 --tool-call-parser qwen3_coder \
 --reasoning-parser qwen3

Lần đầu chạy lệnh này, vLLM sẽ tải mô hình và tokenizer.

Sau đó, mô hình sẽ được nạp vào bộ nhớ GPU. Khi mọi thứ sẵn sàng, bạn sẽ thấy thông báo khởi động máy chủ hoàn tất.

Thao tác này khởi chạy Qwen3.5-27B cục bộ trên cổng 8000 và bảo vệ endpoint bằng API key local-dev-key.

Một vài chi tiết quan trọng:

• --served-model-name đặt tên mô hình để OpenCode tham chiếu
• --enable-auto-tool-choice hỗ trợ hành vi kiểu agent
• --tool-call-parser qwen3_coder phù hợp với quy trình viết mã của Qwen
• --reasoning-parser qwen3 giúp xử lý đúng đầu ra lập luận của Qwen

Giữ terminal này chạy sau khi máy chủ đã sẵn sàng.

Bước 3: Cài đặt và cấu hình OpenCode

Ở bước này, bạn sẽ mở terminal thứ hai, cài đặt OpenCode và kết nối nó với endpoint vLLM cục bộ bạn đã khởi chạy ở Bước 2. 

OpenCode là một agent viết mã mã nguồn mở có thể chạy trong terminal và kết nối tới các mô hình cục bộ thông qua cấu hình provider.

Quay lại cổng phiên bản và mở một terminal Jupyter thứ hai. Giữ terminal đầu tiên đang chạy, vì đó là nơi phục vụ Qwen3.5 qua vLLM. 

Nếu nhấn nút Jupyter Terminal lại mở cùng một terminal, bạn thường có thể mở terminal khác bằng cách đổi số ở cuối URL terminal. Ví dụ, nếu terminal hiện tại kết thúc bằng /terminals/1, hãy đổi thành /terminals/2.

Terminal thứ hai này sẽ là terminal OpenCode của bạn, trong khi terminal đầu tiên tiếp tục chạy máy chủ mô hình.

Cài đặt OpenCode

Chạy lệnh sau để cài đặt OpenCode:

curl -fsSL https://opencode.ai/install | bash

Sau đó làm mới shell của bạn:

exec bash

Thao tác này nạp lại shell, để lệnh opencode khả dụng ngay lập tức.

Trỏ OpenCode tới máy chủ vLLM cục bộ của bạn

OpenCode tìm cấu hình toàn cục ở ~/.config/opencode/opencode.json, và phần thiết lập provider hỗ trợ các giá trị baseURL và apiKey tùy chỉnh. Điều này rất phù hợp với máy chủ tương thích OpenAI cục bộ như endpoint bạn đã khởi chạy bằng vLLM.

Tạo tệp cấu hình với:

mkdir -p ~/.config/opencode && cat > ~/.config/opencode/opencode.json <<'EOF'
{
 "$schema": "https://opencode.ai/config.json",
 "provider": {
   "vllm": {
     "npm": "@ai-sdk/openai-compatible",
     "name": "Local vLLM",
     "options": {
       "baseURL": "http://127.0.0.1:8000/v1",
       "apiKey": "local-dev-key"
     },
     "models": {
       "qwen3.5-27b-local": {
         "name": "Qwen3.5-27B Local"
       }
     }
   }
 },
 "model": "vllm/qwen3.5-27b-local",
 "small_model": "vllm/qwen3.5-27b-local"
}
EOF

Điều này báo cho OpenCode dùng endpoint vLLM cục bộ tại http://127.0.0.1:8000/v1 thay vì API lưu trữ. Nó cũng dùng cùng API key bạn đặt khi khởi chạy máy chủ vLLM ở Bước 2, để OpenCode xác thực thành công.

Bước 4: Kết nối OpenCode với mô hình cục bộ

Bây giờ, tạo thư mục dự án để kiểm thử agent viết mã:

mkdir investment-apicd investment-apiopencode

Lệnh này khởi chạy OpenCode bên trong thư mục investment-api và dùng mô hình Qwen3.5 cục bộ làm backend. 

Từ đây, bạn có thể yêu cầu nó kiểm tra tệp, giải thích mã hoặc tạo các thành phần dự án mới bằng mô hình đang chạy trên GPU thuê.

Bước 5: Kiểm thử Qwen3.5 trên một tác vụ viết mã thực

Giờ là lúc kiểm thử toàn bộ thiết lập trên một tác vụ viết mã thực tế.

Tôi bắt đầu với một prompt rất đơn giản để đảm bảo mọi thứ hoạt động. Chỉ trong vòng một giây, tôi nhận được phản hồi, là dấu hiệu tốt cho thấy mô hình đã được kết nối đúng.

Tiếp theo, tôi giao cho nó một tác vụ agentic coding thực tế hơn:

"Build a FastAPI backend for investment market data that 
collects the latest public data every few minutes for S&P 500, 
gold, silver, Brent, major indices, and selected stocks."

Sau khoảng một phút lập luận, mô hình bắt đầu đặt các câu hỏi truy vấn hữu ích. Nó hỏi nên dùng nguồn dữ liệu nào, loại lưu trữ hay cơ sở dữ liệu nào, và bao gồm những mã cổ phiếu nào. 

Đây là dấu hiệu tốt, vì cho thấy mô hình không nhảy vào viết mã một cách mù quáng. Nó đang cố làm rõ yêu cầu trước.

Sau khi xong, nó lập kế hoạch và bắt đầu thực hiện từng bước. Nó chia nhỏ vấn đề thành các tác vụ nhỏ, thêm vào danh sách việc cần làm và hoàn thành từng phần một.

Chưa đầy năm phút, nó đã tạo cấu trúc dự án đầy đủ và sinh ra một backend FastAPI hầu như chạy được, rất nhanh đối với một tác vụ như vậy.

Sau đó, tôi yêu cầu nó kiểm thử API và chạy smoke test. Kết quả là chúng tôi có một API tài chính gần như hoạt động trọn vẹn. Vẫn còn vài lỗi cần sửa, nhưng với một phiên ngắn như vậy, hiệu năng rất ấn tượng.

Tổng kết

Giờ đây chúng ta có một thiết lập viết mã cục bộ hoàn chỉnh chạy trên một phiên bản Vast.ai H100 SXM thuê. Trong hướng dẫn này, chúng ta dùng vLLM để phục vụ Qwen3.5-27B qua một API tương thích OpenAI, rồi kết nối endpoint đó với OpenCode để dùng mô hình trong quy trình agentic coding.

Cách tiếp cận này cho chúng ta một phương án thực tế để chạy một mô hình viết mã open-weight mạnh trên các tác vụ thật mà không phụ thuộc vào nhà cung cấp dịch vụ lưu trữ. Nó cũng cho phép kiểm soát nhiều hơn với toàn bộ ngăn xếp, từ máy chủ mô hình đến giao diện viết mã.

So với việc cố chạy một mô hình 27B bị lượng tử hóa nặng cục bộ qua llama.cpp, thiết lập này thường ổn định hơn và phù hợp hơn cho công việc viết mã nghiêm túc. Chúng ta tránh được nhiều đánh đổi hiệu năng, hạn chế bộ nhớ và rắc rối thiết lập có thể xuất hiện khi ép các mô hình lớn vào môi trường hoàn toàn cục bộ.

Một lợi thế lớn khác là hiệu năng. Với thiết lập này, chúng ta có thông lượng token mỗi giây rất cao, độ dài ngữ cảnh lớn và trải nghiệm viết mã tổng thể mượt mà hơn nhiều. Điều này khiến nó thực tế hơn nhiều cho các prompt dài, tác vụ đa tệp và quy trình kiểu agent nơi mô hình cần không gian để lập luận và theo dõi nhiều ngữ cảnh hơn.