Practical MCP with FastMCP & LangChain

Primitives vs Capabilities vs Utilities

We have used the term "features" to refer to the various types of interactions in MCP, such as tools, resources, prompts, logging, pagination, completion, sampling, elicitation, and roots. To be more precise, we can categorize these features into three groups: primitives, capabilities, and utilities.

Primitives

Primitives are the fundamental building blocks of interaction in MCP. They define the core kinds of things that can be exchanged between a client and a server.

On the server side, the main primitives are:

• Tools (actions that can be executed)
• Resources (read-only data that can be accessed)
• Prompts (structured conversation templates)

On the client side, the main primitives are:

• Sampling (delegating model generation)
• Elicitation (asking the user for input)
• Roots (defining filesystem boundaries)

Capabilities

The term "capabilities" is often used interchangeably with "primitives" which is fine in most contexts, but there's a subtle nuance.

In MCP, capabilities describe what a client or server can do at the protocol level, they are declared during the handshake/initialization phase of the connection as part of a negotiation process to say "I support these features". For example, a server might declare that it supports:

• Tool execution
• Resource listing
• Sending notifications when the tool config changes
• and so on.

Utilities

Utilities are supporting protocol mechanisms that enhance how primitives behave, but are not core interaction types themselves.

They improve usability, performance, and observability.

Examples include:

• Logging, which allows structured messages to flow from server to client. This is a server-side utility.
• Pagination, which allows large lists to be split into manageable chunks. This is a server-side utility.
• Completion, which helps users fill arguments interactively. This is a server-side utility.
• Cancellation, which allows stopping in-progress requests. This is a server and client-side utility.
• Ping, which allows checking connectivity. This is a server and client-side utility.
• Progress, which allows tracking long-running operations. This is a server and client-side utility.
• Tasks, which allow handling long-running operations asynchronously. This is a server and client-side utility.

Utilities do not represent actions or data themselves. Instead, they support and refine how primitives operate.

Putting It All Together

The following table presents a summary of each feature, its category and whether it is server- or client-side: