The Claude Certified Architect — Foundational (CCA-F) is Anthropic's first official technical certification, launched on March 12, 2026 as a cornerstone of the Claude Partner Network (CPN). It validates that a practitioner can design, build, and operate production-grade systems on top of Claude. Unlike vendor-neutral AI certifications, the CCA-F focuses specifically on Anthropic's platform stack: the Messages API, Claude Code, MCP, agent orchestration, and the operational practices needed to run Claude reliably at scale.

Exam Format & Logistics

Retake Policy

• After 1st failed attempt: Wait 14 days
• After 2nd failed attempt: Wait 30 days
• After 3rd failed attempt: Wait 90 days
• Maximum: 4 attempts per 12-month period

Claude Certified Associate (CCAO-F)

Anthropic also offers the Claude Certified Associate — Foundational (CCAO-F), which opened on July 13, 2026 at $99 USD. The CCAO-F targets non-developers — product managers, business analysts, and operational staff — and covers 7 domains focused on using Claude effectively without writing code. If you are preparing for the CCA-F (the architect-level exam), the CCAO-F content is a proper subset and completing the CCAO-F first can be good warm-up practice.

The Five Exam Domains

Every question on the CCA-F maps to one of five domains. Understanding the weight distribution is critical for allocating your study time efficiently.

Test-Taking Strategy

The CCA-F is entirely scenario-based. Every question places you in a realistic production situation and asks you to make an architectural decision. There are no trivia questions about API parameter names or version numbers. Here is how to approach them:

The STAR Method for Scenario Questions

1. Situation: Read the scenario carefully. Identify the constraints (scale, latency, cost, reliability requirements).
2. Task: What exactly is being asked? "Which architecture," "What is the primary reason," "Which approach best addresses" — the verb tells you the expected depth.
3. Action: Evaluate each option against the stated constraints. Eliminate options that violate a hard constraint first.
4. Result: The correct answer is the one that best satisfies all stated constraints simultaneously, not the one that is generically "best practice."

Common Traps

• The "always" trap: Answers containing "always" or "never" are usually wrong. Production systems require nuance.
• The over-engineering trap: A multi-agent orchestration is not the right answer when a simple API call with prompt chaining would suffice. The exam rewards choosing the simplest adequate architecture.
• The recency trap: Newer features are not automatically better. Extended thinking is powerful but adds latency and cost — the exam tests whether you know when to use it vs. manual chain-of-thought.
• The context confusion trap: Questions about MCP often include an option that conflates Resources with Tools or mixes up transport types. Keep the primitives distinct in your mind.

Time Management

With 60 questions in 120 minutes, you have an average of 2 minutes per question. Strategy:

• First pass (70 minutes): Answer everything you are confident about. Flag uncertain questions.
• Second pass (40 minutes): Return to flagged questions. Re-read the scenario slowly.
• Final review (10 minutes): Scan for any unanswered questions. Never leave a question blank — there is no penalty for guessing.

Recommended Learning Path

Before diving into this prep course, complete the free courses on Anthropic Academy (anthropic.skilljar.com). There are 17 courses covering the fundamentals. Recommended sequence:

1. Claude 101: Foundational concepts, model family overview, safety principles
2. Building with the Claude API: Messages API, streaming, tool use basics
3. Claude Code in Action: Setting up Claude Code, CLAUDE.md, workflows
4. MCP Fundamentals: Protocol architecture, building your first server
5. MCP Advanced Patterns: Authentication, remote servers, production deployment
6. Agent Skills: Agentic patterns, the agentic loop, multi-agent design
7. Subagents & Orchestration: Hub-and-spoke, context isolation, performance outcomes

Domain 1 is the heaviest-weighted domain on the CCA-F, reflecting Anthropic's position that agentic architectures represent the primary way enterprises will deploy Claude in production. This domain tests your ability to design systems where Claude operates with varying degrees of autonomy, uses tools, manages multi-step workflows, and coordinates with other agents.

Defining Agentic Systems

An agentic system is any system where an AI model operates with a degree of autonomy — making decisions about which actions to take, executing those actions through tools, and iterating based on results. The defining characteristics are:

• Autonomy: The model decides what to do next, rather than following a fixed script
• Tool Use: The model can call external functions (APIs, databases, file systems) to interact with the world
• Iterative Reasoning: The model observes tool results and decides whether to continue or stop
• Goal-Directed Behavior: Actions are oriented toward completing a user-specified objective

Agents vs. Workflows vs. Conversational Systems

The exam frequently tests your ability to distinguish between these three system types and choose the right one for a given scenario.

The Fundamental Agentic Loop

Every agentic system built on Claude follows the same core loop. Understanding this loop is essential — at least 4-5 exam questions directly test it.

while True:
    # 1. Send messages to Claude (including any tool results)
    response = client.messages.create(
        model="claude-sonnet-4-5-20250514",
        max_tokens=4096,
        system=system_prompt,
        messages=messages,
        tools=tool_definitions
    )

    # 2. Check stop_reason
    if response.stop_reason == "end_turn":
        # Claude has finished — extract final text response
        break
    elif response.stop_reason == "tool_use":
        # Claude wants to call a tool — extract the tool call
        tool_block = next(b for b in response.content if b.type == "tool_use")
        
        # 3. Execute the tool
        result = execute_tool(tool_block.name, tool_block.input)
        
        # 4. Append assistant response and tool result to messages
        messages.append({"role": "assistant", "content": response.content})
        messages.append({
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_block.id,
                "content": str(result)
            }]
        })
    # Loop continues — Claude sees the tool result and decides next action

The critical insight is the stop_reason field. When Claude returns "tool_use", the system must execute the requested tool and feed the result back. When Claude returns "end_turn", the task is complete. This loop continues until either: Claude signals completion, a maximum iteration count is reached, or an error occurs that cannot be recovered.

Stop Reasons Reference

Agent Patterns

ReAct (Reasoning + Acting)

The ReAct pattern interleaves reasoning and action. The agent first reasons about what it knows and what it needs to find out, then takes an action (tool call), observes the result, reasons again, and repeats. This is the most common pattern for Claude agents because Claude's natural behavior already follows this pattern — it thinks through a problem, identifies what information it needs, and uses tools to get that information.

In practice, ReAct emerges naturally when you give Claude tools and a task. You do not need to explicitly instruct Claude to "reason then act" — it does this by default. However, combining ReAct with extended thinking (where the reasoning happens in a separate thinking block before the response) produces measurably better results on complex multi-step tasks.

Plan-and-Execute

In the plan-and-execute pattern, the agent first creates an explicit plan (a list of steps), then executes each step sequentially, checking off items as it goes. This pattern is superior to pure ReAct when the task has many dependencies between steps and the order matters.

Implementation approach: Use a system prompt that instructs Claude to first output a plan inside <plan> tags, then execute steps one by one, updating the plan after each step to handle any changes. This creates an auditable trail and helps Claude maintain coherence across long tasks.

Multi-Agent Orchestration

Multi-agent architectures use multiple Claude instances, each with a specialized role. Anthropic's research shows that multi-agent systems outperform single-agent by up to 90% on complex tasks when properly coordinated by a lead planner. The key architectures are:

Hub-and-Spoke Model

The hub-and-spoke model is the primary multi-agent pattern used in the Claude Agent SDK. One orchestrator agent (the hub) receives the user's task, breaks it down into subtasks, and delegates each subtask to a specialist subagent (the spokes). Each subagent has:

• Its own context window: Isolated from other subagents, so it only sees relevant information
• Its own tool permissions: A subagent that only needs to read files does not get write tools
• Its own model selection: A simple summarization subagent can use a cheaper model than a reasoning-heavy one
• A focused system prompt: Tailored to its specific role

Claude Agent SDK Architecture

The Claude Agent SDK provides first-class support for building multi-agent systems. Agents are defined as objects with their own configuration:

from claude_agent_sdk import Agent, tool

# Define a specialist subagent
research_agent = Agent(
    name="researcher",
    model="claude-sonnet-4-5-20250514",
    system_prompt="""You are a research specialist. 
    Given a topic, search for relevant information and 
    return a structured summary.""",
    tools=[web_search, read_document],
    max_turns=10
)

# Define the orchestrator
orchestrator = Agent(
    name="orchestrator",
    model="claude-sonnet-4-5-20250514",
    system_prompt="""You coordinate research tasks. 
    Break complex questions into sub-questions and 
    delegate to the research agent.""",
    subagents=[research_agent],
    tools=[file_write]
)

Critical design principles in the Agent SDK:

• Agents are first-class objects: Each has its own context, tools, model, and system prompt
• Subagent invocation is a tool call: The orchestrator "calls" a subagent the same way it calls any other tool
• Context isolation is the default: Subagents get a fresh context window with only the information the orchestrator passes to them
• Results flow back to the orchestrator: The subagent's output becomes a tool result in the orchestrator's context

Dynamic Workflows & Performance Outcomes

Dynamic Workflows (June 2026)

Dynamic Workflows, introduced in June 2026, allow a lead agent to fan out tens to hundreds of parallel subagents. This is a significant capability upgrade from the earlier sequential subagent model. Use cases include:

• Large codebase refactoring: Fan out one subagent per file or module, each making the same type of change in parallel
• Document analysis: Process hundreds of documents simultaneously, with each subagent analyzing one document
• Multi-source research: Query multiple data sources in parallel, then synthesize results

The lead agent defines the fan-out pattern, creates the subagent specifications, and then waits for all results. It then synthesizes the individual results into a coherent output. This pattern reduces wall-clock time dramatically compared to sequential processing.

Performance Outcomes

Performance Outcomes introduce a quality gate into the multi-agent pipeline. A separate grader agent evaluates each subagent's output against a rubric. If the output does not meet the rubric criteria, the grader sends the subagent back to revise its work, providing specific feedback about what needs improvement. This creates a revise-until-quality loop:

1. Subagent produces output
2. Grader evaluates against rubric
3. If passing: output is accepted
4. If failing: grader sends feedback to subagent, subagent revises
5. Repeat until passing or max retries exhausted

Session Management and State

Long-running agents must manage state across multiple interactions. Key patterns:

• Conversation history as state: The messages array IS the state. Persist it between API calls to maintain continuity.
• External state stores: For state that must survive process restarts, use a database or file system. The agent reads current state at the beginning of each turn.
• Checkpoint-and-resume: For long tasks, periodically save progress so the agent can resume after failures without starting over.

Error Handling and Recovery

Production agents must handle failures gracefully. The exam tests three critical patterns:

Idempotent Tool Calls

Design tools so that calling them twice with the same inputs produces the same result. This is essential for crash recovery — if the agent crashes after executing a tool but before recording the result, it must be safe to re-execute the tool on restart. Example: instead of increment_counter(), use set_counter(value=5).

Crash Recovery Without Replaying Side Effects

When an agent crashes mid-task, it must resume without re-executing tool calls that have already produced side effects (sent emails, created records, charged credit cards). Pattern:

1. Before each tool execution, write the tool call to a journal
2. After execution, write the result to the journal
3. On restart, replay the journal: skip tools that have results, re-execute tools that were started but not completed

When to Use Agents vs. Simple API Calls

Not every task requires an agent. The exam tests whether you can identify the appropriate level of complexity:

Practice Questions — Domain 1

Claude Code is Anthropic's official agentic coding tool — a terminal-based AI assistant that operates directly in your development environment. Domain 3 tests your mastery of its configuration system, automation workflows, and integration into CI/CD pipelines. This domain is tightly coupled with Domain 1 (Agentic Architecture) and together they account for 47% of the exam.

The Three-Level CLAUDE.md Hierarchy

CLAUDE.md files are the primary mechanism for giving Claude Code persistent context and instructions. They form a three-level hierarchy that determines scope and precedence:

1. User-Level (~/.claude/CLAUDE.md)

Applies across ALL projects for the current user. Use for personal preferences like coding style, preferred language patterns, or common tools. This file is never committed to version control.

# Example: ~/.claude/CLAUDE.md
- I prefer functional programming patterns over OOP
- Always use TypeScript strict mode
- Use pnpm, not npm or yarn
- My preferred test framework is Vitest

2. Project-Level (./CLAUDE.md)

Applies to the entire project. Committed to version control and shared with the team. Contains project-specific architecture decisions, coding standards, and important context about the codebase.

# Example: ./CLAUDE.md
# Project: Acme Dashboard

## Architecture
- Next.js 14 with App Router
- PostgreSQL via Drizzle ORM
- Authentication via Clerk
- Deployed on Vercel

## Conventions
- All API routes in app/api/
- Database migrations in drizzle/migrations/
- Use server actions for mutations, not API routes
- Error handling: use Result type pattern, never throw

## Important Notes
- Never modify the auth middleware without team review
- The legacy /api/v1 routes are frozen — do not change

3. Directory-Level (./src/components/CLAUDE.md)

Applies only when Claude Code is working on files within that directory or its children. Useful for specialized rules for particular parts of the codebase.

# Example: ./src/components/CLAUDE.md
- All components use the compound component pattern
- Props interfaces go in a separate types.ts file
- Each component folder has: index.tsx, types.ts, styles.module.css, Component.test.tsx
- Use forwardRef for all interactive components

Path-Specific Rules with .claude/rules/

For even more granular control, create rules files in .claude/rules/ with YAML glob frontmatter that specifies which files the rule applies to:

# .claude/rules/api-routes.md
---
globs: ["src/app/api/**/*.ts"]
---
- All API routes must validate input with Zod schemas
- Return consistent error format: { error: string, code: number }
- Include rate limiting middleware
- Log all requests with structured logging

# .claude/rules/database.md
---
globs: ["src/db/**/*.ts", "drizzle/**/*.ts"]
---
- Always use transactions for multi-table operations
- Include created_at and updated_at timestamps on all tables
- Use soft deletes (deleted_at column) instead of hard deletes
- Migration files must be reversible

Custom Slash Commands

Custom slash commands are reusable prompt templates stored in .claude/commands/. Each command is a Markdown file whose body becomes the prompt sent to Claude when the command is invoked.

Creating a Custom Command

# .claude/commands/review.md
---
description: "Perform a thorough code review of the current changes"
allowed-tools: ["Read", "Grep", "Glob"]
model: "claude-sonnet-4-5-20250514"
---
Review the current git diff thoroughly. For each changed file:

1. Check for bugs, logic errors, and edge cases
2. Verify error handling is comprehensive
3. Ensure naming conventions match the project style
4. Look for security vulnerabilities (SQL injection, XSS, etc.)
5. Check test coverage — flag any untested code paths

Format your review as:
## Summary
(Overall assessment)

## File-by-File Review
(Detailed findings per file)

## Action Items
(Numbered list of required changes)

Users invoke this command by typing /review in Claude Code. The optional YAML frontmatter controls:

• description: Shown in command listing and autocomplete
• allowed-tools: Restricts which tools the command can use
• model: Overrides the default model for this command

Built-in Slash Commands

Claude Code ships with several built-in commands that you should know for the exam:

The Hooks System

Hooks allow you to run custom code at specific points in Claude Code's execution lifecycle. They are configured in .claude/settings.json and execute shell commands or scripts.

Hook Types

Hook Configuration Example

// .claude/settings.json
{
  "hooks": {
    "UserPromptSubmit": {
      "command": "bash .claude/hooks/enrich-prompt.sh",
      "timeout": 5000
    },
    "PreToolUse": {
      "command": "python .claude/hooks/tool-guard.py",
      "timeout": 3000
    }
  }
}

# .claude/hooks/enrich-prompt.sh
#!/bin/bash
# Inject current git context and recent test results
echo "Current branch: $(git branch --show-current)"
echo "Last test run: $(cat .test-results/latest.txt 2>/dev/null || echo 'No recent tests')"
echo "Uncommitted files: $(git status --porcelain | wc -l | tr -d ' ')"

The Explore-Plan-Code-Commit Cycle

Claude Code's recommended workflow follows a four-phase cycle that mirrors how experienced developers approach tasks:

1. Explore: Claude reads relevant files, understands the codebase structure, and identifies where changes need to be made. Uses tools like Read, Glob, Grep to build understanding.
2. Plan: Claude creates a concrete plan of changes. This may involve breaking a large task into smaller steps, identifying dependencies between changes, and flagging potential risks.
3. Code: Claude implements the changes using Edit and Write tools. Each edit is targeted and precise.
4. Commit: Claude creates a git commit with a descriptive message. The commit message follows conventional commit format and includes context about why the change was made.

Claude Code in CI/CD

Claude Code can run in non-interactive CI/CD pipelines using specific flags:

The -p (Prompt) Flag

The -p flag runs Claude Code in non-interactive mode with a single prompt. It processes the prompt, performs the requested actions, and exits. This is essential for CI/CD integration.

# Example: Automated code review in CI
claude -p "Review the changes in this PR and create a summary of potential issues" \
  --output-format json > review-results.json

The --bare Flag

The --bare flag skips all ambient discovery — it does not read CLAUDE.md files, does not scan the git history, and does not load project context. It requires an explicit ANTHROPIC_API_KEY environment variable. Use --bare when you want a clean, predictable environment for CI tasks.

# CI pipeline with bare mode
export ANTHROPIC_API_KEY=${{ secrets.ANTHROPIC_KEY }}
claude --bare -p "Analyze the test results in test-output.xml and create a summary"

Skills

Skills are reusable markdown instructions that Claude Code automatically discovers and applies based on the task context. They are similar to CLAUDE.md rules but are more portable — they can be shared across projects and teams. Skills are stored in a location Claude Code scans automatically, and they contain instructions that Claude applies when relevant to the current task.

MCP Server Configuration

Claude Code can connect to MCP servers for extended capabilities. Servers are configured in the settings and provide additional tools, resources, and prompts that Claude can use during sessions.

Practice Questions — Domain 3

Domain 4 covers the art and science of communicating effectively with Claude — from system prompt design through structured output enforcement. While prompt engineering might seem "soft" compared to architecture, the exam questions in this domain are precise and test deep understanding of how Claude processes and responds to different prompt structures.

System Prompts vs. User Prompts

System Prompts

The system prompt sets Claude's persona, instructions, and behavioral constraints for the entire conversation. It is provided via the system parameter in the API call and is NOT part of the messages array. Best practices:

• Identity and role: Define who Claude is in this context ("You are a senior security analyst reviewing code for vulnerabilities")
• Behavioral constraints: What Claude should and should not do ("Never suggest deleting production data", "Always ask for confirmation before making changes")
• Output format: How responses should be structured ("Respond in JSON format with the following fields...")
• Context and background: Information Claude needs to do its job well ("The codebase uses PostgreSQL 15 with PostGIS extensions")
• Prioritization: What matters most ("Prioritize security over performance in all recommendations")

User Prompts

User prompts are the individual messages in the messages array. They can include text, images, and tool results. Best practices for user prompts:

• Be specific: "Refactor the calculateTax function in src/utils/tax.ts to handle negative amounts" is better than "fix the tax code"
• Provide context: Include relevant code, error messages, or requirements directly in the prompt
• State the expected output: "Return only the modified function, no explanations" or "Explain your reasoning step by step"

XML Tag Structuring

Anthropic recommends XML tags as essential for complex prompts. XML tags help Claude parse multi-part prompts, distinguish between instructions and data, and produce structured output. This is one of Anthropic's strongest recommendations and is tested heavily on the exam.

Common XML Tag Patterns

<instructions>
Analyze the following code for security vulnerabilities.
Focus on: SQL injection, XSS, CSRF, authentication bypasses.
Rate each finding as Critical, High, Medium, or Low.
</instructions>

<code>
// The actual code to analyze goes here
app.get('/users/:id', (req, res) => {
  const query = `SELECT * FROM users WHERE id = ${req.params.id}`;
  db.execute(query).then(result => res.json(result));
});
</code>

<output_format>
Return findings in this format:
<finding>
  <severity>Critical|High|Medium|Low</severity>
  <type>Vulnerability type</type>
  <location>File and line</location>
  <description>What the issue is</description>
  <remediation>How to fix it</remediation>
</finding>
</output_format>

Why XML Tags Work

• Clear boundaries: Claude can unambiguously distinguish between instructions, data, and format specifications
• Nesting support: Complex structures with parent-child relationships are naturally expressed
• Consistent extraction: Output wrapped in XML tags is easy to parse programmatically
• Resistance to injection: Data inside XML tags is less likely to be interpreted as instructions

Few-Shot Prompting

Few-shot prompting provides examples of the desired input-output behavior. Claude learns the pattern from the examples and applies it to new inputs. Structure few-shot examples using XML tags for clarity:

<examples>
<example>
  <input>The server returned a 503 error when processing the batch job.</input>
  <output>{"category": "infrastructure", "severity": "high", "component": "batch_processor"}</output>
</example>
<example>
  <input>User reported that the login button is misaligned on mobile.</input>
  <output>{"category": "ui", "severity": "low", "component": "auth_frontend"}</output>
</example>
</examples>

Now classify this issue:
<input>The payment webhook is failing intermittently with timeout errors.</input>

Extended Thinking & Chain-of-Thought

Manual Chain-of-Thought

Before extended thinking was available, developers used manual chain-of-thought by instructing Claude to "think step by step" or reason inside <thinking> tags before producing an answer in <answer> tags:

Before answering, reason through the problem step by step 
inside <thinking> tags. Then provide your final answer 
inside <answer> tags.

<thinking>
(Claude reasons here — visible to the user)
</thinking>

<answer>
(Final answer here)
</answer>

Extended Thinking (GA June 26, 2026)

Extended thinking is a first-class API feature that gives Claude a dedicated, private reasoning space before generating its response. Key differences from manual chain-of-thought:

• Private: Thinking blocks are separate from the response and can be hidden from users
• Controllable: The budget_tokens parameter lets you control how much reasoning to allow
• Higher quality: Extended thinking consistently outperforms manual chain-of-thought on complex reasoning tasks
• Cost trade-off: Thinking tokens are billed at input token rates, so more thinking = higher cost

response = client.messages.create(
    model="claude-sonnet-4-5-20250514",
    max_tokens=8192,
    thinking={
        "type": "enabled",
        "budget_tokens": 4096  # Controls reasoning depth
    },
    messages=[{"role": "user", "content": "..."}]
)

Structured Output

JSON Mode

When you need Claude to return valid JSON, you can instruct it in the system prompt and use the response format parameter. Claude reliably produces well-formed JSON when properly instructed:

response = client.messages.create(
    model="claude-sonnet-4-5-20250514",
    max_tokens=4096,
    system="You are a data extraction API. Always respond with valid JSON.",
    messages=[{
        "role": "user",
        "content": "Extract: name, email, company from: 'John Smith, john@acme.com, works at Acme Corp'"
    }]
)

Tool Use for Structured Data Extraction

A powerful pattern is to define a tool with a JSON Schema that describes the desired output structure, then ask Claude to "use" the tool. Claude's tool use mechanism guarantees that the output matches the schema:

tools = [{
    "name": "extract_contact",
    "description": "Extract contact information from text",
    "input_schema": {
        "type": "object",
        "properties": {
            "name": {"type": "string"},
            "email": {"type": "string", "format": "email"},
            "company": {"type": "string"},
            "role": {"type": "string"}
        },
        "required": ["name", "email"]
    }
}]

response = client.messages.create(
    model="claude-sonnet-4-5-20250514",
    max_tokens=1024,
    tools=tools,
    tool_choice={"type": "tool", "name": "extract_contact"},
    messages=[{"role": "user", "content": text_to_extract_from}]
)

Constrained Decoding

Constrained decoding enforces schemas at the token level during generation. Unlike prompt-based JSON extraction (where Claude might occasionally produce invalid JSON), constrained decoding guarantees schema compliance by restricting which tokens can be generated at each step. This is particularly useful for production systems where invalid output cannot be tolerated and retries are expensive.

Temperature and Sampling Parameters

Prompt Chaining and Decomposition

For complex tasks, breaking the work into a chain of prompts — each handling one step — produces better results than a single monolithic prompt. This is because:

• Each step gets focused context: The prompt for step 2 only contains what it needs, not the entire task description
• Errors are isolated: If step 3 fails, you can retry it without re-running steps 1 and 2
• Intermediate results can be validated: Check each step's output before proceeding
• Different models for different steps: Use a powerful model for reasoning and a fast model for formatting

Example: Document Analysis Pipeline

1. Step 1 (Extract): "Extract all dates, monetary amounts, and party names from this contract." (High accuracy needed → Claude Sonnet with extended thinking)
2. Step 2 (Classify): "Classify each extracted item by type: date, amount, party." (Simple task → fast model)
3. Step 3 (Analyze): "Given the classified items, identify any conflicts between dates or amounts." (Reasoning → extended thinking)
4. Step 4 (Format): "Format the analysis as a structured report with this template." (Formatting → fast model)

Practice Questions — Domain 4

The Model Context Protocol (MCP) is an open protocol that standardizes how AI models connect to external data sources and tools. Domain 5 tests your understanding of MCP architecture, the three core primitives, transport mechanisms, and best practices for building and deploying MCP servers.

MCP Architecture: Host, Client, Server

MCP follows a three-tier architecture with clearly defined roles:

Hosts

Hosts are the applications that users interact with directly. They contain one or more MCP clients and expose the combined capabilities to the AI model. Examples:

• Claude Desktop: Anthropic's desktop application
• IDEs with Claude integration: VS Code, JetBrains, etc.
• Claude Code: The terminal-based coding assistant
• Custom applications: Any app that embeds Claude via the API

Clients

Clients live within the host application. Each client maintains a 1:1 connection with a single MCP server. The client handles:

• Establishing and maintaining the connection to a server
• Protocol negotiation during initialization
• Routing requests from the host to the appropriate server
• Translating between the host's internal format and the MCP protocol

Servers

Servers expose capabilities to clients. Each server provides some combination of tools, resources, and prompts. Servers can be:

• Local: Running on the same machine as the host (connected via stdio)
• Remote: Running on a separate machine (connected via Streamable HTTP)

Three Core Primitives

MCP defines three types of capabilities that servers can expose:

Primitive Methods

Each primitive type supports standard methods for interaction:

• */list — Discovery: Returns all available items of that type (e.g., tools/list returns all tools the server offers)
• */get — Retrieval: Fetches a specific item's details (e.g., resources/get returns a resource's content)
• tools/call — Execution: Invokes a specific tool with the provided arguments

Tool Definition with JSON Schema

Tools are defined using JSON Schema for their input parameters. This schema tells Claude what arguments the tool expects:

{
    "name": "search_codebase",
    "description": "Search for code patterns across the repository. 
        Returns matching file paths and line numbers. Use this when 
        you need to find where a function, class, or pattern is 
        defined or used.",
    "inputSchema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "The search pattern (supports regex)"
            },
            "file_type": {
                "type": "string",
                "description": "Filter by file extension (e.g., '.py', '.ts')",
                "default": null
            },
            "max_results": {
                "type": "integer",
                "description": "Maximum number of results to return",
                "default": 20
            }
        },
        "required": ["query"]
    }
}

Transport Mechanisms

stdio (Standard Input/Output)

The stdio transport is used for local, same-machine connections. The host launches the server as a child process and communicates via standard input and standard output streams.

• Pros: Simple setup, no network configuration, low latency, secure (no network exposure)
• Cons: Server must run on the same machine, limited to single-client connections, requires the host to manage the server process lifecycle
• Use when: The server accesses local resources (file system, local databases) and runs on the user's machine

Streamable HTTP

Streamable HTTP is the transport for remote, multi-client connections. It uses HTTPS for requests and Server-Sent Events (SSE) for streaming responses.

• Pros: Supports remote servers, multiple clients can connect simultaneously, works through firewalls and proxies, supports authentication
• Cons: Requires network infrastructure, higher latency than stdio, must handle authentication and security
• Use when: The server is shared across multiple users, runs in the cloud, or accesses remote APIs

Protocol Format

MCP uses JSON-RPC 2.0 as its wire format. All messages are JSON-RPC requests, responses, or notifications. The protocol includes a lifecycle management system:

1. Initialize: Client sends initialize request with its capabilities. Server responds with its capabilities.
2. Capability negotiation: Both sides agree on which features they support.
3. Ready: After initialization, the client sends an initialized notification. The connection is now active.
4. Operation: Normal request/response flow for tools, resources, and prompts.
5. Shutdown: Either side can close the connection gracefully.

Building Custom MCP Servers

Building an MCP server in Python using the official SDK:

from mcp.server import Server
from mcp.types import Tool, TextContent
import mcp.server.stdio

# Create a server instance
server = Server("my-tools-server")

# Define available tools
@server.list_tools()
async def list_tools():
    return [
        Tool(
            name="get_weather",
            description="Get current weather for a city. Returns temperature, 
                conditions, and humidity.",
            inputSchema={
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "City name (e.g., 'San Francisco')"
                    },
                    "units": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "default": "celsius"
                    }
                },
                "required": ["city"]
            }
        )
    ]

# Handle tool calls
@server.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "get_weather":
        city = arguments["city"]
        units = arguments.get("units", "celsius")
        # Fetch weather data (implementation details)
        weather = await fetch_weather(city, units)
        return [TextContent(
            type="text",
            text=f"Weather in {city}: {weather['temp']}°, "
                 f"{weather['conditions']}, "
                 f"Humidity: {weather['humidity']}%"
        )]
    raise ValueError(f"Unknown tool: {name}")

# Run with stdio transport
async def main():
    async with mcp.server.stdio.stdio_server() as (read, write):
        await server.run(read, write)

import asyncio
asyncio.run(main())

Tool Error Handling

When a tool call fails, the server should return an error result (not throw an exception that crashes the server). The error message becomes part of Claude's context, allowing it to decide how to proceed:

@server.call_tool()
async def call_tool(name: str, arguments: dict):
    try:
        result = await execute_tool(name, arguments)
        return [TextContent(type="text", text=str(result))]
    except ToolNotFoundError:
        return [TextContent(type="text", 
            text=f"Error: Tool '{name}' not found")]
    except ValidationError as e:
        return [TextContent(type="text", 
            text=f"Error: Invalid arguments - {e}")]
    except ExternalServiceError as e:
        return [TextContent(type="text", 
            text=f"Error: External service unavailable - {e}. "
                 f"You may want to retry or try an alternative approach.")]

Authentication Patterns

For remote MCP servers, authentication is critical. Common patterns:

• OAuth 2.0: The standard for web-based MCP servers. The client obtains a token through an OAuth flow and includes it in subsequent requests.
• API keys: Simpler for internal servers. The key is configured in the client settings.
• mTLS: Mutual TLS for high-security environments where both client and server authenticate via certificates.

Practice Questions — Domain 5

Domain 5 covers the operational layer of building with Claude — managing context windows, implementing retrieval-augmented generation, caching, batch processing, and handling the realities of rate limits and token economics. While it carries the lowest weight (15%), questions in this domain tend to be the most practical and directly applicable to day-to-day production work.

Context Window Architecture

Token Limits by Model

Understanding model context windows is essential for architectural decisions. As of mid-2026:

Token Economics

Tokens are the currency of Claude interactions. Every character of input (system prompt, messages, tool definitions, tool results) and output (Claude's response, tool calls) consumes tokens. Architectural decisions have massive cost implications:

• System prompts: Sent with every API call. A 2,000-token system prompt in a 20-turn conversation costs 40,000 input tokens just for the system prompt.
• Tool definitions: Each tool's JSON schema and description is included in every API call. 10 tools averaging 200 tokens each = 2,000 tokens per call.
• Conversation history: The entire message history is resent with each call. In turn 20, you are sending all 19 previous turns.

The "Lost in the Middle" Effect

Research has shown that Claude (and other LLMs) perform better on information at the beginning and end of the context window, with reduced recall for information in the middle. Mitigation strategies:

• Place critical instructions at the beginning (system prompt) and end (most recent user message) of the context
• Summarize long middle sections: Compress earlier conversation turns into summaries
• Use explicit references: When referring to earlier context, quote it directly rather than asking Claude to "recall" it
• Structure with XML tags: Clearly labeled sections are easier for Claude to navigate than unstructured text

RAG Architecture

Retrieval-Augmented Generation (RAG) is the dominant pattern for giving Claude access to large knowledge bases that exceed the context window. Instead of cramming everything into the prompt, you retrieve only the relevant chunks and include them.

The RAG Pipeline

1. Ingestion: Documents are split into chunks (typically 256-1024 tokens each)
2. Embedding: Each chunk is converted to a vector embedding using an embedding model
3. Indexing: Embeddings are stored in a vector database (Pinecone, Weaviate, pgvector, etc.)
4. Query: The user's question is embedded using the same model
5. Retrieval: The vector database finds the most similar chunks (typically top 5-20)
6. Augmentation: Retrieved chunks are inserted into the prompt as context
7. Generation: Claude generates a response grounded in the retrieved context

Chunking Strategies

Retrieval Approaches

• Semantic search: Uses embeddings to find conceptually similar content. Good for natural language queries.
• BM25: Traditional keyword-based search. Good for exact term matching, specific names, error codes.
• Hybrid retrieval: Combines semantic search and BM25, typically with a reciprocal rank fusion to merge results. This is the recommended approach for production systems because it captures both conceptual similarity and keyword precision.

Multi-Index RAG

For complex knowledge bases, use multiple specialized indexes rather than a single index. For example, a customer support system might have separate indexes for:

• Product documentation (semantic search)
• Known issues and bugs (keyword search by error code)
• Previous support tickets (hybrid search)
• API reference (structured search by endpoint path)

The query router determines which index(es) to search based on the user's question type, then merges results before passing to Claude.

Prompt Caching & Batch API

Prompt Caching

Prompt caching allows you to cache frequently reused prompt content (system prompts, tool definitions, large context blocks) so they are not re-processed on every API call.

• Cost savings: Cached tokens are billed at 10% of the base input token price
• Latency reduction: Cached content is processed faster because it does not need to be re-encoded
• Rate limit benefit: Cached tokens do not count toward the ITPM (Input Tokens Per Minute) rate limit

Cache Eligibility Rules

Content must meet specific criteria to be cacheable:

• Content must appear at the beginning of the prompt (system prompt, early messages)
• Cached content must be marked with cache control breakpoints
• The cache has a time-to-live (TTL) — content is evicted after a period of inactivity
• Minimum content size requirements apply (content must be large enough to justify caching overhead)

response = client.messages.create(
    model="claude-sonnet-4-5-20250514",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": large_system_prompt,  # 5000+ tokens
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[{"role": "user", "content": "..."}]
)

Batch API

The Batch API processes large volumes of requests asynchronously within a 24-hour processing window at 50% of the standard API cost. Design considerations:

• Use when: You have many independent requests that do not require real-time responses (bulk classification, batch extraction, mass analysis)
• Do not use when: You need real-time or near-real-time responses, or requests depend on each other's results
• Workload design: Break large datasets into individual requests, each self-contained with all necessary context
• Result retrieval: Poll for results or use a webhook callback

Rate Limiting & Production Operations

Token Bucket Algorithm

Claude's rate limiting uses a token bucket algorithm. Imagine a bucket that holds tokens (capacity) and refills at a steady rate. Each request consumes tokens from the bucket. When the bucket is empty, requests are rejected until tokens refill.

Rate Limit Dimensions

Limits vary by model class and usage tier. The exam tests whether you understand that hitting ANY one of these limits will throttle your requests — you must stay under all three simultaneously.

Server-Side Compaction

For long-running conversations, the context window eventually fills up. Server-side compaction is a technique where the system summarizes older conversation turns to free up space while preserving essential context. Implementation:

1. When the conversation reaches 80% of the context window, trigger compaction
2. Summarize all turns except the most recent N (e.g., last 5 turns)
3. Replace the old turns with a single summary message
4. Continue the conversation with the summary + recent turns

Context Rot

Context rot refers to the phenomenon where accuracy and recall degrade as the token count grows. Even within the context window limit, more tokens means more noise and more opportunities for Claude to lose track of important details. Mitigations:

• Proactive compaction (do not wait until the window is full)
• Explicit anchoring (restate critical instructions periodically)
• Modular context (separate concerns into distinct messages rather than one monolithic blob)
• Session memory strategies (external knowledge bases that persist across sessions)

Retry Strategies

Production systems must handle transient failures gracefully:

• Exponential backoff: Wait 1s, 2s, 4s, 8s, 16s between retries. This is the standard approach.
• Jitter: Add random variation to backoff times to prevent thundering herd problems when many clients retry simultaneously.
• Circuit breaker: After N consecutive failures, stop trying for a cooldown period. This prevents cascading failures.
• Fallback models: If the primary model is rate-limited, fall back to an alternative model that has available capacity.

Monitoring and Observability

Production Claude deployments should monitor:

• Token usage: Track input/output tokens per request and over time to detect anomalies
• Latency: Time-to-first-token (TTFT) and total response time
• Error rates: Rate limit errors (429), server errors (500), timeout errors
• Quality metrics: Task success rate, user satisfaction, accuracy on known-answer tests
• Cost: Track spend per feature, per user, per model to optimize resource allocation

Practice Questions — Domain 6

This practice exam simulates the CCA-F format: 60 scenario-based multiple-choice questions distributed by domain weight. Questions are distributed as: D1 Agentic Architecture (16 questions, 27%), D3 Claude Code (12 questions, 20%), D4 Prompt Engineering (12 questions, 20%), D2 Tool Design & MCP (11 questions, 18%), D5 Context & Reliability (9 questions, 15%). Click each question to reveal the answer and explanation. Use the timer to simulate exam conditions (120 minutes).

Domain 1: Agentic Architecture & Orchestration (Questions 1-16)

Domain 3: Claude Code Configuration & Workflows (Questions 17-28)

Domain 4: Prompt Engineering & Structured Output (Questions 29-40)

Domain 2: Tool Design & MCP Integration (Questions 41-51)

Domain 5: Context Management & Reliability (Questions 52-60)

Key API Parameters

Common Patterns & Anti-Patterns

Architecture Decision Flowchart

MCP Server Checklist

CLAUDE.md Template

# Project: [Project Name]

## Architecture
- Framework: [e.g., Next.js 14 with App Router]
- Database: [e.g., PostgreSQL via Drizzle ORM]
- Auth: [e.g., Clerk]
- Hosting: [e.g., Vercel]

## Directory Structure
- src/app/ — Pages and API routes
- src/components/ — Reusable UI components
- src/lib/ — Utility functions and shared logic
- src/db/ — Database schema and migrations

## Coding Conventions
- [Language/style preferences]
- [Naming conventions]
- [Error handling patterns]
- [Testing requirements]

## Important Context
- [Key architectural decisions and rationale]
- [Known limitations or technical debt]
- [Areas that require special care]

## Do NOT
- [Things Claude should never do in this project]
- [Protected files or patterns]

Prompt Engineering Checklist

Official Resources & Links

Study Plan Templates

1-Week Intensive Plan (for experienced Claude developers)

2-Week Balanced Plan

4-Week Comfortable Plan

Key Numbers to Remember