API Grok 3: Hướng dẫn từng bước kèm ví dụ

Grok 3 là gì?

Grok 3 là mô hình ngôn ngữ lớn mới nhất của xAI, được xây dựng chuyên biệt cho suy luận từng bước, tính nhất quán logic và đầu ra có cấu trúc. Khác với các mô hình chat thông thường ưu tiên dòng hội thoại, Grok 3 "suy nghĩ trước khi trả lời", khiến nó lý tưởng cho các tác vụ đòi hỏi logic sâu, như ra quyết định phức tạp, suy luận toán học và phân tích định lượng.

Grok 3 có hai phiên bản: bản tiêu chuẩn và bản mini. Trong khi bản mini tập trung hoàn toàn vào khía cạnh suy luận và cho phép truy cập dấu vết suy luận, thì bản tiêu chuẩn được quảng bá là sở hữu kiến thức chuyên sâu ở các lĩnh vực như tài chính, y tế, luật và khoa học.

Cả hai phiên bản đều hỗ trợ các khả năng nâng cao như gọi hàm gốc và tạo phản hồi có cấu trúc, giúp nhà phát triển dễ dàng xây dựng các quy trình AI đáng tin cậy và có thể dự đoán.

Nếu bạn muốn biết thêm về kiến trúc và hiệu năng của Grok 3, hãy xem bài tổng quan về Grok 3.

Chuẩn bị: Nhận quyền truy cập API Grok 3

Trong phần này, tôi sẽ giải thích cách tạo khóa API, thiết lập môi trường Python để kết nối tới Grok API và gửi yêu cầu người dùng đầu tiên của bạn.

Tạo khóa API

Để xác thực client Python với API, chúng ta cần tạo một khóa API. Quy trình như sau:

1. Truy cập trang tài liệu xAI.
2. Đăng nhập bằng tài khoản X, xAI hoặc Google—hoặc tạo tài khoản xAI.
3. Nhấp “Create an API key”, đặt tên và nhấp “save”.
4. Khi khóa hiển thị, hãy sao chép nó. Bạn sẽ không thể xem lại sau này, nhưng có thể tạo khóa mới nếu làm mất.
5. Tạo tệp tên .env trong thư mục dự án và dán khóa theo định dạng sau:

XAI_API_KEY=<your_api_key>Được hỗ trợ bởi

Giá thành API Grok 3

Mặc dù dùng API thường gắn với chi phí thấp hơn so với gói thuê bao cao cấp, nhưng không phải miễn phí. Thay vì phí cố định hàng tháng, bắt đầu từ $30 với gói SuperGrok, chi phí hoàn toàn phụ thuộc vào mức sử dụng. Để có cái nhìn tổng quan về chi phí tiềm năng, hãy truy cập trang định giá của xAI.

Mức giá được tính theo mỗi một triệu token, theo quy tắc ước lượng thì tương đương khoảng 750.000 từ đầu vào hoặc đầu ra bằng tiếng Anh.

Bản mini rẻ hơn đáng kể so với bản tiêu chuẩn. Các phiên bản nhanh của cả Grok 3 và Grok 3 mini dùng cùng mô hình nền tảng, nhưng được phục vụ trên hạ tầng nhanh hơn, dẫn đến thời gian phản hồi cải thiện.

Để dùng API, chúng ta cần mua tín dụng. Ban đầu nên dùng tín dụng trả trước thay vì hóa đơn tự động, vì đây là biện pháp bảo vệ tốt trước chi phí ngoài dự kiến. Bạn có thể mua token và xem tổng quan mức sử dụng trong bảng điều khiển xAI tại Invoices > Credits.

Thiết lập môi trường Python

Giờ chúng ta đã có khóa API và đã mua tín dụng, đến lúc thiết lập client Python. Chúng ta cần cài đặt hai phụ thuộc để các yêu cầu API chạy thành công:

• python-dotenv để tải khóa API làm biến môi trường từ tệp .env, và
• client openai làm giao diện gửi yêu cầu tới Grok 3.

Để thiết lập môi trường cho dự án, tôi khuyến nghị dùng Anaconda để tránh xung đột giữa các gói Python. Sau khi cài Anaconda, ta tạo môi trường tên grok3 dùng Python 3.10 và kích hoạt bằng các lệnh sau trong terminal:

conda create -n grok3 python=3.10
conda activate grok3Được hỗ trợ bởi

Cuối cùng, cài đặt các phụ thuộc:

pip install python-dotenv openaiĐược hỗ trợ bởi

Gửi yêu cầu người dùng đầu tiên

Đến lúc bắt đầu với script đầu tiên! Trước hết, ta cần import các hàm sẽ dùng từ những gói đã cài, cùng với os để đọc khóa API.

import os
from dotenv import load_dotenv
from openai import OpenAIĐược hỗ trợ bởi

Biến môi trường chứa khóa API được nạp bằng cách gọi hàm load_dotenv() từ gói dotenv.

# Load environment variables
load_dotenv()Được hỗ trợ bởi

Bước tiếp theo là khởi tạo client. Ta gọi hàm OpenAI với khóa API từ tệp .env và URL máy chủ Grok, rồi gán cho biến client.

client = OpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
)Được hỗ trợ bởi

Hãy hỏi Grok lời khuyên làm gì ở San Francisco khi trời mưa. Việc cần làm là chỉ định model và messages, rồi truyền chúng làm tham số vào hàm client.chat.completions.create. Ngoài ra, ta có thể điều chỉnh tham số như max_tokens để kiểm soát độ dài phản hồi hoặc temperature để ảnh hưởng độ ngẫu nhiên.

# Send a basic reasoning query
response = client.chat.completions.create(
    model="grok-3",
    messages=[
        {"role": "user", "content": "What kind of activity would you suggest, if it rains in San Francisco? Answer in one sentence."}
    ],
    max_tokens=1000,
    temperature=0.2,  # lower temperature for more deterministic answers
)Được hỗ trợ bởi

Để in câu trả lời của Grok, ta cần trích xuất nó từ đối tượng kết quả. Vì biến lưu kết quả là response, câu trả lời nằm ở response.choices[0].message.content.

print(response.choices[0].message.content) # Print the responseĐược hỗ trợ bởi

If it rains in San Francisco, I suggest visiting indoor attractions like the San Francisco Museum of Modern Art or the California Academy of Sciences for an enriching and dry experience.Được hỗ trợ bởi

Suy luận với Grok 3 Mini

Để thấy phong cách suy luận của Grok, hãy hỏi một câu cơ bản cần một chút lập luận logic. Chúng ta sẽ dùng Grok 3 Mini cho yêu cầu đầu vì nó đảm bảo có đầy đủ dấu vết suy luận trong mọi phản hồi API, giúp dễ theo dõi luồng suy nghĩ của mô hình từng bước mà không cần dựa vào kỹ thuật nhắc lệnh đặc biệt.

Tham số quyết định mức độ "suy nghĩ" sâu của mô hình là reasoning_effort. Nó chỉ có ở Grok 3 Mini và mặc định đặt ở tuỳ chọn nhanh hơn "low". Đặt reasoning_effort="high" giúp mô hình cẩn thận đi qua vấn đề từng bước trước khi đưa ra câu trả lời cuối cùng, rất phù hợp cho các tác vụ như lập kế hoạch, ra quyết định hoặc suy luận toán học.

Giả sử ta muốn dùng Grok để quyết định làm gì vào ngày nghỉ, tùy theo thời tiết. Ta có thể truyền cho Grok các tiền đề xác định hoạt động cho ngày nắng và ngày mưa, và một tiền đề dựa trên thời tiết thực tế.

response = client.chat.completions.create(
    model="grok-3-mini-beta",
    reasoning_effort="high",
    messages=[
        {"role": "user", "content": (
            "Premises:\n"
            "- If it is raining, the weather is suitable for indoor activities.\n"
        	"- Visiting a museum is an indoor activity.\n"
        	"- Today, it is raining.\n"
            "Question: What should we do today?"    	
        )}
    ],
    max_tokens=1000,
    temperature=0.2,
)Được hỗ trợ bởi

Để làm việc với dấu vết suy luận, trước tiên ta cần phân tích phản hồi API và trích xuất thuộc tính reasoning_content từ đối tượng message. Đoạn mã sau cho thấy cách in cả các bước suy luận chi tiết và câu trả lời cuối cùng, tương tự như khi hiển thị trên giao diện web.

# Print the reasoning trace if available
reasoning = getattr(response.choices[0].message, "reasoning_content", None)
 
if reasoning:
    print("Reasoning steps:\n")
    print(reasoning)
else:
    print("No detailed reasoning trace found.")
 
# Print the final answer
print("\nFinal Answer:\n")
print(response.choices[0].message.content)Được hỗ trợ bởi

Kết quả trông như sau:

Reasoning steps:
First, the premises are:
1. If it is raining, the weather is suitable for indoor activities.
2. Visiting a museum is an indoor activity.
3. Today, it is raining.
The question is: What should we do today?
I need to reason step by step based on the given premises.
From premise 3, today it is raining.
From premise 1, if it is raining, then the weather is suitable for indoor activities. Since it's raining today, the weather is suitable for indoor activities today.  	
From premise 2, visiting a museum is an indoor activity. So, if the weather is suitable for indoor activities, and visiting a museum is an indoor activity, it makes sense that visiting a museum would be a good choice today.
The conclusion should be that we should visit a museum or engage in some indoor activity. But the question is "What should we do today?" and the premises point towards indoor activities, with a specific example given.
Let me chain the logic:
- It is raining (premise 3).
- Therefore, weather is suitable for indoor activities (from premise 1).
- Visiting a museum is an indoor activity (premise 2).
- So, since the weather is suitable for indoor activities, and museum visiting is an indoor activity, it should be suitable to visit a museum.
The premises don't explicitly say that we should do the most suitable activity or anything like that. They just provide conditions and facts.
However, the question implies a recommendation based on the premises. Given that it's raining and indoor activities are suitable, and a museum is mentioned, it's logical to suggest visiting a museum.
I should stick to what's given. The premises don't suggest any other activities or constraints, so based on the information, visiting a museum is a reasonable suggestion.
Final answer should be something like: "We should visit a museum today."
To make it clear, I can phrase it as: "Since it is raining and the weather is suitable for indoor activities, and visiting a museum is an indoor activity, we should visit a museum today."
But since the instruction is to put the final answer in a box, probably a concise statement.
Looking back at the user's message, it's a reasoning exercise, so the answer should be direct.
Final Answer:
Based on the given premises:
- It is raining today (premise 3).
- If it is raining, the weather is suitable for indoor activities (premise 1).   	
- Therefore, the weather is suitable for indoor activities today.
- Visiting a museum is an indoor activity (premise 2).
A suitable activity for today would be an indoor one, such as visiting a museum. 	
**Recommendation:** We should visit a museum today.Được hỗ trợ bởi

Dù đây là ví dụ khá đơn giản, ta có thể thấy grok-3-mini cẩn trọng đi qua từng tiền đề, xâu chuỗi logic từng bước trước khi đưa ra khuyến nghị. Suy luận của nó có phương pháp và minh bạch, giúp dễ dàng lần theo cách mô hình đi từ sự kiện đến gợi ý cuối cùng.

Gọi hàm với Grok 3

Một trong những tính năng khiến Grok 3 thú vị là khả năng gọi hàm, cho phép nó kết nối với công cụ và hệ thống bên ngoài. Nhờ đó mô hình không chỉ sinh văn bản mà còn kích hoạt hành động như lấy dự báo thời tiết, tra lịch sự kiện, phân tích mục nhập trong cơ sở dữ liệu, thậm chí điều khiển thiết bị thông minh.

Khi ta gửi yêu cầu người dùng, Grok 3 có thể nhận ra rằng cần thêm thông tin và yêu cầu gọi một hàm với các tham số cụ thể. Client Python sau đó thực thi hàm cục bộ, gửi kết quả về cho Grok 3 và nhận phản hồi cuối cùng đã được suy luận đầy đủ.

Nguồn: xAI

Chuẩn bị

Chúng ta sẽ cần gói json để truy cập cấu trúc tham số của hàm được Grok gọi, nên phải import nó.

import jsonĐược hỗ trợ bởi

Để thử gọi hàm, ta cần định nghĩa một hàm callback sẽ được gọi khi Grok yêu cầu trong phản hồi của nó. Trong trường hợp này, hàm get_weather_forecast là một hàm Python đơn giản trả về dự báo thời tiết được mã cứng. Tôi mã cứng để minh họa, nhằm giữ lời giải thích đơn giản và tránh phụ thuộc vào dịch vụ bên ngoài.

# Define the dummy function
def get_weather_forecast(location: str, date: str) -> dict:
    """Simulated function to always return rainy weather."""
    return {
        "location": location,
        "date": “this weekend”, # hardcoded for demo purposes
        "forecast": "rainy"  # hardcoded for demo purposes
    }Được hỗ trợ bởi

Chúng ta cũng phải định nghĩa công cụ sẵn có bằng cách chỉ định tên, mục đích và các tham số bắt buộc trong một JSON schema, sẽ được gửi tới Grok kèm theo yêu cầu sau đó. Thiết lập này cho Grok 3 biết rằng nó có thể gọi công cụ này bất cứ khi nào cần thông tin thời tiết để suy luận.

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather_forecast",
            "description": "Get a simulated weather forecast for a given location and date.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city where the activity will take place."
                    },
                    "date": {
                        "type": "string",
                        "description": "The date for which the weather is needed, in YYYY-MM-DD format."
                    }
            	    },
            	    "required": ["location", "date"]
            }
        }
    }
]Được hỗ trợ bởi

Cuối cùng, tools_map dictionary ánh xạ tên hàm Grok 3 sử dụng tới các hàm Python cục bộ thực tế, cho phép client thực thi đúng các lệnh gọi công cụ được yêu cầu.

# Link the function names to the functions
tools_map = {
    "get_weather_forecast": get_weather_forecast
}Được hỗ trợ bởi

Việc định nghĩa schema công cụ thủ công là ổn với dự án đơn giản, nhưng khi dự án lớn và phức tạp hơn, dùng mô-đun kiểm tra dữ liệu như Pydantic càng có giá trị. Nó cho phép tự động xác thực đầu vào hàm, xử lý lỗi tốt hơn, và mã gọn gàng, dễ bảo trì.

Thực thi

Hãy xem Grok có dùng hàm dự báo thời tiết của chúng ta khi được hỏi về hoạt động gợi ý ở San Francisco cuối tuần này không. Ta sẽ theo cấu trúc của quy trình gọi hàm:

1. Đầu tiên, gửi yêu cầu người dùng ban đầu chứa câu hỏi của ta tới Grok kèm theo tools sẵn có.
2. Kiểm tra câu trả lời của Grok xem có yêu cầu gọi công cụ không; nếu có, gọi hàm cục bộ tương ứng bằng tools_map. Nếu Grok không yêu cầu gọi công cụ, ta có thể xử lý bằng cách trả về câu trả lời ban đầu của mô hình.
3. Tiếp theo, thêm kết quả vào lịch sử tin nhắn; và
4. Gửi lại cho Grok để hoàn tất suy luận và tạo câu trả lời cuối cùng.

# Step 1: Send the initial user request
messages = [
    {"role": "user", "content": "What should I do this weekend in San Francisco?"}
]

response = client.chat.completions.create(
    model="grok-3",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)
 
# Step 2: Check if a tool call was requested
tool_calls = getattr(response.choices[0].message, "tool_calls", [])
 
if tool_calls:
    for tool_call in tool_calls:
        function_name = tool_call.function.name
        function_args = json.loads(tool_call.function.arguments)
 
        # Find and call the matching local function
        if function_name in tools_map:
            function_result = tools_map[function_name](**function_args)
 
            # Step 3: Add the function result back to the message history
            messages.append(response.choices[0].message)  # Grok's tool call message
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(function_result)
        	})
 
        	# Step 4: Send a new request including the tool response
            final_response = client.chat.completions.create(
                model="grok-3",
                messages=messages,
                tools=tools,
                tool_choice="auto"
        	)
 
        	# Print the final answer
            print("\nFinal Answer:")
            print(final_response.choices[0].message.content)
 
else:
    # No tool call: respond directly
    print("\nNo tool call was requested. Final Answer:")
    print(response.choices[0].message.content)Được hỗ trợ bởi

Hàm đã được yêu cầu và thực thi thành công, như câu trả lời của Grok cho thấy:

Thanks for the weather update. Since it's going to be rainy this weekend in San Francisco, I’ll suggest some indoor activities to keep you entertained and dry. Here are a few ideas for your weekend: (...)Được hỗ trợ bởi

Bạn có thể đã để ý tham số tool_choice trong yêu cầu người dùng ban đầu, tham chiếu đến chế độ gọi hàm. Mặc định, chế độ "auto" cho phép Grok 3 quyết định có gọi hàm hay không và gọi hàm nào dựa trên hội thoại. Ngoài ra, ta có thể kiểm soát hành vi bằng cách bắt buộc gọi hàm với "required", chỉ định chính xác hàm cần gọi, hoặc tắt hoàn toàn gọi hàm với "none".

Đầu ra có cấu trúc với Grok 3

Đầu ra có cấu trúc cho phép Grok 3 trả lời theo định dạng nghiêm ngặt, được xác định trước như JSON thay vì văn bản tự do. Điều này giúp dễ dàng phân tích, xác thực và tích hợp phản hồi của mô hình vào ứng dụng hoặc quy trình.

Bằng cách định nghĩa schema trước, ta đảm bảo đầu ra của Grok nhất quán, máy có thể đọc được và sẵn sàng cho xử lý hạ nguồn. Do đó, đây là tính năng rất hữu ích cho các trường hợp như trích xuất dữ liệu có cấu trúc từ tài liệu hoặc đưa insight do AI tạo ra vào các hệ thống hạ nguồn như cơ sở dữ liệu, bảng điều khiển hay pipeline tự động mà không cần phân tích văn bản mong manh.

Chúng ta dùng Pydantic để định nghĩa schema đầu ra vì nó cung cấp cách thức rõ ràng và dễ đọc để cấu trúc dữ liệu phức tạp. Cần import cả BaseModel và Field từ pydantic để định nghĩa schema hoạt động đúng. Vì đầu ra gồm danh sách các bước suy luận, ta cũng import List từ mô-đun typing của Python để chỉ rõ kiểu phần tử.

Dù cũng có thể định nghĩa schema bằng JSON thuần, trong thử nghiệm tôi thấy đôi khi Grok 3 trả về đầu ra không khớp chính xác với cấu trúc mong đợi. JSON trả về tương tự về ý nghĩa nhưng theo schema khác, có thể làm hỏng ứng dụng kỳ vọng cấu trúc cụ thể. Vì sự thiếu nhất quán này, đặc biệt với phần tử lồng nhau như danh sách, tôi khuyến nghị mạnh mẽ dùng Pydantic để đảm bảo đầu ra có cấu trúc được xác thực và phân tích đáng tin cậy.

from pydantic import BaseModel, Field
from typing import ListĐược hỗ trợ bởi

Schema của chúng ta, tên DecisionPlan, gồm situation ban đầu và danh sách DecisionSteps, được xác định bởi số step, phần reasoning đằng sau nó và action được đề xuất.

# Define the schema for the structured output
class DecisionStep(BaseModel):
    step: int = Field(description="Step number in the decision process")
    reasoning: str = Field(description="Reasoning behind this step")
    action: str = Field(description="Suggested action at this step")
 
class DecisionPlan(BaseModel):
    situation: str = Field(description="The initial situation to consider")
    steps: List[DecisionStep] = Field(description="List of reasoning steps leading to the final action")Được hỗ trợ bởi

Có vài điểm cần lưu ý về chính yêu cầu. Trước hết, ta cần dùng client.beta.chat.completions.parse() thay vì create(), để Grok biết rằng ta muốn đầu ra theo định dạng cụ thể. Đây là schema ta vừa định nghĩa, và tương ứng, ta truyền DecisionPlan làm tham số response_format.

Việc đưa tất cả hướng dẫn quan trọng cho một tác vụ vào lời nhắc hệ thống có thể hữu ích, vì nó giúp Grok 3 tập trung vào tác vụ trong suốt cuộc hội thoại. Kết hợp với schema định nghĩa riêng, lời nhắc người dùng không cần chỉ rõ các trường bắt buộc trong JSON đầu ra mà có thể tập trung vào chính tác vụ.

Ví dụ, ta có thể dễ dàng chia nhỏ quá trình lập kế hoạch hoạt động thành ba bước rõ ràng:

# Send a prompt and request structured output
completion = client.beta.chat.completions.parse(
    model="grok-3",
    messages=[
        {"role": "system", "content": (
        "You are an expert travel planner."
        "When asked about activities, always break down the decision process into exactly 3 logical reasoning steps."
        "Return the output in structured JSON format following the provided schema, without any extra text."
        )},
        {"role": "user", "content": (
        "It's raining today in San Francisco. What indoor activity would you recommend?"
        )}
    ],
    response_format=DecisionPlan,
)Được hỗ trợ bởi

Sau khi phân tích đầu ra có cấu trúc của Grok 3, ta có thể hành động dựa trên kết quả bằng cách tóm tắt các khuyến nghị chính, kích hoạt quy trình tự động, hoặc thậm chí đưa ra quyết định tiếp theo một cách lập trình.

Hãy chọn ví dụ đầu tiên và chỉ hiển thị tình huống và khuyến nghị cuối cùng của chuyên gia du lịch Grok. Vì đầu ra theo định dạng JSON định sẵn, ta có thể truy cập khuyến nghị ở bước cuối cùng một cách dễ dàng:

# Access the parsed result
plan = completion.choices[0].message.parsed
 
# Use the final action to create a summary message
final_step = plan.steps[-1]
 
print(f"\nSummary:")
print(f"Situation: {plan.situation}")
print(f"Recommended Action: {final_step.action}")Được hỗ trợ bởi

Summary:
Situation: It's raining today in San Francisco, and an indoor activity is needed to make the most of the day.
Recommended Action: Visiting the California Academy of Sciences in Golden Gate Park for an educational and entertaining indoor experience.Được hỗ trợ bởi

Tổng hợp: Xây dựng ứng dụng suy luận đơn giản với Grok 3

Chúng ta có thể kết hợp gọi hàm và đầu ra có cấu trúc để tạo một ứng dụng đơn giản dùng khả năng suy luận của Grok. Ta có thể sao chép và dán mã cho:

• Việc import tất cả các gói và hàm đã nêu;
• Khởi tạo client;
• Định nghĩa schema hàm, hàm giả và tools_map; và
• Định nghĩa schema đầu ra.

Chúng ta bắt đầu với một lệnh gọi API dùng hàm create() để kích hoạt lệnh gọi công cụ. Để cho phép người dùng nhập câu hỏi trong terminal, ta chỉ cần thay câu hỏi về hoạt động ở San Francisco bằng input(">> ").

Sau khi thêm function_result vào danh sách messages sẽ có một điểm khác biệt: thay vì tạo thêm một lệnh gọi API dùng create(), we parse() và truyền DecisionPlan làm response_format`.

Đây là toàn bộ mã cho ứng dụng nhỏ của chúng ta:

import os
import json
from dotenv import load_dotenv
from openai import OpenAI
from pydantic import BaseModel, Field
from typing import List
 
# Load environment variables
load_dotenv()
 
# Initialize the client
client = OpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
)
 
# 1. Define the function schema (tool definition)
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather_forecast",
            "description": "Get a simulated weather forecast for a given location and date.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city where the activity will take place."
                	},
                    "date": {
                        "type": "string",
                        "description": "The date for which the weather is needed, in YYYY-MM-DD format."
                    }
            	    },
                "required": ["location", "date"]
        	}
        }
    }
]
 
# 2. Dummy weather function (hardcoded)
def get_weather_forecast(location: str, date: str) -> dict:
    return {
        "location": location,
        "date": "this weekend",
        "forecast": "rainy"
    }
 
# 3. Tool mapping
tools_map = {
    "get_weather_forecast": get_weather_forecast
}
 
# 4. Define structured output schema using Pydantic
class DecisionStep(BaseModel):
	step: int = Field(description="Step number in the decision process")
	reasoning: str = Field(description="Reasoning behind this step")
	action: str = Field(description="Suggested action at this step")
 
class DecisionPlan(BaseModel):
	situation: str = Field(description="The initial situation to consider")
	steps: List[DecisionStep] = Field(description="List of reasoning steps leading to the final action")
 
# 5. Defining messages: system prompt and input
messages = [
    {"role": "system", "content": (
        "You are an expert travel planner. When asked about weekend plans, "
        "first get the weather forecast via the tool provided. Then, based on the result, "
        "break down your reasoning into exactly 3 steps and return structured JSON only."
    )},
    {"role": "user", "content": input("> ")} # enter the question in the terminal
]
 
# 6. First API call to trigger the tool call
response = client.chat.completions.create(
    model="grok-3",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)
 
tool_calls = getattr(response.choices[0].message, "tool_calls", [])
 
if tool_calls:
    for tool_call in tool_calls:
        function_name = tool_call.function.name
        function_args = json.loads(tool_call.function.arguments)
        if function_name in tools_map:
            function_result = tools_map[function_name](**function_args)
 
        	# Add the assistant's tool call message and the tool result to the message history
            messages.append(response.choices[0].message)
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(function_result)
        	})
 
        	# 7. Second API call with parse() to get structured output
            final_response = client.beta.chat.completions.parse(
                model="grok-3",
                messages=messages,
                response_format=DecisionPlan
        	)
 
        	plan = final_response.choices[0].message.parsed
 
        	# 8. Use the output
            final_action = plan.steps[-1].action
 
            print(f"\nSummary:")
            print(f"Situation: {plan.situation}")
            print(f"Recommended Action: {final_action}")
 
else:
    print("No tool call was requested.")Được hỗ trợ bởi

Ví dụ thực thi

Để thử ứng dụng, ta điều hướng đến thư mục dự án, tải môi trường và chạy script:

cd <your/working/directory>
conda activate grok3
python app.pyĐược hỗ trợ bởi

Nếu ta xin lời khuyên cho Helsinki, ứng dụng Grok của chúng ta trả lời:

Đây là một gợi ý khá ổn, tôi có thể xác nhận từ kinh nghiệm!

Kết luận

Chúng ta đã đi khá nhiều—giờ tổng kết lại. Chúng ta đã khám phá cách làm việc với Grok 3 API để chạy truy vấn đơn giản, xử lý dấu vết suy luận, và tận dụng tính năng nâng cao như gọi hàm và đầu ra có cấu trúc.

Chúng ta đã kết hợp các khả năng này vào một dự án nhỏ, cho thấy cách Grok có thể dùng công cụ bên ngoài và trả về câu trả lời có cấu trúc, có thể hành động. Kết hợp với các API—trong trường hợp của chúng ta là một API thời tiết—có thể xây dựng những ứng dụng mạnh mẽ tận dụng tối đa điểm mạnh của Grok 3.

Nếu bạn đọc đến đây, có lẽ bạn quan tâm tìm hiểu thêm về LLM. Hãy tham khảo thêm các tài nguyên sau:

• GPT-Image-1 API: Hướng dẫn từng bước kèm ví dụ
• Cách thiết lập và chạy Qwen3 cục bộ với Ollama
• Fine-tuning Qwen3: Hướng dẫn từng bước