Free CCDV-F Tools and MCPs Practice Test — Claude Certified Developer Questions

This free CCDV-F Tools and MCPs practice test covers extending Claude with tool use and the Model Context Protocol — tool definitions and JSON schemas, tool choice, parallel tool calls, and MCP servers and clients. Each question includes a detailed explanation aligned to Anthropic's official Claude Certified Developer – Foundations exam outline.

Key Topics in CCDV-F Tools and MCPs

6 Free CCDV-F Tools and MCPs Practice Questions with Answers

Each question below includes 4 answer options, the correct answer, and a detailed explanation. These are real questions from the FlashGenius CCDV-F question bank for the Tools and MCPs domain (10.6% of the exam).

Sample Question 1 — Tools and MCPs

A developer adds a customer lookup tool to a Claude-powered support app. In testing, Claude emits the following tool request, but no customer data appears in the conversation. Artifact: ``` assistant tool_request: name: lookup_customer arguments: { "email": "sam@example.com" } app log: received assistant message no tool runner configured for lookup_customer returned final text to user ``` What is the BEST next implementation step?

  1. A. Add a harness step that validates the arguments, calls lookup_customer, and returns the tool result to Claude. (Correct answer)
  2. B. Rename the tool to a shorter name so Claude can execute the customer lookup directly.
  3. C. Move the customer API key into the prompt so Claude can complete the lookup itself.
  4. D. Ask Claude to avoid tool calls and infer customer details from the conversation context.

Correct answer: A

Explanation: Correct answer (A): Claude emitting a tool request does not execute the external action. The surrounding application or agentic harness must receive the tool call, validate its arguments against the schema, dispatch the mapped function or API request, and provide the tool result back to Claude so it can continue the task. Why the other options are wrong: - Option B: A clearer tool name can improve selection, but the trace shows the tool was already selected and no runner executed it. - Option C: Putting credentials in the prompt is not an execution mechanism and would create unnecessary credential exposure risk. - Option D: Inferring customer data from context avoids the required external lookup and would not produce reliable account information.

Sample Question 2 — Tools and MCPs

Claude is frequently choosing the wrong internal support tool. The current tool definitions are shown below. Artifact: ``` Tool 1 name: get_info description: Gets information. input_schema: { "type": "object", "properties": { "id": { "type": "string" } } } Tool 2 name: fetch_data description: Fetches data from systems. input_schema: { "type": "object", "properties": { "id": { "type": "string" } } } ``` The app needs one tool for customer profile lookup and another for order shipment lookup. What is the BEST primary fix?

  1. A. Give each tool a specific name, distinct usage description, typed parameters, and required fields. (Correct answer)
  2. B. Keep the schema unchanged and add a system prompt telling Claude to be more careful.
  3. C. Merge both tools into one generic tool that decides the lookup type at runtime.
  4. D. Remove parameter schemas so Claude can send any arguments it thinks are useful.

Correct answer: A

Explanation: Correct answer (A): Reliable tool selection depends on clear, distinguishable tool definitions. Specific names, precise descriptions, explicit parameter types, required fields, and constraints help Claude decide when to use each capability and call it with valid inputs. Why the other options are wrong: - Option B: Prompt guidance may help slightly, but it does not fix the vague and overlapping tool definitions that are causing confusion. - Option C: A generic combined tool can hide distinctions and push ambiguity into runtime dispatch rather than helping Claude choose correctly. - Option D: Removing schemas reduces validation and makes malformed or ambiguous tool calls more likely.

Sample Question 3 — Tools and MCPs

A support assistant has these tools available in production. Artifact: ``` Tool: get_ticket_status Effect: read-only lookup Visible outside app: no Tool: close_ticket Effect: changes ticket state and emails customer Visible outside app: yes ``` The product requirement is to keep status checks fast while preventing accidental customer-visible actions. Which execution pattern is MOST appropriate?

  1. A. Run get_ticket_status automatically, but require explicit approval before close_ticket executes. (Correct answer)
  2. B. Require human approval for both tools every time Claude requests either one.
  3. C. Allow both tools to execute automatically after Claude selects the right tool.
  4. D. Disable tool use and ask Claude to draft instructions for a human operator.

Correct answer: A

Explanation: Correct answer (A): Read-only lookups and state-changing actions should have different execution controls. A read-only status check can be automated for speed, while a customer-visible state change should require approval or confirmation before the harness executes it. Why the other options are wrong: - Option B: Approval for every read-only lookup would reduce the required speed without adding much value for the stated low-risk action. - Option C: Automatic execution for the state-changing email-producing tool does not address accidental customer-visible actions. - Option D: Disabling all tools avoids automation entirely and fails the requirement to keep status checks fast.

Sample Question 4 — Tools and MCPs

A team is designing an MCP server for a billing assistant. Artifact: ``` Needed capability: submit_refund(case_id, amount) Behavior: calls the billing API and creates a refund transaction Also available: refund policy document and refund explanation template ``` How should `submit_refund(case_id, amount)` be exposed through MCP?

  1. A. As an MCP tool, because it performs an executable external action. (Correct answer)
  2. B. As an MCP resource, because it relates to billing data.
  3. C. As an MCP prompt, because it helps Claude discuss refunds.
  4. D. As plain context only, because MCP should not call APIs.

Correct answer: A

Explanation: Correct answer (A): An MCP tool represents an executable capability such as querying or updating an external system. Because `submit_refund` calls a billing API and creates a transaction, it should be exposed as an MCP tool, while the policy document would fit a resource and the explanation template would fit a prompt. Why the other options are wrong: - Option B: An MCP resource is appropriate for readable data or context, not for executing a refund transaction. - Option C: An MCP prompt is a reusable template or interaction pattern, not the API action that creates the refund. - Option D: MCP can expose executable tools; the issue is to classify the API action correctly and control execution appropriately.

Sample Question 5 — Tools and MCPs

A platform team maintains a Jira integration for Claude-powered workflows. Artifact: ``` Clients needing the same integration: - internal web support assistant - desktop research assistant - IDE-based engineering assistant Capabilities: search_issues, create_issue, update_issue_status Goal: avoid duplicating integration code and permission logic ``` Which architecture is the BEST fit?

  1. A. Expose the Jira capabilities through a shared MCP server used by the clients. (Correct answer)
  2. B. Copy the same custom tool code into each client and update them separately.
  3. C. Replace the integration with a Skill that explains Jira workflows to Claude.
  4. D. Put Jira REST examples in each prompt and let Claude construct requests.

Correct answer: A

Explanation: Correct answer (A): MCP is well suited when the same organization-specific tools, resources, or prompts should be reused by multiple Claude-compatible clients. A shared MCP server centralizes the Jira integration and permission logic instead of duplicating it across applications. Why the other options are wrong: - Option B: Duplicating custom tool code may work initially but conflicts with the stated maintainability goal across multiple clients. - Option C: A Skill can package instructions, but it is not a replacement for centralized executable Jira API capabilities. - Option D: Prompt examples do not provide controlled dispatch, validation, credential handling, or reusable integration logic.

Sample Question 6 — Tools and MCPs

A developer is integrating a local MCP server into a desktop Claude client. Artifact: ``` Deployment: runs only on the user's laptop Startup: client launches the server as a child process Network access: not required Communication pattern: local process streams ``` Which transport choice is MOST appropriate?

  1. A. Use stdio transport between the client and the launched local server process. (Correct answer)
  2. B. Use a network socket transport because all MCP servers must be remote services.
  3. C. Avoid MCP and paste the local files into every conversation manually.
  4. D. Use an MCP prompt instead of transport because prompts can carry tool calls.

Correct answer: A

Explanation: Correct answer (A): stdio-based MCP communication is appropriate when the client launches or communicates with a local server process. Socket-based transport is more appropriate for a network-accessible service or separate client/server deployment over a network. Why the other options are wrong: - Option B: Socket transport can be appropriate for networked services, but the artifact specifies a local child process with no network requirement. - Option C: Manual pasting is not a reusable integration and does not expose executable MCP capabilities. - Option D: An MCP prompt is a reusable template, not the communication transport for a server process.

How to Study CCDV-F Tools and MCPs

Combine these CCDV-F Tools and MCPs practice questions with the official Anthropic documentation and hands-on projects. Build a small Claude-powered application with tool use, try Claude Code on a real repository, and iterate on prompts with evals — practical experience is the fastest way to master this domain.

About the CCDV-F Exam

Other CCDV-F Domains

Start the free CCDV-F Tools and MCPs practice test now | 10-question quick start | All CCDV-F domains