Ngày nay, bằng cách kết hợp LLM với các công cụ bên ngoài, chúng ta có thể phát triển một AI Agent dành riêng cho doanh nghiệp để tìm kiếm dữ liệu nội bộ, tính toán, chạy kiểm thử và thao tác với tệp.

Nếu chỉ xây dựng một bản thử nghiệm quy mô nhỏ, chúng ta có thể tận dụng API và các framework hiện có để triển khai hệ thống với lượng mã ít hơn rất nhiều so với trước đây.

Công nghệ cốt lõi của mô hình này chính là Function Calling.

“AI gần đây không chỉ trò chuyện mà còn có thể tự sửa tệp và kiểm thử chương trình. Điều đó có thực sự đang xảy ra không?”

Nếu bạn nhận thấy điều này, quan sát của bạn hoàn toàn chính xác.

Công nghệ xung quanh AI và mô hình ngôn ngữ lớn, hay LLM, gần đây đã có sự thay đổi mạnh mẽ. AI đang chuyển từ giai đoạn chỉ tạo ra những đoạn văn có vẻ hợp lý sang giai đoạn có thể tự sử dụng các công cụ bên ngoài để hoàn thành công việc.

Đằng sau sự phát triển này là những công nghệ được gọi là Function Calling và Tool Use, cùng với mô hình thiết kế AI Agent được xây dựng dựa trên các công nghệ đó.

Trong bài viết này, chúng tôi sẽ giải thích từ cơ chế cơ bản, quá trình phát triển của AI Agent dẫn đến các công cụ hiện đại, cho đến cách các lập trình viên có thể tự xây dựng và ứng dụng cơ chế này vào công việc thực tế.

Trao cho LLM một chiếc máy tính: Function Calling là gì?

LLM rất giỏi tạo văn bản. Tuy nhiên, nó lại không thực sự giỏi thực hiện các phép tính chính xác hoặc lấy thông tin theo thời gian thực, chẳng hạn thời tiết hôm nay hay giá cổ phiếu mới nhất.

Nguyên nhân là vì về bản chất, LLM chỉ dự đoán từ hoặc token có xác suất xuất hiện tiếp theo cao nhất.

Ví dụ, nếu yêu cầu LLM tính 12.345 × 67.890, nó có thể đưa ra một đáp án trông hợp lý nhưng thực tế lại sai. Hiện tượng này được gọi là hallucination.

Function Calling được phát triển để giải quyết vấn đề đó.

Thay vì yêu cầu LLM tự tính toán, hệ thống yêu cầu nó tạo ra chỉ dẫn để sử dụng một hàm hoặc API bên ngoài, chẳng hạn máy tính hoặc API dự báo thời tiết.

Quy trình cụ thể như sau:

1. Người dùng: Nhập câu hỏi “12.345 × 67.890 bằng bao nhiêu?”
2. LLM: Nhận định rằng nó nên sử dụng công cụ nhân thay vì tự tính toán.
3. Đầu ra của LLM: Xuất lệnh gọi hàm dưới dạng dữ liệu, chẳng hạn multiply(a=12345, b=67890).
4. Hệ thống: Chương trình máy tính thực tế thực thi lệnh và nhận kết quả 838102050.
5. Phản hồi của LLM: Nhận kết quả và trả lời bằng ngôn ngữ tự nhiên: “Đáp án là 838.102.050.”

Thay vì bắt LLM tự tính toán, hệ thống giao nhiệm vụ đó cho một chương trình được thiết kế để thực hiện phép tính chính xác.

Nhờ vậy, độ chính xác của câu trả lời từ AI được cải thiện đáng kể.

Lập trình viên có thể bổ sung chức năng này cho LLM hiện có không?

“Tôi hiểu rằng Google Gemini và OpenAI GPT có chức năng này. Nhưng liệu chúng ta có thể kết nối LLM với các hàm trong hệ thống riêng hoặc môi trường cục bộ không?”

Câu trả lời là hoàn toàn có thể.

Trên thực tế, đây đã trở thành một phương pháp tiêu chuẩn trong quá trình phát triển ứng dụng AI hiện đại.

Có hai cách triển khai chính.

Phương pháp A: Sử dụng chức năng tiêu chuẩn của API

Các API lớn như Gemini và GPT đã cung cấp sẵn cơ chế cho phép lập trình viên đăng ký các hàm tùy chỉnh.

Bạn chỉ cần cung cấp cho LLM tên và phần mô tả của chương trình do mình xây dựng, chẳng hạn một hàm tìm kiếm cơ sở dữ liệu khách hàng nội bộ.

Dựa trên câu hỏi của người dùng, LLM sẽ tự động trả về một chỉ dẫn như:

Hãy chạy hàm này với các đối số sau.

Phương pháp B: Điều khiển bằng prompt

Bằng cách sử dụng các framework như LangChain, chúng ta có thể triển khai cơ chế tương tự chỉ thông qua prompt, ngay cả khi API không hỗ trợ Function Calling theo tiêu chuẩn.

Cách này thường được sử dụng với các LLM mã nguồn mở.

Ví dụ, chúng ta có thể đưa ra chỉ dẫn sau cho LLM:

Bạn có thể sử dụng công cụ calc(biểu_thức). Nếu cần tính toán, hãy ngừng tạo văn bản và chỉ xuất Action: calc(biểu_thức).

Khi nhận được văn bản theo định dạng này, chương trình riêng sẽ phát hiện nó, thực hiện phép tính rồi đưa kết quả trở lại LLM dưới dạng ngữ cảnh bổ sung.

Toàn bộ quy trình này được tự động hóa bằng chương trình.

Mô hình thiết kế tinh gọn nhất trong hệ thống thực tế là gì?

“Việc buộc lệnh thực thi hàm vào trong câu trò chuyện bằng ngôn ngữ tự nhiên có vẻ dễ gây lỗi phân tích cú pháp.”

Nếu bạn là lập trình viên và có suy nghĩ như vậy, trực giác đó hoàn toàn chính xác.

Trong phát triển hệ thống thực tế, một phương pháp thường được ưu tiên là không cho LLM tạo bất kỳ câu văn nào trong giai đoạn lựa chọn công cụ, mà chỉ cho phép nó xuất dữ liệu thuần túy, thường là JSON.

[Câu hỏi của người dùng]
       │
       ▼
[LLM: Lần gọi thứ nhất] ── “Không xuất văn bản, chỉ trả về JSON.”
       │
       ▼ Phân tích JSON
[Thực thi trong hệ thống] ── “Tìm kiếm cơ sở dữ liệu hoặc tính toán.”
       │
       ▼ Thêm kết quả vào ngữ cảnh
[LLM: Lần gọi thứ hai] ── “Kết hợp toàn bộ ngữ cảnh và tạo câu trả lời.”

Trong thiết kế này, vai trò chính của LLM được giới hạn ở việc xác định hành động tiếp theo và đóng gói các đối số cần thiết.

Quá trình thực thi được giao cho chương trình an toàn do lập trình viên kiểm soát.

Kết quả thu được sau đó được thêm vào lịch sử hội thoại dưới dạng phản hồi từ công cụ bên ngoài, rồi LLM tiếp tục thực hiện một vòng suy luận mới.

Cấu trúc lặp lại giữa suy luận và thực thi này chính là mô hình thiết kế cốt lõi của một AI Agent tự chủ.

Từ ý tưởng đến ứng dụng thực tế: Lịch sử của AI coding agent

Các công cụ phát triển hiện nay đã tối ưu chu trình sau đến mức rất cao:

Xuất dữ liệu → thực thi chương trình bên ngoài → đưa kết quả trở lại ngữ cảnh

Hãy cùng nhìn lại quá trình phát triển của công nghệ này.

1. Mùa xuân năm 2023: Sự ra đời của khái niệm — AutoGPT và BabyAGI

Khái niệm “AI Agent tự chủ” bắt đầu trở thành một xu hướng toàn cầu với các dự án mã nguồn mở như AutoGPT và BabyAGI, xuất hiện vào tháng 3 năm 2023.

Người dùng chỉ cần cung cấp một mục tiêu cho LLM. Sau đó, hệ thống sẽ tự chia mục tiêu thành các nhiệm vụ nhỏ, liên tục tìm kiếm trên Google và tạo tệp.

Khả năng này đã gây ấn tượng mạnh và giúp nhiều người nhận ra tiềm năng của công nghệ AI Agent.

2. Mùa hè năm 2023: Ứng dụng thực tế trên terminal — Aider

Nhiều AI Agent thời kỳ đầu chỉ dừng lại ở mức ý tưởng và chưa trở thành công cụ thực tế.

Aider xuất hiện như một công cụ mà lập trình viên có thể sử dụng hằng ngày.

Aider chạy trên terminal và tích hợp chặt chẽ với Git. Công cụ này đã thiết lập một phong cách phát triển thực tế, trong đó LLM sửa mã và tự tạo Git commit nếu không phát hiện vấn đề.

3. Mùa xuân năm 2024: Tác động của “kỹ sư AI” quy mô lớn đầu tiên — Devin

Tháng 3 năm 2024, Cognition công bố Devin với tư cách là kỹ sư phần mềm AI hoàn toàn tự chủ đầu tiên trên thế giới.

Devin sử dụng sandbox riêng, trình duyệt tích hợp và terminal. Công cụ có thể đọc GitHub Issue, tự viết và chạy mã kiểm thử, sửa lỗi rồi tự động hóa toàn bộ quy trình đến bước triển khai.

Thông báo này đã tạo ra tác động lớn đối với ngành phần mềm.

4. Từ cuối năm 2024 đến nay: Tích hợp tự nhiên vào IDE — Cursor

Devin sử dụng phương pháp giao toàn bộ công việc cho AI.

Cursor lại tích hợp AI Agent trực tiếp vào IDE mà con người vẫn sử dụng để viết mã hằng ngày.

Thông qua các chức năng như Composer, LLM có thể tự tìm kiếm, sửa và áp dụng thay đổi cho nhiều tệp cùng lúc. Trong khi đó, lập trình viên có thể theo dõi và đưa ra chỉ dẫn theo thời gian thực ngay trong trình soạn thảo.

Nhờ vậy, phát triển bằng AI Agent đã chuyển từ một thử nghiệm dành cho một số người tiên phong thành một phần trong công việc hằng ngày của nhiều lập trình viên.

5. Từ năm 2025: Phát triển sâu hơn theo hướng agent-first — Claude Code và Google Antigravity

AI Agent hiện đang tiếp tục phát triển vượt ra ngoài khuôn khổ của từng nền tảng riêng lẻ.

Claude Code

Claude Code là công cụ AI Agent dạng dòng lệnh do Anthropic phát hành.

Công cụ tận dụng khả năng suy luận và tốc độ phản hồi của Claude để tự sửa lỗi, chỉnh sửa mã và chạy kiểm thử ngay trên terminal.

Google Antigravity

Google Antigravity là nền tảng phát triển thế hệ mới theo hướng agent-first.

Nền tảng tận dụng khả năng xử lý ngữ cảnh cực lớn của LLM, có thể lên đến hàng triệu token, để nắm bắt toàn bộ cấu trúc dự án và tự chạy quá trình build hoặc kiểm thử trong môi trường ảo.

Hướng đến ứng dụng thực tế: Tự xây dựng AI Agent chuyên biệt

“Những hệ thống tiên tiến như Devin hay Cursor chắc chỉ Google hoặc các startup nước ngoài mới có thể phát triển?”

Không cần phải nghĩ như vậy.

Hiện nay, chúng ta cũng có thể tự xây dựng AI Agent dành riêng cho doanh nghiệp hoặc cá nhân dựa trên cơ chế gần như tương tự.

Có ba lý do khiến việc tự xây dựng AI Agent trở nên thực tế hơn.

1. Đầu ra dữ liệu có cấu trúc — Structured Outputs

Các LLM lớn hiện nay, bao gồm Gemini và GPT, cung cấp chức năng giúp JSON đầu ra tuân theo schema hoặc kiểu dữ liệu đã chỉ định.

Nhờ đó, xác suất phát sinh lỗi phân tích cú pháp giảm đáng kể và quá trình tích hợp với hệ thống trở nên ổn định hơn nhiều.

2. Sự phổ biến của các framework AI Agent gọn nhẹ

Các framework và thư viện như LangGraph dành cho JavaScript và TypeScript, cùng với CrewAI, giúp triển khai vòng lặp sau một cách an toàn về kiểu dữ liệu chỉ với vài chục dòng mã:

Để LLM quyết định → thực thi hàm → đưa kết quả trở lại ngữ cảnh

Tiếp theo, hãy xem một ví dụ triển khai cụ thể bằng phiên bản TypeScript của LangGraph.

Ví dụ triển khai AI Agent bằng LangGraph và TypeScript

Đoạn mã TypeScript dưới đây cung cấp cho LLM một công cụ máy tính tùy chỉnh và tự động lặp lại chu trình sau:

Suy luận → thực thi máy tính → đưa kết quả trở lại → tạo câu trả lời cuối cùng

import { tool } from "@langchain/core/tools";
import { z } from "zod";
import { BaseMessage, Annotation } from "@langchain/core/messages";
import { ChatOpenAI } from "@langchain/openai";
import { StateGraph, START, END } from "@langchain/langgraph";
import { ToolNode } from "@langchain/langgraph/prebuilt";

// 1. Định nghĩa kiểu và schema cho bộ nhớ, hay trạng thái, của AI Agent.
// Trạng thái này quản lý mảng messages theo cơ chế tích lũy.
const StateAnnotation = Annotation.Root({
  messages: Annotation<BaseMessage[]>({
    reducer: (x, y) => x.concat(y),
    default: () => [],
  }),
});

// 2. Định nghĩa hàm riêng, hay công cụ, mà LLM có thể sử dụng.
// Schema Zod truyền kiểu dữ liệu và phần mô tả của đối số cho LLM.
const calculateMultiply = tool(
  async ({ a, b }) => {
    return (a * b).toString();
  },
  {
    name: "calculate_multiply",
    description:
      "Hàm nhân hai số. LLM đọc phần mô tả này và xác định các đối số.",
    schema: z.object({
      a: z.number().describe("Số thứ nhất"),
      b: z.number().describe("Số thứ hai"),
    }),
  }
);

const tools = [calculateMultiply];
const toolNode = new ToolNode(tools);

// Đăng ký, hay bind, các công cụ vào mô hình.
const model = new ChatOpenAI({
  modelName: "gpt-4o",
  temperature: 0,
}).bindTools(tools);

// 3. Định nghĩa các node, hay bước xử lý.

// Node này gọi LLM và yêu cầu nó quyết định nên tạo văn bản
// hay thực thi công cụ.
const callModel = async (state: typeof StateAnnotation.State) => {
  const response = await model.invoke(state.messages);
  return { messages: [response] };
};

// Hàm điều hướng có điều kiện này kiểm tra phản hồi của LLM
// và quyết định thực thi công cụ hay kết thúc workflow.
const shouldContinue = (state: typeof StateAnnotation.State) => {
  const lastMessage = state.messages[state.messages.length - 1];

  // Khi LLM quyết định gọi công cụ và tool_calls tồn tại:
  if (
    lastMessage.additional_kwargs.tool_calls &&
    lastMessage.additional_kwargs.tool_calls.length > 0
  ) {
    return "tools"; // Chuyển sang node tools.
  }

  return END; // Kết thúc workflow.
};

// 4. Xây dựng graph, hay mạng xử lý.
const workflow = new StateGraph(StateAnnotation)
  // Thêm các node.
  .addNode("agent", callModel)
  .addNode("tools", toolNode)
  // Thêm edge từ điểm bắt đầu đến agent.
  .addEdge(START, "agent")
  // Sau node agent, phân nhánh theo kết quả của shouldContinue.
  .addConditionalEdges("agent", shouldContinue)
  // Sau khi chạy công cụ, quay lại agent để suy luận lần nữa.
  .addEdge("tools", "agent");

// 5. Compile graph thành một ứng dụng có thể thực thi.
const app = workflow.compile();

// Điểm bắt đầu thực thi.
async function main() {
  const inputs = {
    messages: [
      {
        role: "user",
        content: "Kết quả của phép nhân 12345 với 67890 là bao nhiêu?",
      },
    ],
  };

  const stream = await app.stream(inputs);

  for await (const chunk of stream) {
    // Xuất quá trình chuyển trạng thái theo thời gian thực.
    for (const [node, state] of Object.entries(chunk)) {
      const lastMsg = (state as any).messages?.[
        (state as any).messages.length - 1
      ];

      console.log(
        `[${node}] Đầu ra hiện tại:`,
        lastMsg?.content || "(Đang thực thi công cụ...)"
      );
    }
  }
}

main().catch(console.error);

Trong đoạn mã TypeScript này, .addEdge("tools", "agent") ở cuối thể hiện rõ cấu trúc vòng lặp: sau khi nhận kết quả từ công cụ, hệ thống quay lại node agent để suy luận một lần nữa.

Nhờ định nghĩa an toàn về kiểu dữ liệu, việc quản lý trạng thái nội bộ của AI Agent thông qua StateAnnotation cũng trở nên vững chắc hơn, giúp các workflow tự chủ quy mô lớn có thể được triển khai an toàn trong môi trường production.

3. Lợi thế lớn nhất: AI Agent dành riêng cho doanh nghiệp

Cursor là một công cụ đa dụng để viết mã.

Trong khi đó, AI Agent do bạn tự xây dựng có thể tập trung vào những công việc đặc thù cho lĩnh vực hoặc doanh nghiệp mà một sản phẩm phổ thông không thể tái hiện chính xác.

Ví dụ, AI Agent có thể:

• Tìm kiếm cơ sở dữ liệu nội bộ
• Áp dụng logic tính toán riêng của doanh nghiệp
• Đăng kết quả lên kênh Slack nội bộ

Đây chính là lợi thế lớn nhất của việc tự xây dựng AI Agent.

Tổng kết: AI đang chuyển từ đối tượng trò chuyện thành một đồng nghiệp

Các LLM trước đây chỉ là chatbot trả về những đoạn văn dài cho câu hỏi của người dùng.

Function Calling trao cho LLM vai trò điều phối dữ liệu và công cụ. Chương trình riêng thực hiện hành động thực tế rồi đưa kết quả trở lại ngữ cảnh.

Thông qua cơ chế này, AI đã phát triển thành một Agent có thể suy luận, hành động và tự sửa lỗi.

Cơ chế này không phải là đặc quyền của các tập đoàn lớn.

Chỉ cần kết hợp một script đơn giản để gọi API với logic nghiệp vụ và các hàm riêng, bạn có thể bắt đầu tạo ra một đồng nghiệp kỹ thuật số có khả năng thực hiện một phần công việc thay mình.

Chúng ta sẽ trao cho AI những “tay chân” nào và giao cho nó những công việc gì?

Trọng tâm tiếp theo của phát triển phần mềm đang chuyển sang việc tự xây dựng các AI Agent tùy chỉnh.

Bạn có muốn bắt đầu bước đầu tiên trong quá trình phát triển AI Agent ngay hôm nay không?