MCP là gì? Đóng gói công cụ chatbot quán Mộc thành MCP server
MCP là gì và vì sao nó giúp nhiều ứng dụng AI dùng chung công cụ: viết một MCP server bằng TypeScript, gọi từ chatbot và từ trợ lý khác, kèm test chạy được.
MCP (Model Context Protocol) là chuẩn mở để ứng dụng AI kết nối với công cụ và dữ liệu bên ngoài. Bạn viết công cụ một lần trong một MCP server, rồi mọi ứng dụng hiểu MCP đều dùng được. Bạn có thấy phiền khi phải chép công cụ sang từng app không? Cùng mình làm nhé!
Vì sao không chép công cụ sang ứng dụng thứ hai?
Ở bài trước, chatbot của quán Mộc tìm được chính sách theo nghĩa. Nó đã có ba công cụ: tra đơn theo mã, tìm đơn theo số điện thoại, và thêm món vào đơn đang pha chế. (Quán Mộc là nhân vật minh họa của series này.) Cả ba nằm thẳng trong code của chatbot. Giờ quán muốn có thêm một trợ lý cho nhân viên ở quầy, người hay hỏi kiểu "đơn 1041 đang ở đâu" hoặc "thêm hai bạc xỉu vào đơn này". Trợ lý đó cần đúng ba công cụ ấy.
Cách nhanh nhất là chép code sang. Cái giá thấy ngay từ quy tắc nhỏ nhất. Công cụ them_mon chỉ cho thêm từ 1 đến 5 phần mỗi lần, và quy tắc đó nằm ở hai chỗ: trong mô tả gửi cho mô hình, và trong đoạn code kiểm tra. Có hai ứng dụng thì quy tắc nằm ở bốn chỗ. Hôm nào quán đổi giới hạn thành 10 phần mà bạn quên một chỗ, chatbot cho thêm 10 còn trợ lý quầy chặn ở 5. Hai bản cùng một công cụ sẽ dần lệch nhau, và người chịu thiệt là khách.
Điều mình muốn là công cụ nằm ở một nơi, còn chatbot và trợ lý quầy chỉ "cắm" vào. Đó chính là việc MCP làm.
MCP là gì?
Tài liệu chính thức mô tả MCP là một chuẩn mã nguồn mở để kết nối ứng dụng AI với các hệ thống bên ngoài, gồm nguồn dữ liệu, công cụ và quy trình làm việc. Họ ví nó như cổng USB-C của ứng dụng AI: một kiểu cắm chung thay vì mỗi thiết bị một đầu dây riêng.
Có ba vai. Server là chương trình bán công cụ, ví dụ server của Mộc. Client là phần trong ứng dụng AI nói chuyện với một server. Host là chính ứng dụng AI, như chatbot hay trợ lý quầy, và nó có thể chạy nhiều client để nối nhiều server cùng lúc. Server có thể cung cấp công cụ (tools), tài nguyên đọc được (resources), và mẫu câu lệnh (prompts). Trong bài này mình chỉ làm công cụ, vì đó là thứ chatbot của Mộc đang có.
Về đường truyền, server chạy cùng máy thì thường nói chuyện qua stdin và stdout của một tiến trình con (gọi là stdio), còn server ở xa thì dùng HTTP. Mình dùng stdio cho đơn giản. Một chi tiết quan trọng: với stdio, stdout là đường dành cho giao thức, nên mọi dòng log của server phải ra stderr, đúng như phần hướng dẫn xây server của tài liệu dặn. Trong thử nghiệm của mình, SDK bản 1.32.2 bỏ qua vài dòng console.log bị lọt vào stdout mà không báo lỗi. Dù vậy mình vẫn theo lời dặn, vì mình không muốn cả chương trình phụ thuộc vào việc một client cụ thể dễ tính đến đâu.
Dựng MCP server cho Mộc
Mình dùng SDK chính thức @modelcontextprotocol/sdk (bản 1.32.2 là bản mới nhất mình thấy trên npm ngày 12/11/2026) và Zod để khai báo đầu vào. Bạn cần Node.js 22.18 trở lên, vì Node chạy thẳng file .ts từ bản đó, và client trong bài sẽ chạy server bằng chính lệnh node. Tạo thư mục moc-mcp với cấu trúc sau:
moc-mcp/
package.json
src/thong-tin-quan.ts
src/don-hang.ts
src/may-chu-moc.ts
src/khach-mcp.ts
src/thu-khach.ts
src/thu-chatbot.ts
src/may-chu-moc.test.ts{
"name": "moc-mcp",
"private": true,
"type": "module",
"dependencies": {
"@modelcontextprotocol/sdk": "1.32.2",
"zod": "4.6.7"
},
"devDependencies": {
"vitest": "5.1.0"
}
}Hai file đầu là dữ liệu và logic của quán, lấy từ chatbot ở các bài trước (mình bỏ bớt phần thực đơn không dùng tới). Đây là nơi công cụ thật sự làm việc: thực đơn, danh sách có sẵn hai đơn, và hàm thêm món chỉ chạy khi đơn còn đang pha chế. Hàm datLaiDonHang chỉ để test trả dữ liệu về như lúc đầu.
// Thực đơn của quán Mộc (minh họa): tên món và giá.
export const MENU: Record<string, number> = {
"cà phê đen": 25000,
"cà phê sữa": 29000,
"bạc xỉu": 32000,
"cà phê muối": 35000,
"bánh mì trứng": 25000,
};import { MENU } from "./thong-tin-quan.ts";
export type Don = {
maDon: string;
soDienThoai: string;
mon: string[];
trangThai: "đang pha chế" | "đang giao" | "đã giao";
datLuc: string;
};
const DON_BAN_DAU: Don[] = [
{ maDon: "1041", soDienThoai: "0901000001", mon: ["cà phê sữa", "bánh mì trứng"], trangThai: "đang pha chế", datLuc: "hôm nay 8:12" },
{ maDon: "1042", soDienThoai: "0901000002", mon: ["bạc xỉu"], trangThai: "đang giao", datLuc: "hôm nay 9:40" },
];
let DON_HANG: Don[] = structuredClone(DON_BAN_DAU);
// Trả dữ liệu về như lúc đầu, để các lần chạy thử không ảnh hưởng nhau.
export function datLaiDonHang(): void {
DON_HANG = structuredClone(DON_BAN_DAU);
}
export function timDonTheoMa(maDon: string): Don | undefined {
return DON_HANG.find((don) => don.maDon === maDon);
}
export function timDonTheoSdt(soDienThoai: string): Don | undefined {
return DON_HANG.find((don) => don.soDienThoai === soDienThoai);
}
// Thêm món vào đơn. Chỉ được thêm khi đơn còn đang pha chế: đơn đã lên xe thì không sửa được nữa.
export function themMon(maDon: string, mon: string, soLuong: number): { ok: true; don: Don } | { ok: false; lyDo: string } {
const don = timDonTheoMa(maDon);
if (!don) return { ok: false, lyDo: `Không có đơn ${maDon}.` };
if (!(mon in MENU)) return { ok: false, lyDo: `Quán không bán "${mon}".` };
if (don.trangThai !== "đang pha chế") return { ok: false, lyDo: `Đơn ${maDon} ${don.trangThai}, không thêm món được nữa.` };
for (let i = 0; i < soLuong; i++) don.mon.push(mon);
return { ok: true, don };
}Đến phần chính. Ba công cụ giờ được đăng ký vào một MCP server. Hãy chú ý ba điều trong file này: schema Zod thay cho khối input_schema viết tay, annotations cho mỗi công cụ, và cách báo lỗi.
// MCP server của quán Mộc: đóng gói ba công cụ tra đơn / tìm đơn / thêm món để mọi ứng dụng dùng chung.
// Chạy trực tiếp (node src/may-chu-moc.ts) thì nói chuyện qua stdin/stdout. Nhớ: stdout dành riêng cho giao thức, log phải ra stderr.
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import { themMon, timDonTheoMa, timDonTheoSdt } from "./don-hang.ts";
const maDon = z.string().regex(/^\d{4}$/, "Mã đơn gồm đúng 4 chữ số, không có dấu #").describe("Mã đơn gồm 4 chữ số, không có dấu #");
const ketQua = (noiDung: unknown) => ({ content: [{ type: "text" as const, text: JSON.stringify(noiDung) }] });
const loi = (thongBao: string) => ({ content: [{ type: "text" as const, text: thongBao }], isError: true });
export function taoMayChu(): McpServer {
const server = new McpServer({ name: "moc-don-hang", version: "1.0.0" });
server.registerTool(
"xem_don",
{
title: "Xem đơn hàng",
description:
"Xem món và trạng thái hiện tại của một đơn hàng theo mã đơn (4 chữ số, ví dụ 1041). " +
"Gọi công cụ này mỗi khi khách hỏi đơn đã giao chưa, đang ở đâu, khi nào tới.",
inputSchema: { ma_don: maDon },
annotations: { readOnlyHint: true },
},
async ({ ma_don }) => {
const don = timDonTheoMa(ma_don);
if (!don) return loi(`Không có đơn ${ma_don}.`);
return ketQua({ ma_don: don.maDon, mon: don.mon, trang_thai: don.trangThai, dat_luc: don.datLuc });
},
);
server.registerTool(
"tim_don_theo_sdt",
{
title: "Tìm đơn theo số điện thoại",
description:
"Tìm mã đơn gần nhất của khách theo số điện thoại (10 chữ số, bắt đầu bằng 0). " +
"Chỉ trả về mã đơn; muốn biết trạng thái thì gọi tiếp xem_don.",
inputSchema: { so_dien_thoai: z.string().regex(/^0\d{9}$/, "Số điện thoại gồm 10 chữ số, bắt đầu bằng 0").describe("Số điện thoại 10 chữ số") },
annotations: { readOnlyHint: true },
},
async ({ so_dien_thoai }) => {
const don = timDonTheoSdt(so_dien_thoai);
if (!don) return loi("Không tìm thấy đơn nào với số này.");
return ketQua({ ma_don: don.maDon });
},
);
server.registerTool(
"them_mon",
{
title: "Thêm món vào đơn",
description:
"Thêm món vào một đơn còn đang pha chế. Chỉ gọi khi khách nói rõ muốn thêm món nào, bao nhiêu phần. " +
"Đơn đang giao hoặc đã giao thì công cụ sẽ báo lỗi.",
inputSchema: {
ma_don: maDon,
mon: z.string().describe("Tên món đúng như trong bảng giá, ví dụ: bạc xỉu"),
so_luong: z.number().int().min(1).max(5).describe("Số phần, từ 1 đến 5"),
},
annotations: { readOnlyHint: false, destructiveHint: false },
},
async ({ ma_don, mon, so_luong }) => {
const kq = themMon(ma_don, mon.trim().toLowerCase(), so_luong);
if (!kq.ok) return loi(kq.lyDo);
return ketQua({ ma_don: kq.don.maDon, mon: kq.don.mon, trang_thai: kq.don.trangThai });
},
);
return server;
}
if (import.meta.main) {
await taoMayChu().connect(new StdioServerTransport());
console.error("Máy chủ MCP của Mộc đã sẵn sàng (stdio)"); // stderr, không phải stdout
}Về schema: ở chatbot cũ, mỗi công cụ có một khối input_schema viết tay và một đoạn code kiểm tra ma_don bằng biểu thức chính quy. Ở đây chỉ còn một nơi: schema Zod. SDK dùng nó vừa để sinh JSON Schema gửi cho mô hình, vừa để chặn đầu vào sai trước khi code của công cụ chạy. Mình chỉ viết quy tắc "mã đơn gồm 4 chữ số" một lần, nên nó không thể lệch với chính nó nữa.
Về annotations: readOnlyHint: true nói công cụ chỉ đọc, còn them_mon thì ghi. Chúng chỉ là gợi ý để ứng dụng quyết định có hỏi xác nhận không, và đặc tả nói rõ client phải coi chúng là không đáng tin trừ khi server đáng tin. Đừng xem chúng là cơ chế bảo vệ.
Về lỗi: đặc tả của MCP chia hai loại. Lỗi giao thức (công cụ không tồn tại, đầu vào sai kiểu) và lỗi khi chạy công cụ, như "đơn không tồn tại" hay "đơn đang giao, không thêm món được". Loại thứ hai được trả về như một kết quả bình thường kèm isError: true, để mô hình đọc được lý do và tự xử lý, ví dụ xin lỗi khách rồi giải thích. Hai hàm ketQua và loi ở đầu file làm đúng việc đó. Bạn có thể xem phần mô tả này trong đặc tả về tools (bản 2025-06-18 mình đọc ngày 12/11/2026; trang đặc tả có thể đã có bản mới hơn).
Gọi server từ hai ứng dụng
Giờ đến phía client. File khach-mcp.ts chạy server như một tiến trình con và nối vào nó. Hai ứng dụng của quán đều dùng hai hàm này:
// Kết nối tới MCP server của Mộc bằng cách chạy nó như một tiến trình con. Dùng chung cho mọi ứng dụng của quán.
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
export async function noiTuiMayChu(duongDan = "src/may-chu-moc.ts"): Promise<Client> {
const client = new Client({ name: "ung-dung-cua-moc", version: "1.0.0" });
await client.connect(new StdioClientTransport({ command: process.execPath, args: [duongDan] }));
return client;
}
// Gọi một công cụ và trả về văn bản kết quả, kèm cờ lỗi.
export async function goiCongCu(client: Client, ten: string, dauVao: Record<string, unknown>): Promise<{ noiDung: string; loi: boolean }> {
const ketQua = await client.callTool({ name: ten, arguments: dauVao });
const noiDung = (ketQua.content as { type: string; text?: string }[]).map((phan) => phan.text ?? "").join("");
return { noiDung, loi: ketQua.isError === true };
}Ứng dụng thứ nhất là trợ lý quầy. Nó không cần mô hình ngôn ngữ, chỉ cần gọi công cụ trực tiếp. Script này liệt kê công cụ rồi gọi bốn lần: một lần xem đơn bình thường, một lần thêm món vào đơn đang pha chế, một lần thêm món vào đơn đã đi giao (phải bị từ chối), và một lần với mã đơn chỉ có ba chữ số (phải bị chặn):
// Ứng dụng 1: trợ lý cho nhân viên ở quầy, gọi công cụ trực tiếp. Chạy: node src/thu-khach.ts
import { goiCongCu, noiTuiMayChu } from "./khach-mcp.ts";
const client = await noiTuiMayChu();
const { tools } = await client.listTools();
console.log(`Máy chủ có ${tools.length} công cụ: ${tools.map((t) => t.name).join(", ")}`);
for (const [ten, dauVao] of [
["xem_don", { ma_don: "1041" }],
["them_mon", { ma_don: "1041", mon: "Bạc xỉu", so_luong: 2 }],
["them_mon", { ma_don: "1042", mon: "bạc xỉu", so_luong: 1 }],
["xem_don", { ma_don: "104" }],
] as const) {
const kq = await goiCongCu(client, ten, dauVao);
console.log(`${ten} ${JSON.stringify(dauVao)} → ${kq.loi ? "LỖI: " : ""}${kq.noiDung}`);
}
await client.close();npm install
node src/thu-khach.tsMáy chủ MCP của Mộc đã sẵn sàng (stdio)
Máy chủ có 3 công cụ: xem_don, tim_don_theo_sdt, them_mon
xem_don {"ma_don":"1041"} → {"ma_don":"1041","mon":["cà phê sữa","bánh mì trứng"],"trang_thai":"đang pha chế","dat_luc":"hôm nay 8:12"}
them_mon {"ma_don":"1041","mon":"Bạc xỉu","so_luong":2} → {"ma_don":"1041","mon":["cà phê sữa","bánh mì trứng","bạc xỉu","bạc xỉu"],"trang_thai":"đang pha chế"}
them_mon {"ma_don":"1042","mon":"bạc xỉu","so_luong":1} → LỖI: Đơn 1042 đang giao, không thêm món được nữa.
xem_don {"ma_don":"104"} → LỖI: MCP error -32602: Input validation error: Invalid arguments for tool xem_don: Mã đơn gồm đúng 4 chữ số, không có dấu # at ma_donBa dòng cuối đáng nhìn. Ở dòng thêm món, "Bạc xỉu" viết hoa được đổi về chữ thường bên trong công cụ (mon.trim().toLowerCase()), nên đơn nhận đúng hai phần "bạc xỉu". Ở dòng kế, quy tắc "đơn đã đi giao thì không sửa" nằm trong themMon, và lỗi trở về dưới dạng kết quả để người gọi đọc. Ở dòng cuối, mã 104 không bao giờ tới được code của xem_don: schema chặn nó, và thông báo là chính câu mình viết trong Zod.
Ứng dụng thứ hai là chatbot, và đây là chỗ MCP đỡ việc nhất. Ở bài về tool calling, mình viết tay danh sách công cụ để đưa cho mô hình. Giờ danh sách lấy từ server. MCP và API của Anthropic dùng gần như cùng một dạng cho định nghĩa công cụ, nên chỉ cần đổi tên inputSchema thành input_schema và bỏ trường $schema (dòng khai báo phiên bản JSON Schema) cho gọn. Mình không có khóa API để gọi mô hình thật trong bài này, nên script dưới đây dùng một khối tool_use do mình viết tay, thay cho câu trả lời của mô hình khi khách hỏi "đơn 1042 của em đâu rồi?":
// Ứng dụng 2: chatbot. Lấy danh sách công cụ từ MCP server, đổi sang dạng mà API của Anthropic nhận, rồi chạy một lượt gọi công cụ.
// Không cần ANTHROPIC_API_KEY: khối tool_use dưới đây do mình viết tay thay cho câu trả lời của mô hình. Chạy: node src/thu-chatbot.ts
import { goiCongCu, noiTuiMayChu } from "./khach-mcp.ts";
const client = await noiTuiMayChu();
const { tools } = await client.listTools();
// MCP và API của Anthropic gần như cùng dạng: đổi tên inputSchema thành input_schema, và bỏ trường $schema (dòng khai báo phiên bản JSON Schema) cho gọn.
const congCuChoMoHinh = tools.map(({ name, description, inputSchema: { $schema, ...inputSchema } }) => ({ name, description, input_schema: inputSchema }));
console.log("Công cụ đưa cho mô hình:", JSON.stringify(congCuChoMoHinh.find((t) => t.name === "xem_don"), null, 2));
// Giả sử mô hình trả lời bằng khối tool_use này (khách hỏi: "đơn 1042 của em đâu rồi?").
const toolUse = { type: "tool_use", id: "toolu_01", name: "xem_don", input: { ma_don: "1042" } };
const kq = await goiCongCu(client, toolUse.name, toolUse.input);
// Khối này sẽ được gửi lại cho mô hình ở lượt kế tiếp, y như ở bài tool calling.
console.log("Gửi lại cho mô hình:", JSON.stringify({ type: "tool_result", tool_use_id: toolUse.id, content: kq.noiDung, is_error: kq.loi }));
await client.close();node src/thu-chatbot.tsMáy chủ MCP của Mộc đã sẵn sàng (stdio)
Công cụ đưa cho mô hình: {
"name": "xem_don",
"description": "Xem món và trạng thái hiện tại của một đơn hàng theo mã đơn (4 chữ số, ví dụ 1041). Gọi công cụ này mỗi khi khách hỏi đơn đã giao chưa, đang ở đâu, khi nào tới.",
"input_schema": {
"type": "object",
"properties": {
"ma_don": {
"type": "string",
"pattern": "^\\d{4}$",
"description": "Mã đơn gồm 4 chữ số, không có dấu #"
}
},
"required": [
"ma_don"
]
}
}
Gửi lại cho mô hình: {"type":"tool_result","tool_use_id":"toolu_01","content":"{\"ma_don\":\"1042\",\"mon\":[\"bạc xỉu\"],\"trang_thai\":\"đang giao\",\"dat_luc\":\"hôm nay 9:40\"}","is_error":false}Phần "Công cụ đưa cho mô hình" là thứ chatbot gửi kèm mỗi lượt gọi API, thay cho khối viết tay. Dòng cuối là khối tool_result chatbot gửi lại cho mô hình ở lượt kế tiếp, giống hệt vòng lặp agent ở các bài trước, chỉ khác là bước chạy công cụ giờ đi qua goiCongCu thay vì một hàm trong cùng file. Chatbot và trợ lý quầy đều không còn một dòng logic nghiệp vụ nào của công cụ.
Viết test cho server
Một lợi ích nữa của việc tách riêng là bạn test được công cụ mà không cần mô hình, và không cần chạy tiến trình con. SDK có InMemoryTransport để nối client với server ngay trong một tiến trình:
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
import { beforeEach, expect, test } from "vitest";
import { datLaiDonHang } from "./don-hang.ts";
import { taoMayChu } from "./may-chu-moc.ts";
// Nối client với server trong cùng một tiến trình (không cần chạy tiến trình con): nhanh và dễ kiểm tra.
async function noi(): Promise<Client> {
const [phiaClient, phiaServer] = InMemoryTransport.createLinkedPair();
await taoMayChu().connect(phiaServer);
const client = new Client({ name: "test", version: "1.0.0" });
await client.connect(phiaClient);
return client;
}
const vanBan = (ketQua: Awaited<ReturnType<Client["callTool"]>>) => (ketQua.content as { text: string }[])[0].text;
beforeEach(() => datLaiDonHang());
test("liệt kê đủ ba công cụ, tool chỉ đọc có readOnlyHint", async () => {
const { tools } = await (await noi()).listTools();
expect(tools.map((t) => t.name)).toEqual(["xem_don", "tim_don_theo_sdt", "them_mon"]);
expect(tools.find((t) => t.name === "xem_don")?.annotations?.readOnlyHint).toBe(true);
expect(tools.find((t) => t.name === "them_mon")?.annotations?.readOnlyHint).toBe(false);
});
test("xem_don trả đúng đơn", async () => {
const kq = await (await noi()).callTool({ name: "xem_don", arguments: { ma_don: "1042" } });
expect(JSON.parse(vanBan(kq))).toMatchObject({ ma_don: "1042", trang_thai: "đang giao" });
});
test("đơn không tồn tại: isError, không ném lỗi", async () => {
const kq = await (await noi()).callTool({ name: "xem_don", arguments: { ma_don: "9999" } });
expect(kq.isError).toBe(true);
expect(vanBan(kq)).toBe("Không có đơn 9999.");
});
test("đầu vào sai định dạng bị schema chặn trước khi tới code của công cụ", async () => {
const kq = await (await noi()).callTool({ name: "xem_don", arguments: { ma_don: "104" } });
expect(kq.isError).toBe(true);
expect(vanBan(kq)).toContain("Mã đơn gồm đúng 4 chữ số");
});
test("them_mon chỉ thêm được vào đơn đang pha chế", async () => {
const client = await noi();
const duoc = await client.callTool({ name: "them_mon", arguments: { ma_don: "1041", mon: "Bạc xỉu", so_luong: 2 } });
expect(JSON.parse(vanBan(duoc)).mon).toEqual(["cà phê sữa", "bánh mì trứng", "bạc xỉu", "bạc xỉu"]);
const khong = await client.callTool({ name: "them_mon", arguments: { ma_don: "1042", mon: "bạc xỉu", so_luong: 1 } });
expect(khong.isError).toBe(true);
});
test("số lượng ngoài khoảng 1 đến 5 bị chặn", async () => {
const kq = await (await noi()).callTool({ name: "them_mon", arguments: { ma_don: "1041", mon: "bạc xỉu", so_luong: 6 } });
expect(kq.isError).toBe(true);
});npx vitest run Test Files 1 passed (1)
Tests 6 passed (6)Test thứ tư đáng chú ý: nó khẳng định đầu vào sai định dạng bị schema chặn trước khi tới code của công cụ. Nếu một ngày ai đó bỏ dòng regex trong schema, test này đỏ ngay.
Khi nào nên dùng MCP, khi nào không?
Theo mình, MCP đáng dùng khi công cụ của bạn cần phục vụ nhiều hơn một ứng dụng, hoặc khi bạn muốn dùng công cụ có sẵn của người khác (đã có nhiều server cho các dịch vụ phổ biến) mà không phải tự viết cầu nối. Cái bạn trả là thêm một tiến trình, một lớp giao thức và một thư viện SDK cần cập nhật khi chuẩn thay đổi.
Nếu chỉ có một ứng dụng duy nhất và công cụ không đổi, một hàm bình thường trong cùng code vẫn đơn giản hơn. Chatbot của Mộc đã sống ổn như vậy qua bảy bài. Mình chuyển sang MCP vì có ứng dụng thứ hai, không phải vì MCP là xu hướng. Bạn nên tự hỏi câu đó trước khi thêm nó vào dự án của mình.
Công cụ đã mở ra, vậy ai được dùng nó và dùng thế nào?
Có một điều nên nghĩ kỹ sau bài này. Công cụ them_mon giờ nằm sau một cổng chung, và bất kỳ ứng dụng nào nối vào server đều gọi được. Bên cạnh đó, chatbot vẫn nói chuyện với khách bằng văn bản tự do, và mô hình quyết định gọi công cụ nào dựa trên những gì khách viết. Đặc tả của MCP khuyên luôn có con người có thể từ chối lời gọi công cụ, nhưng chatbot chăm sóc khách hàng thì thường chạy một mình. Điều gì xảy ra nếu một khách khéo lời cố làm mô hình làm việc mà quán không muốn, ví dụ hứa một thứ quán không hề cho phép? Cách một agent bị "dụ" và cách phòng là việc của các bài viết sau.
Bạn theo dõi cả hành trình ở Xây AI agent đầu tiên. Nếu đang ôn phỏng vấn, các câu hỏi về AI agent có trong ngân hàng câu hỏi phỏng vấn.