MCP Server Primitives Explained: Prompts, Resources, and Tools

  

Modern language models are powerful, but their true potential is unlocked when they can interact with structured context and real world systems. This is where MCP servers come into play. They act as the bridge between users, applications, and language models by providing well-defined primitives that enable richer, more meaningful interactions. Instead of treating the model as a standalone entity, MCP introduces a structured way to guide, inform, and empower it.

 

At the core of MCP servers are three fundamental building blocks Prompts, Resources, and Tools. Each of these primitives operates at a different level of control and responsibility, allowing systems to balance user intent, application context, and model autonomy effectively.

 

 

1. Overview

Servers form the foundation for adding contextual intelligence to language models through MCP. They enable structured communication between clients, servers, and models, transforming simple text generation into dynamic, context-aware interactions.

 

These interactions are powered by three key primitives:

 

·      Prompts: Predefined templates or instructions that guide how the model responds. These are typically user-driven and help standardize common interaction patterns.

·      Resources: Structured data or contextual information supplied by the application. This ensures the model operates with relevant, up-to-date knowledge.

·      Tools: Executable functions that the model can invoke to perform actions or fetch external data, extending its capabilities beyond text generation.

 

Together, these primitives create a powerful abstraction layer that separates concerns while enabling seamless collaboration between different components of the system.

 

2. Control Hierarchy of Primitives

Each primitive operates under a different control model, ensuring clear ownership and responsibility:

 

·      Prompts (User-controlled): These are explicitly triggered by users and shape how the interaction begins.

Examples: Slash commands, UI-driven templates

 

·      Resources (Application-controlled): These are managed by the client or application and provide relevant context automatically.

Examples: File contents, database records, Git history

 

·      Tools (Model-controlled): These are functions exposed to the model, allowing it to take actions autonomously when needed.

Examples: API calls, writing to files, triggering workflows

 

3. User defines intent and Prompt helps how that intent is executed

Sometimes the user writes everything manually. Sometimes they choose a template (prompt) and fill in a few inputs.

 

3.1 Direct Intent (No Template)

User types "Summarize this Git commit history in simple terms".

 

Here:

·      Intent = Summarize commit history

·      Prompt = Fully written by user

·      No predefined structure

 

3.2 Intent via Prompt Template

Now imagine your system provides a predefined prompt:

 

Prompt Template: /summarize-code

Summarize the following code changes:

- Focus on key modifications

- Highlight breaking changes

- Keep it under {{length}} words

 

User Interaction

User selects: /summarize-code and then provide below input:

 

Length = 100 words

 

Then it summarize the code changes.

 

3.3 More Business-Oriented Case

Prompt Template: /generate-report

Generate a report for:

- Data source: {{source}}

- Time range: {{range}}

- Include insights and anomalies

 

User Action

User selects /generate-report and fills:

 

·      Source = Sales DB

·      Range = Last 7 days

 

Interpretation:

·      Intent = Analyze sales performance

·      Prompt = Standardized report structure

·      User role = Supplies parameters, not full instrucion

 

Here user doesn’t always write the full prompt, they often choose a prompt that already encodes best practices, and simply provide inputs.

 

In summary, users define intent either by writing instructions directly or by selecting predefined prompts. These prompts act as reusable templates that standardize how the intent is communicated to the model. For example, instead of writing a full instruction to summarize code changes, a user might trigger a /summarize-code prompt and provide only the necessary inputs like file content or desired length. This approach ensures consistency while reducing cognitive load on the user

Previous                                                    Next                                                    Home