Kimi K2 Thinking: Hướng dẫn LLM mã nguồn mở, điểm chuẩn và công cụ

Một mô hình mã nguồn mở vượt mặt GPT-5 và Claude Sonnet 4.5 trên các bộ điểm chuẩn chính với chi phí chỉ bằng một phần nhỏ. Đó là Kimi K2 Thinking, biến thể suy luận của Moonshot AI, ra mắt vào tháng 11 năm 2025.

Kimi K2 Thinking có thể tự động thực hiện 200–300 lần gọi công cụ tuần tự, khiến nó lý tưởng cho các quy trình tác tử phức tạp. Nó cũng hiển thị quá trình suy luận thông qua một trường API riêng, để bạn có thể thấy chính xác cách nó tư duy giải quyết vấn đề.

Hướng dẫn này chỉ cho bạn cách dùng API Kimi K2 Thinking cho các tác vụ suy luận. Bạn sẽ triển khai quy trình gọi công cụ, xây dựng một ứng dụng chat so sánh để kiểm thử K2 với GPT-5 và Claude, và học cách khi nào thế mạnh của K2 khiến nó là lựa chọn tốt hơn.  Nếu bạn muốn học thêm về cách xây dựng ứng dụng với LLM, tôi khuyến nghị khóa Developing LLM Applications with LangChain. Bạn cũng có thể xem các dự án khác của chúng tôi về GPT-5.1-Codex và Qwen3-Max-Thinking. Tôi cũng khuyến nghị hướng dẫn về Kimi K2.5 with Agent Swarm mới.

Đây là phần xem trước của ứng dụng:

Trước khi bắt tay vào thực hành, hãy hiểu điều gì khiến K2 Thinking khác với các mô hình ngôn ngữ truyền thống.

Kimi K2 Thinking là gì?

Hầu hết các mô hình ngôn ngữ tạo phản hồi ngay lập tức. K2 Thinking hoạt động khác. Nó được xây dựng cho các bài toán nhiều bước nơi mô hình cần tự lập kế hoạch, suy luận và hành động.

Kiến trúc và thiết kế

Mô hình sử dụng kiến trúc Mixture-of-Experts (MoE) với tổng cộng 1 nghìn tỷ tham số. Chỉ 32 tỷ tham số được kích hoạt cho mỗi đầu vào. Điều này giúp K2 có sức mạnh của một mô hình khổng lồ mà không tốn chi phí suy luận cao. Cửa sổ ngữ cảnh 256.000 token cho phép bạn đưa vào cả mã nguồn lớn, tài liệu dài, hoặc lịch sử hội thoại mở rộng mà không cần chia nhỏ.

Moonshot AI phát hành hai phiên bản. K2 Instruct xử lý các tác vụ đơn giản như tạo văn bản, phân loại và hỏi đáp cơ bản, nơi tốc độ là quan trọng. K2 Thinking dành cho các tác vụ suy luận phức tạp.

Hai năng lực nổi bật

Tính năng lớn đầu tiên của K2 Thinking là suy luận minh bạch. Bạn có thể thấy cách nó chia nhỏ vấn đề, đánh giá các phương án và đi đến kết luận.

Điểm thứ hai là điều phối công cụ. K2 xử lý gọi công cụ tuần tự ở quy mô lớn, vượt xa phần lớn mô hình khác. Nó quyết định dùng công cụ nào, khi nào dùng và cách kết hợp kết quả mà không cần bạn can thiệp ở mỗi bước.

Tính năng bổ sung

K2 đi kèm các tính năng cho nhiều nhu cầu triển khai. Với môi trường sản xuất nơi độ chính xác là tối quan trọng, Heavy Mode chạy song song tám tuyến suy luận và chọn đáp án tốt nhất, đổi lại chi phí tính toán cao hơn. 

Với ứng dụng nhạy cảm độ trễ, lượng tử hóa INT4 tăng gấp đôi tốc độ suy luận với tổn thất độ chính xác tối thiểu, phù hợp cho môi trường thông lượng cao.

Kimi K2 Thinking so với GPT-5, Claude Sonnet 4.5 và DeepSeek

Dưới đây là cách K2 so sánh với GPT-5, Claude Sonnet 4.5 và DeepSeek V3.2.

Định nghĩa nhanh các điểm chuẩn: HLE kiểm tra kiến thức trình độ sau đại học, AIME25 dùng bài toán toán thi đấu, BrowseComp và Frames kiểm tra điều hướng web và tổng hợp, SWE-bench Verified đo lường sửa lỗi trong mã nguồn mở, LiveCodeBench kiểm tra sinh mã, và GPQA bao quát câu hỏi khoa học bậc cao học.

Việc huấn luyện công cụ của K2 thể hiện rõ nhất ở các điểm chuẩn tác tử. Heavy Mode vượt GPT-5 9 điểm trên HLE vì nó chạy song song tám tuyến suy luận. Việc huấn luyện mã của Claude giúp nó dẫn đầu trên SWE-bench Verified, khiến nó là lựa chọn số một cho dự án kỹ thuật phần mềm.

Ở các tác vụ suy luận thuần, cả ba mô hình cho hiệu năng xấp xỉ nhau. Khác biệt xuất hiện khi có công cụ tham gia. Năng lực 200–300 lần gọi công cụ của K2 cho phép nó xử lý quy trình nghiên cứu tự động, pipeline gỡ lỗi và phân tích dữ liệu nhiều bước mà không cần bạn can thiệp ở mỗi giai đoạn.

Khi nào chọn mỗi mô hình

• Chọn K2 Thinking cho các quy trình tác tử cần điều phối công cụ ở quy mô lớn, nghiên cứu web và tổng hợp thông tin, hoặc khi bạn cần chuỗi suy luận minh bạch để gỡ lỗi hay tuân thủ.
• Chọn GPT-5 cho cửa sổ ngữ cảnh lớn nhất 400k token hoặc khi bạn cần hiệu năng cân bằng giữa các tác vụ với hệ sinh thái trưởng thành.
• Chọn Claude Sonnet 4.5 cho dự án kỹ thuật phần mềm nơi gỡ lỗi và sửa mã là trọng tâm.
• Chọn DeepSeek khi ưu tiên ngân sách với yêu cầu mã nguồn mở theo giấy phép MIT.

Thiết lập quyền truy cập API Kimi K2 Thinking

Bạn có hai cách truy cập K2 Thinking: trực tiếp qua platform.moonshot.ai của Moonshot AI, hoặc qua OpenRouter, một cổng API hợp nhất. Chúng ta sẽ dùng OpenRouter vì nó cung cấp quyền truy cập K2, GPT-5, Claude và hàng chục mô hình khác chỉ với một API key. Quyền truy cập hợp nhất này sẽ trở nên thiết yếu về sau khi bạn xây ứng dụng chat so sánh. OpenRouter cũng xử lý tự động giới hạn tốc độ và chuyển đổi dự phòng, nên bạn không cần quản lý nhiều tài khoản nhà cung cấp.

Đầu tiên, truy cập openrouter.ai và tạo tài khoản. Bạn có thể đăng ký bằng Google hoặc GitHub. Sau khi vào, hãy đến mục “Keys” trong bảng điều khiển và tạo API key mới. 

OpenRouter tặng $5 tín dụng miễn phí khi đăng ký, đủ để thử K2 Thinking với vài truy vấn. Nếu cần thêm tín dụng, bạn có thể thêm phương thức thanh toán trong mục “Credits”.

Sao chép API key của bạn và lưu an toàn. Bạn sẽ cần nó ngay sau đây. Đừng đưa key này vào hệ thống quản lý phiên bản hay chia sẻ công khai, vì ai có key của bạn đều có thể gọi API trên tài khoản của bạn.

Bây giờ hãy thiết lập môi trường Python. Bạn sẽ cần OpenAI Python SDK, tương thích với API của OpenRouter vì họ duy trì khả năng tương thích OpenAI. Bạn cũng nên dùng python-dotenv để quản lý API key an toàn. Cài đặt cả hai gói:

!pip install openai python-dotenvĐược hỗ trợ bởi

Tạo một tệp .env trong thư mục dự án và thêm OpenRouter API key của bạn:

OPENROUTER_API_KEY=your_key_hereĐược hỗ trợ bởi

Nếu bạn dùng git, hãy thêm .env vào tệp .gitignore để tránh vô tình commit thông tin xác thực.

Đây là bài kiểm tra nhanh để xác nhận mọi thứ hoạt động:

import os
from openai import OpenAI
from dotenv import load_dotenv

# Load API key from .env file
load_dotenv()

# Configure client for OpenRouter
client = OpenAI(
   base_url="https://openrouter.ai/api/v1",
   api_key=os.getenv("OPENROUTER_API_KEY")
)

# Test call to K2 Thinking
response = client.chat.completions.create(
   model="moonshotai/kimi-k2-thinking",
   messages=[
       {"role": "user", "content": "What is 15 * 24?"}
   ]
)

print(response.choices[0].message.content)Được hỗ trợ bởi

Kết quả:

15 * 24 = **360**Được hỗ trợ bởi

Nếu bạn thấy câu trả lời, vậy là xong.

Tìm hiểu Chế độ Thinking của Kimi K2

Trước đó, chúng ta đã đề cập đến suy luận minh bạch của K2. Giờ hãy xem chính xác cách truy cập và sử dụng nó trong mã của bạn. K2 Thinking tự động hiển thị quá trình suy luận qua một trường API riêng. 

Khác với một số mô hình khác, nơi bạn phải bật thinking mode thủ công, K2 mặc định bao gồm nội dung suy luận trong mọi phản hồi.

Cách truy cập nội dung suy luận

Khi bạn gọi API tới K2 Thinking, phản hồi gồm hai trường. Trường content chứa câu trả lời cuối cùng, và trường reasoning hiển thị quá trình suy nghĩ theo từng bước. Đây là ví dụ thực tế với phép tính chiết khấu cần nhiều bước:

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
   base_url="https://openrouter.ai/api/v1",
   api_key=os.getenv("OPENROUTER_API_KEY")
)

response = client.chat.completions.create(
   model="moonshotai/kimi-k2-thinking",
   messages=[
       {"role": "user", "content": "A laptop costs $850. There's a 20% discount today, then 8% sales tax applies to the discounted price. What's the final amount I pay?"}
   ],
   temperature=1.0
)

print("Final answer:")
print(response.choices[0].message.content)
print("\nReasoning process:")
print(response.choices[0].message.reasoning)Được hỗ trợ bởi

Kết quả:

Final answer:
The final amount you pay is **$734.40**.

Here's the breakdown:

1. **Discount:** 20% of $850 = $170
2. **Discounted price:** $850 - $170 = $680
3. **Sales tax:** 8% of $680 = $54.40
4. **Final amount:** $680 + $54.40 = **$734.40**Được hỗ trợ bởi

Quá trình suy luận (rút gọn cho dễ đọc):

The user wants to know the final amount they will pay for a laptop with a discount and then sales tax applied.

Step 1: Calculate the discount amount.
Discount amount = $850 * 0.20 = $170

Step 2: Calculate the discounted price.
Discounted price = $850 - $170 = $680

Step 3: Calculate the sales tax amount.
Sales tax amount = $680 * 0.08 = $54.40

Step 4: Calculate the final amount to pay.
Final amount = $680 + $54.40 = $734.40

Let me double-check the calculations...
[verification steps omitted]

The final amount is $734.40Được hỗ trợ bởi

Trường content đưa ra câu trả lời gọn gàng cho người dùng. Trường reasoning cho thấy K2 đã xử lý vấn đề thế nào, giúp bạn hiểu liệu mô hình thực sự suy luận đúng hay chỉ đúng ngẫu nhiên.

K2 tạo token suy luận trong quá trình suy luận, không phải sau đó. Điều này nghĩa là mô hình tư duy trước khi chốt câu trả lời, giống như bạn làm nháp một bài toán trước khi viết đáp án sau cùng. Quá trình suy luận diễn ra theo thời gian thực như một phần của quá trình sinh.

Tham số khuyến nghị cho Thinking mode

Đặt temperature=1.0 khi dùng K2 Thinking. Nhiệt độ thấp hơn sẽ hạn chế không gian khám phá suy luận của mô hình, đi ngược mục đích của Thinking mode. Bạn cũng cần max_tokens=4096 hoặc cao hơn vì chuỗi suy luận tiêu tốn token trước cả khi câu trả lời cuối cùng bắt đầu.

response = client.chat.completions.create(
   model="moonshotai/kimi-k2-thinking",
   messages=[{"role": "user", "content": "Your question here"}],
   temperature=1.0,
   max_tokens=4096
)Được hỗ trợ bởi

Giờ bạn đã hiểu thinking mode, hãy khám phá năng lực chủ chốt khác của K2: gọi công cụ. Dù nhiều mô hình hỗ trợ dùng công cụ cơ bản, cách tiếp cận của K2 khác biệt ở quy mô và mức độ tự chủ.

Năng lực gọi công cụ của Kimi K2

Gọi công cụ cho phép K2 thực thi hàm trong quá trình suy luận. Bạn định nghĩa công cụ dưới dạng JSON schema mô tả chức năng và tham số cần thiết. Khi K2 cần dữ liệu hay tính toán bên ngoài, nó sẽ gọi đúng công cụ và chờ kết quả.

Điều này tạo ra một vòng lặp qua lại: K2 đọc prompt và suy luận. Nếu cần công cụ, nó trả về finish_reason: "tool_calls". Bạn thực thi hàm, gửi kết quả lại với role: "tool", và K2 tiếp tục. Lặp lại cho đến khi K2 trả về finish_reason: "stop" cùng câu trả lời cuối.

Schema tuân theo định dạng của OpenAI với tên, mô tả và tham số. K2 đọc các phần này để hiểu khi nào dùng mỗi công cụ. Mô tả rõ ràng rất quan trọng vì nó định hướng quyết định của mô hình.

Xây dựng công cụ phân tích CSV

Hãy xây một công cụ thực tế phân tích tệp CSV, một tác vụ phổ biến trong khoa học dữ liệu. Công cụ này đọc CSV, trích thông tin cột và trả về thống kê tóm tắt. Nó minh họa cách K2 truy cập dữ liệu ngoài trong quá trình suy luận, điều tối quan trọng cho ứng dụng dựa trên dữ liệu.

Đây là triển khai đầy đủ:

import csv
import os
import json

# Define the tool schema
tools = [
   {
       "type": "function",
       "function": {
           "name": "analyze_csv",
           "description": "Read and analyze the first few rows of a CSV file. Returns columns, sample rows, total row count, and file size.",
           "parameters": {
               "type": "object",
               "properties": {
                   "filepath": {
                       "type": "string",
                       "description": "Path to the CSV file"
                   },
                   "num_rows": {
                       "type": "integer",
                       "description": "Number of rows to read",
                       "default": 10
                   }
               },
               "required": ["filepath"]
           }
       }
   }
]Được hỗ trợ bởi

Schema định nghĩa một công cụ hàm theo định dạng OpenAI. Trường description cho K2 biết công cụ làm gì và định hướng khi nào nên dùng. 

Đối tượng parameters chỉ định đầu vào: filepath là bắt buộc, còn num_rows là tùy chọn với giá trị mặc định 10. Mô tả rõ ràng giúp K2 hiểu khi nào công cụ phù hợp nhu cầu người dùng.

Triển khai sau xử lý tệp thực tế:

# Implement the function
def analyze_csv(filepath: str, num_rows: int = 10) -> dict:
   if not os.path.exists(filepath):
       return {"error": f"File not found: {filepath}"}

   try:
       with open(filepath, 'r') as f:
           reader = csv.DictReader(f)
           columns = reader.fieldnames
           sample_rows = [dict(row) for i, row in enumerate(reader) if i < num_rows]
           f.seek(0)
           total_rows = sum(1 for _ in f) - 1

       return {
           "columns": list(columns),
           "sample_rows": sample_rows,
           "total_rows": total_rows,
           "file_size_kb": round(os.path.getsize(filepath) / 1024, 2)
       }
   except Exception as e:
       return {"error": str(e)}Được hỗ trợ bởi

Hàm xác thực đường dẫn tệp, sau đó dùng csv.DictReader để phân tích CSV thành dict với khóa là tên cột. Nó đọc num_rows dòng đầu, đặt lại con trỏ tệp bằng seek(0) và đếm tổng số dòng. 

Dict trả về gồm tên cột, mẫu dữ liệu, số dòng và kích thước tệp tính bằng KB. Xử lý lỗi đảm bảo công cụ trả về phản hồi hữu ích nếu có trục trặc.

Triển khai vòng lặp thực thi công cụ

Khi đã định nghĩa và triển khai công cụ, bạn cần một vòng lặp xử lý hội thoại giữa K2 và các hàm của bạn. Gọi công cụ không phải thao tác một lần. K2 có thể cần nhiều vòng: gọi công cụ, phân tích kết quả, quyết định có cần công cụ khác hay không, rồi lặp lại. Điều này đòi hỏi một vòng lặp xử lý trao đổi qua lại cho tới khi K2 đưa ra câu trả lời cuối.

Đây là triển khai đầy đủ kèm ví dụ thực:

from openai import OpenAI

client = OpenAI(
   base_url="https://openrouter.ai/api/v1",
   api_key=os.getenv("OPENROUTER_API_KEY")
)

messages = [
   {"role": "user", "content": "Analyze sample_employees.csv and tell me the average salary for Engineering department employees."}
]Được hỗ trợ bởi

Đoạn này khởi tạo client OpenAI cấu hình cho API của OpenRouter và tạo danh sách tin nhắn ban đầu với truy vấn của người dùng về phân tích lương nhân viên.

while True:
   response = client.chat.completions.create(
       model="moonshotai/kimi-k2-thinking",
       messages=messages,
       tools=tools,
       temperature=1.0
   )

   message = response.choices[0].message
   finish_reason = response.choices[0].finish_reason

   messages.append({
       "role": "assistant",
       "content": message.content,
       "tool_calls": message.tool_calls
   })Được hỗ trợ bởi

Vòng lặp chính gửi lịch sử hội thoại tới K2 cùng các công cụ sẵn có. Sau khi trích xuất phản hồi của trợ lý và lý do kết thúc, thêm nó vào lịch sử để duy trì ngữ cảnh.

  if finish_reason == "tool_calls":
       for tool_call in message.tool_calls:
           function_name = tool_call.function.name
           arguments = json.loads(tool_call.function.arguments)

           if function_name == "analyze_csv":
               result = analyze_csv(**arguments)

           messages.append({
               "role": "tool",
               "content": json.dumps(result),
               "tool_call_id": tool_call.id
           })

   elif finish_reason == "stop":
       print(message.content)
       breakĐược hỗ trợ bởi

Khi K2 yêu cầu gọi công cụ, chúng ta thực thi từng hàm với tham số cung cấp và thêm kết quả vào hội thoại với tool_call_id tương ứng. Khi K2 hoàn tất suy luận và trả về "stop", ta in đáp án cuối và thoát vòng lặp.

Với ví dụ này, hãy tạo tệp sample_employees.csv chứa dữ liệu nhân viên gồm tên, phòng ban và lương. Dùng khoảng 12 nhân viên thuộc các phòng Engineering, Marketing, Sales và HR để thử. Khi chạy mã này, K2 thường gọi analyze_csv() với num_rows đặt 12 hoặc cao hơn để đảm bảo bao phủ đầy đủ dữ liệu, rồi xác định nhân viên Engineering và tính lương trung bình của họ.

Kết quả:

Based on the CSV data, I found 5 Engineering employees in the sample:
- Alice Johnson: $95,000
- Carol White: $110,000
- Eve Davis: $88,000
- Iris Martinez: $102,000
- Kate Thomas: $92,000

The average salary for Engineering department employees is $97,400.Được hỗ trợ bởi

Trường tool_call_id trong mỗi phản hồi liên kết kết quả về lời gọi hàm tương ứng. K2 có thể yêu cầu nhiều công cụ trong một phản hồi, vì vậy mỗi công cụ cần ID để ghép đúng. Bảo toàn toàn bộ lịch sử hội thoại giúp K2 có ngữ cảnh cần thiết để suy luận mạch lạc xuyên suốt các lần gọi công cụ.

Hiểu khả năng điều phối độc lập của K2

Khi đã quen với gọi công cụ cơ bản, điểm mạnh thực sự của K2 trở nên rõ ràng: điều phối mở rộng. K2 được huấn luyện điều phối công cụ từ đầu, không phải tính năng bổ sung sau này. Điều này thay đổi cách nó xử lý tác vụ nhiều bước. Phần lớn mô hình chỉ quản lý 20–50 lần gọi công cụ tuần tự trước khi hiệu năng giảm. K2 xử lý 200–300 lần trong khi vẫn giữ suy luận mạch lạc.

Năng lực này quan trọng cho các quy trình độc lập nơi mô hình tự quyết định, thu thập thông tin, kiểm chứng kết quả và lặp cho tới khi giải xong vấn đề. Hãy xem các tác vụ nghiên cứu nơi K2 tìm kiếm cơ sở dữ liệu, đối chiếu phát hiện, xác định khoảng trống, tinh chỉnh truy vấn và tổng hợp mọi thứ. Hoặc các pipeline dữ liệu cần kiểm chứng ở mỗi bước. Hoặc quy trình gỡ lỗi kiểm thử nhiều giả thuyết.

Nếu trường hợp sử dụng của bạn là “thực hiện hành động đơn lẻ này,” hầu hết mô hình đều ổn. Nếu là “tiếp tục làm cho tới khi giải quyết xong,” năng lực gọi công cụ mở rộng của K2 trở thành yếu tố quyết định.

Xây dựng ứng dụng chat so sánh đa mô hình

Bạn đã thấy K2 Thinking xử lý tác vụ riêng lẻ với gọi công cụ và suy luận minh bạch. Giờ hãy đưa nó lên bàn cân với đối thủ. Bạn sẽ xây một ứng dụng Streamlit truy vấn Kimi K2 Thinking, GPT-5 và Claude Sonnet 4.5 bằng cùng một prompt cùng lúc. Giao diện hiển thị cả ba phản hồi cạnh nhau để bạn thấy mỗi mô hình tiếp cận cùng một vấn đề thế nào.

Bạn có thể tìm toàn bộ script ứng dụng trong GitHub Gist này. Nếu bạn chỉ muốn kết quả kiểm thử của ứng dụng, có thể bỏ qua phần này. Các bước sau chứa phân tích chi tiết script (hơn 200 dòng), nên bạn có thể để đọc phần này sau khi có thời gian thực hành theo. Nói vậy, chúng ta bắt đầu thôi.

Bước 1: Thiết lập dự án và phụ thuộc

Ứng dụng so sánh này cần quyền truy cập API tới cả ba mô hình. Bạn sẽ cần tài khoản OpenRouter (đã thiết lập với $5 tín dụng miễn phí), và tùy chọn có thêm API key của OpenAI và Anthropic. $5 tín dụng OpenRouter đủ để thử cả ba mô hình với nhiều truy vấn. Nếu bạn chỉ có OpenRouter, bạn vẫn có thể so sánh K2 với các mô hình khác có trên OpenRouter.

Cài đặt Streamlit cho giao diện web và SDK của Anthropic để truy cập Claude:

pip install streamlit anthropicĐược hỗ trợ bởi

Tạo tệp có tên model_comparison_chat.py. Toàn bộ ứng dụng nằm trong tệp này. Bắt đầu với import:

import os
import time
from typing import Dict, List
from concurrent.futures import ThreadPoolExecutor, as_completed
from dotenv import load_dotenv
import streamlit as st
from openai import OpenAI
from anthropic import Anthropic

load_dotenv()Được hỗ trợ bởi

Bước 2: Cấu hình kết nối API

Bạn đã có OPENROUTER_API_KEY trong tệp .env. Thêm key cho GPT-5 và Claude:

OPENROUTER_API_KEY=your_openrouter_key  # Already set up
OPENAI_API_KEY=your_openai_key           # Add this
ANTHROPIC_API_KEY=your_anthropic_key     # Add thisĐược hỗ trợ bởi

Lấy OpenAI API key của bạn từ platform.openai.com và key Anthropic từ console.anthropic.com. Để biết thêm chi tiết thiết lập GPT-5, xem hướng dẫn GPT-5. Với Claude Sonnet 4.5, xem tổng quan Claude Sonnet 4.5.

Khởi tạo ba client:

KIMI_CLIENT = OpenAI(
   api_key=os.getenv("OPENROUTER_API_KEY"),
   base_url="https://openrouter.ai/api/v1"
)
GPT_CLIENT = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
CLAUDE_CLIENT = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))Được hỗ trợ bởi

Bước 3: Tạo hàm trợ giúp cho mỗi mô hình

Xây một hàm hợp nhất định tuyến tới đúng mô hình dựa trên tên. Cách này giúp mã gọn và dễ thêm mô hình về sau.

Bắt đầu với lời gọi Kimi K2:

def call_model(model_name: str, messages: List[Dict], **kwargs) -> Dict:
   """Call any model with unified interface."""
   try:
       start_time = time.time()

       if model_name == "Kimi K2 Thinking":
           enable_thinking = kwargs.get("enable_thinking", True)

           completion = KIMI_CLIENT.chat.completions.create(
               model="moonshotai/kimi-k2-thinking",
               messages=messages,
               temperature=1.0,
               extra_body={"include_reasoning": True}
           )

           message = completion.choices[0].message
           content = message.content

           # Extract reasoning from the dedicated field
           reasoning_content = None
           if enable_thinking and hasattr(message, 'reasoning') and message.reasoning:
               reasoning_content = message.reasoning

           return {
               "content": content,
               "reasoning_content": reasoning_content,
               "response_time": time.time() - start_time,
               "tokens_used": {
                   "input": completion.usage.prompt_tokens,
                   "output": completion.usage.completion_tokens,
                   "total": completion.usage.total_tokens
               },
               "error": None
           }Được hỗ trợ bởi

GPT-5 dùng cách khác với endpoint responses và nỗ lực suy luận cấu hình được:

      elif model_name == "GPT-5":
           reasoning_effort = kwargs.get("reasoning_effort", "medium")
           input_messages = [
               {"role": m["role"], "content": m["content"]}
               for m in messages
           ]

           response = GPT_CLIENT.responses.create(
               model="gpt-5",
               input=input_messages,
               reasoning={
                   "effort": reasoning_effort,
                   "summary": "auto"
               }
           )

           # Parse response structure
           reasoning_text = None
           content_text = ""

           for item in response.output:
               if item.type == "reasoning" and hasattr(item, "summary"):
                   summaries = [s.text for s in item.summary if hasattr(s, "text")]
                   reasoning_text = "\n\n".join(summaries) if summaries else None
               elif item.type == "message" and hasattr(item, "content"):
                   content_text += "".join(c.text for c in item.content if hasattr(c, "text"))

           return {
               "content": content_text,
               "reasoning_content": reasoning_text,
               "response_time": time.time() - start_time,
               "tokens_used": {
                   "input": getattr(response.usage, "input_tokens", 0),
                   "output": getattr(response.usage, "output_tokens", 0),
                   "total": getattr(response.usage, "total_tokens", 0)
               },
               "error": None
           }Được hỗ trợ bởi

GPT-5 cung cấp bốn mức nỗ lực suy luận: minimal, low, medium và high. Cấu trúc phản hồi tách phần suy luận thành các khối tóm tắt và phần nội dung thành các khối message, bạn sẽ phân tích riêng trước khi trả về cùng định dạng dict tiêu chuẩn như Kimi K2.

Claude Sonnet 4.5 triển khai thinking mode mở rộng với cách tiếp cận ngân sách token:

    else:  # Claude Sonnet 4.5
           enable_thinking = kwargs.get("enable_thinking", True)
           params = {
               "model": "claude-sonnet-4-5",
               "max_tokens": 10000,
               "messages": messages
           }
           if enable_thinking:
               params["thinking"] = {
                   "type": "enabled",
                   "budget_tokens": 5000
               }

           message = CLAUDE_CLIENT.messages.create(**params)

           # Extract content and thinking blocks
           content_text = ""
           thinking_text = None

           for block in message.content:
               if block.type == "thinking":
                   thinking_text = block.thinking
               elif block.type == "text":
                   content_text += block.text

           return {
               "content": content_text,
               "reasoning_content": thinking_text,
               "response_time": time.time() - start_time,
               "tokens_used": {
                   "input": message.usage.input_tokens,
                   "output": message.usage.output_tokens,
                   "total": message.usage.input_tokens + message.usage.output_tokens
               },
               "error": None
           }

   except Exception as e:
       return {
           "content": None,
           "reasoning_content": None,
           "response_time": 0,
           "tokens_used": {"input": 0, "output": 0, "total": 0},
           "error": f"{model_name} Error: {str(e)}"
       }Được hỗ trợ bởi

Claude phân bổ ngân sách token cho suy luận nội bộ trước khi tạo câu trả lời sau cùng. Phản hồi gồm nhiều khối nội dung bạn sẽ lặp qua, tách khối thinking khỏi khối text. Xử lý lỗi ở cuối trả về cùng cấu trúc dict tiêu chuẩn với thông điệp lỗi, đảm bảo lỗi API không làm vỡ giao diện.

Bước 4: Xây dựng giao diện Streamlit

Khi lớp API sẵn sàng, bạn có thể xây giao diện web. Cấu hình trang Streamlit trước:

def main():
   st.set_page_config(
       page_title="Multi-Model Comparison Chat",
       page_icon="🤖",
       layout="wide",
       initial_sidebar_state="expanded"
   )

   st.session_state.setdefault("messages", [])
   st.session_state.setdefault("model_responses", [])Được hỗ trợ bởi

Bố cục rộng tạo không gian cho ba cột cạnh nhau. Trạng thái phiên giữ lịch sử hội thoại và phản hồi mô hình khi Streamlit chạy lại script.

Thêm tiêu đề trang và điều khiển ở sidebar:

st.title("🤖 Multi-Model Comparison Chat")
   st.markdown("""
   Compare **Kimi K2 Thinking**, **GPT-5**, and **Claude Sonnet 4.5** side-by-side.
   All three models support reasoning modes - see how they approach problems differently.
   """)

   with st.sidebar:
       st.header("⚙️ Settings")

       st.subheader("Thinking Mode")
       kimi_thinking = st.checkbox("Enable Kimi K2 Thinking", value=True)
       gpt5_reasoning = st.selectbox(
           "GPT-5 Reasoning Effort",
           options=["minimal", "low", "medium", "high"],
           index=2
       )
       claude_thinking = st.checkbox("Enable Claude Thinking", value=True)Được hỗ trợ bởi

Sidebar cho phép người dùng kiểm soát thinking mode. Kimi K2 và Claude có công tắc bật/tắt. GPT-5 cung cấp bốn mức nỗ lực vì API của nó cho phép điều chỉnh chi tiết này.

Bên dưới phần thinking, thêm chỉ báo trạng thái API để người dùng biết dịch vụ nào đã kết nối:

st.subheader("API Status")
       st.markdown(f"""
       - Kimi K2: {"✅" if os.getenv("OPENROUTER_API_KEY") else "❌"}
       - GPT-5: {"✅" if os.getenv("OPENAI_API_KEY") else "❌"}
       - Claude: {"✅" if os.getenv("ANTHROPIC_API_KEY") else "❌"}
       """)Được hỗ trợ bởi

Dấu tích xuất hiện khi biến môi trường được thiết lập. Dấu X đỏ nghĩa là bạn cần thêm key tương ứng vào tệp .env.

Bước 5: Triển khai logic so sánh

Giờ là chức năng cốt lõi. Khi người dùng gửi tin nhắn, bạn sẽ gọi cả ba mô hình song song và hiển thị kết quả cạnh nhau.

def call_models_parallel(messages: List[Dict], selected_models: List[str],
                       kimi_thinking: bool, gpt5_reasoning: str,
                       claude_thinking: bool) -> Dict[str, Dict]:
   """Call multiple models in parallel."""
   model_kwargs = {
       "Kimi K2 Thinking": {"enable_thinking": kimi_thinking},
       "GPT-5": {"reasoning_effort": gpt5_reasoning},
       "Claude Sonnet 4.5": {"enable_thinking": claude_thinking}
   }

   with ThreadPoolExecutor(max_workers=3) as executor:
       futures = {
           executor.submit(call_model, m, messages, **model_kwargs[m]): m
           for m in selected_models if m in model_kwargs
       }
       return {futures[f]: f.result() for f in as_completed(futures)}Được hỗ trợ bởi

Hàm này gửi ba lời gọi API cùng lúc và thu kết quả khi hoàn tất. Gọi tuần tự sẽ mất 15–30 giây. Thực thi song song rút xuống 5–10 giây vì bạn chỉ chờ mô hình chậm nhất thay vì tổng thời gian cả ba.

Tích hợp thực thi song song vào giao diện chat:

   if prompt := st.chat_input("Ask a question to all models..."):
       st.session_state.messages.append({"role": "user", "content": prompt})

       with st.chat_message("user"):
           st.markdown(prompt)

       api_messages = [
           {"role": m["role"], "content": m["content"]}
           for m in st.session_state.messages
       ]

       with st.spinner("🤔 Models are thinking..."):
           responses = call_models_parallel(
               api_messages,
               ["Kimi K2 Thinking", "GPT-5", "Claude Sonnet 4.5"],
               kimi_thinking,
               gpt5_reasoning,
               claude_thinking
           )

       cols = st.columns(3)
       for idx, (model_name, response_data) in enumerate(responses.items()):
           with cols[idx]:
               st.markdown(f"### {model_name}")
               if response_data["reasoning_content"]:
                   with st.expander("🧠 Thinking Process", expanded=False):
                       st.markdown(response_data["reasoning_content"])
               st.markdown(response_data["content"])Được hỗ trợ bởi

Đoạn này tạo ba cột và hiển thị phản hồi của mỗi mô hình trong cột riêng. Quá trình suy nghĩ được thu gọn mặc định để người dùng thấy đáp án trước. Họ có thể mở phần suy luận khi muốn xem chi tiết.

Bước 6: Kiểm thử và tinh chỉnh

Chạy ứng dụng với:

streamlit run model_comparison_chat.pyĐược hỗ trợ bởi

Bắt đầu với bài test cơ bản để xác nhận mọi thứ hoạt động:

What is 2+2?Được hỗ trợ bởi

Cả ba mô hình nên phản hồi trong vài giây. Điều này xác nhận kết nối API và thực thi song song hoạt động. Ứng dụng chạy cục bộ, cho bạn toàn quyền kiểm soát khi nào gọi API. Mỗi truy vấn phát sinh chi phí API (khoảng $0.01–0.05 cho một lượt so sánh ba mô hình tùy độ dài phản hồi), nhưng chạy cục bộ nghĩa là bạn quyết định chính xác khi nào tiêu tốn.

Kiểm thử ứng dụng với prompt phức tạp

Bạn đã xây ứng dụng so sánh và thấy nó hoạt động với câu hỏi đơn giản. Nhưng khác biệt thực sự giữa các mô hình bộc lộ khi bạn đẩy chúng khó hơn. Để minh họa, tôi đã kiểm thử cả ba mô hình với các prompt phức tạp. Bạn có thể chạy các bài này trong ứng dụng để thấy kết quả trực tiếp. Dưới đây là những phát hiện chính.

Các prompt kiểm thử

Chúng tôi chọn ba thách thức khác nhau để kiểm tra các năng lực suy luận riêng biệt.

Bài test 1: Suy luận toán học nâng cao

Một khu vườn hình chữ nhật dài 24 foot và rộng 18 foot. Có một lối đi rộng 2 foot chạy quanh chu vi bên ngoài khu vườn. Nếu Sarah trồng hoa trong vườn với mật độ 4 bông trên mỗi foot vuông, rồi quyết định thêm đá trang trí trên 30% diện tích đã trồng (loại bỏ số hoa đó), còn lại bao nhiêu bông? Ngoài ra, tổng diện tích (foot vuông) của lối đi là bao nhiêu?

Bài test 2: Suy luận logic nhiều bước

Bốn người bạn - Alice, Bob, Carol và David - cần xếp thành một hàng để chụp ảnh. Các quy tắc sau phải được tuân theo:

1. Alice phải đứng cạnh Bob

2. Carol không được đứng ở hai đầu

3. David phải đứng bên trái Alice

Liệt kê tất cả các cách sắp xếp hợp lệ từ trái sang phải.

Bài test 3: Sinh mã với ràng buộc

Viết một hàm Python kiểm tra một chuỗi có phải địa chỉ IPv4 hợp lệ hay không, với các yêu cầu:

1. Phải xác thực định dạng (bốn octet ngăn cách bằng dấu chấm)

2. Mỗi octet phải trong khoảng 0-255 (không số 0 đứng đầu trừ khi chính nó là "0")

3. Phải loại các định dạng không hợp lệ (chuỗi rỗng, quá nhiều/ít octet, ký tự không phải số)

4. Độ phức tạp thời gian phải là O(n) với n là độ dài chuỗi

5. Bao gồm docstring đầy đủ với ví dụ

6. Thêm type hint cho mọi tham số và giá trị trả về

7. Xử lý các biên (chuỗi rỗng, None, ký tự đặc biệt)

Đồng thời giải thích cách tiếp cận xác thực và vì sao nó là O(n).

Kết quả

Cả ba mô hình đều giải đúng mọi bài. Nhưng họ đi những con đường rất khác nhau. Dưới đây là phân tích hiệu năng:

Đây là những gì mỗi mô hình thực sự làm trong khoảng thời gian đó.

Cách tiếp cận của Kimi K2

Nó liên tục khám phá và tự chất vấn. Ở bài toán khu vườn, nó hình dung bố cục, thực hiện phép tính, rồi dừng lại nói “Chờ đã, để tôi kiểm tra lại…” trước khi tiếp tục. Với bài sắp xếp ảnh, nó kiểm thử từng ràng buộc, thể hiện cách làm cho mọi khả năng. 

Trình kiểm tra IPv4 mất hơn 3 phút vì nó xét từng trường hợp biên, trình bày chứng minh độ phức tạp O(n), và xác minh logic nhiều lần. Bạn như đang xem ai đó nghĩ thành tiếng, tự bắt lỗi và xác nhận suy luận ở mỗi bước.

Cách tiếp cận của GPT-5

Nó có phương pháp và tổ chức. Nó chia bài toán khu vườn thành các phần rõ ràng, đánh số bước và thực hiện tuần tự. Bài sắp xếp ảnh được dẫn dắt có cấu trúc, đặt từng người theo vị trí đồng thời kiểm tra quy tắc. 

Mã đi kèm giải thích rõ và tài liệu hóa tốt. Nó không hay tự nghi ngờ như K2, cũng không quá vội như Claude. Bạn nhận được cái nhìn cân bằng về tư duy mà không quá dài dòng.

Cách tiếp cận của Claude

Nó di chuyển nhanh. Nó nhanh chóng xác định lộ trình lời giải cho mỗi bài và thực thi gọn. Với bài chụp ảnh, nó tổ chức theo trường hợp và xử lý từng trường hợp không dây dưa. Mã IPv4 sạch và tài liệu tốt, nhưng đi thẳng vào trọng tâm nhanh hơn. 

Claude cho thấy suy nghĩ nhưng không sa đà vào các bước xác minh. Tốc độ đến từ sự tự tin vào cách tiếp cận và ít quay đầu.

Những cách tiếp cận khác nhau này tạo ra mẫu đánh đổi rõ ràng. Chọn K2 khi bạn cần suy luận chi tiết để học, gỡ lỗi hoặc yêu cầu kiểm toán. Chọn Claude khi tốc độ quan trọng và bạn tin kết quả mà không cần xem chuỗi suy luận. Chọn GPT-5 khi bạn muốn hiệu năng cân bằng giữa sự chi tiết của K2 và tốc độ của Claude.

Lưu ý: Hãy xem kết quả này với chừng mực vì chúng không thể kiểm thử toàn diện năng lực của cả ba mô hình.

Kết luận

Bạn đã thiết lập Kimi K2 Thinking qua OpenRouter, khám phá khả năng suy luận, xây dựng quy trình gọi công cụ và tạo ứng dụng so sánh để kiểm thử với GPT-5 và Claude. Thế mạnh của K2 là điều phối công cụ độc lập và suy luận minh bạch, phù hợp với quy trình phức tạp nơi bạn cần xác minh quyết định của mô hình.

Năng lực và chi phí hợp lý của K2 giúp điều này khả thi. Nó có thể thực hiện số lượng lớn các lần gọi công cụ tuần tự so với vài chục của hầu hết đối thủ, và trường reasoning_content hiển thị mọi bước suy nghĩ. Với chi phí token đầu ra xấp xỉ bằng 1/4 GPT-5 và 1/6 Claude, bạn có thể chạy thử nghiệm mở rộng mà không lo ngân sách.

Ứng dụng so sánh bạn xây cung cấp bằng chứng trực tiếp về các đánh đổi này. Hãy kiểm thử với bài toán và quy trình của riêng bạn để hình thành trực giác liệu suy luận chi tiết của K2 có xứng đáng với thời gian phản hồi dài hơn không. Kiểm thử thực tế với trường hợp sử dụng cụ thể của bạn sẽ bộc lộ các mẫu mà điểm chuẩn tổng quát không thể nêu bật.

Để mở rộng các khái niệm này, hãy xem hướng dẫn OpenRouter của DataCamp để quản lý nhiều nhà cung cấp LLM, hướng dẫn GPT-5 về các mức độ nỗ lực suy luận, và hướng dẫn Claude Sonnet 4 cho thinking mode mở rộng.