API Grok 4.6: Từ lần gọi đầu tiên đến tác nhân biết dùng công cụ

Cài đặt Grok 4.6 API trong Python như thế nào?

Để bắt đầu, bạn cần một khóa API SpaceXAI và cài đặt xai-sdk.

Lấy khóa API từ console.x.ai

Để tạo khóa API Grok 4.6, chúng ta truy cập trang tạo khóa API trên SpaceX AI console. Tiếp theo, nhấp nút Create API Key ở góc trên bên phải.

Biểu mẫu tạo khóa API khá đơn giản. Chúng ta đặt tên cho khóa để nhận biết khóa thuộc dự án nào. Tôi cũng khuyến nghị luôn đặt ngày hết hạn cho khóa API như một biện pháp an toàn trong trường hợp bị lộ.

Sau khi khóa được tạo, chúng ta sao chép và dán vào tệp tên .env trong cùng thư mục nơi sẽ viết các script Python. Cách này giúp dễ dàng nạp khóa vào script mà không phải đặt trong mã nguồn, tránh việc vô tình để lộ khóa khi chia sẻ hoặc tải mã lên đám mây.

Tệp .env nên có nội dung sau:

XAI_API_KEY=replace_with_the_api_key

Cài đặt xai-sdk và nạp khóa API SpaceXAI

Để kết nối tới SpaceXAI bằng khóa API, chúng ta dùng gói xai-sdk. Thực hành tốt là tạo một môi trường riêng cho từng dự án để tránh xung đột giữa các gói Python của các dự án khác. Để làm vậy, chúng ta sẽ dùng Anaconda với lệnh sau:

conda create -yn grok-46 python=3.10
``` 
This creates an environment named grok-46 that we can activate using:
```bash
conda activate grok-46

Khi môi trường đã kích hoạt, ta có thể cài các gói cần thiết. Trước mắt, hãy bắt đầu với:

• xai-sdk: Gói chính thức của SpaceXAI dùng để gửi yêu cầu tới API của họ.

• python-dotenv: Gói tiện ích giúp dễ dàng nạp khóa API từ tệp .env.

Để cài đặt, dùng lệnh:

pip install xai-sdk python-dotenv

Dưới đây là cách nạp khóa API và tạo SpaceXAI Client trong Python:

from dotenv import load_dotenv
from xai_sdk import Client

load_dotenv()

client = Client()

Lưu ý đoạn mã này chưa gửi yêu cầu nào. Chúng ta sẽ học cách thực hiện ngay sau đây.

Mua tín dụng API SpaceXAI

Để dùng Grok 4.6 API, chúng ta cũng cần mua tín dụng trên nền tảng API của họ. Nếu không, các yêu cầu API sẽ bị từ chối. Hãy vào Credits ở cuối thanh bên, nhấp Add credits, và nạp số tiền bạn muốn.

Chi phí dùng Grok 4.6 qua API là bao nhiêu?

Các yêu cầu tới Grok 4.6 được tính phí theo token. Giá cơ bản là $2 cho mỗi triệu token đầu vào và $6 cho mỗi triệu token đầu ra.

Điều quan trọng cần lưu ý là Grok 4.6 là một mẫu suy luận. Quá trình suy luận được thực hiện như một đối thoại nội bộ và cũng tiêu tốn token, được tính như token đầu ra. Chúng ta sẽ học cách kiểm soát lượng suy luận mà mẫu thực hiện cho một yêu cầu cụ thể.

Các token được cache rẻ hơn nhiều, chỉ tốn $0,5 cho mỗi triệu token.

Như chúng ta sẽ thấy, Grok có ba công cụ tích hợp được tính phí riêng so với token: tìm kiếm web, tìm kiếm X và thực thi mã. Tất cả có giá $5,00 cho mỗi 1.000 lượt gọi.

Với ngữ cảnh dài, cần lưu ý rằng mọi token trong prompt vượt ngưỡng 200K sẽ bị tính phí gấp đôi.

Thực hiện cuộc gọi Grok 4.6 API đầu tiên như thế nào?

Hãy xây dựng tiếp từ đoạn mã trước để dùng SpaceXAI client gửi yêu cầu tới Grok 4.6.

Để gửi yêu cầu, ta khởi tạo một phiên chat nhắm tới grok-4.6 với client.chat.create() và thêm prompt của mình vào lịch sử hội thoại bằng chat.append(user()).

Cuối cùng, gọi chat.sample() sẽ gửi hội thoại đến mẫu để tạo phản hồi, chúng ta hiển thị bằng cách in response.content.

from dotenv import load_dotenv
from xai_sdk import Client
from xai_sdk.chat import user

load_dotenv()

client = Client()

chat = client.chat.create(model="grok-4.6")
chat.append(user("Explain how the Transformer attention mechanism works using a simple analogy."))

response = chat.sample()
print(response.content)

Khi dùng Grok theo cách này, ta nhận toàn bộ phản hồi một lần, nên phải đợi Grok tạo xong toàn bộ câu trả lời mới nhận được gì đó. Chúng ta có thể nhận phản hồi từng từ bằng cách stream.

Stream phản hồi

Thay vì đợi phản hồi hoàn chỉnh với chat.sample(), ta có thể dùng chat.stream() để nhận đầu ra của mẫu theo thời gian thực.

# … Same code as before

chat.append(user("Explain how the Transformer attention mechanism works using a simple analogy."))

for response, chunk in chat.stream():
    print(chunk.content, end="", flush=True)

print()

Đoạn mã này lặp qua luồng stream, tạo ra các đối tượng chunk tăng dần và in mỗi phần văn bản mới (chunk.content) lên console ngay khi đến, tạo trải nghiệm stream phản hồi tức thời theo từng token.

Khi chạy mã, ta sẽ thấy mẫu vẫn mất chút thời gian trước khi bắt đầu sinh token. Lý do là Grok 4.6 là mẫu suy luận. Mặc định, trước khi sinh từ đầu tiên của câu trả lời cuối cùng, mẫu sẽ trải qua giai đoạn suy luận nội bộ "chain-of-thought".

Ta có thể cập nhật mã trên để hiển thị cả quá trình suy luận của mẫu như sau:

# … Same code as before

chat.append(user("Explain how the Transformer attention mechanism works using a simple analogy."))

print("--- Reasoning ---")
is_first_content = True

for response, chunk in chat.stream():
    if chunk.reasoning_content:
        print(chunk.reasoning_content, end="", flush=True)
    if chunk.content:
        if is_first_content:
            print("\n\n--- Response ---")
            is_first_content = False
        print(chunk.content, end="", flush=True)

print()

Luồng Grok 4.6 sau đoạn này cung cấp hai loại token:

• Các token chain-of-thought nội bộ của mẫu
• Câu trả lời cuối cùng

Script này phân biệt hai loại bằng cách kiểm tra chunk.reasoning_content để stream trước quá trình suy nghĩ từng bước của Grok, rồi in chunk.content khi câu trả lời cuối cùng bắt đầu.

Thiết lập mức độ suy luận trong Grok 4.6 như thế nào?

Như đã thấy ở trên, giống các mẫu AI frontier khác, Grok 4.6 dựa vào chain of thought ẩn. Trước khi xuất một từ nào của câu trả lời cuối, mẫu sẽ sinh ra hàng nghìn token suy luận để khảo sát lời giải, kiểm tra logic, và tự sửa lỗi.

Tham số reasoning_effort cho phép chúng ta kiểm soát mức nỗ lực mà mẫu dành cho quá trình suy luận này. Vì chúng ta cũng trả phí cho token suy luận chứ không chỉ câu trả lời cuối, đây là tham số quan trọng để quản lý chi phí.

Grok 3 mini đã cho phép tinh chỉnh reasoning_effort, nhưng Grok 4 đã loại bỏ điều khiển này. Suy luận luôn bật và không thể chỉnh. SpaceXAI đã đưa điều khiển này trở lại trên dòng Grok 4.x (4.3 và 4.5), và Grok 4.6 cũng hỗ trợ, với các mức low, medium, high (mặc định), và xhigh.

Để đặt mức nỗ lực suy luận, chúng ta dùng tham số reasoning_effort khi khởi tạo chat với client.chat.create(). Giá trị là một chuỗi thể hiện mức mong muốn. Mặc định là "high". Ví dụ đặt thành "low":

chat = client.chat.create(
    model="grok-4.6",
    reasoning_effort="low"
)

So sánh low và high trên cùng một prompt

Tôi đã thử nhiều tác vụ với cả low và high, như xây dựng một trò chơi nhỏ, tạo script phân tích dữ liệu lương với nhiều định dạng tiền tệ lỗi và giải câu đố logic.

Trong tất cả các trường hợp, mẫu đều đưa ra các lời giải tương tự với cả low hoặc high.

Để tạo khác biệt, chúng ta cần một tác vụ mà việc dừng giữa chừng suy luận sẽ thất bại. Vì vậy, tôi chuyển sang một câu đố có nhiều nghiệm. Đây là prompt tôi dùng:

Solve the following alphametic puzzle, in which each letter represents a unique digit from 0 to 9. The leading digits cannot be zero.

GROK + DATA = CAMP

Provide a list of all solutions. For each solution, show a single line with the final addition to prove it works.

Ở cả hai mức suy luận, Grok 4.6 đều tìm ra nghiệm đúng. Tuy nhiên, khi đặt low, ngân sách suy luận đã cạn trước khi hoàn tất tác vụ. Do đó, nó trả về một lời giải chưa đầy đủ. Ở mức suy luận cao, Grok 4.6 tìm được đủ 264 nghiệm.

Để so sánh, với low nó dùng 16.422 token suy luận, trong khi high dùng 56.455.

Khi nào xhigh đáng để trả thêm token?

Nếu thiết lập high có thể brute-force thành công các câu đố logic phức tạp và script phân tích dữ liệu, tại sao ai đó lại trả phí cho mức tiêu thụ token khổng lồ của xhigh?

Tôi cho rằng với 99% tác vụ lập trình và khoa học dữ liệu hằng ngày, xhigh là quá mức cần thiết và sẽ chỉ làm cạn ngân sách API của bạn.

Tuy nhiên, xhigh trở nên không thể thiếu khi bạn chuyển từ việc yêu cầu mẫu đóng vai trò trợ lý lập trình sang một tác nhân tự chủ. Về bản chất, bạn đang trả tiền để mẫu chủ động rà soát công việc của chính nó, rẽ vào ngõ cụt, và viết lại logic trước khi hiển thị đầu ra cuối.

Lời khuyên của tôi là bắt đầu từ low và chỉ tăng lên nếu mẫu liên tục thất bại với một tác vụ. Đúng là đôi khi điều này khiến ta trả phí nhiều lần cho cùng một vấn đề, nhưng phần lớn thời gian ta sẽ có lời giải tốt với chỉ một phần nhỏ chi phí.

Gửi hình ảnh tới Grok 4.6 API như thế nào?

Grok 4.6 là đa phương thức nên có thể xử lý dữ liệu hình ảnh.

Gửi ảnh qua URL

Cách đơn giản nhất để cung cấp ảnh cho mẫu là dùng URL. Chúng ta có thể truyền nó như tham số thứ hai của tin nhắn người dùng:

from dotenv import load_dotenv
from xai_sdk import Client
from xai_sdk.chat import image, user

load_dotenv()
client = Client()

chat = client.chat.create(model="grok-4.6")

image_url = "https://images.pexels.com/photos/25810993/pexels-photo-25810993.jpeg"

chat.append(
    user(
        "Describe what you see in this image in detail.",
        image(image_url=image_url),
    )
)

for response, chunk in chat.stream():
    print(chunk.content, end="", flush=True)

print()

Gửi ảnh qua tải tệp

Nhiều khi ta muốn dùng ảnh cục bộ thay vì URL. Điều này có thể làm được bằng cách nạp ảnh thành chuỗi base64. Hàm encode_image() có thể giúp chúng ta:

import base64
import mimetypes

def encode_image(image_path: str) -> str:
    mime_type, _ = mimetypes.guess_type(image_path)
    if not mime_type:
        mime_type = "image/jpeg"
    with open(image_path, "rb") as image_file:
        encoded_string = base64.b64encode(image_file.read()).decode("utf-8")
    return f"data:{mime_type};base64,{encoded_string}"

Khi ảnh đã được mã hóa, ta cung cấp cho mẫu theo cùng cách:

chat.append(
    user(
        "Describe what you see in this image in detail.",
        image(image_url=encode_image("image.png")),
    )
)

Dù hỗ trợ đầu vào hình ảnh, Grok 4.6 chỉ xuất văn bản. Nếu muốn tìm hiểu thêm về sinh ảnh của SpaceXAI, tôi khuyên bạn đọc hướng dẫn Grok Imagine API của chúng tôi.

Bật công cụ cho tác nhân Grok 4.6 như thế nào?

Grok 4.6 cung cấp quyền truy cập ba công cụ hữu ích phía máy chủ và cho phép tạo công cụ tùy chỉnh.

Gọi công cụ phía máy chủ (tìm kiếm web, tìm kiếm X, thực thi mã)

Grok 4.6 đi kèm ba công cụ máy chủ:

• Tìm kiếm web: Cho phép tác nhân thực hiện tìm kiếm web để củng cố câu trả lời.
• Tìm kiếm X: Truy vấn dữ liệu nền tảng theo thời gian thực từ X.
• Thực thi mã: Thực thi mã trong sandbox để hỗ trợ trả lời truy vấn.

Các công cụ này chạy trên máy chủ SpaceXAI, và mỗi lần gọi công cụ được tính phí độc lập với token.

Để bật chúng, chúng ta cần import và truyền vào khi khởi tạo chat với client.chat.create():

from xai_sdk.tools import code_execution, web_search, x_search
chat = client.chat.create(
    model="grok-4.6",
    tools=[web_search(), x_search(), code_execution()],
)

Khi stream phản hồi, ta có thể biết tác nhân có đang dùng công cụ hay không bằng cách kiểm tra cờ chunk.tool_calls.

Dưới đây là đoạn mã xử lý phản hồi stream theo cách cho người dùng biết khi tác nhân đang dùng công cụ:

for response, chunk in chat.stream():
    for tool_call in chunk.tool_calls:
        print(f"\n--> Agent is calling tool: {tool_call.function.name}\n", flush=True)
    if chunk.content:
        print(chunk.content, end="", flush=True)

Bạn có thể xem ví dụ script đầy đủ với công cụ máy chủ trong repo GitHub đi kèm của tôi.

Triển khai công cụ cục bộ tùy chỉnh

Ngoài các công cụ máy chủ trên, chúng ta cũng có thể trang bị cho tác nhân Grok 4.6 các công cụ tùy chỉnh. Hãy xem cách triển khai công cụ cho phép tác nhân đọc và ghi tệp cục bộ.

Để triển khai một công cụ tùy chỉnh, cần hai thứ:

1. Đặc tả công cụ bằng đối tượng tool() chính thức từ SpaceXAI SDK.

2. Một hiện thực Python của công cụ, tức là đoạn mã sẽ được thực thi khi công cụ được gọi.

Một đặc tả công cụ gồm có:

• Tên hàm Python sẽ gọi.
• Mô tả giải thích công cụ làm gì. Điều này rất quan trọng vì quyết định khi nào tác nhân gọi công cụ.
• Đặc tả tham số của hàm.

Dưới đây là hàm chúng ta có thể dùng để triển khai công cụ đọc tệp cục bộ:

def execute_read_file(file_path: str) -> str:
    print(f"\n🔒 [Permission Request] Grok wants to read local file: '{file_path}'")
    confirm = input("Allow access? [y/N]: ").strip().lower()
    if confirm not in ("y", "yes"):
        print(f"❌ Denied access to '{file_path}'")
        return f"Permission denied by user. Access to file '{file_path}' was not granted."

    if not os.path.exists(file_path):
        return f"Error: File '{file_path}' does not exist."

    try:
        with open(file_path, "r", encoding="utf-8") as f:
            content = f.read()
        print(f"✅ Read {len(content)} characters from '{file_path}'\n")
        return content
    except Exception as e:
        return f"Error reading file '{file_path}': {e}"

Vì lý do an toàn, chúng ta triển khai công cụ để luôn hỏi người dùng cấp quyền trước khi đọc tệp. Điều này giúp tránh vô tình cung cấp dữ liệu riêng tư cho tác nhân.

Đây là đặc tả công cụ cho hàm trên:

from xai_sdk.chat import tool
read_file_tool = tool(
    name="read_local_file",
    description="Reads the text contents of a local file given its relative or absolute path. Use this whenever the user asks to inspect, summarize, or analyze a local file.",
    parameters={
        "type": "object",
        "properties": {
            "file_path": {
                "type": "string",
                "description": "The path to the local file to read.",
            }
        },
        "required": ["file_path"],
    },
)

Mã để ghi vào tệp tương tự và có thể tìm thấy trong tệp tools.py từ kho lưu trữ.

Chạy vòng lặp tác nhân dùng công cụ với Grok 4.6 như thế nào?

Trong phần này, chúng ta tổng hợp mọi thứ đã học để xây dựng vòng lặp tác nhân Grok 4.6, nơi ta có thể trò chuyện với một tác nhân có khả năng thực hiện công việc thực sự bằng cách thao tác trên tệp cục bộ đồng thời củng cố câu trả lời bằng dữ liệu trực tuyến qua tìm kiếm.

Tác nhân sẽ hoạt động như trong sơ đồ dưới đây. Người dùng gửi prompt, sau đó tác nhân phản hồi và dùng công cụ nếu cần. Tiếp đến câu trả lời được gửi lại cho người dùng, và người dùng có thể tiếp tục tương tác với tác nhân.

Tác nhân theo dõi toàn bộ hội thoại bằng cách dùng hàm chat.append() để nối prompt của người dùng, phản hồi và kết quả công cụ. Kết quả công cụ phải được bọc trong một thể hiện của tool_result().

Dưới đây là hiện thực đầy đủ của tác nhân:

import json
from dotenv import load_dotenv
from xai_sdk import Client
from xai_sdk.chat import tool_result, user
from xai_sdk.tools import code_execution, web_search, x_search
from tools import (
    execute_read_file,
    execute_write_file,
    read_file_tool,
    write_file_tool,
)

load_dotenv()

# 1. Initialize the chat client with both server-side and client-side tools
client = Client()
chat = client.chat.create(
    model="grok-4.6",
    tools=[web_search(), x_search(), code_execution(), read_file_tool, write_file_tool],
)

# 2. Interactive chat loop
while True:
    try:
        prompt = input("> ")
    except (EOFError, KeyboardInterrupt):
        print()
        break

    if not prompt.strip():
        continue
    if prompt.strip().lower() in ("exit", "quit"):
        break

    # Append the user prompt to the conversation
    chat.append(user(prompt))

    # Agent loop: keeps running until Grok finishes (no further client tool calls)
    print("How can I help you?\n")
    while True:
        response = None
        announced_tools = set()
        started_content = False

        for response, chunk in chat.stream():
            # Announce tool calls
            if chunk.tool_calls:
                for tc in chunk.tool_calls:
                    name = getattr(tc.function, "name", "")
                    tc_id = getattr(tc, "id", None) or name
                    if tc_id and tc_id not in announced_tools:
                        announced_tools.add(tc_id)
                        display_name = name or "tool"
                        print(f"\n⚙️  [Agent Tool] Calling: {display_name}...", flush=True)

            # Stream generated content
            if chunk.content:
                if not started_content:
                    print("\nGrok > ", end="", flush=True)
                    started_content = True
                print(chunk.content, end="", flush=True)

        if response:
            chat.append(response)

        # Check if Grok triggered client-side tools
        client_tool_executed = False
        if response and response.tool_calls:
            for tool_call in response.tool_calls:
                fn_name = tool_call.function.name
                if fn_name == "read_local_file":
                    client_tool_executed = True
                    try:
                        args = json.loads(tool_call.function.arguments)
                        file_path = args.get("file_path", "")
                    except Exception:
                        file_path = tool_call.function.arguments or ""
                    
                    result = execute_read_file(file_path)
                    chat.append(tool_result(result, tool_call_id=tool_call.id))

                elif fn_name == "write_local_file":
                    client_tool_executed = True
                    try:
                        args = json.loads(tool_call.function.arguments)
                        file_path = args.get("file_path", "")
                        content = args.get("content", "")
                    except Exception:
                        file_path = ""
                        content = ""
                    
                    result = execute_write_file(file_path, content)
                    chat.append(tool_result(result, tool_call_id=tool_call.id))

        # If Grok called a client-side tool, re-enter the loop so Grok processes the tool result
        if client_tool_executed:
            continue
        
        break

    print("\n")

Kiểm thử tác nhân Grok 4.6 để phân tích danh mục cổ phiếu

Để kiểm thử tác nhân, tôi tạo một tệp CSV danh mục cổ phiếu mẫu. Tệp khá đơn giản, liệt kê các mã cổ phiếu, đặc biệt là ngày mua và giá mua.

Ý tưởng là yêu cầu tác nhân:

1. Nạp tệp CSV.
2. Tìm kiếm web để lấy giá hiện tại của từng mã cổ phiếu.
3. Cập nhật CSV bằng cách thêm một cột mới với giá hiện tại.
4. Yêu cầu tác nhân tạo báo cáo về danh mục của chúng ta, thể hiện diễn biến gần đây trong các ngành.

Dưới đây là ảnh chụp tương tác với Tác nhân cho các bước 1 đến 3.

Ta thấy nó đã dùng tìm kiếm web, thực thi mã, và các công cụ tùy chỉnh để đọc và ghi tệp cục bộ. Cuối cùng, nó cập nhật tệp CSV bằng cách thêm một cột với giá cổ phiếu hiện tại.

Vì tác nhân chạy theo vòng lặp, chúng ta có thể tiếp tục hội thoại. Ở tương tác tiếp theo, tôi yêu cầu nó tra cứu tin tức liên quan đến các mã này, phân tích đa dạng hóa danh mục, và tạo báo cáo markdown.

Nếu bạn tò mò về báo cáo nó tạo, nó nằm trong kho GitHub.

Kiểm thử tác nhân trên một tác vụ thực như phân tích danh mục cổ phiếu cho thấy Grok 4.6 có thể làm được gì. Bằng cách tự mình thực hiện tìm kiếm web, chạy mã và gọi các công cụ cục bộ, mẫu dễ dàng xử lý các yêu cầu phức tạp.

Bộ nhớ đệm prompt và “vách giá” 200k

Khi triển khai tác nhân đa lượt, chúng ta nên đảm bảo hội thoại được cache để mẫu không phải xử lý lại toàn bộ lịch sử ở mỗi lượt. Không làm vậy có thể phát sinh chi phí rất lớn.

Caching diễn ra tự động, nhưng các mục cache được lưu theo máy chủ, và mặc định, yêu cầu có thể được định tuyến tới các máy chủ khác nhau và bỏ lỡ cache. Để tối đa hóa cache hit, ta cung cấp một định danh hội thoại ổn định để tất cả yêu cầu trong một hội thoại đi tới cùng máy chủ. Cách truyền phụ thuộc vào API:

• xai-sdk (gRPC): x-grok-conv-id, truyền như metadata gRPC khi khởi tạo client

• OpenAI Responses API: prompt_cache_key, đặt trong thân yêu cầu

Đoạn mã sau minh họa cách thực hiện:

import uuid
from dotenv import load_dotenv
from xai_sdk import Client
from xai_sdk.chat import tool_result, user

load_dotenv()

# 1. Generate a unique ID for the conversation loop
conv_id = str(uuid.uuid4()) 

# 2. Pass the ID when initializing the Client
client = Client(
    metadata=(("x-grok-conv-id", conv_id),)
)

# ... [the rest of the code remains the same]

Một lưu ý quan trọng là hình phạt về chi phí trở nên đặc biệt nghiêm trọng với các hội thoại kéo dài. Khi tổng độ dài prompt của bạn đạt hoặc vượt 200k token, API áp dụng hệ số nhân 2x, tính toàn bộ yêu cầu với mức giá gấp đôi tiêu chuẩn.

Để tránh các vòng lặp đa lượt vượt ngưỡng 200k, nên triển khai nén ngữ cảnh. Thực hiện bằng cách định kỳ tóm tắt các lượt hội thoại cũ hoặc trượt cửa sổ ngữ cảnh. Chiến lược này giúp bạn tiếp tục hưởng lợi từ cache rẻ cho chỉ dẫn cốt lõi trong khi tránh khoản phạt nặng từ cửa sổ ngữ cảnh tăng mãi.

Kết luận

Trong hướng dẫn này, chúng ta đã học cách dùng SpaceXAI API với Python để tương tác với Grok 4.6. Chúng ta học những điều cơ bản về cách gửi prompt văn bản và hình ảnh, cũng như cách xử lý đầu ra để cho người dùng biết mẫu đang làm gì.

Bằng cách học cách cung cấp công cụ cho mẫu AI, chúng ta đã có thể ghép tất cả lại và xây dựng một tác nhân AI có khả năng dùng Grok 4.6 để giải quyết các tác vụ đời thực như phân tích danh mục cổ phiếu. Cuối cùng, chúng ta nhận ra rằng thực thi các tác vụ ngữ cảnh dài có thể cực kỳ tốn kém, đặc biệt nếu không dùng cache.

Như một bài tập để kiểm tra những gì bạn đã học, tôi gợi ý bạn triển khai caching trong tác nhân và cập nhật đầu ra để hiển thị cả token suy luận.

Nếu bạn muốn đào sâu kiến thức về xây dựng AI agent với API, tôi khuyến nghị khóa Working with the OpenAI API. Nơi tốt nhất để đi sâu về AI agent là lộ trình kỹ năng AI Agent Fundamentals.