Cách cài đặt và chạy Qwen3 cục bộ với Ollama

Qwen3 là thế hệ mới nhất của các mô hình ngôn ngữ lớn open-weight do Alibaba phát triển. Với khả năng hỗ trợ hơn 100 ngôn ngữ và hiệu suất mạnh mẽ trong các tác vụ lập luận, viết mã và dịch thuật, Qwen3 sánh ngang với nhiều mô hình hàng đầu hiện nay, bao gồm DeepSeek-R1, o3-mini và Gemini 2.5.

Trong hướng dẫn này, tôi sẽ giải thích từng bước cách chạy Qwen3 cục bộ bằng Ollama.

Chúng ta cũng sẽ xây dựng một ứng dụng nhẹ chạy cục bộ với Qwen3. Ứng dụng cho phép bạn chuyển đổi giữa các chế độ lập luận của Qwen3 và dịch giữa các ngôn ngữ khác nhau.

Chúng tôi cập nhật cho độc giả những thông tin mới nhất về AI qua The Median, bản tin miễn phí mỗi thứ Sáu tóm lược các câu chuyện nổi bật trong tuần. Đăng ký để nắm bắt nhanh chỉ trong vài phút mỗi tuần:

Vì sao nên chạy Qwen3 cục bộ?

Chạy Qwen3 cục bộ mang lại một số lợi ích quan trọng:

• Quyền riêng tư: Dữ liệu của bạn không bao giờ rời khỏi máy.
• Độ trễ: Suy luận cục bộ nhanh hơn do không phải gọi API qua mạng.
• Hiệu quả chi phí: Không có phí token hay hóa đơn đám mây.
• Kiểm soát: Bạn có thể tinh chỉnh prompt, chọn mô hình và cấu hình chế độ tư duy.
• Truy cập ngoại tuyến: Sau khi tải mô hình, bạn có thể làm việc mà không cần internet.

Qwen3 được tối ưu cho cả lập luận sâu (chế độ thinking) và phản hồi nhanh (chế độ non-thinking), đồng thời hỗ trợ hơn 100 ngôn ngữ. Hãy thiết lập nó cục bộ.

Thiết lập Qwen3 cục bộ với Ollama

Ollama là công cụ cho phép bạn chạy các mô hình ngôn ngữ như Llama hoặc Qwen cục bộ trên máy tính thông qua giao diện dòng lệnh đơn giản.

Bước 1: Cài đặt Ollama

Tải Ollama cho macOS, Windows hoặc Linux tại: https://ollama.com/download.

Làm theo hướng dẫn cài đặt và sau khi hoàn tất, hãy xác minh bằng cách chạy lệnh sau trong terminal:

ollama --version

Bước 2: Tải và chạy Qwen3

Ollama cung cấp ngày càng nhiều biến thể Qwen3 phù hợp với nhiều cấu hình phần cứng, từ laptop gọn nhẹ đến máy chủ cao cấp.

ollama run qwen3

Chạy lệnh trên sẽ khởi chạy mô hình Qwen3 mặc định trong Ollama, hiện đang mặc định là qwen3:8b. Nếu bạn có tài nguyên hạn chế hoặc muốn thời gian khởi động nhanh hơn, bạn có thể chỉ định chạy các biến thể nhỏ hơn như mô hình 4B:

ollama run qwen3:4b

Hiện Qwen3 có nhiều biến thể, từ nhỏ nhất 0.6b (523MB) đến lớn nhất 235b (142GB) tham số. Các biến thể nhỏ hơn vẫn cho hiệu năng ấn tượng ở tác vụ lập luận, dịch và sinh mã, đặc biệt khi dùng chế độ thinking.

Các mô hình MoE (30b-a3b, 235b-a22b) đặc biệt thú vị vì mỗi bước suy luận chỉ kích hoạt một tập con chuyên gia, cho phép tổng số tham số rất lớn trong khi chi phí thời gian chạy vẫn hiệu quả.

Nói chung, hãy dùng mô hình lớn nhất mà phần cứng của bạn có thể xử lý, và quay về 8B hoặc 4B để thử nghiệm cục bộ nhanh trên máy tiêu dùng.

Dưới đây là tóm tắt nhanh tất cả các mô hình Qwen3 bạn có thể chạy:

Bước 3: Chạy Qwen3 nền (tùy chọn)

Để phục vụ mô hình qua API, chạy lệnh này trong terminal:

ollama serve

Lệnh này sẽ giúp mô hình sẵn sàng tích hợp với ứng dụng khác tại http://localhost:11434.

Sử dụng Qwen3 cục bộ

Phần này tôi sẽ hướng dẫn bạn một số cách dùng Qwen3 cục bộ, từ tương tác CLI cơ bản đến tích hợp mô hình với Python.

Tùy chọn 1: Chạy suy luận qua CLI

Sau khi tải mô hình, bạn có thể tương tác trực tiếp với Qwen3 trong terminal. Chạy lệnh sau trong terminal:

echo "What is the capital of Brazil? /think" | ollama run qwen3:8b

Cách này hữu ích cho việc thử nhanh hoặc tương tác nhẹ mà không cần viết mã. Thẻ /think ở cuối prompt yêu cầu mô hình lập luận sâu, từng bước. Bạn có thể thay bằng /no_think để có phản hồi nhanh hơn và nông hơn, hoặc bỏ qua hoàn toàn để dùng chế độ lập luận mặc định của mô hình.

Tùy chọn 2: Truy cập Qwen3 qua API

Khi ollama serve đang chạy nền, bạn có thể tương tác với Qwen3 bằng lập trình thông qua HTTP API, rất phù hợp cho tích hợp backend, tự động hóa hoặc thử nghiệm các REST client.

curl http://localhost:11434/api/chat -d '{
  "model": "qwen3:8b",
  "messages": [{ "role": "user", "content": "Define entropy in physics. /think" }],
  "stream": false
}'

Cách hoạt động như sau:

• curl gửi một yêu cầu POST (cách chúng ta gọi API) đến máy chủ Ollama cục bộ chạy tại localhost:11434.
• Payload là một đối tượng JSON gồm:
• "model": Chỉ định mô hình sử dụng (ở đây là qwen3:8b).
• "messages": Danh sách các tin nhắn chat chứa role và content.
• "stream": false: Đảm bảo phản hồi được trả về một lần, không theo từng token.

Tùy chọn 3: Truy cập Qwen3 qua Python

Nếu bạn làm việc trong môi trường Python (như Jupyter, VSCode hoặc script), cách dễ nhất để tương tác với Qwen3 là qua Ollama Python SDK. Bắt đầu bằng cách cài đặt ollama:

pip install ollama

Sau đó, chạy mô hình Qwen3 của bạn với đoạn mã này (chúng ta dùng qwen3:8b bên dưới):

import ollama
response = ollama.chat(
    model="qwen3:8b",
    messages=[
        {"role": "user", "content": "Summarize the theory of evolution. /think"}
    ]
)
print(response["message"]["content"])

Trong đoạn mã trên: 

• ollama.chat(...) gửi một yêu cầu kiểu chat tới máy chủ Ollama cục bộ.
• Bạn chỉ định mô hình (qwen3:8b) và danh sách tin nhắn ở định dạng tương tự API của OpenAI.
• Thẻ /think yêu cầu mô hình lập luận từng bước.
• Cuối cùng, phản hồi được trả về dưới dạng dictionary, và bạn có thể truy cập câu trả lời của mô hình bằng ["message"]["content"].

Cách này lý tưởng cho thử nghiệm cục bộ, tạo mẫu hoặc xây dựng ứng dụng dựa trên LLM mà không phụ thuộc vào API đám mây.

Xây dựng ứng dụng lập luận cục bộ với Qwen3

Qwen3 hỗ trợ hành vi suy luận lai bằng các thẻ /think (lập luận sâu) và /no_think (phản hồi nhanh). Ở phần này, chúng ta sẽ dùng Gradio để tạo ứng dụng web tương tác cục bộ với hai thẻ (tab) riêng:

1. Giao diện lập luận để chuyển đổi giữa các chế độ thinking.
2. Giao diện đa ngôn ngữ để dịch hoặc xử lý văn bản ở các ngôn ngữ khác nhau.

Bước 1: Demo lập luận lai 

Ở bước này, chúng ta xây dựng thẻ lập luận lai với các thẻ /think và /no_think.

import gradio as gr
import subprocess
def reasoning_qwen3(prompt, mode):
    prompt_with_mode = f"{prompt} /{mode}"
    result = subprocess.run(
        ["ollama", "run", "qwen3:8b"],
        input=prompt_with_mode.encode(),
        stdout=subprocess.PIPE
    )
    return result.stdout.decode()
reasoning_ui = gr.Interface(
    fn=reasoning_qwen3,
    inputs=[
        gr.Textbox(label="Enter your prompt"),
        gr.Radio(["think", "no_think"], label="Reasoning Mode", value="think")
    ],
    outputs="text",
    title="Qwen3 Reasoning Mode Demo",
    description="Switch between /think and /no_think to control response depth."
)

Trong đoạn mã trên:

• Hàm reasoning_qwen3() nhận prompt của người dùng và chế độ lập luận ("think" hoặc "no_think").
• Hàm nối chế độ đã chọn vào cuối prompt.
• Sau đó, phương thức subprocess.run() chạy lệnh ollama run qwen3:8b, truyền prompt qua standard input.
• Cuối cùng, đầu ra (phản hồi từ Qwen3) được bắt và trả về dưới dạng chuỗi đã giải mã.

Sau khi định nghĩa hàm sinh đầu ra, hàm gr.Interface() bọc nó thành giao diện web tương tác bằng cách chỉ định các thành phần đầu vào—một Textbox cho prompt và nút Radio để chọn chế độ lập luận—và ánh xạ chúng tới tham số của hàm.

Bước 2: Demo ứng dụng đa ngôn ngữ

Bây giờ, hãy thiết lập thẻ ứng dụng đa ngôn ngữ.

import gradio as gr
import subprocess
def multilingual_qwen3(prompt, lang):
    if lang != "English":
        prompt = f"Translate to {lang}: {prompt}"
    result = subprocess.run(
        ["ollama", "run", "qwen3:8b"],
        input=prompt.encode(),
        stdout=subprocess.PIPE
    )
    return result.stdout.decode()
multilingual_ui = gr.Interface(
    fn=multilingual_qwen3,
    inputs=[
        gr.Textbox(label="Enter your prompt"),
        gr.Dropdown(["English", "French", "Hindi", "Chinese"], label="Target Language", value="English")
    ],
    outputs="text",
    title="Qwen3 Multilingual Translator",
    description="Use Qwen3 locally to translate prompts to different languages."
)

Tương tự bước trước, đoạn mã này hoạt động như sau:

• Hàm multilingual_qwen3() nhận một prompt và ngôn ngữ đích.
• Nếu ngôn ngữ đích không phải tiếng Anh, hàm sẽ thêm hướng dẫn “Translate to {lang}:” để dẫn dắt mô hình.
• Mô hình tiếp tục chạy cục bộ qua subprocess sử dụng Ollama.
• Kết quả được trả về dưới dạng văn bản thuần.

Bước 3: Khởi chạy cả hai thẻ trong Gradio

Hãy gộp cả hai thẻ vào một ứng dụng Gradio.

demo = gr.TabbedInterface(
    [reasoning_ui, multilingual_ui],
    tab_names=["Reasoning Mode", "Multilingual"]
)
demo.launch(debug = True)

Trong đoạn mã trên, chúng ta làm những việc sau:

• Hàm gr.TabbedInterface() tạo giao diện với hai thẻ:
• Một thẻ để điều khiển độ sâu lập luận.
• Một thẻ để dịch prompt đa ngôn ngữ.
• Hàm demo.launch(debug=True) chạy ứng dụng cục bộ và mở trên trình duyệt với chế độ gỡ lỗi bật.

Kết luận

Qwen3 mang khả năng lập luận nâng cao, giải mã nhanh và hỗ trợ đa ngôn ngữ lên máy của bạn thông qua Ollama.

Chỉ với vài bước thiết lập, bạn có thể:

• Chạy suy luận LLM cục bộ mà không phụ thuộc đám mây
• Chuyển đổi giữa phản hồi nhanh và phản hồi có tính suy nghĩ
• Dùng API hoặc Python để xây dựng ứng dụng thông minh

Để tìm hiểu thêm về Qwen3, tôi gợi ý:

• Đọc bài viết giới thiệu này về Qwen3
• Tìm hiểu cách fine-tune Qwen3