Skip to main content
VTFriday

Understanding MCP Primitives: Tools, Resources, and Prompts Explained

Updated

Source: https://www.vtfriday.com/2026/10/understanding-mcp-primitives-tools.html

⚡ 1-Minute Summary (Key Points)
  • The Model Context Protocol (MCP) is an open standard that lets AI models like Anthropic's Claude and Salesforce Agentforce safely plug into external business databases and apps.
  • Every MCP server is built on three foundational building blocks (called primitives): Tools, Resources, and Prompts.
  • Tools are executable actions controlled by the AI model (e.g., creating a Salesforce Lead or running a live SOQL search).
  • Resources are read-only files and context controlled by the application (e.g., reading an Account profile or PDF contract).
  • Prompts are pre-built instruction templates controlled by the user (e.g., a slash command that formats an executive sales briefing).
  • The Golden Memory Trick: Tool = DO (Model-Controlled), Resource = KNOW (App-Controlled), Prompt = GUIDE (User-Controlled).
  • With Salesforce's native MCP support in Agentforce and MuleSoft, enterprise architects can combine all three primitives to build secure, reusable AI workflows without writing custom glue code from scratch.
💬 In Plain Words: The AI Worker Sitting at a Desk
Imagine hiring a brilliant human assistant (Claude or an Agentforce Agent) and sitting them down at an office desk.

• A Tool is something the worker can physically DO—like picking up the phone, sending an email, or clicking "Save" on a new Salesforce Opportunity.
• A Resource is reference material the worker can KNOW—like opening a printed customer folder sitting on the desk to read their past purchase history.
• A Prompt is the standard operating checklist that GUIDES their output—like a company rulebook showing the exact three paragraphs required in a weekly sales summary.

🗺️ Module Map: Claude & Enterprise AI Foundation

CLAUDE & ENTERPRISE AI FOUNDATION
├── What Is Claude?
├── Claude Model Families
├── Claude Reasoning & Extended Thinking
├── Claude Tool Use
├── Autonomous AI Agents
├── Model Context Protocol (MCP) Overview
├── MCP Client-Server Architecture
├── MCP Security, Trust & Governance
├── Claude + MCP + Salesforce Agentforce
├── Tools, Resources & Prompts 📍 (You are here)
└── Claudeforce Reference Architecture
  
📌 Quick Example: Preparing for a Big Customer Pitch
Suppose a Sales Director opens their AI assistant and asks: "Prepare me for tomorrow's renewal meeting with ABC Healthcare." Here is how MCP splits the heavy lifting behind the scenes:
  • 📄 The Resource (KNOW): Attaches the static account background (company size, industry tier, and signed master service agreement).
  • 🛠️ The Tool (DO): Reaches into Salesforce in real time to query open support cases, active opportunities, and yesterday's call logs.
  • 📝 The Prompt (GUIDE): Applies your company's standardized "Executive Renewal Briefing" template so the AI doesn't ramble.
Claude's reasoning engine blends all three inputs together to deliver a boardroom-ready brief in seconds.

🎬 Real-Life Scenario: The Overwhelmed Sales Analyst

The Business Problem:
Sarah is an Enterprise Account Executive preparing for a high-stakes QBR (Quarterly Business Review). Normally, she wastes 45 minutes clicking through ten Salesforce tabs, downloading PDFs from SharePoint, and formatting a briefing doc.

The MCP-Powered Solution:
Instead of tab-hopping, Sarah triggers an MCP workflow connected to Salesforce:

1. Prompts (User-Controlled): Sarah selects the /qbr-prep slash command template in her AI workspace.
2. Resources (App-Controlled): The MCP server automatically attaches ABC Healthcare's static Account_Profile.json and contract renewal terms as read-only context.
3. Tools (Model-Controlled): Realizing it needs live pipeline numbers, the AI autonomously invokes the get_open_opportunities and log_prep_task tools against Salesforce.
4. AI Reasoning: Claude spots a high-severity open support ticket returned by the Tool, cross-references it with the SLA rules in the Resource, and highlights it at the very top of the Prompt's output layout.

Key Architectural Takeaway: In the Model Context Protocol, not everything is a Tool. Separating passive data (Resources), active system changes (Tools), and formatting instructions (Prompts) keeps your enterprise AI fast, predictable, and secure.

🧠 Core Concepts: Deep Dive into the 3 MCP Primitives

When an MCP Client (like Claude Desktop, Cursor, or Salesforce Agentforce) connects to an MCP Server, they communicate using JSON-RPC 2.0 messages. To keep boundaries crystal clear, the official MCP specification divides server capabilities into three distinct primitives—each with its own controller and security model.

🛠️ 1. MCP Tools — The "DO" Layer (Model-Controlled)

An MCP Tool is an executable function exposed by the server via the tools/list and tools/call endpoints. Think of Tools as POST or GET API endpoints that the AI model can decide to call on its own whenever it needs live data or wants to change a record in an external system.

  • Who controls it? The AI Model. Based on the user's conversation, Claude decides when and how to call a Tool (often with a human approval prompt for sensitive actions).
  • Common Salesforce Use Cases: Running a dynamic SOQL search for open Opportunities, creating a new Task or Case record, updating an Opportunity stage, or firing a Slack alert to an account team.

How it looks in code: Every Tool requires a strict JSON Schema so the AI knows exactly what parameters to pass.

{
  "name": "search_salesforce_opportunities",
  "description": "Queries live Salesforce Opportunities by account ID and minimum deal amount.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "account_id": { "type": "string", "description": "18-character Salesforce Account ID" },
      "min_amount": { "type": "number", "description": "Minimum Opportunity Amount in USD" }
    },
    "required": ["account_id"]
  }
}

📄 2. MCP Resources — The "KNOW" Layer (Application-Controlled)

An MCP Resource is read-only, file-like data exposed by the server via resources/list and resources/read. Every resource is identified by a unique URI (Uniform Resource Identifier), working just like a web URL or file path.

  • Who controls it? The Host Application or User. The client app decides how to fetch and attach resources into the AI's context window (for example, when a user attaches a file or selects an Account from a dropdown menu).
  • Common Salesforce Use Cases: Reading a static customer profile (salesforce://account/0015g00000XYZ), viewing Salesforce Object metadata schemas, reading a Knowledge Base article, or inspecting a product pricing sheet.

Crucial Security Boundary: Resources are strictly passive and free of side effects. Giving an AI model access to read a Resource never grants it permission to edit, delete, or trigger workflows on that data.

📝 3. MCP Prompts — The "GUIDE" Layer (User-Controlled)

An MCP Prompt is a pre-written, parameterized instruction template stored on the server and exposed via prompts/list and prompts/get. Instead of forcing every sales rep to learn complex prompt engineering, architects build reusable MCP Prompts on the server that anyone can trigger with a simple click or slash command.

  • Who controls it? The User. A human explicitly picks a Prompt from the UI menu (like typing /customer_review) and fills in the required blanks.
  • Common Salesforce Use Cases: Standardizing Apex code review checklists, formatting P1 incident post-mortems, or enforcing a 3-paragraph executive briefing layout across an entire global sales team.

Important Distinction: A Prompt provides the instructions and structure—it does not hold live business data by itself. Instead, a Prompt often tells the AI how to analyze the data pulled from Resources and Tools.

🔄 How MCP Maps to Salesforce Agentforce

If you work in the Salesforce ecosystem, you have likely used Prompt Builder, Data Cloud, and Agentforce Actions. In recent Salesforce releases, Salesforce adopted the Model Context Protocol (MCP) natively inside the Agentforce platform and MuleSoft. This means Agentforce can act as an MCP Client to consume external MCP servers, and you can also expose Salesforce capabilities to external AI models like Claude.

Here is how the three MCP primitives map directly to Salesforce Agentforce concepts:

  • MCP Tool ↔ Agentforce Custom Action: Just like an MCP Tool executes code, an Agentforce Action invokes an Autolaunched Flow, an Apex InvocableMethod, or a MuleSoft API to create or update records.
  • MCP Resource ↔ Data Cloud Grounding / Knowledge: Just like an MCP Resource feeds read-only context via a URI, Agentforce uses Data Cloud Vector Search (RAG) and Salesforce Knowledge articles to ground the AI in factual company data.
  • MCP Prompt ↔ Salesforce Prompt Builder Template: Just like an MCP Prompt accepts variables to standardize instructions, Prompt Builder uses merge fields to create reusable, governed prompt templates across your org.

🧩 Step-by-Step Execution Flow: Putting All 3 Together

Let's trace the exact technical lifecycle when all three primitives team up inside a single conversation:

1. USER ACTION: Selects the "/meeting_prep" MCP Prompt for "ABC Healthcare"
   ↓
2. PROMPT (User-Controlled): Injects the standardized 3-section briefing instructions
   ↓
3. RESOURCE (App-Controlled): Client attaches read-only URI `customer://ABC-10025` (Account History)
   ↓
4. CLAUDE REASONING: Reads Prompt + Resource, realizes it needs live pipeline numbers
   ↓
5. TOOL CALL (Model-Controlled): Claude executes `search_opportunities(account_id="ABC-10025")`
   ↓
6. CLAUDE SYNTHESIS: Combines the Resource background + live Tool results using the Prompt layout
   ↓
7. FINAL OUTPUT: Delivers the finished Executive Briefing & calls `create_task` Tool to log prep
  
🧭 360 Card — MCP Tools, Resources & Prompts

Rule: Always match the MCP primitive to the right control boundary. Never build an executable Tool when a read-only Resource is all you need.
Gain: Gives you a clean separation between passive data (KNOW), active mutations (DO), and prompt engineering (GUIDE). Drastically reduces AI hallucinations and security risks.
Price: Requires upfront architectural design. You must define strict JSON schemas for Tools, URI structures for Resources, and role-based permissions.
Limits: A Resource can never modify system state. A Prompt cannot fetch live database records on its own. Tools require strict least-privilege scoping and human-in-the-loop guardrails for destructive actions.
Quick Mirror: Tool = DO (Model) | Resource = KNOW (App) | Prompt = GUIDE (User)
Connects to: Anthropic Claude, Salesforce Agentforce, Prompt Builder, MuleSoft MCP Connectors, and Enterprise AI Governance.
⚠ INTERVIEW TRAP & COMMON ARCHITECT MISTAKES

❌ Wrong: "Everything an MCP Server exposes to Claude is called a Tool."
✅ Correct: "MCP Servers expose three distinct primitives: Tools (executable functions), Resources (read-only context URIs), and Prompts (reusable instruction templates). Each has a different controller."

❌ Wrong: "I will use an MCP Resource to update the Opportunity Stage in Salesforce."
✅ Correct: "Resources are strictly read-only, side-effect-free context (like a GET request for a static file). To insert, update, or delete a Salesforce record, the AI must invoke an MCP Tool."

❌ Wrong: "The MCP Prompt stores all of our live customer database records."
✅ Correct: "The Prompt only stores the reusable instructions and formatting structure. Live customer data is dynamically fed into the conversation via Resources or fetched on demand via Tools."

💡 Core Q&A (Must-Know Concepts)

Q1: What is the fastest way to remember the difference between Tools, Resources, and Prompts in an interview?

A: Lead with the action verb and who controls it:
• Tool = DO (Model-Controlled): Executable capabilities the AI calls to fetch live data or change records.
• Resource = KNOW (Application-Controlled): Read-only files or records attached as passive background context.
• Prompt = GUIDE (User-Controlled): Pre-built instruction templates triggered by the user to standardize how the AI responds.

Q2: Can a single enterprise AI workflow use all three MCP primitives at the exact same time?

A: Absolutely—and the best enterprise architectures do exactly that. A user triggers a Prompt to set the formatting rules, the host application attaches a Resource with static account context, and the AI model calls a Tool to pull live Salesforce metrics or log a follow-up task.

Q3: What is a Resource Template in MCP, and how is it different from a static Resource?

A: While a static Resource points to one fixed file (like docs://company_policy.pdf), a Resource Template uses URI variables (following RFC 6570) such as salesforce://account/{account_id}/summary. This lets the client application dynamically pull read-only context for any specific Salesforce Account ID without turning it into an executable Tool.

Q4: Who actually executes the code when Claude calls an MCP Tool?

A: Claude never executes your code directly on Anthropic's servers. When Claude decides to use a Tool, it simply outputs a structured JSON request saying, "Please run search_opportunities with these parameters." Your MCP Client intercepts that request, passes it to your secure MCP Server (which runs inside your firewall or Salesforce org), executes the API call, and sends the plain-text result back to Claude.

🔗 Connecting the Dots (Follow-Up Scenarios)

Scenario 1: A sales rep types, "Create a follow-up task for ABC Healthcare due tomorrow." Which MCP primitive handles this?

A: A Tool. Creating a Salesforce Task writes new data to the database and changes system state. The AI model will invoke an executable Tool like create_salesforce_task.

Scenario 2: Before drafting a cold email, the AI needs to read your company's official "Compliance & Tone Guidelines" PDF. Which primitive fits best?

A: A Resource. A compliance manual is static, read-only reference material. Exposing it via a Resource URI (like policy://compliance-guidelines) lets the application inject those rules into context without running any custom code.

Scenario 3: Your VP of Sales demands that every AI-generated deal summary follows the exact same 4-bullet MEDDIC format. Which primitive solves this?

A: A Prompt. By publishing a centralized meddic_deal_summary Prompt on your MCP server, any rep can select it from their menu and get the exact 4-bullet layout every single time—without having to copy-paste instructions.

Scenario 4: How does MCP connect with Salesforce Agentforce in a real enterprise architecture?

A: Salesforce supports MCP natively across the Agentforce platform. Earlier, connecting an Agentforce agent to an external system (like Jira, GitHub, or an internal ERP) required building custom Apex callouts from scratch. Now, Agentforce can act as an MCP Client and plug directly into any pre-built MCP Server, automatically discovering its Tools and Resources while still enforcing strict Einstein Trust Layer guardrails and Salesforce user permissions.

Scenario 5: From a cybersecurity perspective, why is separating Tools from Resources such a big deal?

A: It comes down to blast radius and least privilege. Because Resources are strictly read-only, you can safely allow an AI agent to read dozens of Resources with zero risk of corrupting your database. Tools, however, can modify records, trigger emails, or delete data. By isolating Tools, security architects can put strict human-in-the-loop approval gates (requiring a user to click "Approve" before execution) on high-risk Tools while letting read-only Resources flow smoothly.

Scenario 6: When both a Resource and a Tool can read data from Salesforce, how do I choose which one to build?

A: Ask yourself: Who knows what data is needed first—the user/app, or the AI? If the user is already viewing a specific Account page in their app and you want to automatically attach that Account's baseline profile, use a Resource. If the AI needs to dynamically search, filter, or figure out what records to look up mid-conversation based on complex reasoning (like searching for all overdue deals over $50k), build a Tool.

🎯 Key Takeaway: The Ultimate Enterprise AI Formula
Tools (DO / Model-Controlled) + Resources (KNOW / App-Controlled) + Prompts (GUIDE / User-Controlled)
↓
Fed into Claude or Salesforce Agentforce Reasoning Engine
↓
Executes a Governed, Secure Enterprise Workflow.

In Salesforce Terms: Resource = Customer Context & Knowledge | Tool = Flow / Apex Action | Prompt = Prompt Builder Template.

Sources and Official References:
This architectural guide aligns with the latest official Model Context Protocol (MCP) specification and Salesforce Agentforce developer documentation.
• Official MCP Specification: Core Architecture: Tools, Resources, and Prompts
• Salesforce Official Docs: Salesforce Agentforce & Model Context Protocol Integration
• Anthropic Documentation: Model Context Protocol (MCP) in Claude

Was this article helpful?

Have a question or spotted a mistake? Ask here about this article

Found this guide useful? Buy me a coffee (opens in a new tab)

Comments

Questions, corrections and your own experience are all welcome.