Hướng dẫn Claude Fable 5 API: Xây Trợ lý Nhiệm vụ cho Nhà phát triển bằng Python

Cập nhật (1/7/2026): Quyền truy cập Claude Fable 5 đã được khôi phục, hiện khả dụng toàn cầu trên Claude Platform, Claude.ai, Claude Code và Claude Cowork sau khi lệnh kiểm soát xuất khẩu được dỡ bỏ. Mythos 5 vẫn giới hạn cho các đối tác Project Glasswing đã được thẩm định.

Cập nhật (2/9/2026): Anthropic đã phát hành mô hình kế nhiệm của Fable 5. Tôi khuyên bạn nên đọc hướng dẫn Claude Fable 5.1 của chúng tôi để biết đầy đủ chi tiết.

Khi tôi thử nghiệm một mô hình mới qua API, tôi ít quan tâm đến ghi chú ra mắt và chú trọng hơn đến các phần tôi phải đấu nối vào mã: lệnh gọi API trông như thế nào, có gì thay đổi so với mô hình trước, chi phí bao nhiêu, và chuyện gì xảy ra khi lớp an toàn từ chối?

Bài tổng quan về Claude Fable 5 của chúng tôi đã đề cập đến lần ra mắt, kết quả benchmark và thiết lập an toàn khiến Fable 5 khác biệt. Phần mã dưới đây sẽ tiếp nối từ đó. Cụ thể, chúng ta sẽ dùng một Trợ lý Nhiệm vụ cho Nhà phát triển nhận yêu cầu tính năng phần mềm và trả về kế hoạch triển khai có cấu trúc, rồi bổ sung streaming, tool use, theo dõi chi phí và một endpoint FastAPI.

Chúng ta sẽ đi qua:

• Thực hiện một lệnh gọi API Fable 5 và đọc phản hồi
• Dẫn dắt mô hình bằng system prompt
• Trả về JSON bằng structured outputs
• Stream phản hồi dài ra terminal hoặc web client
• Kết nối một tool đơn giản và chạy vòng lặp tool
• Ước tính và theo dõi chi phí token trước và sau mỗi yêu cầu
• Xử lý từ chối mà không làm ứng dụng sập
• Xử lý đầu vào hình ảnh cho đánh giá UI hoặc phân tích trực quan
• Phục vụ toàn bộ quy trình qua một endpoint FastAPI

Claude Fable 5 là gì?

Claude Fable 5 là một mô hình của Anthropic phát hành ngày 9/6/2026, với chuỗi mô hình API claude-fable-5. Anthropic mô tả đây là cùng mô hình nền tảng với Claude Mythos 5, nhưng áp dụng bộ phân loại an toàn để phát hành rộng rãi. Mythos 5 vẫn giới hạn trong Project Glasswing, một chương trình hạn chế cho các tổ chức an ninh đáng tin cậy.

Với nhà phát triển, các chi tiết API liên quan gồm:

• Ngữ cảnh 1M token và tối đa 128k token đầu ra mỗi yêu cầu

• Giá $10 mỗi triệu token đầu vào và $50 mỗi triệu token đầu ra, gấp đôi Opus 4.8

• Adaptive thinking luôn bật. Bạn không thể tắt. Tham số effort điều chỉnh độ sâu; lập luận nội bộ của mô hình vẫn được tạo và tính phí dù bạn có hiển thị hay không

• Đây là “Covered Model”, nghĩa là bắt buộc lưu giữ dữ liệu 30 ngày. Zero Data Retention không khả dụng cho mô hình này.

Tôi sẽ không dùng nó cho mọi lệnh gọi API. Nó hợp lý hơn cho các tác vụ đòi hỏi suy luận về kiến trúc, trường hợp biên và chi tiết triển khai. Với công việc đơn giản hơn, Sonnet 4.6 hoặc Haiku 4.5 có lẽ là đủ.

Chúng ta sẽ xây gì với Fable 5: Trợ lý Nhiệm vụ cho Nhà phát triển

Trợ lý chúng ta xây dựng sẽ nhận một yêu cầu tính năng phần mềm và trả về một kế hoạch có cấu trúc: tóm tắt kỹ thuật, các bước triển khai theo thứ tự, những tệp có khả năng thay đổi, rủi ro và kiểm thử.

Tôi dùng ví dụ này vì nó buộc phải xử lý các chi tiết API thường quan trọng trong tích hợp thực tế: structured output, streaming, lệnh gọi tool, chi phí và xử lý từ chối. Ví dụ nhỏ, nhưng không chỉ là Hello World.

Các phần dưới đây sẽ xây từng mảnh một.

Yêu cầu tính năng chuyển thành kế hoạch có cấu trúc. Ảnh: Tác giả.

Mã chính nằm trong task_assistant.py cho script cục bộ và app.py cho endpoint FastAPI.

Yêu cầu tiên quyết

Để theo dõi, bạn cần:

• Python 3.9 trở lên (hướng dẫn dùng tính năng 3.10+ như type hints dựng sẵn trong các mô hình Pydantic, nhưng SDK hỗ trợ 3.9+)

• Khóa API Anthropic có quyền truy cập claude-fable-5

• Hiểu biết cơ bản về biến môi trường, JSON và HTTP APIs

• Một terminal và trình soạn thảo mã

Thiết lập dự án

Bắt đầu bằng cách tạo thư mục dự án và môi trường ảo.

mkdir task-assistant
cd task-assistant
python -m venv .venv
source .venv/bin/activate   # Windows: .venv\Scripts\activateĐược hỗ trợ bởi

Cài đặt Anthropic SDK, FastAPI và một vài tiện ích.

pip install anthropic fastapi uvicorn python-dotenv pydanticĐược hỗ trợ bởi

Tạo tệp .env ở thư mục gốc dự án với khóa API của bạn. Không bao giờ commit tệp này lên kho mã.

ANTHROPIC_API_KEY=sk-ant-...Được hỗ trợ bởi

Nạp tệp ở đầu script. Anthropic() đọc ANTHROPIC_API_KEY từ môi trường tự động.

from dotenv import load_dotenv
from anthropic import Anthropic

load_dotenv()
client = Anthropic()Được hỗ trợ bởi

Khởi tạo client một lần ở cấp module và tái sử dụng xuyên suốt hướng dẫn.

Thực hiện lệnh gọi Claude Fable 5 API đầu tiên trong Python

Trước khi thêm logic dự án, tôi thường gửi yêu cầu tối thiểu để xác nhận thiết lập đã hoạt động. Messages API nhận chuỗi mô hình, giới hạn max_tokens và mảng messages. max_tokens là bắt buộc; SDK sẽ raise TypeError nếu bạn bỏ qua.

MODEL = "claude-fable-5"

def get_text(response):
    """Return the first text block, skipping thinking or tool blocks."""
    return next((b.text for b in response.content if b.type == "text"), "")

response = client.messages.create(
    model=MODEL,
    max_tokens=512,
    messages=[{"role": "user", "content": "Reply in one sentence to confirm the API connection is working."}]
)

print(get_text(response))
print(f"Model: {response.model}")
print(f"Input tokens: {response.usage.input_tokens}")
print(f"Output tokens: {response.usage.output_tokens}")Được hỗ trợ bởi

Phản hồi API Fable 5 và token. Ảnh: Tác giả.

response.content là danh sách các khối nội dung, không phải chuỗi đơn. Do hành vi adaptive thinking nêu trên, khối đầu thường là khối thinking, và content[0].text có thể raise AttributeError. Trợ thủ get_text lọc theo block.type == "text" thay vì vậy.

Đối tượng usage cung cấp số token vào/ra sau mỗi yêu cầu. response.model cho biết mô hình đã trả lời, điều này quan trọng khi có cấu hình fallback.

Kiểm soát độ sâu suy luận bằng effort

Tham số effort được truyền trong output_config, là nút điều khiển độ sâu suy luận.

response = client.messages.create(
    model=MODEL,
    max_tokens=2048,
    output_config={"effort": "high"},  # low | medium | high | xhigh | max
    messages=[{"role": "user", "content": feature_request}]
)Được hỗ trợ bởi

Mặc định là "high". Tôi sẽ bắt đầu ở đó, sau đó dùng "low" hoặc "medium" khi độ trễ quan trọng hơn và "xhigh" hoặc "max" cho vấn đề dài hơn. Effort thay đổi số token thinking được tạo, không phải việc có tạo hay không.

Thêm System Prompt cho vai trò Trợ lý

Tham số system là trường cấp cao trong yêu cầu, tách biệt với mảng messages . Bất cứ nội dung nào bạn đặt ở đó sẽ áp dụng cho mọi lượt, nên hiệu lực trên mỗi từ cao hơn so với hướng dẫn trong một lượt đơn lẻ.

Với Trợ lý Nhiệm vụ cho Nhà phát triển, tôi giữ system prompt hẹp: trả về kế hoạch kỹ thuật súc tích thay vì phân tích rộng.

SYSTEM_PROMPT = """You are a senior software engineer who reviews feature requests and returns
implementation plans. For every request:
- Write a one sentence technical summary
- List the implementation steps in order
- Name the files or components most likely to change
- Call out at most three risks or edge cases
- Suggest concrete tests
Do not narrate options you won't pursue. Act on what you know; ask only when key details are missing."""Được hỗ trợ bởi

Câu chỉ dẫn cuối cùng rất quan trọng. Fable 5 có thể lập kế hoạch quá mức cho các yêu cầu đơn giản, vì vậy prompt giới hạn đầu ra trước khi phản hồi bị trôi.

Truyền system prompt cùng với mọi lệnh gọi.

response = client.messages.create(
    model=MODEL,
    max_tokens=2048,
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": feature_request}]
)Được hỗ trợ bởi

Prefill lượt trợ lý không được hỗ trợ trên Fable 5. Nếu bạn có mã Claude cũ bắt đầu lượt trợ lý bằng {"role": "assistant", "content": "{"} để ép JSON output, hãy gỡ bỏ. Mẫu này trả về 400 trên Fable 5, là cái bẫy dễ gặp khi port mã cũ.

Xây dựng quy trình lập kế hoạch tính năng

Lập kế hoạch tính năng nghĩa là theo dõi kiến trúc, chế độ lỗi và chiến lược kiểm thử trong một phản hồi. Đây là quy trình khởi đầu tốt vì đủ nhỏ để xem xét, nhưng không phải prompt đồ chơi.

feature = (
    "Add password reset to our Django app. "
    "Users should receive a token via email and land on a form to set a new password."
)

response = client.messages.create(
    model=MODEL,
    max_tokens=2048,
    output_config={"effort": "high"},
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": feature}]
)

print(get_text(response))Được hỗ trợ bởi

Một phản hồi điển hình sẽ bao quát tạo token, gửi email, xử lý form và dọn dẹp hết hạn trong một lượt.

Trả về Structured JSON Outputs với Claude Fable 5

Văn bản thuần là ổn trên terminal. Khi kế hoạch cần trở thành dữ liệu ứng dụng, structured output dễ xử lý hơn. Claude API hỗ trợ structured outputs qua client.messages.parse() và một mô hình Pydantic, và hoạt động với claude-fable-5.

Định nghĩa hình dạng đầu ra kỳ vọng dưới dạng mô hình Pydantic.

from pydantic import BaseModel

class FeaturePlan(BaseModel):
    summary: str
    steps: list[str]
    files: list[str]
    risks: list[str]
    tests: list[str]Được hỗ trợ bởi

Truyền lớp làm output_format. SDK sẽ chuyển nó thành JSON schema, chạy constrained decoding trên máy chủ Anthropic và trả về đối tượng có kiểu tại response.parsed_output.

response = client.messages.parse(
    model=MODEL,
    max_tokens=2048,
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": feature}],
    output_format=FeaturePlan
)

plan = response.parsed_output
if plan is not None:
    print(f"Summary: {plan.summary}")
    print(f"Steps: {plan.steps}")Được hỗ trợ bởi

Kiểm tra parsed_output có None không trước khi sử dụng. Từ chối trong lúc streaming hoặc bị cắt sớm do max_tokens có thể khiến rỗng. Nhánh này cũng tránh vấn đề khối thinking vì bạn đọc parsed_output thay vì thò tay vào content.

Nếu bạn cần structured output trên mô hình không hỗ trợ qua API, hãy yêu cầu JSON trong prompt và xác thực bằng FeaturePlan.model_validate_json(text), thử lại một lần nếu thất bại. Không ghép structured output với prefill lượt trợ lý; Fable 5 trả về 400 cho mẫu đó.

Streaming phản hồi từ Claude Fable 5

Chính hành vi adaptive thinking đó có thể tăng thời gian chờ token đầu tiên với prompt phức tạp. Streaming in các mảnh văn bản ngay khi đến.

Dùng client.messages.stream() context manager. stream.text_stream trả về các mảnh văn bản và tự động bỏ qua khối thinking.

with client.messages.stream(
    model=MODEL,
    max_tokens=2048,
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": feature}]
) as stream:
    for chunk in stream.text_stream:
        print(chunk, end="", flush=True)

final = stream.get_final_message()
print(f"\nInput tokens: {final.usage.input_tokens}")
print(f"Output tokens: {final.usage.output_tokens}")Được hỗ trợ bởi

Gọi get_final_message() sau khi khối with đóng, không phải bên trong. Ở đó mới có stop reason và số liệu usage.

Streaming và structured output có thể cùng tồn tại, nhưng hãy gom toàn bộ phản hồi trước khi parse. JSON một phần không hợp lệ.

Thêm Tool Use (Function Calling)

Tool use cho phép mô hình yêu cầu thông tin thay vì chỉ dựa vào prompt. Tôi giữ tool đầu tiên nhỏ gọn: read_project_file. Mô hình yêu cầu đọc tệp, mã của bạn đọc, và mô hình dùng những gì tìm thấy.

Vòng lặp tool có hình dạng cố định. Claude trả về stop_reason: "tool_use" khi muốn gọi tool, bạn thực thi tool và gửi lại khối tool_result, và vòng lặp tiếp tục cho đến khi stop_reason là "end_turn" hoặc "refusal".

Vòng lặp tool từ yêu cầu đến câu trả lời. Ảnh: Tác giả.

READ_FILE_TOOL = {
    "name": "read_project_file",
    "description": "Read the contents of a file in the project.",
    "input_schema": {
        "type": "object",
        "properties": {
            "path": {"type": "string", "description": "Relative path to the file"}
        },
        "required": ["path"]
    }
}

messages = [{"role": "user", "content": feature}]

while True:
    response = client.messages.create(
        model=MODEL,
        max_tokens=2048,
        system=SYSTEM_PROMPT,
        tools=[READ_FILE_TOOL],
        messages=messages
    )

    if response.stop_reason in ("end_turn", "refusal"):
        break

    if response.stop_reason == "tool_use":
        tool_block = next(b for b in response.content if b.type == "tool_use")

        # Execute the tool locally
        try:
            with open(tool_block.input["path"]) as f:
                result = f.read()[:2000]
        except FileNotFoundError:
            result = f"File not found: {tool_block.input['path']}"

        messages.append({"role": "assistant", "content": response.content})
        messages.append({
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_block.id,
                "content": result
            }]
        })

# Read the final answer
text_block = next((b for b in response.content if b.type == "text"), None)
print(text_block.text if text_block else "No text in final response")Được hỗ trợ bởi

Mô hình không bao giờ thực thi đoạn mã này. Nó phát ra yêu cầu có cấu trúc với tên tool và đầu vào JSON; ứng dụng của bạn chạy phần đọc tệp. Đừng thêm văn bản hội thoại trong cùng lượt user với khối tool_result , nếu không mô hình có thể dừng thay vì tiếp tục kế hoạch.

Ước tính mức dùng token và chi phí API của Claude Fable 5

Trước khi biến thành ứng dụng, hãy kiểm tra hình dạng chi phí. Fable 5 có giá $10 mỗi triệu token đầu vào và $50 mỗi triệu token đầu ra. Đầu ra thường là khoản lớn hơn: một kế hoạch 2.000 token tốn $0,10 cho phần đầu ra.

Dưới đây là bảng giá trong gia đình Anthropic.

Bộ nhớ đệm prompt có thể giảm chi phí lặp lại system prompt. Khi khối system prompt đã được cache, lần đọc lặp lại có giá $1 mỗi triệu token thay vì $10. Khối tối thiểu có thể cache là 512 token trên Claude API.

# Count tokens before sending an expensive request
count = client.messages.count_tokens(
    model=MODEL,
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": feature}]
)
print(f"Estimated input tokens: {count.input_tokens}")

# Calculate actual cost after each request
INPUT_PRICE = 10.0 / 1_000_000
OUTPUT_PRICE = 50.0 / 1_000_000

response = client.messages.create(...)
cost = (
    response.usage.input_tokens * INPUT_PRICE +
    response.usage.output_tokens * OUTPUT_PRICE
)
print(f"Total cost: ${cost:.6f}")Được hỗ trợ bởi

count_tokens không tốn tiền và không tính vào giới hạn tốc độ đầu ra. Hãy dùng nó để chặn các yêu cầu đắt đỏ. Với công việc không cần tương tác, Batch API cắt đôi giá cả cho cả đầu vào và đầu ra.

Fable 5 dùng tokenizer được giới thiệu với Opus 4.7, có thể tạo nhiều hơn khoảng 30% token trên cùng văn bản so với các mô hình Claude cũ. Tính đến điều đó khi di trú từ Claude 4.6.

Xử lý Từ chối và Fallback mô hình

Fable 5 chạy các bộ phân loại an toàn song song với quá trình sinh. Khi một bộ kích hoạt, API trả về HTTP 200 thành công, không phải lỗi, và tín hiệu duy nhất là stop_reason: "refusal". Xử lý lỗi chỉ bắt exceptions sẽ bỏ lỡ hoàn toàn các từ chối, và ứng dụng của bạn sẽ âm thầm trả về rỗng.

Luôn kiểm tra stop reason.

response = client.messages.create(
    model=MODEL,
    max_tokens=2048,
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": user_input}]
)

if response.stop_reason == "refusal":
    category = (
        response.stop_details.category
        if response.stop_details else "policy"
    )
    print(f"Request declined ({category}). Please rephrase and try again.")
else:
    print(get_text(response))Được hỗ trợ bởi

Trong thử nghiệm của tôi, Fable 5 thường từ chối các yêu cầu ranh giới bằng văn bản thuần, trả về end_turn bình thường. Trường hợp bộ phân loại cứng, với stop_reason: "refusal" và content rỗng, hiếm hơn. Kiểm tra trên xử lý đường này để ứng dụng không âm thầm trả về rỗng.

stop_details.category có thể là "cyber", "bio", hoặc "reasoning_extraction". Cái cuối kích hoạt khi prompt cố trích xuất chuỗi suy nghĩ nội bộ của mô hình. Với công cụ cho nhà phát triển kiểm tra trình quét bảo mật mạng hoặc pipeline dữ liệu sinh học, bạn có thể gặp false positive. Diễn đạt lại để làm rõ tính phòng thủ thường giải quyết được.

Với hệ thống triển khai, bạn có thể cấu hình fallback tự động sang Opus 4.8 bằng fallbacks beta chạy trên máy chủ trong Claude API và Claude Platform trên AWS. Điều này không giống Amazon Bedrock: Bedrock, Vertex AI và Foundry cần logic fallback trong ứng dụng của bạn.

response = client.beta.messages.create(
    model=MODEL,
    max_tokens=2048,
    system=SYSTEM_PROMPT,
    messages=[{"role": "user", "content": user_input}],
    fallbacks=[{"model": "claude-opus-4-8"}],
    betas=["server-side-fallback-2026-06-01"]
)Được hỗ trợ bởi

Yêu cầu bị từ chối không tạo ra đầu ra thì không bị tính phí. Từ chối giữa dòng sẽ tính những gì đã tạo trước khi bộ phân loại kích hoạt.

Dùng Claude Fable 5 với đầu vào Hình ảnh (Vision)

Nếu ứng dụng của bạn chỉ xử lý văn bản, bạn có thể bỏ qua phần này. Phần này tách biệt với luồng lập kế hoạch, nhưng dùng cùng cấu trúc Messages API. Fable 5 nhận hình ảnh dạng block mã hóa base64 hoặc URL. Một trường hợp sử dụng là đánh giá ảnh chụp màn hình UI so với yêu cầu tính năng.

import base64

with open("login_form.png", "rb") as f:
    img_data = base64.standard_b64encode(f.read()).decode("utf-8")

response = client.messages.create(
    model=MODEL,
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "image",
                "source": {
                    "type": "base64",
                    "media_type": "image/png",
                    "data": img_data
                }
            },
            {
                "type": "text",
                "text": "Review this UI against the requirement: add a 'Forgot password' link below the login button. Is it present? If not, describe what needs to change."
            }
        ]
    }]
)
print(get_text(response))Được hỗ trợ bởi

Một hình ảnh kích thước đầy đủ tốn khoảng 4.784 token đầu vào bất kể nội dung, nên hãy thay đổi kích thước hoặc nén trước khi gửi nếu bạn không cần độ phân giải đầy đủ. Fable 5 xử lý ảnh rộng tới 2.576 px và thu nhỏ bất cứ gì lớn hơn. Định dạng hỗ trợ gồm JPEG, PNG, GIF và WebP.

Biến quy trình thành một endpoint FastAPI

Tại thời điểm này, script cục bộ đã có đầy đủ quy trình. Bao bọc trợ lý trong một route FastAPI để frontend hoặc dịch vụ có thể gọi. Dùng AsyncAnthropic trong các route async, vì client sync sẽ chặn event loop. Khởi tạo một lần khi khởi động, không phải mỗi yêu cầu.

from contextlib import asynccontextmanager
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from anthropic import AsyncAnthropic

client_instance: AsyncAnthropic | None = None

@asynccontextmanager
async def lifespan(app: FastAPI):
    global client_instance
    client_instance = AsyncAnthropic()
    yield
    await client_instance.close()

app = FastAPI(lifespan=lifespan)

class PlanRequest(BaseModel):
    feature_request: str

@app.post("/plan")
async def create_plan(body: PlanRequest):
    response = await client_instance.messages.create(
        model="claude-fable-5",
        max_tokens=2048,
        system=SYSTEM_PROMPT,
        messages=[{"role": "user", "content": body.feature_request}]
    )

    if response.stop_reason == "refusal":
        raise HTTPException(status_code=400, detail="Request declined by safety classifier.")

    return {
        "plan": get_text(response),
        "input_tokens": response.usage.input_tokens,
        "output_tokens": response.usage.output_tokens
    }Được hỗ trợ bởi

Chạy với uvicorn app:app --reload và kiểm thử endpoint /plan qua tài liệu FastAPI tại http://localhost:8000/docs.