Extended Thinking + Tool Use — Suy luận sâu kết hợp công cụ

Nếu Extended Thinking giúp Claude "suy nghĩ to", thì kết hợp với Tool Use tạo ra một combination cực kỳ mạnh mẽ: Claude không chỉ suy luận mà còn biết khi nào cần gọi tool, gọi tool nào, và truyền tham số gì. Kết quả: agent thông minh hơn, ít lỗi hơn, và dễ debug hơn.

Vấn đề với Tool Use thông thường

Khi dùng Tool Use mà không có Extended Thinking, Claude đôi khi:

• Gọi sai tool cho tình huống (nhầm tool search với tool calculator)
• Truyền tham số thiếu hoặc sai format
• Gọi nhiều tool không cần thiết (over-calling)
• Bỏ qua tool khi nên dùng (under-calling)

Extended Thinking giải quyết điều này bằng cách cho Claude "suy nghĩ trước" về strategy — trước khi commit vào bất kỳ tool call nào.

Setup: Định nghĩa Tools

Đầu tiên định nghĩa các tools. Ví dụ: một agent phân tích tài chính:

import anthropic
import json

client = anthropic.Anthropic()

tools = [
    {
        "name": "get_stock_price",
        "description": "Lấy giá cổ phiếu hiện tại và lịch sử. Dùng khi cần dữ liệu giá thực tế.",
        "input_schema": {
            "type": "object",
            "properties": {
                "symbol": {
                    "type": "string",
                    "description": "Mã cổ phiếu, ví dụ: AAPL, MSFT, VNM"
                },
                "period": {
                    "type": "string",
                    "enum": ["1d", "1w", "1m", "3m", "1y"],
                    "description": "Khoảng thời gian lịch sử"
                }
            },
            "required": ["symbol"]
        }
    },
    {
        "name": "calculate_metrics",
        "description": "Tính toán các chỉ số tài chính: P/E ratio, ROE, CAGR. Dùng khi có số liệu thô cần tính toán.",
        "input_schema": {
            "type": "object",
            "properties": {
                "metric": {
                    "type": "string",
                    "enum": ["pe_ratio", "roe", "cagr", "volatility"]
                },
                "values": {
                    "type": "array",
                    "items": {"type": "number"},
                    "description": "Dãy số liệu đầu vào"
                },
                "period_years": {
                    "type": "number",
                    "description": "Số năm (cho CAGR)"
                }
            },
            "required": ["metric", "values"]
        }
    },
    {
        "name": "search_news",
        "description": "Tìm tin tức gần đây về công ty hoặc thị trường. Dùng khi cần thông tin định tính, sentiment.",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string"},
                "days_back": {"type": "integer", "default": 7}
            },
            "required": ["query"]
        }
    }
]

Kích hoạt Extended Thinking + Tools

def analyze_with_thinking(user_question):
    messages = [{"role": "user", "content": user_question}]

    response = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=20000,
        thinking={
            "type": "enabled",
            "budget_tokens": 12000
        },
        tools=tools,
        messages=messages
    )

    return response

question = """
Tôi đang xem xét đầu tư vào AAPL. Hãy phân tích:
1. Xu hướng giá 3 tháng gần đây
2. Tính P/E ratio dựa trên giá hiện tại (EPS = 6.57)
3. Tin tức quan trọng gần đây
Cho tôi khuyến nghị mua/giữ/bán.
"""

response = analyze_with_thinking(question)

Xử lý Tool Call Loop với Thinking

Phần phức tạp nhất là xử lý agentic loop — Claude có thể gọi nhiều tools liên tiếp:

def run_agent_loop(user_question):
    messages = [{"role": "user", "content": user_question}]
    all_thinking = []

    while True:
        response = client.messages.create(
            model="claude-opus-4-5",
            max_tokens=20000,
            thinking={"type": "enabled", "budget_tokens": 8000},
            tools=tools,
            messages=messages
        )

        # Thu thập thinking blocks để debug
        for block in response.content:
            if block.type == "thinking":
                all_thinking.append(block.thinking)
                print(f"
[Thinking #{len(all_thinking)}]")
                print(block.thinking[:500] + "..." if len(block.thinking) > 500 else block.thinking)

        # Kiểm tra stop reason
        if response.stop_reason == "end_turn":
            # Claude đã xong, không cần gọi thêm tool
            final_text = next(
                (b.text for b in response.content if b.type == "text"),
                ""
            )
            return final_text, all_thinking

        elif response.stop_reason == "tool_use":
            # Claude muốn gọi tools — xử lý và tiếp tục
            tool_results = []

            for block in response.content:
                if block.type == "tool_use":
                    print(f"
[Tool Call: {block.name}]")
                    print(f"Input: {json.dumps(block.input, ensure_ascii=False)}")

                    # Gọi tool thực tế
                    result = execute_tool(block.name, block.input)
                    print(f"Result: {result}")

                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": str(result)
                    })

            # Thêm response + results vào message history
            messages.append({"role": "assistant", "content": response.content})
            messages.append({"role": "user", "content": tool_results})

        else:
            break

    return None, all_thinking

Implement Tool Execution

def execute_tool(tool_name, tool_input):
    """Mock implementations — thay bằng real APIs trong production"""

    if tool_name == "get_stock_price":
        symbol = tool_input["symbol"]
        period = tool_input.get("period", "1m")
        # Trong production: gọi Yahoo Finance, Alpha Vantage, etc.
        mock_data = {
            "symbol": symbol,
            "current_price": 189.30,
            "period": period,
            "prices": [175.2, 178.4, 182.1, 185.6, 189.3],
            "change_pct": 8.04
        }
        return json.dumps(mock_data)

    elif tool_name == "calculate_metrics":
        metric = tool_input["metric"]
        values = tool_input["values"]

        if metric == "pe_ratio":
            price, eps = values[0], values[1]
            return {"pe_ratio": round(price / eps, 2)}

        elif metric == "cagr":
            start, end = values[0], values[-1]
            years = tool_input.get("period_years", 1)
            cagr = ((end / start) ** (1 / years) - 1) * 100
            return {"cagr": round(cagr, 2)}

    elif tool_name == "search_news":
        query = tool_input["query"]
        # Trong production: gọi News API, Google News, etc.
        return {
            "articles": [
                {"title": f"Apple reports strong Q4 results", "sentiment": "positive"},
                {"title": f"iPhone 16 demand exceeds expectations", "sentiment": "positive"},
                {"title": f"Competition from Samsung intensifies", "sentiment": "neutral"}
            ]
        }

    return {"error": f"Unknown tool: {tool_name}"}

Quan sát Thinking trong Tool Selection

Phần thú vị nhất: nhìn vào thinking để thấy Claude "lý luận" về việc dùng tool nào:

# Chạy agent và in thinking
final_answer, thinking_log = run_agent_loop(question)

print("
" + "="*60)
print("THINKING ANALYSIS:")
print("="*60)
for i, thought in enumerate(thinking_log, 1):
    print(f"
--- Thinking Round {i} ---")
    print(thought)

print("
" + "="*60)
print("FINAL ANSWER:")
print("="*60)
print(final_answer)

Typical thinking output trông như sau:

--- Thinking Round 1 ---
Người dùng muốn phân tích cổ phiếu AAPL. Tôi cần:
1. Lấy dữ liệu giá 3 tháng -> dùng get_stock_price(AAPL, 3m)
2. Tính P/E ratio -> cần giá hiện tại từ bước 1, EPS đã cho (6.57)
   -> dùng calculate_metrics(pe_ratio, [price, 6.57])
3. Tìm tin tức -> dùng search_news("Apple AAPL stock")
Tôi sẽ gọi get_stock_price trước để có giá, sau đó tính metrics.

--- Thinking Round 2 ---
Đã có giá AAPL: 189.30, tăng 8.04% trong 3 tháng.
Bây giờ tính P/E: 189.30 / 6.57 = 28.81 — hơi cao so với industry average ~25.
Cũng cần tin tức để có context đầy đủ cho recommendation.

--- Thinking Round 3 ---
Có đủ data:
- Giá tăng 8%: tích cực
- P/E 28.81: slightly premium nhưng justified với growth
- News: 2/3 positive, 1 neutral
Khuyến nghị: BUY với target price 195, stop loss 180.

Best Practices

1. Tool Description phải cực kỳ rõ ràng

Thinking giúp Claude chọn đúng tool hơn, nhưng chỉ khi description đủ tốt:

# Tệ
{"name": "search", "description": "Search something"}

# Tốt
{
    "name": "search_knowledge_base",
    "description": "Tìm kiếm trong knowledge base nội bộ của công ty. Dùng khi câu hỏi liên quan đến policy, procedure, hoặc thông tin nội bộ. KHÔNG dùng cho thông tin real-time hoặc dữ liệu bên ngoài."
}

2. Budget Tokens phù hợp với độ phức tạp

# Đơn giản: ít tools, query rõ ràng
thinking={"type": "enabled", "budget_tokens": 3000}

# Phức tạp: nhiều tools, cần strategy
thinking={"type": "enabled", "budget_tokens": 12000}

# Research-level: multi-step, uncertain path
thinking={"type": "enabled", "budget_tokens": 25000}

3. Log thinking để debug agent behavior

import logging

def log_agent_step(step_num, thinking, tool_name=None, tool_result=None):
    logging.info(f"Step {step_num} | Tool: {tool_name}")
    logging.debug(f"Thinking: {thinking[:200]}...")
    if tool_result:
        logging.info(f"Tool result: {str(tool_result)[:100]}...")

So sánh: Với và không có Extended Thinking

Tổng kết

Extended Thinking + Tool Use là combination lý tưởng cho complex agentic tasks. Claude không chỉ biết dùng tools mà còn "lý luận" về strategy tổng thể trước khi hành động.

Khi nào nên dùng combination này:

• Agent có 3+ tools với overlap về use case
• Task đòi hỏi multi-step planning
• Correctness quan trọng hơn speed
• Cần khả năng debug và explain decisions

Khám phá tiếp: Agent Workflows — Chaining, Routing, Parallelization để xây dựng hệ thống multi-agent phức tạp hơn.

Bài viết liên quan

• Extended Thinking — Để Claude suy luận từng bước minh bạch
• Calculator Tool — Bài học đầu tiên về Tool Use với Claude
• Tìm kiếm Wikipedia với Claude — Research agent đơn giản
• Extended Thinking & Ultrathink — Khai thác suy luận sâu của Claude
• Autonomous Coding Agent — AI tự viết code từ spec