CCDV-F practice questions: Applications and integration.

A response comes back with stop_reason set to max_tokens. What happened?

• The output reached the max_tokens limit and was cut off before the model finished
• The input exceeded the context window and the request was rejected with a 400
• The model reached the natural end of its turn, so the text is complete as returned
• The model emitted a tool_use block and is waiting for a tool_result from your code

A response has stop_reason tool_use. What must your code do next?

• Execute the requested tool, append a tool_result block with the matching id, and call the model again
• Retry the same request with tool_choice set to none so the model answers in plain text
• Return the text blocks to the user, since the API already executed the tool on the server side before responding
• Wait for the model's next message, which will carry the tool_result once execution finishes

Users should see the answer appear as it is generated. What do you use?

• Set stream to true and render content_block_delta events as they arrive
• Poll the messages endpoint with the message id until a status field reports completion
• Submit the request through the Message Batches API and read results as they land
• Lower max_tokens so each response returns quickly enough to feel incremental

You have 20,000 documents to classify overnight, with no latency requirement, and cost matters. Best choice?

• Submit them through the Message Batches API and collect results when the batch completes
• Send 20,000 synchronous requests through a worker pool sized to your rate limit
• Concatenate all the documents into one request with a large max_tokens and split the output back apart by document
• Stream each request so results can be written to disk as the tokens arrive

Every request includes the same 30,000-token reference manual followed by a short question. How do you cut cost?

• Upload the manual through the Files API so its tokens are billed once instead of per request
• Send the question first and the manual second so the model reads the task before the context
• Put a cache_control breakpoint on the manual block so the prefix is reused across requests
• Lower temperature and max_tokens so each request generates fewer billable output tokens

Your integration starts receiving HTTP 429 responses. What is the right client behavior?

• Rotate to a second API key from the same organization so requests keep flowing
• Treat 429 as a transient server fault and fail the request back to the user
• Retry immediately in a tight loop, since the limit clears as soon as the window rolls over
• Back off exponentially with jitter and honor the retry-after header when it is present

Which fields are required in a Messages API request?

• model, messages, and system
• model, messages, and temperature
• model, messages, and max_tokens
• model, max_tokens, and stream

Where does the system prompt go in a Messages API request?

• As a text block at the start of the first user message
• As the first entry in messages with role set to system
• In the top-level system parameter of the request
• In the metadata object alongside the user_id

A response's content array contains a text block followed by a tool_use block. What does that mean?

• The model wrote some text, then requested a tool call; you run it and return a tool_result
• The response was truncated by max_tokens while writing the tool arguments
• Two parallel responses were merged; keep the tool_use block and drop the text
• The model finished its turn with end_turn; the tool_use block is a suggestion your code may ignore

Your app sends an image for analysis. How is it included?

• As a file uploaded through the Files API and referenced from the tools array by its file id
• As a data URL pasted into the text of the user message
• As an image content block, with a base64 or URL source, inside a user message
• As an image block inside the system parameter next to the instructions

What does stop_reason end_turn tell you?

• The model finished its turn naturally and is not waiting on anything
• The model stopped at a stop sequence you supplied in the request
• The output was cut off because the response reached max_tokens
• The model paused a long-running server tool turn and you should call again

A streaming response is interrupted midway. What should a robust client do?

• Render the partial text as the final answer, since deltas are already committed
• Detect the missing message_stop event, then retry or mark the partial output as incomplete
• Send a follow-up request with stop_reason set to resume so the model continues
• Fall back to non-streaming requests for the rest of the session so the failure does not recur

You need consistent structured data from many documents. Which approach is most robust?

• Define a tool with a JSON schema for the fields, force it with tool_choice, and validate the arguments
• Extract the values from free text with regular expressions tuned on sample documents
• Ask for a markdown table in the prompt, set temperature to 0, and split each returned row on the pipe character
• Set temperature to 0 and ask for JSON, trusting the output to be well formed

Which header carries your credential when calling the API directly?

• Authorization with a Bearer token
• anthropic-version with the key appended
• x-api-key with the key as its value
• x-anthropic-token with the key as its value

A request returns HTTP 400 with an invalid_request_error. Most likely cause?

• The request exceeded the rate limit for your organization's tier
• The model is overloaded and the request should be retried later
• The API key is valid but the organization lacks permission for the requested model
• A malformed body, such as a missing required field or an unsupported parameter

What is the Files API useful for?

• Caching a document so later requests skip input token billing for it
• Storing conversation history server-side so you send only new turns
• Uploading a document once and referencing it by file id across many requests
• Attaching a document to a Message Batch so every request inside that batch can read it

A batch job finished but some requests show errors. What should your code do?

• Retry the batch at a smaller size so fewer requests time out
• Read each request's result, retry the failed ones, and treat the batch as non-atomic
• Cancel the batch and resubmit every request, since partially failed batches are not billed at all
• Treat the whole batch as failed and raise an error for the caller to handle

You want to count tokens before sending a large prompt to avoid exceeding limits. Which capability?

• The token counting endpoint, which returns input tokens for a prompt
• The count_tokens flag on the messages request
• An estimate from character count divided by four
• The usage field on the streaming message_start event, which reports input tokens early

Which SDK pattern avoids re-implementing the tool loop by hand?

• Streaming with a callback that executes tools inline
• A tool runner or agent helper provided by the SDK
• Wrapping the messages call in a retry decorator
• Setting tool_choice to auto so the API runs the tools itself

A multi-turn app appends every response to the history. After 50 turns the requests fail. What is the fix?

• Raise max_tokens so the model has room to answer the longer thread
• Trim or summarize older turns to stay inside the context window
• Add a cache_control breakpoint so cached turns are excluded from the limit
• Switch to a model with extended thinking to handle the longer input