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

Bắt đầu với API Grok 4

Trước khi gửi yêu cầu đầu tiên, chúng ta cần khóa API và một môi trường Python có thể kết nối tới API Grok.

Tạo khóa API của bạn

Để tạo khóa API dùng xác thực client với API, bạn có thể làm theo các bước sau:

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

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

Giá API Grok 4

Dùng API có thể rẻ hơn so với đăng ký gói cao cấp, nhưng không miễn phí. Khác với gói SuperGrok, bắt đầu từ $30/tháng với mức phí cố định, chi phí API hoàn toàn dựa trên mức độ sử dụng. Tuy nhiên, nếu bạn muốn truy cập Grok 4 Heavy, cơ chế lại khác: bạn sẽ cần một đăng ký SuperGrok Heavy đang hoạt động ($300/tháng), ngay cả khi dùng API.

Để xem chi tiết các khoản chi phí có thể phát sinh, hãy tham khảo trang giá trên xAI.

Nguồn: xAI

Giá API Grok dựa trên mức sử dụng, tính theo mỗi triệu token. Tham chiếu, một triệu token xấp xỉ 750.000 từ tiếng Anh, tính cho cả đầu vào lẫn đầu ra. Dù cửa sổ ngữ cảnh gần như tăng gấp đôi so với phiên bản trước, Grok 4 vẫn có mức giá y hệt mô hình Grok 3 tiêu chuẩn. Bạn sẽ trả $3 cho mỗi triệu token đầu vào và $15 cho mỗi triệu token đầu ra.

Để truy cập API, bạn sẽ cần mua credit. Khi mới bắt đầu, nên dùng credit trả trước thay vì tự động thanh toán—điều này giúp tránh các khoản phí bất ngờ. Bạn có thể mua token và theo dõi 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

Khi đã có khóa API và credit, bước tiếp theo là chuẩn bị môi trường Python. Bạn sẽ cần hai gói để tích hợp API mượt mà:

• python-dotenv để tải khóa API từ tệp .env dưới dạng biến môi trường.
• Client openai để tương tác với API Grok 4.

Để quản lý phụ thuộc dự án gọn gàng, bạn có thể dùng Anaconda. Sau khi cài Anaconda, tạo môi trường mới tên grok4 với Python 3.10 bằng cách chạy:

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

Khi môi trường đã kích hoạt, cài đặt các gói cần thiết:

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

Chuẩn bị cuối cùng

Hãy bắt đầu bằng cách viết script đầu tiên. Khởi động bằng cách import các hàm cần thiết từ những gói đã cài, cùng với os để truy cập khóa API:

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

Tiếp theo, dùng load_dotenv() từ gói dotenv để tải biến môi trường, giúp khóa API khả dụng cho script:

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

Bây giờ, khởi tạo client API bằng cách truyền khóa API (từ tệp .env) và URL máy chủ Grok vào lớp OpenAI (chúng ta dùng SDK OpenAI trong hướng dẫn này, nhưng Grok 4 cũng có SDK Python gốc của xAI, và cũng tương thích với SDK của Antrhopic). Gán vào biến client:

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

Với các bước này, script của bạn đã sẵn sàng gửi yêu cầu tới Grok 4.

Nhận diện hình ảnh với Grok 4

Giờ mọi thứ đã sẵn sàng, hãy thử tính năng nhận diện hình ảnh—một điểm mới của Grok 4. Chúng ta sẽ minh họa bằng cách tải lên bức ảnh lasagna chay bên dưới và yêu cầu Grok nhận diện các nguyên liệu nhìn thấy được.

Để phân tích hình ảnh với API Grok 4, ta cần gửi yêu cầu bao gồm cả ảnh và prompt. Cách khuyến nghị là dùng Python client tương thích OpenAI, chỉ định model là grok-4 và đưa URL ảnh cùng câu hỏi của bạn trong mảng messages. API sẽ trả về câu trả lời chi tiết mô tả nội dung ảnh, có thể truy cập trong đối tượng phản hồi.

Trước khi gửi yêu cầu, cần đảm bảo ảnh đáp ứng yêu cầu API. Chỉ hỗ trợ định dạng JPEG và PNG, kích thước tệp không vượt quá 20 MB. Ảnh phải truy cập được qua liên kết trực tiếp, và máy chủ phải gửi đúng Content-Type (image/jpeg hoặc image/png).

Sau khi import các gói cần thiết, tải biến môi trường và thiết lập client, ta có thể gửi truy vấn như sau:

# Sending the query
response = client.chat.completions.create(
    model="grok-4",
    messages=[
    {
      "role": "user",
      "content": [
        {
          "type": "image_url",
          "image_url": {
            "url": "https://shorturl.at/mVDEh",
            "detail": "high"
          }
        },
        {
          "type": "text",
          "text": "Which ingredients do you notice on the picture?"
        }
      ]
    }
  ],
    max_tokens=2000,
    temperature=0.2,  # lower temperature for more deterministic answers
)

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

Based on the picture, it looks like a delicious slice of vegetarian lasagna! Here's what I can clearly see in terms of ingredients (I'm basing this purely on visual cues, so it's not a full recipe—just what's noticeable):
### Main Visible Ingredients:
- **Pasta sheets/lasagna noodles**: The flat, layered pasta that's the base structure of the dish.
- **Tomato sauce**: A red, chunky sauce (likely marinara or similar) that's spread between layers and on top.
- **Cheese**:
  - Melted, bubbly cheese on top (probably mozzarella or Parmesan, given the golden-brown spots).
  - White, creamy cheese in the filling layers (looks like ricotta or cottage cheese).
- **Spinach (or similar greens)**: Dark green leaves mixed into the layers, giving it a veggie-packed look (this seems like a spinach lasagna variant).
- **Basil leaf**: A fresh green leaf garnishing the top for decoration and flavor.
It doesn't appear to have any meat (like ground beef or sausage), so it's likely a vegetarian version. If this is from a specific recipe or if you have more context, I could refine my observations! What do you think it is? 😊Được hỗ trợ bởi

Trong trường hợp này, Grok thậm chí còn nhận ra đây là phiên bản chay chỉ từ bức ảnh—khá ấn tượng!

Lập luận với Grok 4

Grok 4 được thiết kế cho lập luận nâng cao và có thể giải các bài toán phức tạp theo từng bước. Tuy nhiên, khác với một số mô hình trước đây, Grok 4 không để lộ dấu vết lập luận nội bộ, vì vậy bạn không thể trích xuất “quy trình suy nghĩ” chi tiết hay chuỗi lập luận như một trường riêng trong phản hồi API. Đầu ra bạn nhận được là câu trả lời cuối cùng, không phải các bước trung gian hay nội dung lập luận thô của mô hình.

Ngoài ra, Grok 4 không hỗ trợ tham số reasoning_effort từng được dùng, ví dụ trong Grok 3 mini (để học cách dùng tham số đó, hãy xem hướng dẫn API Grok 3). Điều này có nghĩa bạn không thể điều chỉnh mức độ “suy nghĩ” trước khi mô hình đưa ra kết luận cuối. Do đó, mọi truy vấn lập luận đều được xây dựng giống hệt truy vấn thông thường.

Hãy thử thách Grok với một nhiệm vụ lập luận khác liên quan đến lasagna và nhắc mô hình thể hiện lập luận trong đầu ra.

# Send a basic reasoning query
response = client.chat.completions.create(
    model="grok-4",
    messages=[
        {"role": "user", "content": (
            "You want to cook lasagna for a dinner party, but several guests have dietary restrictions. One is vegetarian, one is lactose-intolerant, and another cannot eat gluten. You have six different lasagna recipes (classic, vegetarian, vegan, gluten-free, cheese-heavy, and meat-based). Which recipe or combination of recipes would best satisfy everyone, and what specific ingredient substitutions would you need to make? Explain your reasoning step by step."
        )}
    ],
    max_tokens=5000,
    temperature=0.2,  # lower randomness
)
# Print the final answer
print(response.choices[0].message.content)Được hỗ trợ bởi

Below, I'll explain my reasoning step by step for selecting the best recipe (or combination of recipes) to satisfy all guests at your dinner party, including the vegetarian, the lactose-intolerant person, the gluten-intolerant person, and everyone else (who presumably have no restrictions). I'll base this on logical inferences about what each recipe likely contains, since the problem doesn't provide exact ingredient lists. Then, I'll recommend specific ingredient substitutions and why this approach works.
(...)
### Step 3: Selecting the Best Recipe or Combination
- **Recommended approach**: Use a **combination of the vegan and gluten-free recipes** to create a single modified lasagna that everyone can eat. Start with the vegan recipe as your base (it already handles no meat and no lactose/dairy), then incorporate elements from the gluten-free recipe (e.g., ingredient swaps to eliminate gluten). This results in a **vegan, gluten-free lasagna**.
  - Why not multiple lasagnas? Preparing separate dishes (e.g., one vegetarian, one gluten-free) could work but might not fully satisfy everyone in a shared meal—e.g., the lactose-intolerant guest couldn't eat a dairy-based vegetarian version. A single inclusive dish promotes unity at the party and simplifies cooking/serving. If you have time and oven space, you could make a small "classic" version on the side for unrestricted guests who prefer meat and cheese, but the modified vegan/gluten-free one would still be the core option.
  - Why this combination over others? Vegan + gluten-free covers all restrictions without needing to add meat or dairy (which would violate rules). Starting with gluten-free and making it vegan would require more substitutions (e.g., removing meat and cheese), while vegan is already "80% there." Other combos (e.g., vegetarian + gluten-free) would still need dairy removals for lactose intolerance, making them less efficient.
This approach ensures:
- The vegetarian can eat it (no meat).
- The lactose-intolerant can eat it (no dairy/lactose).
- The gluten-intolerant can eat it (no gluten).
- Others can eat it (it's still a flavorful lasagna, though it won't have "real" meat or cheese—unrestricted guests might find it less indulgent, but it's a fair compromise).
(...)Được hỗ trợ bởi

Tôi đã rút gọn phản hồi của Grok để làm nổi bật ý chính, nhưng ngay cả với phiên bản ngắn hơn này, có thể thấy mô hình đã làm tốt. Grok đi từng bước để

• Hiểu các hạn chế về chế độ ăn
• Đánh giá các công thức hiện có
• Chọn kết hợp công thức tối ưu
• Đề xuất thay thế nguyên liệu cụ thể
• Đưa ra dàn ý công thức đã chỉnh sửa đầy đủ
• Quay lại giải thích vì sao đáp ứng được mọi người
• Bàn về nhược điểm tiềm ẩn và phương án thay thế

Gọi hàm với Grok 4

Giống phiên bản trước, Grok 4 hỗ trợ gọi hàm. Tính năng này cho phép mô hình tương tác trực tiếp với công cụ và dịch vụ bên ngoài. Điều này có nghĩa Grok không chỉ tạo văn bản—mà còn có thể thực hiện hành động như lấy cập nhật thời tiết, kiểm tra thời gian sự kiện, phân tích bản ghi cơ sở dữ liệu, hoặc thậm chí vận hành thiết bị nhà thông minh.

Khi bạn gửi yêu cầu, Grok có thể xác định nếu cần thêm dữ liệu và sẽ yêu cầu gọi một hàm cụ thể với tham số phù hợp. Python client sẽ chạy hàm này cục bộ, chuyển kết quả lại cho Grok, rồi bạn nhận được câu trả lời hoàn chỉnh, có lập luận.

Chuẩn bị

Để làm việc với gọi hàm, ta cần import gói json, giúp truy cập cấu trúc đối số của bất kỳ hàm nào Grok gọi. Tiếp theo, định nghĩa một hàm callback mà Grok sẽ gọi khi nó yêu cầu dữ liệu cụ thể.

Trong ví dụ này, hàm suggest_lasagna_recipe là một hàm Python đơn giản trả về gợi ý công thức cố định. Cách làm hard-code này giúp minh họa đơn giản và tránh phụ thuộc vào dịch vụ bên ngoài.

import json

# Define the callback function
def suggest_lasagna_recipe(ingredients: list) -> dict:
    # Very simplified logic for demo purposes
    if "zucchini" in ingredients:
        return {"recipe": "Vegetarian Zucchini Lasagna"}
    if "beef" in ingredients:
        return {"recipe": "Classic Beef Lasagna"}
    if "tofu" in ingredients:
        return {"recipe": "Vegan Tofu Lasagna"}
    return {"recipe": "Basic Cheese Lasagna"}Được hỗ trợ bởi

Chúng ta cũng cần định nghĩa công cụ mà Grok có thể gọi. Việc này bao gồm chỉ định tên, mục đích và tham số bắt buộc của công cụ trong một JSON schema. Schema này được gửi kèm yêu cầu, thông báo cho Grok rằng nó có thể gọi công cụ này bất cứ khi nào cần thêm thông tin để hỗ trợ lập luận.

# Define the JSON schema for the tool
tools = [
    {
        "type": "function",
        "function": {
            "name": "suggest_lasagna_recipe",
            "description": "Suggests a lasagna recipe based on available ingredients.",
            "parameters": {
                "type": "object",
                "properties": {
                    "ingredients": {
                        "type": "array",
                        "items": {"type": "string"},
                        "description": "List of available ingredients"
                    }
                },
                "required": ["ingredients"]
            }
        }
    }
]Được hỗ trợ bởi

Cuối cùng, từ điển tools_map nối tên hàm mà Grok dùng với các hàm Python thực tế trong mã của bạn. Bản đồ này cho phép client thực thi chính xác các lời gọi hàm được yêu cầu.

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

Dù tự định nghĩa schema công cụ hoạt động tốt cho dự án đơn giản, khi dự án lớn lên, rất nên dùng thư viện kiểm tra dữ liệu như Pydantic. Pydantic cung cấp xác thực đầu vào tự động, xử lý lỗi tốt hơn, và giúp mã gọn gàng, dễ bảo trì.

Thực thi

Hãy kiểm tra xem Grok có dùng hàm của chúng ta khi được hỏi công thức lasagna hay không. Quy trình gọi hàm diễn ra như sau:

1. Đầu tiên, ta gửi câu hỏi của người dùng—“Tôi có thể làm lasagna nào với những nguyên liệu này?”—cho Grok, kèm theo tools khả dụng. 
2. Sau đó, Grok xem xét yêu cầu và nếu xác định cần gọi hàm, nó sẽ yêu cầu công thức bằng cách kích hoạt hàm cục bộ của chúng ta. Nếu không có lời gọi công cụ, ta chỉ dùng câu trả lời ban đầu của Grok.
3. Khi có yêu cầu gọi công cụ, ta chạy hàm cục bộ tương ứng và thêm kết quả vào lịch sử hội thoại đang diễn ra.
4. Lịch sử đã cập nhật này được gửi lại cho Grok, cho phép mô hình hoàn tất lập luận và cung cấp câu trả lời cuối cùng có ngữ cảnh.

# Step 1: Send the initial user request
messages = [
    {"role": "user", "content": "I have beef, ricotta, and tomato sauce. Which lasagna can I make?"}
]

response = client.chat.completions.create(
    model="grok-4",
    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
        print(f"{function_name} successfully called")
        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)  # Assistant'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-4",
                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

suggest_lasagna_recipe successfully called

Final Answer:
Based on your available ingredients (beef, ricotta, and tomato sauce), you can make a **Classic Beef Lasagna**! (...)Được hỗ trợ bởi

Như ta thấy, Grok đã gọi hàm của chúng ta và đề xuất công thức tương ứng.

Bạn cũng có thể để ý đối số tool_choice trong yêu cầu ban đầu. Theo mặc định, “auto” cho phép Grok quyết định có gọi hàm và gọi hàm nào. Nếu muốn kiểm soát nhiều hơn, bạn có thể ép gọi một hàm cụ thể, chỉ định chính xác hàm cần dùng, hoặc tắt hoàn toàn việc gọi hàm bằng cách thay đổi tham số này.

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

Tương tự gọi hàm, đầu ra có cấu trúc là tính năng được giới thiệu từ Grok 3. Tính năng này cho phép Grok trả lời theo định dạng nghiêm ngặt như JSON thay vì văn bản thuần. Cách tiếp cận này giúp việc phân tích cú pháp, xác thực và sử dụng phản hồi của mô hình trong ứng dụng/quy trình của bạn trở nên dễ dàng hơn nhiều.

Bằng cách thiết lập schema trước, bạn có thể chắc chắn đầu ra của Grok luôn nhất quán, máy có thể đọc được và sẵn sàng cho xử lý tiếp theo. Điều này đặc biệt hữu ích khi bạn cần trích xuất dữ liệu có cấu trúc từ tài liệu hoặc đưa nội dung do AI tạo trực tiếp vào cơ sở dữ liệu, bảng điều khiển hoặc công cụ tự động hóa, mà không phải lo việc phân tích văn bản thiếu tin cậy.

Để định nghĩa schema đầu ra, chúng ta dùng Pydantic, giúp cấu trúc dữ liệu phức tạp đơn giản và dễ đọc hơn (hướng dẫn Pydantic này sẽ giúp bạn tìm hiểu thêm). Với việc này, bạn cần import cả BaseModel và Field từ pydantic. Vì đầu ra của chúng ta chứa danh sách nguyên liệu, ta cũng import List từ mô-đun typing của Python để chỉ rõ kiểu của từng phần tử danh sách.

Dù có thể thiết lập schema bằng JSON thuần, đôi khi Grok trả về đầu ra không khớp hoàn toàn với cấu trúc mong đợi. Ý nghĩa có thể giống nhau, nhưng schema có thể khác, gây vấn đề nếu ứng dụng của bạn cần định dạng cụ thể. Điều này đặc biệt đúng với các phần tử lồng nhau như danh sách. Vì vậy tôi khuyến nghị dùng Pydantic—giúp đảm bảo đầu ra có cấu trúc được xác thực và phân tích đáng tin cậy mỗi lần.

Trong ví dụ của chúng ta, schema—gọi là Recipe—bao gồm tên, số khẩu phần và danh sách nguyên liệu. Mỗi Ingredient được xác định bởi tên, lượng cần cho công thức, tình trạng có sẵn tại nhà, giá theo kilogram, và thông tin liệu nguyên liệu đó phù hợp cho người ăn chay, thuần chay hay không chứa gluten. Rất hữu ích khi đặt giá trị mặc định ngay trong schema, như chúng ta làm với số khẩu phần.

# import additionally needed packages
from pydantic import BaseModel, Field
from typing import List

# Define the schema for the structured output
class Ingredient(BaseModel):
    name: str = Field(description="Name of the ingredient")
    amount: int = Field(description="Amount in g needed for recipe")
    is_at_home: bool = Field(description="Is the item already at home?")
    price: float = Field(description="Price of the ingredient in USD per kg")
    is_vegetarian: bool = Field(description="Is the ingredient vegetarian?")
    is_vegan: bool = Field(description="Is the ingredient vegan?")
    is_gluten_free: bool = Field(description="Is the ingredient gluten-free?")

class Recipe(BaseModel):
    name: str = Field(description="The name of the recipe")
    portions: int = Field(default=4, description="Amount of portions")
    ingredients: List[Ingredient] = Field(description="List of ingredients for the recipe")Được hỗ trợ bởi

Có vài chi tiết cần lưu ý khi gửi yêu cầu. Thay vì dùng client.chat.completions.create(), chúng ta sẽ gọi client.beta.chat.completions.parse(). Điều này báo cho Grok rằng chúng ta mong đợi đầu ra theo định dạng cụ thể, và schema Recipe được truyền vào đối số response_format.

Cũng hữu ích khi đặt toàn bộ hướng dẫn chính cho tác vụ trong system prompt. Điều này giúp Grok 4 tập trung và nhất quán suốt cuộc hội thoại. Vì schema được định nghĩa riêng, prompt của người dùng có thể tập trung vào bản thân tác vụ, không cần liệt kê các trường bắt buộc cho JSON đầu ra.

Ví dụ, bạn có thể thiết lập Grok đóng vai một đầu bếp Ý, đảm bảo mọi công thức đưa ra đều chuẩn vị Ý, nên sẽ không có chuyện dứa “lạc” vào pizza của bạn!

# Send a prompt and request structured output
completion = client.beta.chat.completions.parse(
    model="grok-4",
    messages=[
        {"role": "system", "content": (
        "You are a master chef specialized in italian cuisine."
        "When asked about recipes, return the output in structured JSON format following the provided schema, without any extra text."
        )},
        {"role": "user", "content": (
        "I have beef, ricotta, and tomato sauce, and want to cook for 4 persons. Which lasagna can I make?"
        )}
    ],
    response_format=Recipe,
)Được hỗ trợ bởi

Khi đã phân tích đầu ra có cấu trúc của Grok 4, lợi ích so với văn bản thuần trở nên rõ ràng. Ta có thể dễ dàng sắp xếp và tùy biến thông tin theo nhu cầu, hoặc đẩy các điểm dữ liệu cụ thể vào quy trình tự động. Trong ví dụ của chúng ta, điều này có nghĩa có thể nhanh chóng nhân giá nguyên liệu theo kilogram với lượng yêu cầu, cộng chi phí dựa trên những gì đã có sẵn trong bếp, và tính giá cuối cùng cho mỗi khẩu phần chỉ với vài bước.

# Access the parsed result
recipe = completion.choices[0].message.parsed


price = 0 # initialize price variable
print(f"Recipe: {recipe.name}")
print("Ingredients:")
for i in recipe.ingredients:
    print("- " + i.name + " " + str(i.amount) + " g")
    if not i.is_at_home:
        price += (i.price * i.amount / 1000)
print(f"Price per portion: USD {round((price/recipe.portions), 2)}")Được hỗ trợ bởi

Recipe: Classic Beef Lasagna
Ingredients:
- Ground beef 500 g
- Ricotta cheese 400 g
- Tomato sauce 800 g
- Lasagna noodles 300 g
- Mozzarella cheese 300 g
- Parmesan cheese 100 g
- Onion 200 g
- Garlic 20 g
- Olive oil 30 g
- Egg 50 g
Price per portion: USD 1.7625Được hỗ trợ bởi

Kết luận

Grok 4 mang đến các tính năng mới như cửa sổ ngữ cảnh lớn hơn và năng lực lập luận tốt hơn. Khả năng nhận diện hình ảnh và gọi hàm mở ra nhiều khả năng thú vị để kết hợp AI với dữ liệu và hành động thế giới thực, trong khi đầu ra có cấu trúc đảm bảo phản hồi đáng tin cậy và máy có thể đọc. Thiết lập API đơn giản, cho phép tích hợp nhanh vào dự án Python của bạn chỉ với vài phụ thuộc.

Và nếu loạt ví dụ về lasagna khiến bạn thấy đói bụng, bạn không cô đơn đâu—có lẽ tôi cũng phải đi lấy một miếng thôi!