API AI tích hợp sẵn: Việc nên làm và không nên làm

Ngày xuất bản: 30 tháng 4 năm 2026

Nhờ AI tích hợp, trang web hoặc ứng dụng web của bạn có thể thực hiện các nhiệm vụ dựa trên AI mà không cần triển khai, quản lý hoặc tự lưu trữ mô hình. Bạn có thể gặp khó khăn khi chuyển từ bản minh hoạ sang một tính năng sẵn sàng phát hành công khai. Tài liệu này đề cập đến các yếu tố cần cân nhắc về kỹ thuật và trải nghiệm người dùng để giúp bạn tránh những sai lầm thường gặp.

Hầu hết hướng dẫn đều áp dụng cho tất cả API AI tích hợp sẵn. Có ghi chú các trường hợp ngoại lệ.

Chuẩn bị mô hình vào thời điểm hợp lý

Nên: Khởi động phiên ngay khi bạn xác định rõ ý định của người dùng về việc sử dụng tính năng AI, ví dụ: khi người dùng chuyển đến một nền tảng công cụ AI có liên quan, di chuột qua một không gian làm việc AI hoặc tương tác với giao diện người dùng xung quanh tính năng đó. Việc khởi động trước phiên cho phép mô hình tải vào bộ nhớ một cách thầm lặng ở chế độ nền trong khi người dùng đang thiết lập nhiệm vụ, giúp loại bỏ độ trễ khởi động nguội có thể tránh được. Cố gắng đi trước một bước bằng cách bắt đầu tác vụ AI có khả năng xảy ra tiếp theo ngay khi bạn bắt đầu kết xuất kết quả hiện tại, ví dụ: nếu tính năng này được thiết kế để sử dụng lặp lại.

Không nên: Trừ phi cần thiết, đừng đợi người dùng nhấp vào "Tạo" để khởi chạy phiên. Điều này dẫn đến độ trễ khởi động nguội, vì trước tiên, mô hình phải tải vào bộ nhớ và chuẩn bị quy trình thực thi.

Đặt câu lệnh ban đầu trong quá trình tạo

Hướng dẫn sau đây áp dụng cho Prompt API.

Nên: Cung cấp chỉ dẫn hệ thống trong quá trình khởi chạy phiên để cải thiện tốc độ của câu lệnh đầu tiên.

Không nên: Bắt đầu bằng một phiên trống và gửi chỉ dẫn hệ thống trong lệnh gọi prompt() đầu tiên. Điều này làm tăng độ trễ vì buộc mô hình phải xử lý các chỉ dẫn đó vào phút cuối.

// ✅ DO: Create the session as early as possible (warm up the model early) and
// use initialPrompts for system instructions in the create call
const session = await LanguageModel.create({
  initialPrompts: [
    {
      role: 'system',
      content: 'You are a helpful assistant specialized in code reviews.'
    }
  ]
});

// Once the user triggers the AI feature
const review = await session.prompt(`Review the following code:\n\n${code}`);

// ❌ DON'T: Send instructions using prompt() after creation
// const slowerSession = await LanguageModel.create();
// await slowerSession.prompt(`You are a helpful assistant specialized in code reviews.\n\nReview the following code:\n\n${code}`); // Higher latency

Sao chép phiên cho các tác vụ lặp lại

Hướng dẫn sau đây áp dụng cho Prompt API.

Đối với Prompt API, mỗi phiên sẽ theo dõi bối cảnh của cuộc trò chuyện, xem xét tất cả các lượt tương tác trước đó. Vì bản sao kế thừa mọi thứ từ phiên gốc, bao gồm cả câu lệnh ban đầu và tất cả nhật ký tương tác cho đến thời điểm sao chép, nên hãy cấu trúc cách sử dụng để chỉ kế thừa những gì bạn cần.

Nên làm:

  • Tạo phiên cơ sở: Để xử lý các nhiệm vụ không liên quan một cách hiệu quả, hãy tạo một phiên cơ sở chỉ chứa các chỉ dẫn hệ thống và không có ngữ cảnh trò chuyện trước đó.
  • Sao chép phiên cơ sở: Sử dụng clone() trên phiên cơ sở đó cho các tác vụ mới để tiết kiệm tài nguyên cho việc phân tích cú pháp lại các chỉ dẫn hệ thống. Nhờ đó, bạn có thể tạo các cuộc trò chuyện song song hoặc đặt lại một nhiệm vụ về trạng thái ban đầu.

Không nên:

  • Đừng sử dụng lại cùng một phiên cho các nhiệm vụ không liên quan và tránh sao chép bất kỳ phiên nào đã chứa nhật ký tương tác không cần thiết. Cả hai mẫu này đều có thể khiến bối cảnh trước đó không liên quan can thiệp vào nhiệm vụ hiện tại của bạn.
  • Đừng gọi create() nhiều lần bằng cùng một chỉ dẫn hệ thống. Thay vào đó, hãy sử dụng mẫu sao chép để tối ưu hoá hiệu suất.
// ✅ DO: Create a baseline session and clone it for each new task
const baseSession = await LanguageModel.create({
  initialPrompts: [{
    role: 'system',
    content: 'You are a technical editor...',
  }],
});

// Clone the base session once for the first task
const task1 = await baseSession.clone();
const response1 = await task1.prompt("Review this first draft...");
// ... Repeat the cloning pattern for subsequent independent tasks
// Each task starts fresh from the baseline system instructions

// ❌ DON'T:
// Bad performance pattern: repeated create() calls for identical tasks.
// This forces the model to re-parse instructions every time, increasing latency.
// const sessionA = await LanguageModel.create({ initialPrompts: [...] });
// await sessionA.prompt("Task 1...");
// const sessionB = await LanguageModel.create({ initialPrompts: [...] });
// await sessionB.prompt("Task 2...");
// Bad quality pattern: reusing the same session for unrelated tasks.
// const session = await LanguageModel.create();
// await session.prompt("Analyze this financial report...");
// Unrelated task in the same session:
// await session.prompt("Now write a children's story...");

Huỷ các phiên không dùng đến

Nên làm: Gọi rõ ràng destroy() trên các phiên mà bạn không cần nữa để giải phóng bộ nhớ khi một tính năng không còn được sử dụng. Nếu bạn sử dụng mẫu sao chép, hãy giữ lại phiên cơ sở và huỷ các bản sao bạn không cần nữa.

Không nên: Duy trì nhiều phiên lớn đang hoạt động. Mỗi phiên đều tiêu tốn bộ nhớ, điều này tạo ra mức sử dụng tài nguyên không cần thiết và có thể trở thành vấn đề. Trình thu gom rác sẽ tự động dọn dẹp các phiên, nhưng việc gọi destroy() sẽ giải phóng bộ nhớ nhanh hơn.

// ✅ DO: Use the clone and destroy it immediately after
const clone = await baseSession.clone();
const response = await clone.prompt("Quick task...");
// Free memory right away: destry the clone, keep the baseSession
clone.destroy();

Hiển thị câu trả lời trực tuyến một cách an toàn và hiệu quả

Hướng dẫn này áp dụng cho các API có hỗ trợ truyền trực tuyến (Prompt, Summarizer, Writer, Rewriter và Translator).

Nên: Coi tất cả kết quả của LLM là nội dung không đáng tin cậy. Hãy dọn dẹp toàn bộ kết quả kết hợp, chứ không chỉ các đoạn, vì mã độc hại có thể được phân tách giữa các bản cập nhật. Trước khi kết xuất, hãy sử dụng API Trình dọn dẹp nếu được hỗ trợ. Để tránh làm giảm hiệu suất, hãy sử dụng trình phân tích cú pháp Markdown trực tuyến như streaming-markdown.

Không nên: Đặt trực tiếp innerHTML trên mỗi lần cập nhật phân đoạn. Cách này chậm, đặc biệt là khi định dạng phức tạp như làm nổi bật cú pháp và dễ bị chèn.

import * as smd from "streaming-markdown";
// Set up virtual buffer and Sanitizer API
const sanitizer = new Sanitizer({
  allowElements: ['figure', 'figcaption', 'p', 'br', 'strong', 'em', 'img', 'a'],
  allowAttributes: {
    'loading': ['img'], 'decoding': ['img'], 'src': ['img'], 'href': ['a']
  }
});

// Create an off-screen fragment so the parser doesn't cause flicker
// or trigger XSS in the live DOM during the building process.
const buffer = new DocumentFragment();
const parser = smd.parser_new(buffer);

// Use sanitizer as a gatekeeper / cleaner function so we can combine it with the streaming Markdown parser
function syncSanitized(target, sourceFragment) {
  // .sanitize() returns a fresh, clean DocumentFragment
  const cleanFragment = sanitizer.sanitize(sourceFragment);
  // replaceChildren is the modern high-performance way to swap DOM content
  target.replaceChildren(cleanFragment);
}

// Streaming Logic
// `chunks` keeps track of the raw string (useful for logs/debug)
chunks += chunk;
// Let the parser build the DOM incrementally in the buffer.
// This is high-performance because the buffer is not live
smd.parser_write(parser, chunk);
// Use the Sanitizer API to port the content safely to the container.
syncSanitized(container, buffer);

Tối ưu hoá dữ liệu đầu vào để tăng tốc độ

Nên làm: Chỉ truyền cho mô hình những thông tin thực sự cần thiết. Loại bỏ mọi thứ không liên quan đến nhiệm vụ hiện tại. Đối với các tập dữ liệu lớn, hãy cung cấp thông tin tổng quan ngắn gọn và một số mục có liên quan.

Không nên: Gửi văn bản thô chưa xử lý, siêu dữ liệu không cần thiết, thẻ HTML hoặc danh sách lớn chưa lọc đến API. Độ trễ tăng đáng kể theo kích thước đầu vào, điều này có thể khiến tính năng AI có vẻ như bị hỏng trên nhiều thiết bị.

// ✅ DO: Send only relevant text
const cleanText = document.querySelector('#article').innerText;
const summary = await Summarizer.summarize(cleanText);

// ❌ DON'T: Send the entire DOM structure
// const dirtyText = document.querySelector('#article').innerHTML;

Sử dụng kết quả có cấu trúc để có kết quả dễ đoán

Hướng dẫn sau đây áp dụng cho Prompt API.

Nên: Khi bạn cần mô hình trả về dữ liệu ở một định dạng cụ thể, hãy sử dụng đầu ra có cấu trúc bằng cách cung cấp trường responseConstraint để cung cấp Lược đồ JSON. Điều này đảm bảo kết quả đầu ra có thể dự đoán được và giúp bạn không cần phải xử lý hậu kỳ phức tạp hoặc phân tích cú pháp theo cách thủ công.

Không nên: Chỉ dựa vào hướng dẫn bằng ngôn ngữ tự nhiên (chẳng hạn như "chỉ xuất JSON"). Mô hình có thể bao gồm từ đệm trong cuộc trò chuyện khiến trình phân tích cú pháp của bạn bị lỗi.

// ✅ DO: Use a JSON Schema for predictable results
const schema = {
  type: "object",
  properties: {
    isTopicCats: { type: "boolean" }
  }
};

const result = await session.prompt(`Is this post about cats?\n\n${post}`, {
  responseConstraint: schema,
});
console.log(JSON.parse(result).isTopicCats);

Tách biệt việc tạo nội dung khỏi các quy định hạn chế về độ dài

Hướng dẫn sau đây áp dụng cho Prompt API.

Nên: Để mô hình tạo phản hồi một cách tự nhiên, sau đó sử dụng logic phía máy khách để cắt bớt văn bản cho phù hợp với giao diện người dùng.

Không nên: Áp dụng giới hạn ký tự nghiêm ngặt như maxLength: 125 bằng cách sử dụng lược đồ đầu ra có cấu trúc. Khi câu trả lời của mô hình dài hơn giới hạn bạn đặt, mô hình có thể chuyển sang các mã thông báo có mật độ cao như tiếng nước ngoài hoặc biểu tượng cảm xúc để nén ý nghĩa, dẫn đến kết quả vô nghĩa.

/*  DO: Handle overflow using CSS */
.result {
  overflow: hidden;
  white-space: nowrap;
  text-overflow: ellipsis; /* Displays '…' */
}
// ❌ DON'T: Force length in the prompt
const result = await session.prompt("Write a bio in exactly 50 characters.");

Thông báo cho người dùng

Nên: Tuỳ thuộc vào độ phức tạp và thời lượng dự kiến của nhiệm vụ, hãy sử dụng ảnh động, tín hiệu hình ảnh và chỉ báo tiến trình để thông báo cho người dùng. Phương pháp tối ưu phụ thuộc vào trường hợp sử dụng và độ dài dự kiến của kết quả đầu ra API. Một số ý tưởng:

  • Truyền trực tuyến cho nội dung dài: Đối với bản tóm tắt hoặc cuộc trò chuyện, tính năng truyền trực tuyến sẽ tạo hiệu ứng máy đánh chữ theo từng mã thông báo theo mặc định. Điều này có thể mang lại cảm giác tự nhiên và cung cấp ý kiến phản hồi ngay lập tức.
  • Không truyền trực tuyến cho các tác vụ ngắn (hoặc tác vụ không đồng bộ dài): Đối với kết quả ngắn, ví dụ: văn bản thay thế, việc không truyền trực tuyến có thể tạo ra giao diện người dùng tinh tế hơn. Tính năng này cũng giúp bạn có thời gian chuẩn bị cho tác vụ AI tiếp theo trong khi tác vụ hiện tại đang kết xuất. Phương pháp này cũng áp dụng cho các tác vụ không đồng bộ hoặc tác vụ nền dài hơn. Nếu người dùng không bị chặn ở đầu ra để tiếp tục hành trình của họ, thì bạn không cần phải tạo đầu ra ngay lập tức. Báo hiệu rằng quá trình này đang diễn ra trong giao diện người dùng.
  • Hiệu ứng chuyển đổi hình ảnh cho nội dung cập nhật: Khi dịch hoặc viết lại văn bản, hãy sử dụng ảnh động, ví dụ: biến đổi từ.

Không nên: Cập nhật giao diện người dùng mà không có tín hiệu hình ảnh.

Phù hợp với mô hình tư duy của người dùng về thời gian và công việc

Nên: Cân nhắc việc trì hoãn nhân tạo từ một đến hai giây nếu phản hồi gần như tức thì. Ngược lại, người dùng có thể thấy kết quả đáng tin cậy hơn khi họ nhận thấy quy trình tạo phù hợp với độ khó của nhiệm vụ mà họ nhận thấy. Sử dụng ảnh động để báo hiệu rằng một quy trình xử lý bằng AI đã diễn ra.

Không nên: Làm người dùng bất ngờ khi thay thế giao diện người dùng ngay lập tức.

Cho phép người dùng nhanh chóng di chuyển và huỷ các nội dung chỉnh sửa bằng AI

Nên: Trang bị cho giao diện người dùng một bộ điều khiển từng bước hoặc nhật ký điều hướng để người dùng có thể tự tin khám phá nhiều kết quả, đồng thời cho phép họ nhanh chóng huỷ các nội dung chỉnh sửa bằng AI. Điều này đảm bảo rằng các phiên bản khác nhau vẫn có sẵn.

Không nên: Ghi đè lên bản nháp trước đó của người dùng hoặc kết quả AI mà họ có thể đã thích mà không có cách nào để quay lại, huỷ bỏ hoặc so sánh các phiên bản.

Phần tử trên giao diện người dùng của Stepper cho thấy nhật ký điều hướng.
Mẫu giao diện người dùng: Từ chối/Chấp nhận đề xuất (Google Tài liệu)
Nút huỷ tất cả nội dung chỉnh sửa của tác nhân trong giao diện người dùng của Google Antigravity.
Mẫu giao diện người dùng: Huỷ tất cả nội dung chỉnh sửa của tác nhân (Google Antigravity)
Nút Từ chối hoặc Chấp nhận đề xuất trong Google Tài liệu.
Mẫu giao diện người dùng: Stepper (Bản minh hoạ văn bản thay thế)

Trao quyền kiểm soát và ghi đè cho người dùng

Nên: Để người dùng là người chỉnh sửa cuối cùng cho tất cả nội dung được tạo. Cung cấp các chế độ ghi đè trực quan để người dùng có toàn quyền sở hữu kết quả cuối cùng. Các API có thể tạo ra kết quả không chính xác.

Không nên: Đưa ra kết quả do AI tạo làm lựa chọn duy nhất.

Lưu kết quả vào bộ nhớ đệm cho các việc cần làm định kỳ

Nên: Triển khai bộ nhớ đệm kết quả cục bộ (ví dụ: sử dụng sessionStorage hoặc IndexedDB) cho các dữ liệu đầu vào hoặc truy vấn lặp lại. Chuẩn hoá thông tin đầu vào bằng cách cắt bớt khoảng trắng và viết thường để tăng kết quả tìm kiếm trong bộ nhớ cache. Đối với dữ liệu đầu vào có kích thước lớn, ví dụ: hình ảnh, hãy tạo một hàm băm để dùng làm khoá bộ nhớ đệm. Đặt thời gian tồn tại (TTL) vừa phải cho bộ nhớ đệm (hoặc phân phát kết quả được lưu vào bộ nhớ đệm trong khi cập nhật kết quả ở chế độ nền). Cho phép người dùng kích hoạt một suy luận mới nếu kết quả không đạt yêu cầu.

Không nên: Chạy lại cùng một suy luận cho một cụm từ tìm kiếm lặp lại hoặc dữ liệu đầu vào giống hệt nhau khi không cần đến sự biến thiên, chẳng hạn như khi người dùng di chuyển qua lại giữa các kết quả tìm kiếm. Điều này giúp tối ưu hoá khả năng phản hồi và sử dụng hiệu quả tài nguyên điện toán cục bộ.

// ✅ DO: Check a local cache before running inference
async function getAiResponse(userInput, forceRefresh = false) {
  // Normalize the query to increase cache hits
  const query = userInput.trim().toLowerCase();
  const cacheKey = `ai_results_${query}`;
  const TTL_MS = 3600000; // 1 hour conservative TTL

  if (!forceRefresh) {
    const itemStr = localStorage.getItem(cacheKey);
    if (itemStr) {
      const item = JSON.parse(itemStr);
      const now = Date.now();

      // Check if the item has expired
      if (now < item.expiry) {
        // Lightweight safety check before rendering
        if (isValid(item.value)) return item.value;
      } else {
        // Delete the stale entry if the TTL has passed
        localStorage.removeItem(cacheKey);
      }
    }
  }

  // Fallback: Run inference if no valid cache exists
  const session = await LanguageModel.create();
  const response = await session.prompt(userInput);

  // Store the result for future use (with an expiration)
  const cacheData = {
    value: response,
    expiry: Date.now() + TTL_MS
  };
  localStorage.setItem(cacheKey, JSON.stringify(cacheData));

  return response;
}