Cách Sử Dụng LLM Cục Bộ Làm API

Máy tính xách tay của bạn có thể chạy một mô hình 70B tham số phía sau cùng một endpoint có dạng OpenAI mà bạn dùng trong production. Nếu client của bạn đã gọi POST /v1/chat/completions, bạn chỉ cần đổi base_url; phần lớn mã, test và CI vẫn giữ nguyên. Cách làm này giúp bạn phát triển offline, giảm chi phí token về 0 trong môi trường dev, và giữ dữ liệu nhạy cảm trong hạ tầng riêng. Bài viết này hướng dẫn cách chọn runtime, expose endpoint, trỏ client tới đó và kiểm tra toàn bộ luồng với Apidog trước khi đẩy thay đổi lên mô hình hosted.

Dùng thử Apidog hôm nay

TL;DR

Bạn có thể chạy một API LLM cục bộ bằng Ollama, vLLM hoặc llama.cpp. Cả ba đều có thể expose endpoint REST tương thích OpenAI.

Ví dụ, với Ollama:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",
)

resp = client.chat.completions.create(
    model="llama3.3:70b-instruct-q4_K_M",
    messages=[{"role": "user", "content": "Reply with OK only."}],
)

print(resp.choices[0].message.content)

Nếu code của bạn đang dùng OpenAI SDK, điểm cần đổi thường chỉ là:

- base_url="https://api.openai.com/v1"
+ base_url="http://localhost:11434/v1"

Sau đó, dùng Apidog để chạy cùng một bộ request/test trên cả Local và Production, giúp hợp đồng API nhất quán giữa mô hình cục bộ và mô hình hosted.

Giới thiệu

Ngăn xếp API LLM cục bộ đã chuyển từ công cụ nghiên cứu sang công cụ dev hằng ngày. Apple đã đưa bộ nhớ hợp nhất 128 GB lên M3 Max. Ollama đạt một triệu lượt tải xuống hằng tuần. vLLM vượt mốc 30.000 sao trên GitHub. Nhưng thay đổi quan trọng nhất với lập trình viên API là: các runtime chính đều hỗ trợ định dạng /v1/chat/completions của OpenAI.

Điều này có nghĩa là bạn không cần duy trì hai client riêng. Một SDK call có thể trỏ đến localhost hoặc api.openai.com bằng một biến môi trường.

Nếu bạn đã có request trong Apidog trỏ tới:

https://api.openai.com/v1/chat/completions

hãy đổi host thành biến:

{{BASE_URL}}/chat/completions

Sau đó đặt:

BASE_URL=http://localhost:11434/v1
API_KEY=ollama

Bạn sẽ nhận cùng dạng JSON response từ mô hình đang chạy trên GPU hoặc CPU của mình. Không cần schema mới. Không cần flow xác thực mới. Nếu bạn đang theo dõi chi phí API theo tính năng, bạn cũng có thể A/B test mô hình local với mô hình hosted và so sánh chi phí, độ trễ, chất lượng output.

Bài viết này đi qua các phần:

• Chọn runtime local LLM.
• Chạy OpenAI-compatible endpoint.
• Kết nối Python/JavaScript client.
• Kiểm thử bằng Apidog.
• Tối ưu lượng tử hóa, GPU offload, streaming và batching.
• So sánh chi phí và độ trễ giữa local và hosted.

Các ví dụ được kiểm tra với Ollama 0.6 và vLLM 0.7 trên macOS 15.4 và Ubuntu 24.04. Nếu bạn muốn khảo sát thêm mô hình, xem Các LLM cục bộ tốt nhất năm 2026.

Tại sao LLM cục bộ hữu ích với nhà phát triển API

Bạn không chỉ chạy code trong production. Bạn còn phải debug trên máy bay, tại hội nghị có Wi-Fi yếu, hoặc trong mạng khách hàng chặn outbound tới *.openai.com.

Một API LLM cục bộ giúp bạn có môi trường dev giống production nhưng không phụ thuộc mạng.

Các lợi ích chính:

1. Phát triển offline
   
   Bạn vẫn có thể chạy prompt, test API, debug agent và kiểm tra regression mà không cần Internet.

2. Dữ liệu không rời khỏi máy hoặc mạng nội bộ
   
   Prompt có thể chứa hồ sơ bệnh nhân, hợp đồng, mã nguồn, thông tin tài khoản hoặc dữ liệu định danh. Với mô hình local, payload không phải đi qua nhà cung cấp hosted.

3. Chi phí dev gần như bằng 0 theo token
   
   Nếu team gửi hàng chục triệu token mỗi ngày trong quá trình test, chạy local có thể giảm đáng kể chi phí thử nghiệm. Bạn có thể tham khảo cách tính chi phí trong Cách sử dụng GPT-5.5 Instant và áp dụng cho workload của mình.

4. Tính ổn định cho regression test
   
   Mô hình hosted có thể thay đổi snapshot hoặc ngừng hỗ trợ phiên bản cũ. Mô hình local là file trên đĩa. Nếu bạn pin đúng model file và runtime, test có khả năng lặp lại cao hơn.

Điểm mấu chốt: endpoint tương thích OpenAI giúp bạn có các lợi ích trên mà không phải viết lại client.

Ba runtime cung cấp endpoint tương thích OpenAI

Hiện có nhiều runtime local LLM, nhưng với nhu cầu API development, ba lựa chọn thực dụng nhất là:

• Ollama
• vLLM
• llama.cpp

Chọn theo workload, không chỉ theo độ phổ biến.

1. Ollama: nhanh nhất để bắt đầu

Ollama phù hợp nếu bạn muốn chạy một mô hình local trên laptop hoặc workstation cá nhân. Nó xử lý việc tải model, quản lý GGUF, prompt template và HTTP server.

Cài và chạy trên macOS:

brew install ollama
ollama serve &
ollama pull llama3.3:70b-instruct-q4_K_M
ollama run llama3.3:70b-instruct-q4_K_M

Endpoint OpenAI-compatible mặc định:

http://localhost:11434/v1

Test nhanh bằng curl:

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ollama" \
  -d '{
    "model": "llama3.3:70b-instruct-q4_K_M",
    "messages": [
      { "role": "user", "content": "Reply with OK only." }
    ]
  }'

Ollama phù hợp cho:

• Dev cá nhân.
• Demo nội bộ.
• CI runner có tài nguyên đủ.
• Test prompt và API contract trước khi gọi model hosted.

Trên M3 Max, mô hình 70B Q4_K_M đạt khoảng 12 token/giây. Các mô hình nhỏ hơn có thể đạt 80-120 token/giây tùy cấu hình.

2. vLLM: phù hợp cho cụm dev hoặc server GPU

vLLM phù hợp hơn với môi trường nhiều request đồng thời. Nó dùng PagedAttention và continuous batching để tăng throughput so với runner thông thường.

Cài và chạy:

pip install vllm

vllm serve meta-llama/Llama-3.3-70B-Instruct \
  --port 8000 \
  --gpu-memory-utilization 0.9 \
  --max-model-len 8192

Endpoint:

http://localhost:8000/v1

Test:

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meta-llama/Llama-3.3-70B-Instruct",
    "messages": [
      { "role": "user", "content": "Return a JSON object with status ok." }
    ]
  }'

vLLM phù hợp cho:

• Shared dev cluster.
• Server có CUDA GPU hoặc AMD ROCm mới.
• Load test nhiều request song song.
• Môi trường staging nội bộ.

Nó không phải lựa chọn phù hợp cho Apple Silicon laptop, nhưng rất mạnh trên GPU server.

3. llama.cpp: kiểm soát tối đa và chạy được trên nhiều phần cứng

llama.cpp là runtime C++ phổ biến trong hệ sinh thái GGUF. Nó chạy được từ Raspberry Pi đến máy nhiều GPU. Binary llama-server hỗ trợ endpoint tương thích OpenAI.

Build và chạy trên macOS với Metal:

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make -j LLAMA_METAL=1

./llama-server \
  -m models/llama-3.3-70b-q4_k_m.gguf \
  --port 8080 \
  --host 0.0.0.0 \
  -c 8192 \
  -ngl 99

Endpoint:

http://localhost:8080/v1/chat/completions

Cờ quan trọng:

-ngl 99

Cờ này chuyển số lớp transformer tối đa sang GPU. Nếu VRAM không đủ, giảm dần giá trị này.

llama.cpp phù hợp khi bạn cần:

• Chạy trên phần cứng hạn chế.
• Kiểm soát lượng tử hóa.
• Tối ưu memory mapping.
• Thử nghiệm nhiều file GGUF khác nhau.
• Nhúng model vào môi trường không chuẩn.

LM Studio và Jan cũng dùng llama.cpp phía dưới và expose endpoint OpenAI trên cổng cấu hình được. Chúng hữu ích nếu thành viên không chuyên terminal cần test prompt.

Kiểm tra endpoint bằng OpenAI Python SDK

Sau khi runtime chạy, xác minh bằng SDK bạn đang dùng trong app.

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",
)

resp = client.chat.completions.create(
    model="llama3.3:70b-instruct-q4_K_M",
    messages=[
        {"role": "user", "content": "Reply with the word OK only."}
    ],
)

print(resp.choices[0].message.content)

Nếu output là OK, nghĩa là:

• Runtime đang chạy.
• Port đúng.
• Endpoint tương thích OpenAI.
• SDK contract khớp.

Kiểm tra LLM cục bộ với Apidog

Một local LLM API chỉ hữu ích nếu test suite có thể gọi nó giống production. Apidog xử lý việc này bằng environment variables.

Bước 1: Tạo environment Local

Trong Apidog, tạo environment mới:

Name: Local
BASE_URL: http://localhost:11434/v1
API_KEY: ollama

Nếu dùng vLLM:

BASE_URL: http://localhost:8000/v1

Nếu dùng llama.cpp:

BASE_URL: http://localhost:8080/v1

Bước 2: Tạo environment Production

Sao chép environment OpenAI hiện có và đặt:

Name: Production
BASE_URL: https://api.openai.com/v1
API_KEY: <production-api-key>

Bước 3: Chuẩn hóa request URL

Thay URL hard-code:

https://api.openai.com/v1/chat/completions

bằng:

{{BASE_URL}}/chat/completions

Header:

Authorization: Bearer {{API_KEY}}
Content-Type: application/json

Body mẫu:

{
  "model": "llama3.3:70b-instruct-q4_K_M",
  "messages": [
    {
      "role": "system",
      "content": "You are a JSON-only assistant."
    },
    {
      "role": "user",
      "content": "Return {\"status\":\"ok\"}."
    }
  ],
  "response_format": {
    "type": "json_object"
  }
}

Bước 4: Thêm assertions

Trong test script của request hoặc scenario, kiểm tra các điểm tối thiểu:

pm.test("assistant role exists", function () {
  const json = pm.response.json();
  pm.expect(json.choices[0].message.role).to.eql("assistant");
});

pm.test("content is not empty", function () {
  const json = pm.response.json();
  pm.expect(json.choices[0].message.content).to.not.be.empty;
});

pm.test("usage has total_tokens", function () {
  const json = pm.response.json();
  pm.expect(json.usage.total_tokens).to.be.above(0);
});

Nếu runtime local không trả usage giống hosted provider, hãy nới assertion:

pm.test("response has assistant message", function () {
  const json = pm.response.json();
  pm.expect(json.choices).to.be.an("array").that.is.not.empty;
  pm.expect(json.choices[0].message.content).to.not.be.empty;
});

Bước 5: Chạy cùng scenario trên hai environment

Chạy scenario với:

Environment: Local

Sau đó đổi sang:

Environment: Production

Nếu cả hai đều pass, app của bạn đang dùng cùng API contract cho local và hosted model.

Scenario này cũng là smoke test tốt sau khi bạn:

ollama pull llama3.3:70b-instruct-q4_K_M

hoặc nâng cấp runtime. Nếu response shape thay đổi, bạn phát hiện trước khi application code bị ảnh hưởng.

Mẫu này cũng áp dụng cho kiểm thử các tác nhân AI gọi API nhiều bước.

Kết nối từ Python app

Đừng hard-code endpoint. Dùng environment variables.

import os
from openai import OpenAI

def get_client():
    if os.getenv("ENV") == "local":
        return OpenAI(
            base_url=os.getenv("LOCAL_LLM_BASE_URL", "http://localhost:11434/v1"),
            api_key=os.getenv("LOCAL_LLM_API_KEY", "ollama"),
        )

    return OpenAI(
        base_url=os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1"),
        api_key=os.environ["OPENAI_API_KEY"],
    )

client = get_client()

response = client.chat.completions.create(
    model=os.getenv("MODEL", "llama3.3:70b-instruct-q4_K_M"),
    messages=[
        {"role": "system", "content": "You are a JSON-only assistant."},
        {"role": "user", "content": "Return {\"status\": \"ok\"}."},
    ],
    response_format={"type": "json_object"},
)

print(response.choices[0].message.content)

Chạy local:

ENV=local \
LOCAL_LLM_BASE_URL=http://localhost:11434/v1 \
LOCAL_LLM_API_KEY=ollama \
MODEL=llama3.3:70b-instruct-q4_K_M \
python app.py

Chạy production:

ENV=production \
OPENAI_API_KEY=$OPENAI_API_KEY \
MODEL=gpt-5.5-instant \
python app.py

Kết nối từ JavaScript/TypeScript

import OpenAI from "openai";

const isLocal = process.env.ENV === "local";

const client = new OpenAI({
  baseURL: isLocal
    ? process.env.LOCAL_LLM_BASE_URL || "http://localhost:11434/v1"
    : process.env.OPENAI_BASE_URL || "https://api.openai.com/v1",
  apiKey: isLocal
    ? process.env.LOCAL_LLM_API_KEY || "ollama"
    : process.env.OPENAI_API_KEY,
});

const resp = await client.chat.completions.create({
  model: process.env.MODEL || "llama3.3:70b-instruct-q4_K_M",
  messages: [
    {
      role: "user",
      content: "Say hi.",
    },
  ],
});

console.log(resp.choices[0].message.content);

Chạy local:

ENV=local \
LOCAL_LLM_BASE_URL=http://localhost:11434/v1 \
LOCAL_LLM_API_KEY=ollama \
MODEL=llama3.3:70b-instruct-q4_K_M \
node app.js

Đưa Apidog scenario vào CI

Bạn có thể export project thành collection cho apidog-cli và gọi trong GitHub Actions.

Ví dụ workflow:

name: API contract test

on:
  pull_request:
  push:
    branches: [main]

jobs:
  test-local-llm-contract:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Install Apidog CLI
        run: npm install -g apidog-cli

      - name: Run Apidog scenario
        run: |
          apidog run ./apidog-collection.json \
            --env Local

Nếu assertion fail, CLI trả exit code khác 0 và build sẽ fail.

Các kỹ sư QA có thể gắn cùng luồng này vào quy trình kiểm thử API hiện có.

Kỹ thuật nâng cao và mẹo triển khai

1. Chọn mức lượng tử hóa phù hợp

Lượng tử hóa quyết định mô hình có vừa laptop hay không.

Các mức phổ biến trong GGUF:

Mức	Dung lượng	Chất lượng	Khi nào dùng
Q8	Lớn	Gần FP16 nhất	Sinh code, tác vụ cần chất lượng cao
Q5_K_M	Trung bình-lớn	Rất tốt	Khi có đủ RAM và muốn an toàn
Q4_K_M	Trung bình	Cân bằng tốt	Chat, dev, test, agent
Q2_K	Nhỏ	Suy giảm rõ	Chỉ dùng khi thiếu RAM nghiêm trọng

Khuyến nghị thực tế:

Chat/dev: Q4_K_M
Code generation: Q8 hoặc Q5_K_M
Máy ít RAM: Q3 hoặc Q2, nhưng cần kiểm tra chất lượng kỹ

Q4_K_M thường là lựa chọn mặc định vì giảm mạnh dung lượng nhưng vẫn giữ chất lượng đủ tốt cho nhiều tác vụ.

2. GPU offload

Trong llama.cpp, dùng -ngl:

./llama-server \
  -m models/model.gguf \
  -ngl 99

Trong Ollama, bạn có thể cấu hình số GPU/layer thông qua model options.

Nguyên tắc:

• Đẩy càng nhiều layer lên GPU càng tốt.
• Nếu VRAM không đủ, giảm dần.
• Mỗi phần rơi về CPU có thể làm throughput giảm đáng kể.

3. Memory mapping

llama.cpp và Ollama thường bật mmap mặc định. Cơ chế này cho phép OS phân trang trọng số theo nhu cầu thay vì load toàn bộ model ngay khi start.

Giữ mặc định nếu bạn chạy trên laptop hoặc workstation. Chỉ tắt nếu bạn đang ở container có giới hạn memory đặc biệt và đã đo đạc kỹ.

4. Batching với vLLM

vLLM mạnh nhất khi có nhiều request đồng thời.

Ví dụ:

vllm serve meta-llama/Llama-3.3-70B-Instruct \
  --port 8000 \
  --max-num-seqs 64 \
  --gpu-memory-utilization 0.9

Gợi ý:

Laptop/shared memory: --max-num-seqs 64
Server H100-class:    --max-num-seqs 256

Hãy đo bằng workload thật. Batching cao hơn không phải lúc nào cũng tốt nếu latency từng request tăng quá nhiều.

5. Streaming để giảm độ trễ cảm nhận

Trong Python:

stream = client.chat.completions.create(
    model="llama3.3:70b-instruct-q4_K_M",
    messages=[{"role": "user", "content": "Explain local LLMs briefly."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="")

Streaming không làm model tính nhanh hơn, nhưng user thấy token đầu tiên sớm hơn.

6. Dùng Ollama Modelfile để đóng gói cấu hình

Ví dụ Modelfile:

FROM llama3.3:70b-instruct-q4_K_M

SYSTEM """
You are a JSON-only assistant. Always return valid JSON.
"""

PARAMETER temperature 0.2
PARAMETER stop "</json>"

Tạo model:

ollama create my-assistant -f Modelfile

Client chỉ cần gọi:

response = client.chat.completions.create(
    model="my-assistant",
    messages=[
        {"role": "user", "content": "Return status ok."}
    ],
)

Cách này giúp application code sạch hơn và giảm việc lặp system prompt ở mọi request.

Những lỗi thường gặp

• Hard-code http://localhost:11434 trong production code. Hãy dùng biến môi trường.
• Quên gửi header Authorization. Ollama có thể bỏ qua, nhưng vLLM với --api-key sẽ trả 401.
• Chạy hai runtime trên cùng một port.
• Dùng model Q4 và kỳ vọng chất lượng reasoning như model hosted mạnh hơn.
• Không pin model tag hoặc file GGUF, làm regression test thay đổi theo thời gian.
• Không đặt max_tokens hoặc stop sequence, khiến response local dài ngoài dự kiến.
• Giả định mọi runtime trả usage giống OpenAI. Hãy viết assertion linh hoạt nếu cần.

Local so với hosted: chi phí và độ trễ

Các con số dưới đây giả định một M3 Max với 128 GB unified memory cho local, và giá public hiện tại cho endpoint hosted. TTFT là “time to first token”, đo cold run, không batching, với prompt 1.024 token.

Mô hình	TTFT cục bộ	Thông lượng cục bộ	Tương đương hosted	Giá hosted	TTFT hosted
Llama 3.3 70B Q4_K_M	1.2 s	12 tok/s	GPT-5.5 Instant	$5 / $30 mỗi 1M	200 ms
DeepSeek V4 67B Q4_K_M	1.4 s	10 tok/s	DeepSeek-Chat hosted	$0.55 / $2.20 mỗi 1M	280 ms
Qwen 3.6 32B Q5_K_M	0.7 s	28 tok/s	Qwen-Max hosted	$1.60 / $6.40 mỗi 1M	240 ms
Gemma 4 27B Q4_K_M	0.5 s	35 tok/s	Gemini 3 Flash	$0.35 / $1.05 mỗi 1M	180 ms

Kết luận thực dụng:

• Hosted thường thắng về latency.
• Local thắng về chi phí trong development và workload token lớn.
• Local thắng về quyền riêng tư ngay từ request đầu tiên.
• Production hướng user thường vẫn phù hợp với hosted, trừ khi yêu cầu dữ liệu không cho phép.
• Development, regression test và prompt iteration rất phù hợp với local.

Một pattern dễ triển khai:

Local dev:      Ollama / llama.cpp
Shared staging: vLLM hoặc hosted model
Production:    hosted model hoặc private deployment
CI:            chạy cùng Apidog scenario trên nhiều environment

Các bài test scenario trong Apidog hỗ trợ pattern này bằng một dropdown environment duy nhất.

Nếu bạn cần benchmark sâu hơn, xem Cách chạy DeepSeek V4 cục bộ và hướng dẫn sử dụng DeepSeek V4.

Các trường hợp sử dụng thực tế

Fintech compliance

Một nhóm tuân thủ fintech ở Singapore dùng Ollama trên laptop của kỹ sư để soạn báo cáo hoạt động đáng ngờ. Prompt chứa số tài khoản và mẫu giao dịch không được phép rời khỏi quốc gia theo quy định MAS.

Trong production, endpoint hosted chỉ nhận bản prompt đã ẩn danh. Apidog scenario kiểm tra rằng bước ẩn danh luôn chạy trước khi request rời khỏi localhost.

Game studio

Một studio game ở Stockholm huấn luyện thực tập sinh thiết kế prompt bằng Qwen 3.6 local. Cách này miễn phí, offline và không làm rò rỉ cốt truyện game mới cho bên thứ ba.

Khi lên production, họ chuyển sang Gemini 3 Flash bằng một biến môi trường. Họ tái sử dụng hướng dẫn API Gemini 3 Flash để cấu hình production endpoint.

Healthtech trong mạng bệnh viện

Một startup y tế chạy vLLM trên A100 thuê bên trong mạng bệnh viện của khách hàng. Endpoint không có DNS public. Integration test chạy từ Jenkins agent trong cùng VLAN và vẫn dùng OpenAI SDK giống local.

Kết quả:

Một codebase
Ba target triển khai
Một bộ scenario test

Checklist triển khai nhanh

Dùng checklist này nếu bạn muốn setup trong một buổi chiều.

1. Chạy runtime

Với Ollama:

brew install ollama
ollama serve &
ollama pull llama3.3:70b-instruct-q4_K_M

2. Test endpoint

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ollama" \
  -d '{
    "model": "llama3.3:70b-instruct-q4_K_M",
    "messages": [
      { "role": "user", "content": "Reply OK." }
    ]
  }'

3. Đổi app config

ENV=local
LOCAL_LLM_BASE_URL=http://localhost:11434/v1
LOCAL_LLM_API_KEY=ollama
MODEL=llama3.3:70b-instruct-q4_K_M

4. Tạo Apidog environments

Local:
BASE_URL=http://localhost:11434/v1
API_KEY=ollama

Production:
BASE_URL=https://api.openai.com/v1
API_KEY=<real-key>

5. Dùng URL biến hóa

{{BASE_URL}}/chat/completions

6. Thêm assertions

Kiểm tra tối thiểu:

choices[0].message.content không rỗng
choices[0].message.role == assistant
response status == 200

7. Chạy cùng scenario trên Local và Production

Nếu cả hai pass, bạn đã có API contract thống nhất giữa local và hosted LLM.

Kết luận

Local LLM API đã đủ trưởng thành để đưa vào workflow hằng ngày của developer. Bạn có thể chuyển prompt khỏi hosted endpoint trong dev mà không phải viết lại client, test hoặc CI.

Năm bước quan trọng:

• Chọn Ollama cho laptop, vLLM cho shared GPU server, llama.cpp cho phần cứng hạn chế.
• Expose endpoint tương thích OpenAI và xác minh bằng curl hoặc SDK.
• Đưa base_url, api_key, model vào environment variables.
• Xây dựng scenario test trong Apidog để chạy giống nhau trên local và production.
• Dùng bảng chi phí/độ trễ để quyết định workload nào nên chạy local, workload nào nên chạy hosted.

Nếu bạn chưa chọn mô hình, hãy bắt đầu với Các LLM cục bộ tốt nhất năm 2026. Nếu bạn muốn kiểm thử agent nhiều bước trên các endpoint này, đọc tiếp Cách kiểm thử API tác nhân AI.