Build & submit taskBetaintermediate

Build a Full MCP Server and Connect Claude as a Client

Build a complete Model Context Protocol server exposing tools, resources, and prompts, then connect Claude to it as an MCP client. Handle project-vs-user configuration with env-var secrets, and design token-efficient tool results with pagination so large outputs do not blow the context. Submit a single script or notebook for instant, rubric-based feedback.

3 hrs

Est. time

Outcomes

Rubric criteria

65%

Pass score

What you'll learn

Skills you'll have real reps in after shipping this.

The full MCP surface

MCP servers expose tools, resources (readable data), and prompts (reusable templates), not just tools.

The client side

Claude consumes an MCP server by opening a session, listing capabilities, and calling tools or reading resources.

Configuration levels

Project-level config (committed) is shared by the team; user-level config is personal. Secrets always come from the environment.

Token-efficient results

Large tool results must be paginated or trimmed, or a single call can flood the context and degrade the agent.

See how it works

The MCP surface

model context protocol (MCP)

integrations

3 + 3 = 6

add a new tool

one server, all agents get it

One standard interface instead of N×M glue. Without a standard, every agent integrates every tool with its own custom code, so three agents and three tools is nine bespoke integrations, and a new tool means wiring it into each agent. The Model Context Protocol puts tools behind one standard server interface, so any MCP-speaking agent can talk to any MCP tool server. Three plus three becomes six, and a new tool server is instantly usable by every agent. The leverage is ecosystem-wide: tools become portable instead of welded to one app.

An MCP server publishes tools, resources, and prompts. A client lists them and calls in, with configuration and secrets supplied at the boundary.

Token-efficient results

dispatch a tool call

tools: add, upper, neg

model proposes

↓ your code dispatches ↓

{ "result": 5 }

valid call to a real tool (5)

■ result■ unknown_tool■ bad_args

You run the tool; the model only asks. The model never executes anything. It proposes a name and arguments, and your dispatcher checks the tool exists, calls it, and wraps the return value. Its two mistakes both land here: a tool it invented becomes unknown_tool, and arguments that do not fit become bad_args instead of an exception that kills the run. Catching them in the act step is what lets the agent observe the error and try again, rather than crashing on the first imperfect decision.

A tool that returns an entire dataset floods the context. Pagination and limits keep each result small enough for the agent to use.

The scenario

Your team wants to expose an internal system (a docs store, a ticketing API) to Claude through MCP so any client can use it. The first attempt exposed three tools and nothing else, returned entire 50-kilobyte documents in a single tool result that swamped the context, and hardcoded the credentials.

You are going to build the server properly: tools, resources, and prompts, consumed by Claude as a real MCP client, configured at the right level with secrets from the environment, and returning results that are paginated and trimmed so they stay token-efficient.

Your role

You are a Claude solutions architect building an MCP integration end to end. Your deliverable is one module with a complete MCP server, a Claude client that consumes it, correct configuration, and token-efficient result design.

Start the task to unlock the full brief

You'll get the step-by-step requirements, setup commands, the 6-criterion grading rubric, tips, and the ability to submit your solution for instant AI grading.

Free to start · submit when you're ready

Learning resources

Model Context Protocol

Tools, resources, and prompts in MCP.

modelcontextprotocol.io

MCP Python SDK

FastMCP server plus the client session API.

github.com

Anthropic API: tool use

Driving tool calls from Claude.

docs.anthropic.com

What you'll build in this MCP server suite task

This is a build-and-submit task, not a guided lab. You build a complete Model Context Protocol integration: a server exposing tools, resources, and prompts, consumed by Claude as a real MCP client, configured at the right level with secrets from the environment. The deliverable is one Python module that shows the full protocol surface working end to end.

The depth here is what production MCP integrations actually require. You expose more than tools, you drive the client side rather than assuming it, you separate project from user configuration, and, critically, you design tool results to be token-efficient with pagination and limits so a single large response cannot swamp the context window and degrade the agent.

Grading is rubric-based and explainable. Your submission is scored against weighted criteria (SDK setup, the full server surface, the client, configuration levels, token-efficient results, and the demonstration) with per-criterion feedback quoted from your code. The pass threshold is 65 percent and you can resubmit. These are the MCP integration skills the Claude Certified Architect exam tests.

Frequently asked questions

How is this different from the tool and MCP design task?

That task focuses on tool design and tool_choice with a basic MCP server. This one goes deeper into MCP itself: resources and prompts as well as tools, the client side, project-vs-user configuration, and token-efficient result design with pagination.

Why paginate tool results?

A tool that returns a whole dataset or a 50-kilobyte document in one result floods the context window, costs tokens, and degrades the agent. Returning a bounded slice with a cursor or has_more flag keeps each result usable.

Do I need a remote server?

No. A local MCP server built with the official SDK, consumed by a local client session, is enough to demonstrate the full surface (tools, resources, prompts) and the configuration and result-design patterns.

What counts as a complete submission?

A single .py or .ipynb with an MCP server exposing tools, a resource, and a prompt; Claude connecting as an MCP client; project-vs-user configuration with env secrets; token-efficient paginated results; and a demonstration of Claude using a tool and a resource through MCP.