Project: Enterprise Agents - Supply Chain Intelligence Copilot

The submission points to README.md, run-agent.ps1, and the npm scripts start-mcp and start. Begin by reading the setup instructions and checking whether the documented MCP server and agent workflow start successfully. Done would mean the listed supply-chain capabilities can be demonstrated, but the issue does not define a specific code change.

Track

Enterprise Agents (M365 Agents Toolkit)

Project Name

Supply Chain Intelligence Copilot

GitHub Username

@nagaraj-biradar

Repository URL

https://github.com/nagaraj-biradar/Supply-Chain-Intelligence-Copilot

Project Description

An enterprise-ready Supply Chain Intelligence Agent built with Microsoft Copilot Studio
and powered by a Node.js MCP (Model Context Protocol) server. The agent enables
real-time order tracking, supplier risk analysis, inventory monitoring, cost
optimization insights, and executive KPI dashboards through conversational AI.

project_type: agent

industry_focus:

• Supply Chain
• Manufacturing
• Logistics
• Procurement

scenario:
primary: >
Enable supply chain teams to interact conversationally with operational data
to track orders, monitor supplier performance, analyze risks, identify cost
savings opportunities, and review real-time KPIs.
secondary:
- Executive KPI reporting
- Supplier risk management
- Inventory monitoring
- Cost optimization discovery

tech_stack:
platform:
- Microsoft Copilot Studio
backend:
- Node.js
- Express.js
- MCP (Model Context Protocol)
frontend:
- Adaptive Cards
authentication:
- Azure AD (Production-ready configuration included)

features:

• Conversational order tracking
• Real-time inventory visibility
• Supplier risk scoring and assessment
• Cost savings opportunity recommendations
• Executive metrics dashboard
• Role-based access control (RBAC)
• Multi-step workflows
• REST API integration
• Mock data for rapid testing

architecture:
summary: >
The agent connects Microsoft Copilot Studio to a local MCP server (Node.js REST API).
The server exposes endpoints for suppliers, orders, inventory, risks,
cost opportunities, and metrics. Copilot Studio uses actions and topics
to orchestrate conversational workflows and render Adaptive Cards.

components:
- Copilot Studio Agent (Topics, Actions, Adaptive Cards)
- MCP Server (Node.js REST API on localhost:3001)
- Mock Supply Chain Data Layer

Demo Video or Screenshots

Primary Programming Language

TypeScript/JavaScript

Key Technologies Used

platform:
- Microsoft Copilot Studio
backend:
- Node.js
- Express.js
- MCP (Model Context Protocol)
frontend:
- Adaptive Cards

Submission Type

Individual

Team Members

No response

Submission Requirements

• My project meets the track-specific challenge requirements
• My repository includes a comprehensive README.md with setup instructions
• My code does not contain hardcoded API keys or secrets
• I have included demo materials (video or screenshots)
• My project is my own work with proper attribution for any third-party code
• I agree to the Code of Conduct
• I have read and agree to the Disclaimer
• My submission does NOT contain any confidential, proprietary, or sensitive information
• I confirm I have the rights to submit this content and grant the necessary licenses

Quick Setup Summary

1. Clone the repo

2. Navigate to project directory
   cd "Supply Chain Intelligence"
   npm install

3. Option A: Use the startup script
   .\run-agent.ps1

4. Option B: Start MCP server directly
   npm run start-mcp

5. Option C: Start both servers
   npm run start

Technical Highlights

MCP-Based Decoupled Architecture

One of the strongest technical decisions was implementing a Model Context Protocol (MCP) server layer between Microsoft Copilot Studio and supply chain data.

Instead of embedding logic directly inside Microsoft Copilot Studio, I built a dedicated Node.js REST API server that:

• Abstracts data sources
• Handles business logic
• Normalizes responses
• Can scale independently

Is deployable to Azure App Service or Container Apps
This separation creates:

• Cleaner architecture
• Better maintainability
• Production scalability
• Easier integration with real ERP systems later

It transforms the agent from a demo bot into an enterprise-ready system design.

Production-Ready Deployment Thinking
Even though this is a prototype, it was designed with production deployment in mind:
Azure AD authentication configuration
Environment separation (dev / stage / prod concept)
REST connection abstraction
Scalable backend architecture
Clear monitoring strategy
Modular documentation package (9 docs + checklist + deployment plan)

Most hackathon submissions focus only on features — this implementation focused on enterprise readiness from day one.

Challenges & Learnings

1️⃣ Designing for Enterprise Scale (Not Just a Demo)

Challenge:
It was tempting to build a quick conversational bot with hardcoded responses. However, the real challenge was designing something that could realistically scale in an enterprise environment.

What I Learned:

Architecture decisions matter more than features.

Separating concerns (Copilot Studio vs backend API) makes long-term evolution easier.

Building with production in mind from day one prevents major refactoring later.

This is why I introduced a decoupled MCP server layer instead of embedding all logic directly inside Microsoft Copilot Studio.

2️⃣ Structuring Conversational Workflows Properly

Challenge:
Turning natural language into structured actions required careful topic design. Trigger phrases alone are not enough — entity capture, parameter prompting, and conditional logic must be orchestrated carefully.

For example:

Handling partial inputs ("Track my order")

Prompting for missing parameters (orderId)

Mapping output to structured Adaptive Cards

What I Learned:

Conversation design is a system design problem.

Intent clarity improves reliability dramatically.

Clear action boundaries reduce ambiguity and runtime errors.

Conversational AI is not about clever replies — it’s about predictable orchestration.

3️⃣ Designing Realistic Supply Chain Data Models

Challenge:
Creating believable supply chain scenarios required more than mock objects. The data had to represent real operational relationships:

Orders linked to suppliers

Inventory distributed across warehouses

Shipment tracking lifecycle

Risk scoring logic

What I Learned:

Data modeling defines the intelligence ceiling of the system.

Even a prototype benefits from realistic entity relationships.

Poor data structure limits future AI enhancements.

The learning: design the data model first — the AI layer depends on it.

4️⃣ Balancing UX Simplicity with Technical Depth

Challenge:
Supply chain systems are complex. The difficulty was making interactions simple while maintaining meaningful business logic.

For example:

Showing KPIs without overwhelming the user

Returning concise yet actionable responses

Designing Adaptive Cards that are informative but not cluttered

What I Learned:

UX clarity increases perceived intelligence.

Visual response formatting matters as much as backend logic.

Enterprise users prefer decision-ready summaries, not raw data dumps.

5️⃣ Thinking Through Security & Production Deployment

Challenge:
Many prototypes ignore security and environment separation. Incorporating Azure AD configuration, RBAC thinking, and deployment strategy added complexity.

What I Learned:

Security must be designed early, not added later.

Authentication strategy impacts architecture decisions.

Production-readiness thinking improves system credibility.

It reinforced the importance of aligning with enterprise standards from the beginning.

6️⃣ Documentation as a Technical Multiplier

Challenge:
Documenting architecture, setup steps, deployment plans, and test scenarios required almost as much effort as building the solution.

What I Learned:

Documentation increases reproducibility.

Clear implementation guides reduce friction.

Well-documented systems scale beyond the creator.

This shifted my mindset from “building a project” to “building a deployable solution.”

Biggest Overall Learning

The most important realization was:

Building AI agents is less about AI and more about system design, data modeling, orchestration, and business alignment.

Using Microsoft tools effectively requires architectural discipline — not just conversational creativity.

Contact Information

nagarajbiradar1900@gmail.com

Country/Region

India