Prompt Template

The core of a prompt template is its textual structure, which contains placeholder variables (often denoted with curly braces like {variable_name}). This text defines the instruction's format, tone, and logical flow. The variables act as slots to be filled with specific data by the client, enabling dynamic prompt generation without rewriting the core instruction each time.

• Example: Summarize the following customer feedback: {feedback_text}
• Purpose: Separates the reusable instruction logic from the volatile contextual data.

Every variable in the template is formally defined by an input JSON Schema. This schema specifies the expected data type (string, number, array), any validation rules (format, enum, pattern), and a human-readable description for each parameter. This ensures the client provides valid, well-structured inputs before prompt assembly.

• Key Fields: type, description, enum (for constrained choices).
• Function: Guarantees type safety and provides clear documentation for template consumers.

A prompt template includes metadata that describes its purpose and usage. This always includes a unique name and a clear description of what the template does and when to use it. This metadata is crucial for tool discovery within an MCP ecosystem, allowing clients and developers to search for and understand available prompts.

• Essential Metadata: name, description.
• Optional Metadata: categories, version, author.

The rendering process is executed by the MCP client. The client retrieves the template definition from the server, validates the provided arguments against the input schema, and then performs string interpolation to substitute the variables with the actual values. The result is a complete, ready-to-use prompt string that is sent to the language model.

• Process Flow: Fetch Template → Validate Inputs → Interpolate Variables → Send to LLM.
• Benefit: Centralizes prompt logic on the server while allowing decentralized, contextual execution.

Prompt templates often define the role of the generated text within a chat-based LLM API (e.g., OpenAI's Chat Completions). A template may be designed to produce a system message (setting high-level behavior and constraints) or a user message (posing a specific query). This role is typically implied by the template's structure and documented in its description.

• System Template Example: You are a helpful assistant for {company_name}. Always respond in a {tone} tone.
• User Template Example: Based on the {document_type} provided, answer: {question}

Prompt templates are rarely used in isolation. A powerful pattern involves chaining MCP capabilities: a client first invokes a tool or reads a resource to fetch data, then uses that data to populate a prompt template. For example, a get_customer_record tool provides data that fills variables in a summarize_account prompt template.

• Pattern: Tool/Resource Call → Data Extraction → Prompt Rendering → LLM Query.
• Value: Creates deterministic, data-grounded workflows where the prompt is the final assembly point for context.

An MCP Server is a process that implements the Model Context Protocol to expose capabilities to an AI client. It acts as the source for prompt templates, tools, and resources.

• Hosts Templates: Stores and serves reusable prompt templates via the MCP prompt interface.
• Defines the Namespace: Provides the unique URIs for its prompts and resources (e.g., prompt://server-name/template-id).
• Handles Requests: Listens for client connections over a defined transport (stdio, SSE) and responds to prompts/get requests with the template text and its input schema.

An MCP Client is the AI application (e.g., an AI assistant or IDE plugin) that connects to MCP servers. It is the consumer of prompt templates, responsible for variable substitution and execution.

• Retrieves Templates: Calls the prompts/get method on a connected server to fetch a specific template.
• Performs Variable Substitution: Replaces placeholders (e.g., {{customer_name}}) in the template with concrete values from the user's context.
• Generates Final Prompt: Sends the fully rendered text to the language model for completion or action.

A Tool Definition is the formal specification for an executable function exposed by an MCP server. While distinct from prompts, tools and prompts are complementary MCP capabilities.

• Structured vs. Unstructured: A tool definition uses a strict JSON Schema to define its input parameters, ensuring type-safe execution. A prompt template produces unstructured text instructions.
• Execution vs. Instruction: A tool is invoked to perform an action (call an API, run code). A prompt template is used to construct an instruction for an LLM.
• Common Use Case: A prompt template might instruct an LLM on when and how to call a tool defined in the same MCP server.

Context Injection is the core process enabled by MCP, where an AI client dynamically inserts external information into a model's context window. Prompt templates are a primary mechanism for this.

• The Template's Role: A prompt template defines the structure for the injection, specifying where dynamic data (from resources or user input) should be placed within an instruction.
• Beyond Static Prompts: Moves from hardcoded system messages to templates that can be populated with live database queries, API results, or user-specific variables.
• Enables Grounding: This process is fundamental to Retrieval-Augmented Generation (RAG), where retrieved documents are injected via templates to ground the model's responses in factual data.

JSON Schema is a declarative language for validating the structure and data types of JSON objects. In MCP, it is used to define the expected inputs for both tools and prompt templates.

• Template Input Contract: When an MCP server defines a prompt, it can include an inputSchema. This schema specifies the variables the client must provide (e.g., query: string, count: integer).
• Enforces Correctness: The client validates user-provided values against this schema before performing variable substitution, preventing malformed prompts.
• Enables Discovery: The schema provides a machine-readable description of what a template needs, allowing clients to intelligently collect or request the necessary information from the user.