AI, AI Strategy, DP-800, Microsoft Certification, SQL

Configure model and Model Context Protocol (MCP) tool options in a GitHub Copilot or Copilot in Fabric chat session – Part 2 (DP-800 Exam Prep)

Part 2 – Configuring Model Context Protocol (MCP) Tool Options

This post is a part of the DP-800: Developing AI-Enabled Database Solutions Exam Prep Hub.
This topic falls under these sections:
Design and develop database solutions (35–40%)
   --> Design and implement SQL solutions by using AI-assisted tools
      --> Configure model and Model Context Protocol (MCP) tool options in a GitHub Copilot or Copilot in Fabric chat session

Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.

Introduction

The DP-800 exam expects candidates to understand how modern AI assistants can securely interact with external tools and enterprise systems through the Model Context Protocol (MCP). Rather than being limited to answering questions from their built-in knowledge, AI assistants can use MCP to retrieve live information, interact with databases, execute approved operations, and integrate with enterprise development workflows.

Understanding MCP is becoming increasingly important because Microsoft is integrating MCP support across GitHub Copilot, Azure services, Microsoft Fabric, and other AI-powered development experiences.

Learning Objectives

After studying this article, you should be able to:

  • Explain the purpose of Model Context Protocol (MCP)
  • Understand the components of an MCP architecture
  • Differentiate between models and tools
  • Explain MCP servers, tools, resources, and prompts
  • Configure MCP tool usage within GitHub Copilot
  • Understand how Copilot in Fabric uses MCP-enabled tools
  • Recognize security implications of MCP
  • Apply governance best practices
  • Identify common DP-800 exam scenarios involving MCP

What Is Model Context Protocol (MCP)?

Model Context Protocol (MCP) is an open protocol that enables AI assistants to securely connect to external tools, applications, services, databases, and other data sources using a standardized interface.

Before MCP, AI assistants were generally limited to:

  • their training data
  • information provided in prompts
  • uploaded files
  • conversation history

With MCP, an AI assistant can also interact with external systems in real time.

For example, instead of merely explaining how to query a SQL database, an MCP-enabled assistant can:

  • inspect a database schema
  • retrieve table metadata
  • read documentation
  • query approved data sources
  • access REST APIs
  • invoke external business services

This allows AI to generate responses based on current information rather than relying solely on previously learned knowledge.

Why MCP Exists

Organizations typically use dozens or hundreds of systems, such as:

  • Azure SQL Database
  • SQL Server
  • Microsoft Fabric
  • Azure Storage
  • Azure AI Search
  • GitHub repositories
  • SharePoint
  • Microsoft Learn documentation
  • Internal APIs
  • CRM systems
  • ERP systems
  • Ticketing systems

Without MCP, each AI assistant would require custom integrations for every external system.

MCP standardizes these integrations so that AI clients can communicate with many different services using a common protocol.

High-Level MCP Architecture

A simplified architecture looks like this:

Developer
     │
     ▼
GitHub Copilot Chat
or
Copilot in Fabric
     │
     ▼
Large Language Model
     │
     ▼
Model Context Protocol
     │
     ▼
MCP Server
     │
     ▼
External Resources
• SQL Database
• Azure SQL
• REST APIs
• GitHub
• Fabric
• Documentation
• Azure AI Search

The AI model determines what information it needs, while MCP provides the standardized mechanism for retrieving that information or invoking approved tools.

Core MCP Components

Model Context Protocol consists of several key building blocks.

These include:

  • Clients
  • Servers
  • Tools
  • Resources
  • Prompts

Each plays a specific role in the overall architecture.

MCP Client

The client is the application through which the user interacts with AI.

Examples include:

  • GitHub Copilot Chat
  • Copilot in Microsoft Fabric
  • Visual Studio Code
  • Visual Studio
  • Other MCP-compatible AI clients

The client sends prompts to the language model and coordinates interactions with MCP servers when external information is required.

MCP Server

The MCP server exposes capabilities that AI assistants can use.

Rather than connecting directly to every application, the AI communicates with an MCP server that provides standardized access to approved resources and operations.

Examples include servers that expose:

  • SQL databases
  • Azure SQL Database
  • GitHub repositories
  • Documentation
  • File systems
  • REST APIs
  • Internal enterprise applications

The MCP server determines which capabilities are available and enforces any configured permissions or policies.

MCP Tools

A tool represents an action that the AI can request.

Unlike resources, which provide information, tools perform operations.

Examples include:

  • Execute SQL
  • Search a database schema
  • Create a pull request
  • Retrieve execution plans
  • Query Azure AI Search
  • Generate documentation
  • Run a deployment pipeline
  • Validate a SQL script

Tools typically accept parameters, perform an action, and return structured results to the AI model.

Example

Suppose a developer asks:

Show me the indexes on the Sales.Orders table.

Rather than guessing, the AI could invoke an MCP tool that queries the database metadata and returns the actual index definitions.

MCP Resources

Resources represent information that the AI can read.

Examples include:

  • SQL schemas
  • Database documentation
  • Markdown files
  • JSON configuration files
  • API specifications
  • Technical documentation
  • Data dictionaries
  • Knowledge bases

Resources provide context that helps the model generate more accurate responses.

Unlike tools, resources generally do not modify data.

MCP Prompts

Prompts are reusable templates or predefined instructions that help standardize interactions with AI.

An organization might define prompts such as:

  • Generate a secure stored procedure.
  • Review SQL for performance issues.
  • Explain an execution plan.
  • Generate Azure SQL documentation.
  • Review database security.

These prompts promote consistency and help developers follow organizational standards.

How MCP Works

Consider this prompt:

Optimize my stored procedure and recommend missing indexes.

Without MCP:

The AI only analyzes the SQL text supplied by the developer.

With MCP:

The AI can:

  1. Inspect the actual schema.
  2. Read index metadata.
  3. Review execution statistics.
  4. Analyze execution plans.
  5. Recommend optimizations based on the current database.

The response becomes significantly more accurate because it is grounded in live data rather than assumptions.

Example Workflow

Developer
     │
     ▼
"Optimize this procedure"
     │
     ▼
LLM decides additional information is needed
     │
     ▼
Invoke MCP Tool
     │
     ▼
Retrieve indexes
Retrieve statistics
Retrieve execution plan
Retrieve schema
     │
     ▼
Return results to LLM
     │
     ▼
Generate optimized SQL

MCP in GitHub Copilot

GitHub Copilot increasingly supports MCP-compatible servers that allow Copilot Chat to interact with external development resources.

Depending on the environment and organizational configuration, developers can enable approved MCP servers to provide additional context during coding sessions.

Common scenarios include:

  • accessing repository metadata
  • reading project documentation
  • querying SQL schema information
  • retrieving API specifications
  • integrating with issue tracking systems
  • interacting with approved development tools

When multiple MCP servers are available, Copilot can select the appropriate server based on the user’s request and the permissions granted.

MCP in Microsoft Copilot in Fabric

Copilot in Fabric benefits from MCP by enabling AI to access enterprise data and services while respecting organizational governance.

Examples include:

  • examining Fabric Warehouse metadata
  • understanding Lakehouse schemas
  • retrieving semantic model information
  • exploring SQL endpoints
  • reading documentation
  • accessing Azure AI Search indexes
  • connecting to approved enterprise resources

This allows Copilot to produce responses that are informed by the organization’s current data landscape rather than relying solely on general knowledge.

Tool Selection

One MCP server may expose many tools.

For example:

Azure SQL MCP Server
│
├── List Tables
├── Execute Query
├── Show Indexes
├── Retrieve Statistics
├── Analyze Execution Plan
├── List Stored Procedures
└── Search Metadata

The AI chooses the appropriate tool based on the user’s request.

Security Model

One of MCP’s primary goals is secure interaction with enterprise systems.

Security principles include:

  • authenticated access
  • authorized operations
  • least privilege
  • explicit user consent where appropriate
  • encrypted communication
  • auditability

The AI never bypasses organizational security policies.

Instead, it operates within the permissions granted to the authenticated user and the configured MCP server.

Authentication

MCP servers generally rely on existing enterprise authentication mechanisms.

Examples include:

  • Microsoft Entra ID
  • OAuth
  • Personal Access Tokens (where appropriate)
  • Managed identities
  • Service principals

Developers should avoid embedding credentials directly in prompts or code.

Authorization

Authentication answers:

Who is the user?

Authorization answers:

What is the user allowed to do?

Even if an MCP server exposes a database, the AI can only perform operations that the authenticated user is permitted to execute.

For example:

Developer A

  • Read schema ✔
  • Read tables ✔
  • Execute SELECT ✔
  • Drop tables ✖

The AI inherits these permissions rather than receiving elevated privileges.

Least Privilege

Microsoft recommends following the principle of least privilege.

Only expose:

  • required databases
  • required APIs
  • required resources
  • approved tools

Avoid granting broad administrative access to MCP servers unless absolutely necessary.

Data Governance

Organizations should establish governance policies for AI-assisted development.

Recommendations include:

  • approve trusted MCP servers
  • monitor AI interactions
  • audit tool usage
  • classify sensitive resources
  • restrict production access
  • review generated SQL
  • require human approval for deployments

Strong governance reduces the risk of accidental exposure of sensitive information or unintended database changes.

Common Security Risks

Potential risks include:

Excessive Permissions

The AI can only be as secure as the permissions granted to it. Overly broad access increases risk.

Sensitive Data Exposure

Developers should avoid exposing confidential production data unless organizational policies permit it.

Prompt Injection

Malicious or misleading instructions embedded in external content could attempt to manipulate AI behavior. Organizations should validate trusted sources and limit exposure to untrusted content.

Unverified SQL

AI-generated SQL should always be reviewed and tested before execution.

Best Practices for Configuring MCP

  • Enable only trusted MCP servers.
  • Grant the minimum required permissions.
  • Review available tools before enabling them.
  • Use enterprise authentication mechanisms.
  • Monitor audit logs where available.
  • Validate AI-generated recommendations.
  • Restrict production resources when appropriate.
  • Keep MCP server configurations up to date.
  • Follow organizational security and compliance policies.

DP-800 Exam Tips

Remember the following points for the exam:

  • MCP is a protocol, not an AI model.
  • MCP standardizes communication between AI assistants and external tools or resources.
  • Clients (such as GitHub Copilot Chat or Copilot in Fabric) use MCP to interact with servers.
  • Servers expose tools, resources, and prompts.
  • Tools perform actions, while resources provide information.
  • AI assistants operate within the authenticated user’s permissions and do not automatically receive elevated privileges.
  • Organizations should enable only trusted MCP servers and follow the principles of least privilege, authentication, authorization, and governance.
  • Understanding the distinction between AI reasoning and externally grounded information retrieved through MCP is an important concept for DP-800.

Go to the DP-800 Exam Prep Hub main page

Leave a comment