# Extend Agents with Model Context Protocol (MCP) Tools

This project demonstrates how to extend an Azure AI agent with Model Context Protocol (MCP) tools using the Foundry Toolkit for VS Code. It includes both remote MCP integration with Microsoft Learn Docs and a custom MCP server/client example for inventory scenarios.

## Learning Purpose

- How to create a Foundry project in VS Code.
- How to deploy an Azure AI model for agent development.
- How to connect an Azure AI agent to a remote MCP server.
- How to build a custom MCP server with callable tools.
- How to connect MCP tools to an agent for dynamic tool use.

## Prerequisites

- Visual Studio Code
- Azure subscription
- Python 3.13 or later
- Git

## Project Overview

This project includes two scenarios:

1. **Remote MCP integration**
   - Connect an Azure AI agent to the Microsoft Learn Docs remote MCP server.
   - Ask the agent for up-to-date technical documentation and Azure CLI examples.

2. **Custom MCP tools**
   - Build a local MCP server with tools for inventory and weekly sales.
   - Connect the tools to an agent that can make restock and clearance recommendations.

## Setup Steps

### 1. Create a Foundry project
- Install the **Foundry Toolkit** extension in VS Code.
- Sign in to Azure.
- Create a Foundry project in your subscription and resource group.

### 2. Deploy a model
- Open the Model Catalog.
- Deploy the `gpt-5.2` model\(I'm using gpt-5.2, yours might be different model\).
- Set the deployment name and increase the tokens-per-minute quota if needed.
- Copy the project endpoint for later use.

### 3. Clone the repository
```bash
git clone https://github.com/MicrosoftLearning/mslearn-ai-agents.git
```

Open the `Labfiles/03-mcp-integration` folder in VS Code.

### 4. Set up Python
```bash
python -m venv labenv
.\labenv\Scripts\Activate.ps1
pip install -r requirements.txt
```

### 5. Configure environment variables
Update the `.env` file with:
- Your Foundry project endpoint
- Your model deployment name

## Remote MCP Example

The `agent.py` sample connects to the Microsoft Learn Docs MCP server and creates an agent that can answer questions using external documentation. The agent:
- Uses `DefaultAzureCredential` to authenticate.
- Creates an `AIProjectClient` connected to the Foundry project.
- Registers an `MCPTool` pointing to the Microsoft Learn MCP endpoint.
- Sends a prompt asking for Azure CLI commands.
- Processes MCP approval requests automatically.
- Deletes the agent version after execution.

## Custom MCP Server Example

The `server.py` file defines a local MCP server using `FastMCP`. It exposes tools such as:
- `get_inventory_levels()`
- `get_weekly_sales()`

The `client.py` file:
- Starts the MCP server over stdio.
- Creates an MCP session.
- Discovers available tools.
- Wraps the tools as function tools for the agent.
- Sends tool outputs back to the model.

The agent uses these tools to:
- Recommend restock when inventory is low and sales are high.
- Recommend clearance when inventory is high and sales are low.

## Testing

Run the remote MCP agent:

```bash
python agent.py
```

Run the custom MCP client:

```bash
python client.py
```

Example prompts:
- Show me the current inventory levels for all products.
- Are there any products that should be restocked?
- Which products would you recommend for clearance?
- What are the best sellers this week?

## Cleanup

After testing:
- Delete the deployed model from the Foundry Toolkit.
- Delete the Azure resource group to avoid unnecessary charges.

## Notes

- Some features in this lab are in preview or active development.
- You may need to retry if rate limits are exceeded.
- The conversation thread is stateful, so the agent retains context across turns.