Read and write JSON-RPC requests, responses, notifications, identifiers, parameters, result objects, and error objects. Practice tracing a short MCP conversation from raw messages.

Follow MCP from its original release through protocol versioning, wider ecosystem adoption, remote transports, stronger authorization, and extension support. See why MCP complements rather than replaces ordinary APIs and model tool calling.

Handle initialization, protocol-version agreement, capability declarations, readiness notifications, health checks, and orderly connection closure. Detect incompatible peers without leaving a session in an uncertain state.

Represent text, images, audio, embedded resources, resource links, and structured data in protocol messages. Design JSON Schema definitions that give models clear inputs while remaining practical for applications to validate.

Compare local standard-input/output connections with remote Streamable HTTP sessions, including streaming responses, session identifiers, resumability, and reconnection. Recognize legacy HTTP-and-SSE implementations and plan safe migrations.

Publish callable operations with precise names, descriptions, input schemas, output schemas, annotations, and structured results. Build tools that validate arguments, report failures clearly, and avoid misleading the model about side effects.

Expose files, records, documentation, and application state through resource URIs, metadata, MIME types, and resource templates. Implement resource listing and reading without turning every data access into a tool call.

Create reusable prompt definitions with named arguments, messages, roles, and embedded content. Design prompts as user-selectable workflows rather than hidden instructions controlled by the server.

Implement list operations, cursors, argument completion, and discovery interfaces for large catalogs of tools, resources, and prompts. Keep discovery responsive as an MCP server grows.

Let servers request the filesystem or workspace boundaries that a client is willing to expose. Handle root changes carefully and keep server access inside approved locations.

Allow a server to request model generations through its connected client while preserving user control over model choice, context, costs, and tool use. Build a safe sampling loop and inspect the messages exchanged at each step.

Request missing information or approval from a user through structured forms and external URL flows. Validate responses, support cancellation, and avoid using elicitation to collect secrets in unsafe ways.

Coordinate asynchronous work with notifications, progress tokens, cancellation requests, and list-change events. Make long operations responsive without sending invalid or duplicated terminal results.

Emit useful protocol logs, choose appropriate severity levels, and return errors at the correct layer. Separate JSON-RPC failures, protocol errors, tool execution failures, and user-facing messages.

Set up an official MCP SDK, inspect generated types, and use MCP Inspector to connect, negotiate capabilities, invoke tools, and read resources. Compare SDK conveniences with the underlying protocol messages they produce.

Build a local server around a small real data source, then add tools, resources, prompts, validation, logging, and graceful failure behavior. Connect it over standard input/output and verify it with an inspector and an existing host.

Build a client that discovers server capabilities, lists primitives, invokes tools, reads resources, retrieves prompts, and handles notifications. Add connection state, timeouts, cancellation, and clear user approval points.

Design a host that manages one client connection per server, selects relevant capabilities, assembles model context, executes tool-use loops, and presents consent decisions. Address context limits, duplicate capabilities, and untrusted server output.

Turn a local implementation into a Streamable HTTP service with session management, streaming, reconnection, origin checks, and stateless or stateful operation. Test behavior across connection loss and multiple concurrent clients.

Protect remote servers with OAuth-based discovery, authorization-server metadata, protected-resource metadata, PKCE, resource indicators, scopes, and token validation. Distinguish MCP authorization from authentication inside the underlying business system.

Defend against prompt injection, confused-deputy attacks, token passthrough, command injection, path traversal, SSRF, malicious schemas, DNS rebinding, and excessive permissions. Apply least privilege, explicit consent, sandboxing, origin validation, and secure secret storage.

Set rules for collecting, retaining, transmitting, and deleting user data that passes through hosts and servers. Add disclosure, audit records, redaction, tenant separation, and controls for sensitive resources and model providers.

Write unit, integration, transport, and adversarial tests for MCP implementations. Use mock peers, malformed messages, capability matrices, protocol-version fixtures, and conformance checks to catch interoperability failures.

Package servers reproducibly, pin dependencies, sign or verify release artifacts, and generate software bills of materials. Reduce risks from compromised packages, install scripts, server updates, and unreviewed third-party code.

Deploy remote servers behind suitable gateways and load balancers while preserving streaming and session behavior. Add structured logs, traces, metrics, rate limits, health checks, back-pressure, rollout controls, and incident procedures.

Represent operations that outlive a single request with task creation, status tracking, result retrieval, cancellation, and retention policies where supported by the protocol version in use. Design fallbacks for peers that do not advertise task support.

Create interactive interfaces delivered through MCP App resources and connected to server capabilities. Apply isolation, content security policy, permission boundaries, and graceful fallback for hosts without app-extension support.

Prepare metadata, installation instructions, configuration requirements, and trust information for publishing a server. Work with registries and package ecosystems while treating discovery as separate from endorsement or security review.

Connect several servers without losing provenance, permission boundaries, or predictable naming. Design gateways, adapters, and compatibility layers for existing APIs while preventing capability collisions and accidental privilege expansion.

Carry a real integration from requirements and threat modeling through schema design, server implementation, client or host connection, authorization, testing, deployment, monitoring, and maintenance. Deliver working code, protocol traces, documentation, and a security review.

Map MCP skills to server engineering, client and host development, platform work, security review, developer relations, and open-source maintenance. Build a proof-of-skill portfolio, assess third-party implementations, follow specification changes, and contribute through proposals, issues, tests, and SDKs.