Claude & Claude Code 面经题库 v2

📖 "Claude Haiku 4.5 - Fastest model with near-frontier intelligence." — Intro to Claude

📖 "If you're unsure which model to use, start with Claude Opus 4.8 for complex agentic coding and enterprise work. For workloads that need the highest available capability, use Claude Fable 5." — 原文

📖 "Claude Fable 5 (claude-fable-5) is Anthropic's most capable widely released model." — 原文

📖 "model": "claude-opus-4-8" — Get started with Claude

📖 "Every Claude model ID is a pinned snapshot. Models with a date in the ID (for example, 20250929) are fixed to that specific release. Starting with the Claude 4.6 generation, model IDs use a dateless format that is also a pinned snapshot, not an evergreen pointer." — 原文

curl https://api.anthropic.com/v1/messages \
  -H "anthropic-version: 2023-06-01" \
  -d '{"model": "claude-opus-4-8", "max_tokens": 1000, "messages": [...]}'

📖 "Compare Claude models by capability and cost to pick the best fit for your use case." — Intro to Claude

📖 "On Claude Opus 4.8, the effort parameter defaults to high on all surfaces, including the Claude API, Claude Code, and claude.ai. On Claude Sonnet 5, it defaults to high on the Claude API and Claude Code." — 原文

📖 "Up to 1M tokens for processing large documents, extensive code bases, and long conversations." — Features overview

📖 "Server-side context summarization for long-running conversations. When context approaches the window limit, the API automatically summarizes earlier parts of the conversation." — Features overview

📖 "Automatically manage conversation context with configurable strategies. Supports clearing tool results when approaching token limits and managing thinking blocks in extended thinking conversations." — Features overview

📖 "Let Claude dynamically decide when and how much to think. The only thinking mode on Claude Opus 4.8 and Claude Opus 4.7. Use the effort parameter to control thinking depth." — Features overview

📖 "Enhanced reasoning capabilities for complex tasks, providing transparency into Claude's step-by-step thought process before delivering its final answer." — Features overview

📖 "Control how many tokens Claude uses when responding with the effort parameter, trading off between response thoroughness and token efficiency." — Features overview

📖 client.messages.create( model="claude-opus-4-8", max_tokens=1000, messages=[...] ) — Get started with Claude

📖 "Token counting enables you to determine the number of tokens in a message before sending it to Claude, helping you make informed decisions about your prompts and usage." — Features overview

import anthropic
client = anthropic.Anthropic()
message = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1000,
    messages=[{"role": "user", "content": "..."}],
)
for block in message.content:
    if block.type == "text":
        print(block.text)
# 大输出改用流式,避免 HTTP 超时:
with client.messages.stream(model="claude-opus-4-8", max_tokens=64000, messages=[...]) as stream:
    final = stream.get_final_message()

📖 "Batch API calls cost 50% less than standard API calls." — Features overview

📖 "Provide Claude with more background knowledge and example outputs to reduce costs and latency." — Features overview

📖 "Introductory pricing of $2 / $10 per MTok applies to Claude Sonnet 5 through August 31, 2026." — 原文

📖 "Pair a faster executor model with a higher-intelligence advisor model that provides strategic guidance mid-generation for long-horizon agentic workloads." — Features overview

📖 "Retry a refused request inside a single API call. Name up to three fallback models, and when the requested model declines, the API runs the next model in the chain on the same request. The fallbacks parameter is not available in the Message Batches API." — Features overview

📖 "Claude Mythos 5 (claude-mythos-5) shares Claude Fable 5's specs and pricing and joins the invitation-only Claude Mythos Preview (claude-mythos-preview) within Project Glasswing." — 原文

📖 "Prompt caching allows you to cache prompt prefixes... significantly reduces processing time and costs for repetitive tasks or prompts with consistent elements." — Prompt caching

📖 "The system checks if a prompt prefix, up to a specified cache breakpoint, is already cached from a recent query. If found, it uses the cached version... Otherwise, it processes the full prompt and caches the prefix once the response begins." — Prompt caching

📖 "By default, the cache has a 5-minute lifetime. The cache is refreshed for no additional cost each time the cached content is used." — Prompt caching

📖 "Cache prefixes are created in the following order: tools, system, then messages. This order forms a hierarchy where each level builds upon the previous ones." — Prompt caching

📖 "Cache hits require 100% identical prompt segments, including all text and images up to and including the block marked with cache control." — Prompt caching

📖 "The lookback window is 20 blocks. The system checks at most 20 positions per breakpoint, counting the breakpoint itself as the first." — Prompt caching

📖 "You can define up to 4 cache breakpoints if you want to: Cache different sections that change at different frequencies... or ensure a cache hit when a growing conversation pushes your breakpoint 20 or more blocks past the last cache write." — Prompt caching

📖 "Start with automatic caching for multi-turn conversations. It handles breakpoint management automatically." — Prompt caching

📖 "Place the breakpoint on the last block that stays identical across requests. For a prompt with a static prefix and a varying suffix... that is the end of the prefix, not the varying block." — Prompt caching

{
  "system": [
    {"type": "text", "text": "固定手册...", "cache_control": {"type": "ephemeral"}}
  ]
}

📖 "5-minute cache write tokens are 1.25 times the base input tokens price; 1-hour cache write tokens are 2 times the base input tokens price; Cache read tokens are 0.1 times the base input tokens price." — Prompt caching

📖 "By default, the cache has a 5-minute lifetime. The cache is refreshed for no additional cost each time the cached content is used." — Prompt caching

📖 "If you find that 5 minutes is too short, Anthropic also offers a 1-hour cache duration at additional cost." — Prompt caching

📖 "Shorter prompts cannot be cached, even if marked with cache_control. Any requests to cache fewer than this number of tokens will be processed without caching, and no error is returned." — Prompt caching

📖 "The minimum cacheable prompt length is: 512 tokens for Claude Fable 5 and Claude Mythos 5... 1,024 tokens for Claude Opus 4.8, Claude Sonnet 5... 4,096 tokens for Claude Opus 4.6 and Claude Opus 4.5..." — Prompt caching

📖 "total_input_tokens = cache_read_input_tokens + cache_creation_input_tokens + input_tokens" — Prompt caching

📖 "cache_creation_input_tokens: Number of tokens written to the cache when creating a new entry. cache_read_input_tokens: Number of tokens retrieved from the cache for this request. input_tokens: Number of input tokens which were not read from or used to create a cache." — Prompt caching

📖 "Monitor cache performance using these API response fields, within usage in the response (or message_start event if streaming)." — Prompt caching

📖 "Place cache_control: {\"type\": \"ephemeral\"} on the last tool in your tools array. This caches the entire tool-definitions prefix, from the first tool through the marked breakpoint." — Tool use with prompt caching

📖 "Modifying tool definitions → Invalidates entire cache (tools, system, messages); Changing tool_choice → Messages cache; Toggling images present/absent → Messages cache." — Tool use with prompt caching

📖 "This automatic breakpoint always uses the default 5-minute TTL, independent of any TTL you set on your own cache_control markers... so you may see 5-minute cache writes even when every cache_control you set uses a 1-hour TTL." — Tool use with prompt caching

📖 "Pass the id of your previous response, and the API compares the two requests and tells you where they diverged (the model, the system prompt, the tools, or the message history) so you can fix the root cause instead of guessing." — Cache diagnostics

📖 "Fingerprints contain only hashes and token-count estimates (never raw prompt content), are retained for a limited time, are scoped to your organization and workspace, and are not used for any other purpose." — Cache diagnostics

📖 "The response reports the earliest divergence only, so fix it first; later ones may be hidden behind it." — Cache diagnostics

📖 "Place the breakpoint on the last block that stays identical across requests... that is the end of the prefix, not the varying block." — Prompt caching

📖 "For concurrent requests, note that a cache entry only becomes available after the first response begins. If you need cache hits for parallel requests, wait for the first response before sending subsequent requests." — Prompt caching

📖 "Set max_tokens: 0 in your request. The API reads your prompt into the model and writes the cache at any cache_control breakpoint, then returns immediately without generating any output... A pre-warm request incurs a cache write charge if the prefix is not already cached." — Prompt caching

📖 The "context window" refers to all the text a language model can reference when generating a response, including the response itself. This is different from the large corpus of data the language model was trained on, and instead represents a "working memory" for the model. — Context windows

📖 A larger context window allows the model to handle more complex and lengthy prompts, but more context isn't automatically better. As token count grows, accuracy and recall degrade, a phenomenon known as context rot. This makes curating what's in context just as important as how much space is available. — Context windows

📖 Chat interfaces such as claude.ai can also manage the context window on a rolling "first in, first out" basis. — Context windows

📖 Everything in the request counts toward the context window: the system prompt, every message in messages (including tool results, images, and documents), and your tool definitions. The output Claude generates for the turn, including its extended thinking, counts too. Every response reports what the request consumed in its usage field. — Context windows

📖 As the conversation advances through turns, each user message and assistant response accumulates within the context window, and previous turns are preserved completely. — Context windows

📖 If you use prompt caching, the input count is split across input_tokens, cache_read_input_tokens, and cache_creation_input_tokens, and all three count toward the window. — Context windows

📖 Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 5, and Claude Sonnet 4.6 have a 1M-token context window on the Claude API, Amazon Bedrock, Google Cloud, and Microsoft Foundry. ... Other Claude models, including Claude Sonnet 4.5, have a 200k-token context window. — Context windows

📖 For every model with a 1M-token context window, 1M is the default: you don't need a beta header, and long-context requests are billed at standard pricing. — Context windows

📖 A single request can include up to 600 images or PDF pages (100 for models with a 200k-token context window). If you send many images or large documents, you might reach request size limits before the token limit. — Context windows

📖 If the input alone already exceeds the model's context window, the API returns a 400 invalid_request_error ("prompt is too long") on every model. — Context windows

📖 On Claude 4.5 models and newer, if input tokens plus max_tokens exceeds the context window size, the API accepts the request. If generation then reaches the context window limit, it stops with stop_reason: "model_context_window_exceeded". On earlier models, the API returns a validation error instead. To opt in to the model_context_window_exceeded behavior on those models, use the model-context-window-exceeded-2025-08-26 beta header. — Context windows

📖 Token counting lets you determine the number of tokens in a message before you send it to Claude. ... Proactively manage rate limits and costs; Make smart model routing decisions; Optimize prompts to a specific length. — Token counting

📖 The token count should be considered an estimate. In some cases, the actual number of input tokens used when creating a message may differ by a small amount. Token counts may include tokens added automatically by Anthropic for system optimizations. You are not billed for system-added tokens. Billing reflects only your content. — Token counting

📖 Token counting is free to use but subject to requests per minute rate limits based on your usage tier. ... Token counting and message creation have separate and independent rate limits. Usage of one does not count against the limits of the other. — Token counting

resp = client.messages.count_tokens(
    model="claude-opus-4-8",
    system="You are a scientist",
    messages=[{"role": "user", "content": "Hello, Claude"}],
)
# -> { "input_tokens": 14 }

📖 With extended thinking, all input and output tokens, including thinking tokens, count toward the context window limit... The thinking budget tokens are a subset of your max_tokens parameter, are billed as output tokens, and count toward rate limits. — Context windows

📖 On Claude Opus 4.5 and later Opus models, Claude Sonnet 4.6 and later Sonnet models, Claude Fable 5, Claude Mythos 5, and Claude Mythos Preview, the API keeps previous thinking blocks by default... On earlier Opus and Sonnet models and all Haiku models, the API automatically strips previous thinking blocks from the conversation history when you pass them back. — Context windows

📖 Thinking blocks from previous assistant turns are ignored and do not count toward your input tokens. Current assistant turn thinking does count toward your input tokens. — Token counting

📖 Claude Opus 4.7 and later Opus models, Claude Fable 5, Claude Mythos 5, Claude Mythos Preview, and Claude Sonnet 5 use a newer tokenizer. The same input text produces approximately 30% more tokens than on earlier models. The exact increase depends on the content and workload shape. Recount prompts against the model you plan to use rather than reusing counts measured against earlier models. — Token counting

📖 The token counting endpoint returns the count under the tokenizer of the model you pass, so to measure the difference for your workload, count the same request twice: once with your current model and once with model: "claude-fable-5" (or "claude-mythos-5"), and compare the two input_tokens values. — Token counting

📖 "Context editing is applied server-side before the prompt reaches Claude. Your client application maintains the full, unmodified conversation history." — Context editing

📖 "When activated, the API automatically clears the oldest tool results in chronological order. The API replaces each cleared result with placeholder text so Claude knows it was removed." — Context editing

📖 "Ensures a minimum number of tokens is cleared each time the strategy activates. If the API can't clear at least the specified amount, the strategy will not be applied." — Context editing

📖 "Compaction extends the effective context length for long-running conversations and tasks by automatically summarizing older context when approaching the context window limit." — Compaction

📖 "You must pass the compaction block back to the API on subsequent requests to continue the conversation with the shortened prompt." — Compaction

📖 "The top-level input_tokens and output_tokens do not include compaction iteration usage... To calculate total tokens consumed and billed for a request, sum across all entries in the usage.iterations array." — Compaction

📖 "The Message Batches API is a powerful, cost-effective way to asynchronously process large volumes of Messages requests." — Batch processing

📖 "All usage is charged at 50% of the standard API prices." — Batch processing

📖 "This approach is well-suited to tasks that do not require immediate responses..." — Batch processing

📖 "Batch results can be returned in any order... always use the custom_id field." — Batch processing

📖 "Anthropic does not offer its own embedding model. One embeddings provider that has a wide variety of options... is Voyage AI." — Embeddings

📖 "The pricing discounts from prompt caching and Message Batches can stack, providing even greater cost savings when both features are used together." — Batch processing

📖 "When extended thinking is turned on, Claude creates thinking content blocks where it outputs its internal reasoning. Claude incorporates insights from this reasoning before crafting a final response." — Extended thinking

📖 "gives Claude enhanced reasoning capabilities for complex tasks, while providing varying levels of transparency into its step-by-step thought process before it delivers its final answer." — Extended thinking

📖 "Summarized thinking provides the full intelligence benefits of extended thinking, while preventing misuse." — Adaptive thinking

📖 "The budget_tokens parameter sets the maximum number of tokens Claude can use for its internal reasoning process. This limit applies to full thinking tokens, not to the summarized output." — Extended thinking

📖 "Because budget_tokens must be less than max_tokens, extended thinking cannot be combined with max_tokens: 0 (cache pre-warming)." — Extended thinking

📖 "Larger budgets can improve response quality by enabling more thorough analysis for complex problems, although Claude may not use the entire budget allocated, especially at ranges above 32k." — Extended thinking

📖 "You're charged for the full thinking tokens generated by the original request, not the summary tokens. The billed output token count will not match the count of tokens you see in the response." — Extended thinking

📖 "Setting display: \"omitted\" is useful when your application doesn't surface thinking content to users ... You're still charged for the full thinking tokens. Omitting reduces latency, not cost." — Adaptive thinking

📖 "The signature field is identical whether display is \"summarized\" or \"omitted\". Switching display values between turns in a conversation is supported." — Adaptive thinking

📖 "Tool use with thinking only supports tool_choice: {\"type\": \"auto\"} (the default) or tool_choice: {\"type\": \"none\"}. Using ... any or ... tool ... will result in an error because these options force tool use, which is incompatible with extended thinking." — Extended thinking

📖 "During tool use, you must pass thinking blocks back to the API for the last assistant message. Include the complete unmodified block back to the API to maintain reasoning continuity." — Extended thinking

📖 "When a mid-turn thinking conflict occurs (such as toggling thinking on or off during a tool use loop), the API automatically disables thinking for that request." — Extended thinking

📖 "Extended thinking with tool use in Claude 4 models supports interleaved thinking, which enables Claude to think between tool calls and make more sophisticated reasoning after receiving tool results." — Extended thinking

📖 "With interleaved thinking, the budget_tokens can exceed the max_tokens parameter, as it represents the total budget across all thinking blocks within one assistant turn." — Extended thinking

📖 "Adaptive thinking also automatically enables interleaved thinking. This means Claude can think between tool calls, making it especially effective for agentic workflows." — Adaptive thinking

📖 "Instead of manually setting a thinking token budget, adaptive thinking lets Claude dynamically determine when and how much to use extended thinking based on the complexity of each request." — Adaptive thinking

📖 "Adaptive thinking can drive better performance than extended thinking with a fixed budget_tokens for many workloads, especially workloads that mix trivial and complex requests, and long-horizon agentic workflows. No beta header is required." — Adaptive thinking

📖 "At the default effort level (high), Claude almost always thinks. At lower effort levels, Claude may skip thinking for simpler problems." — Adaptive thinking

📖 "Use max_tokens as a hard limit on total output (thinking + response text). The effort parameter provides additional soft guidance on how much thinking Claude allocates. Together, these give you effective control over cost." — Adaptive thinking

📖 "At high and max effort levels, Claude may think more extensively and can be more likely to exhaust the max_tokens budget. If you observe stop_reason: \"max_tokens\" ... consider increasing max_tokens ... or lowering the effort level." — Adaptive thinking

📖 "If your workload requires predictable latency or precise control over thinking costs, extended thinking with budget_tokens is still functional on Claude Opus 4.6 and Claude Sonnet 4.6 but is deprecated and no longer recommended." — Adaptive thinking

📖 "Plan your thinking strategy at the start of each turn rather than trying to toggle mid-turn." — Extended thinking

📖 "Extended thinking tasks often take longer than 5 minutes to complete. Consider using the 1-hour cache duration to maintain cache hits across longer thinking sessions and multistep workflows." — Extended thinking

📖 "As Anthropic seeks to improve the extended thinking feature, summarization behavior is subject to change." — Adaptive thinking

📖 "The effort parameter lets you control how eager Claude is about spending tokens when responding to requests." — Effort

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=4096,
    messages=[{"role": "user", "content": "分析微服务与单体架构的取舍"}],
    output_config={"effort": "medium"},   # 一个旋钮同时调质量与成本
)

📖 "Effort is a behavioral signal, not a strict token budget. At lower effort levels, Claude will still think on sufficiently difficult problems, but it will think less than it would at higher effort levels for the same problem." — Effort

📖 "For Claude Opus 4.6 and Sonnet 4.6, effort replaces budget_tokens as the recommended way to control thinking depth." — Effort

📖 "Task budgets let you tell Claude how many tokens it has for a full agentic loop, including thinking, tool calls, tool results, and output. The model sees a running countdown and uses it to prioritize work and finish gracefully as the budget is consumed." — Task budgets

output_config={
    "effort": "high",
    "task_budget": {"type": "tokens", "total": 64000},
}  # 需 betas=["task-budgets-2026-03-13"]

📖 "Task budgets are a soft hint, not a hard cap. Claude may occasionally exceed the budget if it is in the middle of an action that would be more disruptive to interrupt than to finish." — Task budgets

📖 "An orchestration mode is a session-level switch: when it is on, the model puts maximum thoroughness behind every substantive request, scouting the task itself and then fanning work out to parallel subagents by default." — Build an orchestration mode

📖 "Tool use is a contract between your application and the model. You specify what operations are available and what shape their inputs and outputs take; Claude decides when and how to call them. The model never executes anything on its own." — How tool use works

📖 "This contract makes the model behave less like a text generator and more like a function you call... the caller on the other side is a language model choosing which function to invoke based on the conversation." — How tool use works

📖 "The tell that you should be using tools: if you're writing a regex to extract a decision from model output, that decision should have been a tool call." — How tool use works

📖 "In practice this reads as: while stop_reason == \"tool_use\", execute the tools and continue the conversation. The loop exits on any other stop reason (\"end_turn\", \"max_tokens\", \"stop_sequence\", or \"refusal\")..." — How tool use works

📖 "The model can't run your code, so every tool call is a round trip: the model asks, you execute, you report back, the model continues." — How tool use works

📖 "If the model is still iterating when it hits the cap, the response comes back with stop_reason: \"pause_turn\" instead of \"end_turn\"... re-send the conversation (including the paused response) to let the model continue where it left off." — How tool use works

📖 "input_schema: A JSON Schema object defining the expected parameters for the tool." — Define tools

📖 "When you call the Claude API with the tools parameter, the API constructs a special system prompt from the tool definitions, tool configuration, and any user-specified system prompt." — Define tools

📖 "For the full set of optional properties available on any tool definition, including cache_control, strict, defer_loading, and allowed_callers, see the Tool reference." — Define tools

{
  "name": "get_weather",
  "description": "Get the current weather in a given location",
  "input_schema": {
    "type": "object",
    "properties": {
      "location": {"type": "string", "description": "The city and state, e.g. San Francisco, CA"},
      "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
    },
    "required": ["location"]
  }
}

📖 "Provide extremely detailed descriptions. This is by far the most important factor in tool performance." — Define tools

📖 "Consolidate related operations into fewer tools. Rather than creating a separate tool for every action (create_pr, review_pr, merge_pr), group them into a single tool with an action parameter." — Define tools

📖 "Design tool responses to return only high-signal information. Return semantic, stable identifiers (e.g., slugs or UUIDs)... Bloated responses waste context and make it harder for Claude to extract what matters." — Define tools

📖 "any tells Claude that it must use one of the provided tools, but doesn't force a particular tool. tool forces Claude to always use a particular tool." — Define tools

📖 "when you have tool_choice as any or tool, the API prefills the assistant message to force a tool to be used. This means that the models will not emit a natural language response or explanation before tool_use content blocks, even if explicitly asked to do so." — Define tools

📖 "Combine tool_choice: {\"type\": \"any\"} with strict tool use to guarantee both that one of your tools will be called AND that the tool inputs strictly follow your schema." — Define tools

📖 "The response will have a stop_reason of tool_use and one or more tool_use content blocks that include: id... name... input..." — Handle tool calls

📖 "Claude may use various phrasings and approaches when explaining its actions. Your code should treat these responses like any other assistant-generated text, and not rely on specific formatting conventions." — Define tools

📖 "Use the latest Claude Opus (4.8) model for complex tools and ambiguous queries... Use Claude Haiku models for straightforward tools, but note they may infer missing parameters." — Define tools

{"type": "tool_use", "id": "toolu_01A09q90qw90lq917835lq9",
 "name": "get_weather", "input": {"location": "San Francisco, CA", "unit": "celsius"}}

📖 "Tool result blocks must immediately follow their corresponding tool use blocks in the message history... the tool_result blocks must come FIRST in the content array. Any text must come AFTER all tool results." — Handle tool calls

📖 "You never construct a tool_result block for these [server] tools." — How tool use works

{"role": "user", "content": [
  {"type": "tool_result", "tool_use_id": "toolu_01A09q90qw90lq917835lq9", "content": "15 degrees"}
]}

📖 "Ask for at most one tool call per turn. tool_choice: {type: \"auto\", disable_parallel_tool_use: true}" — How tool use works

📖 "The loop also hands control back to you before a server tool runs if Claude calls that server tool and a client tool in the same group of parallel tool calls. The response then comes back with stop_reason: \"tool_use\" and a server_tool_use block that has no result block yet; the API runs it after you return the client tool results." — How tool use works

📖 "Write instructive error messages. Instead of generic errors like \"failed\", include what went wrong and what Claude should try next, e.g., \"Rate limit exceeded. Retry after 60 seconds.\"" — Handle tool calls

📖 "When a turn calls only server tools, the server-side loop executes the operation and feeds the output back to the model before the response reaches you..." — How tool use works

{"type": "tool_result", "tool_use_id": "toolu_01A...",
 "content": "ConnectionError: the weather service API is not available (HTTP 500)", "is_error": true}

📖 "Whichever strategy you use, return one tool_result for each tool_use block, all together in the next user message." — Parallel tool use

📖 "The API does not guarantee the order in which tools should be executed." — Parallel tool use

📖 "Splitting results across multiple user messages ... teaches Claude to call fewer tools in parallel." — Parallel tool use

// 对: 一条 user 消息装全部结果 → 保持并行
[{"role":"assistant","content":[tool_use_1, tool_use_2]},
 {"role":"user","content":[tool_result_1, tool_result_2]}]
// 错: 拆成两条 user 消息 → 削弱并行
[{"role":"user","content":[tool_result_1]},
 {"role":"user","content":[tool_result_2]}]

📖 "To turn it off, set disable_parallel_tool_use: true inside the tool_choice object. It is not a top-level request parameter." — Parallel tool use

📖 "With auto, Claude uses at most one tool. With any or tool, Claude uses exactly one tool." — Parallel tool use

📖 "disable_parallel_tool_use: true is not supported with programmatic calling." — Programmatic tool calling

"tool_choice": {"type": "auto", "disable_parallel_tool_use": true}
// auto → 最多一个工具(也可只回文本)
"tool_choice": {"type": "any",  "disable_parallel_tool_use": true}
// any  → 恰好一个工具
"tool_choice": {"type": "tool", "name": "get_weather", "disable_parallel_tool_use": true}
// tool → 恰好调 get_weather 一次

📖 "Setting strict: true on a tool definition guarantees Claude's tool inputs match your JSON Schema by constraining the model's token sampling to schema-valid outputs." — Strict tool use

📖 "Without strict mode, Claude might return a string like \"2\" where you expect an integer, or omit a required field." — Strict tool use

📖 "Tools with strict: true are not supported with programmatic calling." — Programmatic tool calling

📖 "Because the API does not buffer or validate a tool's input before streaming it, you might receive partial or invalid JSON." — Fine-grained tool streaming

📖 "Set eager_input_streaming: true on the tool ... This per-tool field replaces the fine-grained-tool-streaming-2025-05-14 beta header." — Fine-grained tool streaming

📖 "A max_tokens cutoff can truncate the input mid-stream, leaving unparseable JSON." — Fine-grained tool streaming

{"type":"tool_result","tool_use_id":"toolu_...","is_error":true,
 "content":"{\"INVALID_JSON\": \"<the unparseable input you received>\"}"}

📖 "You provide every tool definition in the tools array and set defer_loading: true on the tools that shouldn't load up front. At least one tool, normally the tool search tool itself, must stay non-deferred." — Tool search tool

📖 "defer_loading controls what enters the context window, not what you send in the request ... You still send every tool's full definition in the tools array on every request, including the deferred ones." — Tool search tool

📖 "A typical multiserver setup ... can consume ~55k tokens in definitions before Claude does any work. Tool search typically reduces this by over 85 percent." — Tool search tool

📖 "With tool_search_tool_regex_20251119, Claude writes Python re.search() patterns, not natural language queries. Matching is case-insensitive. ... Maximum pattern length: 200 characters" — Tool search tool

📖 "With tool_search_tool_bm25_20251119, Claude searches with natural language queries. Maximum query length: 500 characters." — Tool search tool

📖 "Maximum deferred tools: 10,000 tools with defer_loading: true per request ... each search returns up to 5 matching tools by default." — Tool search tool

📖 "Programmatic tool calling allows Claude to write code that calls your tools programmatically within a code execution container, rather than requiring round trips through the model for each tool invocation." — Programmatic tool calling

📖 "Tools that allow a code execution caller are exposed to Claude's code as async Python functions ... Each function takes a single dict of arguments and returns a string: the text of the tool_result you send back." — Programmatic tool calling

📖 "The tool_id is the id of the code execution server_tool_use block that made the call, so you can match each programmatic tool_use to the code execution run that produced it." — Programmatic tool calling

rows = json.loads(await query_database({"sql": "<sql>"}))
top = sorted(rows, key=lambda x: x["revenue"], reverse=True)[:5]
print(f"Top 5 customers: {top}")   # 只有这行 stdout 进 Claude 上下文

📖 "Structured outputs: Tools with strict: true are not supported with programmatic calling ... disable_parallel_tool_use: true is not supported with programmatic calling." — Programmatic tool calling

📖 "If there are pending programmatic tool calls waiting for results, your response message must contain only tool_result blocks. You cannot include any text content, even after the tool results." — Programmatic tool calling

📖 "On a 75-tool project-management agent benchmark, enabling programmatic tool calling reduced billed input tokens by roughly 38% with no change in task accuracy." — Programmatic tool calling

// 非法: 夹带 text
{"role":"user","content":[{"type":"tool_result","tool_use_id":"toolu_01","content":"[...]"},
                          {"type":"text","text":"下一步?"}]}
// 合法: 只有 tool_result(content 为字符串)
{"role":"user","content":[{"type":"tool_result","tool_use_id":"toolu_01","content":"[...]"}]}

📖 "The grammar for strict mode ... builds from the full toolset, so defer_loading and strict mode compose without grammar recompilation." — Tool search tool

📖 "A tool with defer_loading: true can't also carry cache_control: the API returns a 400. Put the cache breakpoint on a non-deferred tool." — Tool search tool

📖 "The following tools cannot be called programmatically: Tools provided by an MCP connector." — Programmatic tool calling

📖 "Each approach targets a different source of context pressure. Pick the one that matches where your tokens are going." — Manage tool context

📖 "Cache writes carry a 25% markup over base input pricing, which pays back on the second request that hits the cache." — Manage tool context

📖 "Both tools are client-executed, so your application controls which files and commands are accessible." — Tool combinations

📖 "Send multiple tool_result blocks in ONE user message, not one per turn." — Troubleshooting tool use

📖 "Send a user message containing only the tool_result blocks for the client tool_use ids and keep the same tools array." — Troubleshooting tool use

📖 "Structured outputs constrain Claude's responses to follow a specific schema, ensuring valid, parseable output for downstream processing." — Structured outputs

📖 "Structured outputs guarantee schema-compliant responses through constrained decoding: Always valid: No more JSON.parse() errors ... Type safe ... Reliable: No retries needed for schema violations" — Structured outputs

📖 "Without structured outputs, Claude can generate malformed JSON responses or invalid tool inputs that break your applications." — Structured outputs

📖 "The parse() method automatically transforms your Pydantic model, validates the response, and returns a parsed_output attribute." — Structured outputs

📖 "The output_format parameter has moved to output_config.format, and beta headers are no longer required. The old beta header (structured-outputs-2025-11-13) and output_format parameter will continue working for a transition period." — Structured outputs

📖 "Use JSON outputs when you need to: Control Claude's response format; Extract data from images or text; Generate structured reports; Format API responses" — Structured outputs

📖 "JSON outputs control Claude's response format (what Claude says); Strict tool use validates tool parameters (how Claude calls your functions). When combined, Claude can call tools with guaranteed-valid parameters AND return structured JSON responses." — Structured outputs

📖 "Setting strict: true on a tool definition guarantees Claude's tool inputs match your JSON Schema by constraining the model's token sampling to schema-valid outputs (a technique called grammar-constrained sampling)." — Strict tool use

📖 "Without strict mode, Claude might return incompatible types (\"2\" instead of 2) or omit required fields, breaking your functions and causing runtime errors." — Strict tool use

📖 "Numerical constraints (such as minimum, maximum, multipleOf); String constraints (minLength, maxLength); Array constraints beyond minItems of 0 or 1 ... If you use an unsupported feature, you'll receive a 400 error with details." — Structured outputs

📖 "required and additionalProperties (must be set to false for objects)" — Structured outputs

📖 "The Python, TypeScript, Ruby, and PHP SDKs automatically transform schemas with unsupported features. The C# and Go SDKs apply the same transformations when the schema is derived from a native type." — Structured outputs

📖 "Structured outputs are generally available on the Claude API for Claude Fable 5, Claude Mythos 5, Claude Opus 4.8, Claude Mythos Preview, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 5, Claude Sonnet 4.6, Claude Sonnet 4.5, Claude Opus 4.5, and Claude Haiku 4.5." — Structured outputs

📖 "Strict tools per request | 20 | Maximum number of tools with strict: true. Non-strict tools don't count toward this limit." — Structured outputs

📖 "This feature qualifies for Zero Data Retention (ZDR) with limited technical retention." — Structured outputs

📖 "First request latency: The first time you use a specific schema, there is additional latency while the grammar compiles ... Compiled grammars are cached for 24 hours from last use ... Changing only name or description fields does not invalidate the cache" — Structured outputs

📖 "required properties appear first, followed by optional properties" — Structured outputs

📖 "Claude may return a value that differs from your schema only in capitalization, typically in the first letter of a word following a space ... Compare enum values case-insensitively, and avoid enum values that differ only in capitalization." — Structured outputs

📖 "The Messages API is stateless, which means that you always send the full conversational history to the API." — Using the Messages API

📖 "Earlier conversational turns don't necessarily need to actually originate from Claude. You can use synthetic assistant messages." — Using the Messages API

// 请求
{"model":"claude-opus-4-8","max_tokens":1024,
 "messages":[{"role":"user","content":"Hello, Claude"}]}
// 响应
{"id":"msg_01XF...","type":"message","role":"assistant",
 "content":[{"type":"text","text":"Hello!"}],
 "model":"claude-opus-4-8","stop_reason":"end_turn",
 "stop_sequence":null,"usage":{"input_tokens":12,"output_tokens":6}}

📖 "When creating a Message, you can set \"stream\": true to incrementally stream the response using server-sent events (SSE)." — Streaming messages

📖 "This is especially useful for requests with large max_tokens values, where the SDKs require streaming to avoid HTTP timeouts." — Streaming messages

📖 "The .stream() call keeps the HTTP connection alive with server-sent events, then .get_final_message() (Python) or .finalMessage() (TypeScript) accumulates all events and returns the complete Message object." — Streaming messages

# ① 逐字消费文本增量
with client.messages.stream(
    model="claude-opus-4-8", max_tokens=256,
    messages=[{"role":"user","content":"Hello"}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

# ② 大 max_tokens,只要最终完整 Message、不逐字处理
with client.messages.stream(
    model="claude-opus-4-8", max_tokens=128000,
    messages=[{"role":"user","content":"Write a detailed analysis..."}],
) as stream:
    message = stream.get_final_message()   # 等价于 .create() 的返回
print(message.content[0].text)

📖 "1. message_start: contains a Message object with empty content. 2. A series of content blocks, each of which has a content_block_start, one or more content_block_delta events, and a content_block_stop event... 3. One or more message_delta events... 4. A final message_stop event." — Streaming messages

📖 "Each server-sent event includes a named event type and associated JSON data. Each event uses an SSE event name (for example, event: message_stop), and includes the matching event type in its data." — Streaming messages

📖 "In accordance with the versioning policy, new event types may be added, and your code should handle unknown event types gracefully." — Streaming messages

// 纯文本响应
message_start
→ content_block_start(index 0, text) → ping
→ content_block_delta(text_delta)×N → content_block_stop(index 0)
→ message_delta(stop_reason: end_turn) → message_stop

// 带工具:两个块,index 0 是 text,index 1 是 tool_use
message_start
→ [index 0: start → text_delta×N → stop]
→ [index 1: start(tool_use) → input_json_delta×N → stop]
→ message_delta(stop_reason: tool_use) → message_stop

📖 "To support maximum granularity, the deltas are *partial JSON strings*, whereas the final tool_use.input is always an *object*." — Streaming messages

📖 "Current models only support emitting one complete key and value property from input at a time. As such, when using tools, there may be delays between streaming events while the model is working." — Streaming messages

📖 "For thinking content, a special signature_delta event is sent just before the content_block_stop event. This signature is used to verify the integrity of the thinking block." — Streaming messages

// tool_use 块的分片(index 1),需累积再解析:
delta:{"type":"input_json_delta","partial_json":"{\"location\":"}
delta:{"type":"input_json_delta","partial_json":" \"San"}
delta:{"type":"input_json_delta","partial_json":" Francisc"}
delta:{"type":"input_json_delta","partial_json":"o, CA\"}"}
// 收到 content_block_stop 后拼接: {"location": "San Francisco, CA"}

// thinking 块:signature_delta 在 content_block_stop 之前到达
delta:{"type":"thinking_delta","thinking":"1071 = 2 × 462 + 147"}
delta:{"type":"signature_delta","signature":"EqQBCgIYAhIM..."}
content_block_stop(index 0)

📖 "Every Messages API response includes a stop_reason field that tells you why Claude stopped generating. Check this field to decide whether to use the response as-is, continue the conversation, retry, or fall back to another model." — Stop reasons and fallback

📖 "The stop_reason field is part of every successful Messages API response. Unlike errors, which indicate failures in processing your request, stop_reason tells you why Claude completed its response generation." — Stop reasons and fallback

📖 "[model_context_window_exceeded] The response filled the model's context window. [What to do:] Treat the response as truncated." — Stop reasons and fallback

// max_tokens 很小 → 被 token 上限截断
{"content":[{"type":"text","text":"C"}],
 "stop_reason":"max_tokens","stop_sequence":null}

// 命中自定义停止序列 END
{"stop_reason":"stop_sequence","stop_sequence":"END"}

📖 "[The continuation] message must contain nothing except the tool_result blocks, and the request must keep the same tools array." — Stop reasons and fallback

📖 "Returned when the server-side sampling loop reaches its iteration limit while executing server tools like web search or web fetch. The default limit is 10 iterations per request." — Stop reasons and fallback

📖 "On a refusal, the stop_details object identifies the policy category that triggered it... stop_details is null for all stop reasons other than refusal." — Stop reasons and fallback

# pause_turn:把 assistant content 原样放回继续
if response.stop_reason == "pause_turn":
    messages = [
        {"role": "user", "content": user_query},
        {"role": "assistant", "content": response.content},
    ]
    continuation = client.messages.create(
        model="claude-opus-4-8", max_tokens=4096,
        messages=messages, tools=tools)

# refusal:重置上下文后再继续(否则会持续被拒)
if response.stop_reason == "refusal":
    messages = reset_context(messages)   # 移除/改写触发轮,或清空历史
    # 也可换到 fallback 模型重试同一请求

📖 "The token counts shown in the usage field of the message_delta event are *cumulative*." — Streaming messages

📖 "Tool use and extended thinking blocks cannot be partially recovered. You can resume streaming from the most recent text block." — Streaming messages

📖 "For Claude 4.6 and later models... instead of placing the partial response in an assistant message, add a user message that instructs the model to continue from where it left off." — Streaming messages

// 流内 error 事件:高负载过载,等价非流式 HTTP 529
event: error
data: {"type":"error","error":{"type":"overloaded_error","message":"Overloaded"}}

# 空响应坑:不要在 tool_result 后加 text;若仍空,用新 user 消息续写
if response.stop_reason == "end_turn" and not response.content:
    messages.append({"role": "user", "content": "Please continue"})
    response = client.messages.create(
        model="claude-opus-4-8", max_tokens=1024, messages=messages)

📖 "Claude supports JPEG, PNG, GIF, and WebP images. Animations are unsupported, and only the first frame is used." — Vision

📖 "provide images to Claude as image content blocks using one of three source types: A base64-encoded image ... A URL reference ... A file_id returned by the Files API" — Vision

{"type":"image","source":{"type":"base64","media_type":"image/jpeg","data":"$BASE64"}}
{"type":"image","source":{"type":"url","url":"https://.../ant.jpg"}}
{"type":"image","source":{"type":"file","file_id":"file_abc123"}}

📖 "Each patch is a 28×28-pixel block of the image, referred to as a visual token. An image, therefore, costs ⌈width / 28⌉ × ⌈height / 28⌉ visual tokens." — Vision

📖 "High-resolution images can use up to roughly three times more visual tokens than the same image on a standard-tier model." — Vision

📖 "Claude works best with absolute pixel coordinates. ... Claude does not work well when you ask for normalized coordinates." — Coordinates and bounding boxes

📖 "The token limit can also trigger a resize when neither side exceeds the edge limit. Overlooking this is the most common cause of misaligned coordinates." — Coordinates and bounding boxes

📖 "Maximum pages per request | 600 (100 when the request's context window is under 1M tokens)" — PDF support

{"type":"document","source":{"type":"url","url":"https://.../doc.pdf"}}
{"type":"document","source":{"type":"base64","media_type":"application/pdf","data":"<b64>"}}
{"type":"document","source":{"type":"file","file_id":"file_011C..."}}

📖 "The system converts each page of the document into an image. The text from each page is extracted and provided alongside each page's image." — PDF support

📖 "The Files API provides a create-once, use-many-times approach for working with files" — Files API

uploaded = client.beta.files.upload(file=("doc.pdf", f, "application/pdf"))
# 之后任意多次复用:
{"type":"document","source":{"type":"file","file_id": uploaded.id}}

📖 "Set citations.enabled=true on each of your documents. Currently, citations must be enabled on all or none of the documents within a request." — Citations

{"type":"page_location","cited_text":"Water is essential for life.",
 "document_index":1,"start_page_number":5,"end_page_number":6}

📖 "Search result content blocks enable natural citations with proper source attribution, bringing web search-quality citations to your custom applications." — Search results

{"type":"search_result","source":"https://docs.co/guide","title":"User Guide",
 "content":[{"type":"text","text":"..."}],"citations":{"enabled":true}}

📖 "The citation blocks generated in responses cannot be cached directly, but the source documents they reference can be cached." — Citations

📖 引用—"Claude's Model Context Protocol (MCP) connector feature enables you to connect to remote MCP servers directly from the Messages API without a separate MCP client." — MCP connector

📖 引用—"Of the feature set of the MCP specification, only tool calls are currently supported." — MCP connector

📖 引用—"MCP provides a universal protocol—developers implement MCP once in their agent and it unlocks an entire ecosystem of integrations." — 原文 (2025-11)

📖 引用—"1. MCP Server Definition (mcp_servers array): Defines server connection details (URL, authentication) 2. MCP Toolset (tools array): Configures which tools to enable and how to configure them" — MCP connector

📖 引用—"name ... A unique identifier for this MCP server. Must be referenced by exactly one MCPToolset in the tools array." — MCP connector

📖 引用—"Tool configuration now lives in the tools array as MCPToolset objects, not in the MCP server definition." — MCP connector

"mcp_servers": [{"type":"url","url":"https://example-server.modelcontextprotocol.io/sse","name":"example-mcp","authorization_token":"YOUR_TOKEN"}],
"tools": [{"type":"mcp_toolset","mcp_server_name":"example-mcp"}]

📖 引用—"These servers are not owned, operated, or endorsed by Anthropic. Users should only connect to remote MCP servers they trust and should review each server's security practices and terms before connecting." — Remote MCP servers

📖 引用—"The server must be publicly exposed through HTTP (supports both Streamable HTTP and SSE transports). Local STDIO servers cannot be connected directly." — MCP connector

📖 引用—"Once connected, remote MCP tools follow the same triggering behavior as any other tool." — Remote MCP servers

📖 引用—"Traffic flows over an outbound-only connection, so you don't need to open inbound firewall ports, expose services to the public internet, or allowlist Anthropic's IP ranges on your origin." — MCP tunnels

📖 引用—"The phrase \"outbound-only\" describes the connection, not the requests carried over it." — Architecture and components

📖 引用—"MCP tunnels are in research preview. ... provided \"as-is\" ... they depend on a third-party network provider (Cloudflare)." — MCP tunnels

📖 引用—"Because the proxy terminates inner TLS using a certificate that only you hold, Cloudflare cannot read request or response payloads." — MCP tunnels

📖 引用—"Anthropic does not connect to a tunnel until a CA certificate is registered, so payloads are always encrypted when they cross Cloudflare's network." — MCP tunnels

📖 引用—"If an attacker obtains your tunnel token and one of your TLS private keys, they could impersonate your proxy and read MCP request payloads. Treat both as high-value secrets." — MCP tunnels

📖 引用—"Once an MCP server is connected, Claude calls its tools when the user's request maps to a tool's described capability, either explicitly ... or implicitly ... Claude does not call an MCP tool for general knowledge questions about a connected service." — MCP connector

📖 引用—"Configuration values merge with this precedence (highest to lowest): 1. Tool-specific settings in configs 2. Set-level default_config 3. System defaults" — MCP connector

📖 引用—"Denylisting write or destructive tools is recommended when building read-only assistants, or when you want a human confirmation step before state changes." — MCP connector

{"type":"mcp_toolset","mcp_server_name":"google-calendar-mcp",
 "configs":{"delete_all_events":{"enabled":false},"share_calendar_publicly":{"enabled":false}}}

📖 引用—"API consumers are expected to handle the OAuth flow and obtain the access token prior to making the API call, and to refresh the token as needed." — MCP connector

📖 引用—"This feature is not eligible for Zero Data Retention (ZDR). Data is retained according to the feature's standard retention policy." — MCP connector

📖 引用—"MCP tool calls through the Batches API are priced the same as those in regular Messages API requests." — MCP connector

📖 "The API executes the tool internally. You see the call and its result in the response, but you don't handle execution. Unlike client tool_use blocks, you don't need to respond with a tool_result." — Server tools

📖 "Its id field uses the srvtoolu_ prefix to distinguish it from client tool calls." — Server tools

📖 "The tool's result block (for example, web_search_tool_result for web search) follows the server_tool_use block in the same assistant turn, paired by tool_use_id." — Server tools

📖 "On a long-running turn, the API might pause that loop and return a pause_turn stop reason." — Server tools

📖 "A paused turn can end with a server_tool_use block whose tool has not run yet, and the API returns a validation error if that tool is missing from the continuation." — Server tools

📖 "A continued turn can pause again. Check stop_reason on each response and continue until you get a different stop reason, capping the number of continuations as you would any retry loop." — Server tools

📖 "Web search is available on the Claude API for $10 per 1,000 searches, plus standard token costs for search-generated content." — Web search tool

📖 "Citations are always enabled for web search... cited_text: Up to 150 characters of the cited content. The web search citation fields cited_text, title, and url do not count toward input or output token usage." — Web search tool

📖 "If encrypted_content is missing or modified, the request fails with a 400 validation error." — Web search tool

📖 "To minimize exfiltration risks, Claude is not allowed to dynamically construct URLs. Claude can only fetch URLs that have been explicitly provided by the user or that come from previous web search or web fetch results." — Web fetch tool

📖 "The web fetch tool is available on the Claude API at no additional cost. You only pay standard token costs for the fetched content that becomes part of your conversation context." — Web fetch tool

📖 "Unlike web search where citations are always enabled, citations are optional for web fetch and disabled by default." — Web fetch tool

📖 "The container has no internet access, so Claude can't download packages at runtime: only the pre-installed libraries are available." — Code execution tool

📖 "Memory: 5GiB RAM · Disk space: 5GiB workspace storage · CPU: 1 CPU ... Expiration: Containers expire 30 days after creation." — Code execution tool

📖 "This feature is not eligible for Zero Data Retention (ZDR). Data is retained according to the feature's standard retention policy." — Code execution tool

📖 "The repetition of steps 3 and 4 without user input is referred to as the 'agent loop' (that is, Claude responding with a tool use request and your application responding to Claude with the results of evaluating that request)." — Computer use tool

📖 "The API downscales oversized images before Claude sees them, and Claude returns coordinates for the image it sees, so relying on the server-side downscale leaves you without the scale factor you need to map those coordinates back to your screen." — Computer use tool

📖 "If your screen is larger than the limit, resize the screenshot before sending it, set display_width_px/display_height_px to the resized dimensions, and scale Claude's returned coordinates back to the original screen space." — Computer use tool

📖 "Anthropic has trained the model to resist these prompt injections and has added an extra layer of defense. If you use the computer use tools, classifiers will automatically run on your prompts to flag potential instances of prompt injections. When these classifiers identify potential prompt injections in screenshots, they will automatically steer the model to ask for user confirmation before proceeding with the next action." — Computer use tool

📖 "In some circumstances, Claude will follow commands found in content even when they conflict with your instructions... instructions on webpages or contained in images might override your instructions or cause Claude to make mistakes." — Computer use tool

📖 "These precautions remain important even with the classifier defense layer in place." — Computer use tool

📖 "If Claude calls one of your client tools at the same time, the server_tool_use block appears without its result, and the response ends with stop_reason: \"tool_use\"." — Server tools

📖 "The follow-up user message must contain nothing except tool_result blocks. A block added after the results, such as text, tells the API that the assistant turn is over." — Server tools

📖 "The _20260209 and later versions with dynamic filtering are not ZDR-eligible by default because dynamic filtering relies on code execution internally." — Server tools

📖 "The memory tool lets Claude store and retrieve information across conversations in a directory of memory files." — Memory tool

📖 "The memory tool operates client-side: Claude requests file operations, and your application executes them. You control where and how the data is stored through your own infrastructure." — Memory tool

📖 "IMPORTANT: ALWAYS VIEW YOUR MEMORY DIRECTORY BEFORE DOING ANYTHING ELSE." — Memory tool

📖 "Your application keeps one bash process alive across tool calls, so state persists between commands." — Bash tool

📖 "This version removes the undo_edit command but maintains all other capabilities." — Text editor tool

📖 "Your application runs whatever command Claude requests. Run the session in an isolated environment, such as a container or a virtual machine, as the least-privileged user that can do the work. Treat every command as untrusted input." — Bash tool

📖 引用—"Claude Code is an agentic coding tool that reads your codebase, edits files, runs commands, and integrates with your development tools." — Overview

📖 引用—"It understands your entire codebase and can work across multiple files and tools to get things done." — Overview

📖 引用—"Claude Code combines a model that reasons about your code with built-in tools for file operations, search, execution, and web access." — Extend Claude Code

📖 引用—"Claude Code runs on several surfaces: the terminal, IDE extensions, a desktop app, and the web." — Overview

📖 引用—"Claude Code runs the same underlying engine everywhere, but each surface is tuned for a different way of working." — Platforms and integrations

📖 引用—"Mobile is a thin client into those same cloud sessions or into a local session via Remote Control, and can send tasks to Desktop with Dispatch." — Platforms and integrations

📖 引用—"The CLI is the most complete surface for terminal-native work: scripting and the Agent SDK are CLI-only." — Platforms and integrations

📖 引用—"The web runs in Anthropic's cloud, so tasks keep going after you disconnect." — Platforms and integrations

📖 引用—"If you're not sure where to start, install the CLI and run it in a project directory. If you'd rather not use a terminal, Desktop gives you the same engine with a graphical interface." — Platforms and integrations

📖 引用—"Claude Code handles the tedious tasks that eat up your day: writing tests for untested code, fixing lint errors across a project, resolving merge conflicts, updating dependencies, and writing release notes." — Overview

📖 引用—"Claude Code works directly with git. It stages changes, writes commit messages, creates branches, and opens pull requests." — Overview

📖 引用—"Describe what you want in plain language. Claude Code plans the approach, writes the code across multiple files, and verifies it works." — Overview

📖 引用—"This guide covers the extension layer: features you add to customize what Claude knows, connect it to external services, and automate workflows." — Extend Claude Code

📖 引用—"Skills are the most flexible extension. A skill is a markdown file containing knowledge, workflows, or instructions." — Extend Claude Code

📖 引用—"Subagents run their own loops in isolated context, returning summaries." — Extend Claude Code

📖 引用—"Each surface connects to the same underlying Claude Code engine, so your CLAUDE.md files, settings, and MCP servers work across all of them." — Overview

📖 引用—"You can mix surfaces on the same project. Configuration, project memory, and MCP servers are shared across the local surfaces." — Platforms and integrations

📖 引用—"Sessions aren't tied to a single surface. Move work between them as your context changes." — Overview

📖 引用—"In CI, you can automate code review and issue triage with GitHub Actions or GitLab CI/CD." — Overview

📖 引用—"Run Claude on a schedule to automate work that repeats: morning PR reviews, overnight CI failure analysis, weekly dependency audits, or syncing docs after PRs merge." — Overview

📖 引用—"Routines run on Anthropic-managed infrastructure, so they keep running even when your computer is off." — Overview

📖 "When you give Claude a task, it works through three phases: gather context, take action, and verify results. These phases blend together." — How Claude Code works

📖 "Claude decides what each step requires based on what it learned from the previous step, chaining dozens of actions together and course-correcting along the way." — How Claude Code works

📖 "You're part of this loop too. You can interrupt at any point to steer Claude in a different direction." — How Claude Code works

📖 "Claude Code serves as the agentic harness around Claude: it provides the tools, context management, and execution environment that turn a language model into a capable coding agent." — How Claude Code works

📖 "The tools, context management, and execution environment that turn a language model into a capable coding agent. Claude Code is the harness; Claude is the model inside it." — Glossary

📖 "The harness supplies file access, shell execution, permission gating, memory loading, and the loop that chains actions together." — Glossary

📖 "Claude's context window holds your conversation history, file contents, command outputs, CLAUDE.md, auto memory, loaded skills, and system instructions." — How Claude Code works

📖 "A markdown file of persistent instructions you write for Claude, loaded at the start of every session as a user message after the system prompt." — Glossary

📖 "MCP tool definitions are deferred by default and loaded on demand via tool search, so only tool names consume context until Claude uses a specific tool." — How Claude Code works

📖 "Tools are what make Claude Code agentic. Without tools, Claude can only respond with text. With tools, Claude can act." — How Claude Code works

📖 "Each tool use returns information that feeds back into the loop, informing Claude's next decision." — How Claude Code works

📖 "Claude also has tools for spawning subagents, asking you questions, and other orchestration tasks." — How Claude Code works

📖 "Claude Code manages context automatically as you approach the limit. It clears older tool outputs first, then summarizes the conversation if needed." — How Claude Code works

📖 "Your requests and key code snippets are preserved; detailed instructions from early in the conversation may be lost. Put persistent rules in CLAUDE.md rather than relying on conversation history." — How Claude Code works

📖 "If a single file or tool output is so large that context refills immediately after each summary, Claude Code stops auto-compacting after a few attempts and shows an error instead of looping." — How Claude Code works

📖 "A conversation tied to your current directory, with its own independent context window. Sessions can be resumed with claude -c, forked with --fork-session... Running /clear starts a new session." — Glossary

📖 "Any place you access Claude Code... All surfaces share the same engine, so your CLAUDE.md, settings, and skills work the same way across them." — Glossary

📖 "A specialized AI assistant that runs in its own context window with a custom system prompt, specific tool access, and independent permissions. It works on a delegated task and returns a summary to the main conversation." — Glossary

📖 "A SKILL.md file containing instructions, knowledge, or a workflow... Claude loads a skill automatically when relevant, or you invoke it directly with /skill-name. Skills follow the Agent Skills open standard." — Glossary

📖 "Hooks are deterministic: they fire at fixed lifecycle points rather than at the model's discretion." — Glossary

📖 "Most extension points, including hooks, skills, and MCP, plug into specific phases of this loop." — Glossary

📖 "Because Claude sees your whole project, it can work across it... This is different from inline code assistants that only see the current file." — How Claude Code works

📖 "Every file edit is reversible. Before Claude edits any file, it snapshots the current contents. If something goes wrong, press Esc twice to rewind." — How Claude Code works

📖 "The Agent SDK is the Python and TypeScript equivalent [of non-interactive mode]." — Glossary

📖 "Native installations automatically update in the background to keep you on the latest version." — Advanced setup

📖 "Claude Code always asks for permission before modifying files. You can approve individual changes or enable \"Accept all\" mode for a session." — Quickstart

📖 "Pressing Enter submits your message. To add a line break without submitting, press Ctrl+J, or type \\ and then press Enter." — Configure your terminal for Claude Code

📖 "With Claude Code installed in that container, commands Claude runs execute inside it rather than on the host machine, while edits to your project files appear in your local repository as you work." — Development containers

📖 "Claude Code checks for updates on startup and periodically while running. Updates download and install in the background, then take effect the next time you start Claude Code." — Advanced setup

📖 "For a more detailed check of your installation and configuration, run claude doctor." — Advanced setup

📖 "Individual users can log in with a Claude.ai account, while teams can use Claude for Teams or Enterprise, the Claude Console, or a cloud provider like Amazon Bedrock, Google Cloud's Agent Platform, or Microsoft Foundry." — Authentication