Claude Architect · 课时

必须提供完整历史记录

每个请求都携带完整的对话。

必须提供完整历史记录 是 CoddyKit 上的免费 Claude Architect 课时。这是第 1 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Claude Architect 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Claude Architect 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

The Model Keeps No State

The most important fact about the Claude API: the model is stateless. It remembers nothing between requests. There is no hidden session on Anthropic's side holding your earlier turns.

Every time you call the API, you send the entire conversation history in the messages array. If a fact isn't in that array, the model simply doesn't know it — even if it told you the same fact thirty seconds ago.

For a Claude Certified Architect, internalizing this changes how you design every multi-turn system, agentic loop, and multi-agent handoff.

Anatomy of a Request

A Claude API request carries a fixed set of fields. The ones you'll touch on every turn:

model — which Claude model to call
max_tokens — output budget
system — the system prompt (instructions, persona, rules)
messages — the full conversation history as an array of role/content objects
tools and tool_choice — optional tool definitions and selection control

Notice what is NOT here: any kind of conversation ID or session token. State lives entirely in what you resend.

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    system="You are a concise travel assistant.",
    messages=[
        {"role": "user", "content": "I want to visit Japan in spring."}
    ],
)

Building the History Array

To continue a conversation, you don't 'reply' to a session — you append the model's previous answer and the new user turn to the same messages list, then resend the whole thing.

The pattern: take last turn's messages, push the assistant's response, push the new user message, and call again. The array grows with every exchange.

messages = [
    {"role": "user", "content": "I want to visit Japan in spring."},
    {"role": "assistant", "content": "Great — cherry blossom season peaks in early April."},
    {"role": "user", "content": "What about the weather then?"},
]

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    messages=messages,  # full history, every turn
)

What Happens If You Forget

Suppose you send only the latest user message — "What about the weather then?" — and drop the earlier turns. The model has no idea what 'then' refers to or that Japan was ever mentioned.

It will either ask for clarification or hallucinate a context. This is the single most common cause of 'the bot forgot what we were talking about' bugs. The fix is never a prompt trick — it's resending the full history.

Tool Results Are Part of History Too

History isn't just user and assistant text. When the model calls a tool, the conversation continues with structured turns:

an assistant turn containing a tool_use block
a user turn containing the matching tool_result

You must append the tool result back into messages and resend everything. The model only 'sees' the tool's output because it's now part of the history you carry forward.

messages.append({"role": "assistant", "content": response.content})  # has tool_use
messages.append({
    "role": "user",
    "content": [{
        "type": "tool_result",
        "tool_use_id": tool_use_id,
        "content": "Tokyo, April: ~15C, mild, occasional rain.",
    }],
})

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    tools=tools,
    messages=messages,  # history now includes the tool_result
)

The Agentic Loop Carries History

This is why the agentic loop works the way it does. Each iteration: send the request, inspect stop_reason, and if it's tool_use, run the tools, append the results to history, and loop again — until stop_reason is end_turn.

The loop is fundamentally a history-accumulation loop. Terminate on the stop_reason, NEVER by scanning the text for words like 'done'. An iteration cap is a safety net, not the primary stop mechanism.

while True:
    response = client.messages.create(
        model="claude-sonnet-4-5", max_tokens=1024,
        tools=tools, messages=messages,
    )
    if response.stop_reason == "tool_use":
        messages.append({"role": "assistant", "content": response.content})
        messages.append({"role": "user", "content": run_tools(response)})
        continue  # resend the FULL grown history
    break  # end_turn -> done

Subagents Do NOT Inherit History

Here's the multi-agent trap. In a hub-and-spoke system, a coordinator delegates work to subagents via Task calls. But a subagent gets a fresh conversation — it does NOT inherit the coordinator's message history.

If the subagent needs the customer's ID, the order number, or any earlier finding, the coordinator must pass it explicitly inside the subagent's prompt. Assuming inheritance is a guaranteed failure: the subagent runs blind.

Passing Context Explicitly

Because state isn't shared, the coordinator's job includes packaging the right context into each delegation. Give the subagent exactly what it needs to act — no more (least privilege also applies to context).

Multiple Task calls in one response run in parallel, and each one is a self-contained brief. Treat every subagent prompt as a complete, standalone request.

subagent_prompt = f"""
You are researching flight options.
Context (you have no other history):
- Destination: Tokyo, Japan
- Travel window: early April 2026
- Origin: Istanbul (IST)
Return the 3 cheapest round-trip options with dates and prices.
"""
# Coordinator allowedTools must include "Task".
# Subagent starts with a blank message history -> context must be inline.

History Grows — and So Does Cost

Resending everything has a consequence: each turn re-tokenizes the entire history. Long conversations mean larger, slower, costlier requests, and eventually the context window fills up.

Architect-level reliability work is about managing that growth without losing fidelity:

Trim verbose tool output to only the relevant fields before appending.
Progressive summarization compresses old turns — but beware: it makes numbers, percentages, and dates vague.

Keep Transactional Facts Verbatim

The fix for vague summaries: pull hard facts — order IDs, amounts, dates, verified identities — into a separate 'case facts' block kept verbatim, outside the summary. Summarize the chatter, never the numbers.

Also mind lost-in-the-middle: models attend most to the start and end of the context. Put the most critical facts and the current instruction where they'll be seen, not buried in the middle of a long history.

messages = [
    {"role": "user", "content":
        "CASE FACTS (verbatim):\n"
        "- Order #A-4471, total $129.00, placed 2026-03-02\n"
        "- Customer verified: ID CUST-8830\n\n"
        "CONVERSATION SUMMARY:\n"
        "Customer reported a late delivery and requested options."
    },
    {"role": "user", "content": "Now: can you process a partial refund?"},
]

Sessions Resume — Tool Results May Be Stale

Claude Code persists history across sessions: --resume <name> continues a named session, and fork_session branches from a shared point. Convenient — but a caution worth remembering for the exam.

Resumed tool results can be stale if the codebase changed since they were captured. Carrying forward old history isn't always right; sometimes a fresh session seeded with a clean, structured summary beats replaying outdated context.

# Continue a prior named session (history reloaded)
claude --resume refactor-auth

# Branch from a shared point without polluting the original
# fork_session -> new line of exploration from the same base

Quick Check: The Forgetful Subagent

A scenario testing the core decision of this lesson.

Recap: Full History Is Required

Lock these in for the exam and for real systems:

The model is stateless; every request must carry the entire messages history.
Tool calls extend history — append each tool_result and resend everything.
The agentic loop is a history-accumulation loop; stop on stop_reason, not on parsed text.
Subagents do not inherit the coordinator's history — pass all context explicitly in each prompt.
History grows: trim verbose tool output, summarize old turns, but keep transactional facts verbatim and mind lost-in-the-middle.
Resumed sessions can carry stale tool results — sometimes a fresh session with a clean summary is better.

常见问题解答

「必须提供完整历史记录」课时是免费的吗？

是的 — 「必须提供完整历史记录」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Claude Architect 课程的其余内容，请升级到 CoddyKit PRO。 Claude Architect 课程共包含 4 节课。

「必须提供完整历史记录」这节课中我会学到什么？

每个请求都携带完整的对话。你通过在浏览器中直接运行的动手代码来练习 Claude Architect，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Claude Architect 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Claude Architect 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 1 节课，共 4 节。

「必须提供完整历史记录」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Claude Architect 课中编写并运行代码吗？

能。每节 Claude Architect 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Claude Architect