MCP Customer Support AI
README.md
# MCP Customer Support AI
A production-oriented **Model Context Protocol (MCP)** project built with **Node.js, TypeScript, MongoDB, and an LLM**.
This project demonstrates how an AI application can interact with external systems through MCP tools in a structured, secure, and scalable way.
The project is being developed incrementally, from a basic MCP server and tool to a production-style AI-powered customer support system.
---
## 🚀 Project Overview
The goal of this project is to build an AI-powered customer support assistant that can understand user requests and use MCP tools to perform real-world operations.
### Example
A user can ask:
> "Check my latest order and create a support ticket if it is delayed."
The AI can determine that it needs to:
1. Find the customer.
2. Retrieve the customer's orders.
3. Identify the delayed order.
4. Create a support ticket.
The AI does not directly access the database.
Instead, it interacts with the application through MCP tools.
```text
User
│
▼
AI / LLM
│
▼
MCP Client
│
▼
┌─────────────┐
│ MCP Server │
└──────┬──────┘
│
┌────────────┼────────────┐
▼ ▼ ▼
Customer Tool Order Tool Ticket Tool
│ │ │
└────────────┼────────────┘
▼
Services
│
▼
MongoDB
```
---
# 🎯 Project Objectives
This project demonstrates:
* MCP server development
* MCP tool creation
* MCP client communication
* AI tool calling
* TypeScript architecture
* MongoDB integration
* Service-layer architecture
* Input validation
* Error handling
* Authentication and authorization
* Logging and monitoring
* Audit logging
* Production-oriented MCP architecture
* AI agent workflows
---
# 🛠️ Tech Stack
## Backend
* Node.js
* TypeScript
* MCP SDK
* Zod
* MongoDB
* Mongoose
## AI
* LLM integration
* Tool calling
* AI Agent workflow
## Development
* MCP Inspector
* Git
* GitHub
* npm
## Planned Production Infrastructure
* Docker
* Redis
* Authentication
* Rate limiting
* Logging
* Monitoring
* CI/CD
---
# 📁 Project Structure
```text
mcp-customer-support/
│
├── src/
│ │
│ ├── index.ts
│ │
│ ├── tools/
│ │ ├── customer.tools.ts
│ │ ├── order.tools.ts
│ │ └── ticket.tools.ts
│ │
│ ├── services/
│ │ ├── customer.service.ts
│ │ ├── order.service.ts
│ │ └── ticket.service.ts
│ │
│ ├── models/
│ │ ├── customer.model.ts
│ │ ├── order.model.ts
│ │ └── ticket.model.ts
│ │
│ ├── db/
│ │ └── database.ts
│ │
│ ├── middleware/
│ │ └── auth.ts
│ │
│ └── utils/
│ ├── logger.ts
│ └── errors.ts
│
├── tests/
│
├── .env.example
├── .gitignore
├── package.json
├── package-lock.json
├── tsconfig.json
└── README.md
```
---
# 🏗️ Development Phases
The project is intentionally divided into phases so each phase introduces an important MCP or production concept.
---
# Phase 1 — MCP Server Foundation
### Objective
Create a basic MCP server and expose the first tool.
### Implemented
* Node.js project
* TypeScript configuration
* MCP SDK
* MCP server
* STDIO transport
* Zod input validation
* First MCP tool
* MCP Inspector integration
### First Tool
```text
find_customer
```
Input:
```json
{
"email": "ashwani@example.com"
}
```
Output:
```json
{
"id": "customer_123",
"name": "Ashwani Yadav",
"email": "ashwani@example.com"
}
```
### Architecture
```text
MCP Inspector
│
▼
MCP Client
│
│ STDIO
▼
MCP Server
│
▼
find_customer()
│
▼
Dummy Data
```
### Status
**Completed ✅**
---
# Phase 2 — Multiple MCP Tools
### Objective
Create multiple tools representing real customer-support operations.
### Tools
```text
find_customer
get_customer_orders
create_support_ticket
```
### Example
#### find_customer
```text
find_customer(email)
```
#### get_customer_orders
```text
get_customer_orders(customerId)
```
#### create_support_ticket
```text
create_support_ticket(
customerId,
orderId,
issue
)
```
### Expected Architecture
```text
MCP Server
│
┌───────────────┼───────────────┐
▼ ▼ ▼
find_customer() get_orders() create_ticket()
```
### Status
**Planned 🚧**
---
# Phase 3 — MongoDB Integration
### Objective
Replace dummy data with real persistent data.
### Database
MongoDB
### Collections
```text
customers
orders
support_tickets
```
### Architecture
```text
MCP Tool
│
▼
Service Layer
│
▼
Mongoose
│
▼
MongoDB
```
### Example
```text
find_customer()
│
▼
customer.service.ts
│
▼
Customer Model
│
▼
MongoDB
```
### Benefits
* Persistent data
* Proper database queries
* Indexing
* Schema validation
* Scalable data access
### Planned Index
```text
customers.email
```
This allows customer lookup by email to remain efficient as the dataset grows.
### Status
**Planned 🚧**
---
# Phase 4 — Service Layer & Clean Architecture
### Objective
Keep MCP tools separate from business logic.
Instead of putting database logic directly inside the MCP tool:
```text
Tool
↓
Service
↓
Database
```
### Example
```text
customer.tools.ts
│
▼
customer.service.ts
│
▼
customer.model.ts
│
▼
MongoDB
```
### Why?
This gives us:
* Separation of concerns
* Testability
* Reusability
* Maintainability
* Easier migration to REST/GraphQL/internal services
### Status
**Planned 🚧**
---
# Phase 5 — MCP Client
### Objective
Build a dedicated MCP client that connects to the MCP server.
```text
┌──────────────┐
│ MCP Client │
└──────┬───────┘
│
▼
┌──────────────┐
│ MCP Server │
└──────────────┘
```
The client will be able to:
### Discover tools
```text
listTools()
```
### Execute tools
```text
callTool()
```
For example:
```text
callTool(
"find_customer",
{
email: "ashwani@example.com"
}
)
```
### Status
**Planned 🚧**
---
# Phase 6 — LLM Integration
### Objective
Connect an LLM to the MCP client.
The architecture becomes:
```text
User
│
▼
LLM
│
▼
MCP Client
│
▼
MCP Server
│
▼
Tools
│
▼
MongoDB
```
The LLM will decide which tool should be called based on the user's request.
### Example
User:
```text
Check my latest order.
```
AI:
```text
I need the customer's orders.
```
Tool:
```text
get_customer_orders()
```
The tool returns the order data.
The AI then generates a natural-language response.
### Status
**Planned 🚧**
---
# Phase 7 — AI Agent Workflow
### Objective
Allow the LLM to perform multi-step workflows.
Example request:
```text
Check my latest order and create a support
ticket if it is delayed.
```
The AI workflow:
```text
User Request
│
▼
LLM
│
▼
find_customer()
│
▼
get_customer_orders()
│
▼
Analyze orders
│
▼
Is order delayed?
/ \
Yes No
│ │
▼ ▼
create_support_ticket Response
│
▼
Response
```
This demonstrates the difference between simply exposing tools and building an **AI agent capable of tool orchestration**.
### Status
**Planned 🚧**
---
# Phase 8 — Authentication & Authorization
### Objective
Secure MCP operations.
Authentication verifies:
> Who is the user?
Authorization verifies:
> What is the user allowed to do?
Example permissions:
```text
customer.read
order.read
ticket.create
ticket.update
admin.refund
```
Example:
```text
Customer
├── find_customer ✅
├── get_orders ✅
├── create_ticket ✅
└── refund_order ❌
Admin
├── find_customer ✅
├── get_orders ✅
├── create_ticket ✅
└── refund_order ✅
```
### Status
**Planned 🚧**
---
# Phase 9 — Error Handling
### Objective
Create consistent error handling across tools.
Example:
```text
CustomerNotFoundError
OrderNotFoundError
UnauthorizedError
ValidationError
DatabaseError
ToolExecutionError
```
MCP tool responses will clearly communicate failures.
Example:
```json
{
"isError": true,
"message": "Customer not found"
}
```
### Status
**Planned 🚧**
---
# Phase 10 — Logging & Observability
### Objective
Track MCP operations in production.
Each tool execution should provide information such as:
```text
Request ID
User ID
Tool name
Arguments
Execution time
Status
Error
Timestamp
```
Example:
```text
INFO Tool Execution
tool: get_customer_orders
customerId: customer_123
duration: 85ms
status: success
```
### Monitoring Goals
* Tool latency
* Error rate
* Database latency
* AI response latency
* Tool usage frequency
* Failed tool calls
### Status
**Planned 🚧**
---
# Phase 11 — Rate Limiting
### Objective
Protect the MCP server from excessive or abusive requests.
Potential strategy:
```text
User
│
▼
Rate Limiter
│
├── Allowed ──→ MCP Tool
│
└── Blocked ──→ Rate Limit Error
```
Redis can be introduced for distributed rate limiting.
Example:
```text
100 requests / minute / user
```
### Status
**Planned 🚧**
---
# Phase 12 — Audit Logging
### Objective
Record sensitive AI-driven operations.
For example:
```text
User:
customer_123
AI requested:
create_support_ticket
Order:
order_123
Action:
Support ticket created
Timestamp:
2026-08-23T10:30:00Z
```
This is particularly important when AI agents can perform actions that modify business data.
### Status
**Planned 🚧**
---
# Phase 13 — Testing
### Unit Tests
Test:
* Services
* Validation
* Business logic
* Error handling
### Integration Tests
Test:
```text
MCP Tool
↓
Service
↓
MongoDB
```
### MCP Tests
Test:
```text
MCP Client
↓
MCP Server
↓
Tool
```
### Example
```text
find_customer
↓
valid email
↓
customer returned
```
and:
```text
find_customer
↓
invalid email
↓
validation error
```
### Status
**Planned 🚧**
---
# Phase 14 — Dockerization
### Objective
Containerize the application.
```text
Docker
│
├── MCP Server
│
├── MongoDB
│
└── Redis
```
Example production architecture:
```text
┌─────────────┐
│ AI App │
└──────┬──────┘
│
▼
┌─────────────┐
│ MCP Server │
└──────┬──────┘
│
┌──────────┼──────────┐
▼ ▼ ▼
MongoDB Redis Logs
```
### Status
**Planned 🚧**
---
# Phase 15 — CI/CD
### Objective
Automate testing and deployment.
Pipeline:
```text
Developer
│
▼
Git Push
│
▼
GitHub Actions
│
├── Install dependencies
├── Lint
├── Type check
├── Run tests
├── Build
└── Deploy
```
### Status
**Planned 🚧**
---
# 🔐 Environment Variables
Never commit `.env` to GitHub.
Use:
```text
.env
```
for local development.
Example:
```env
MONGODB_URI=mongodb://localhost:27017/mcp-support
OPENAI_API_KEY=your_api_key
JWT_SECRET=your_secret
```
Provide:
```text
.env.example
```
instead:
```env
MONGODB_URI=
OPENAI_API_KEY=
JWT_SECRET=
```
---
# 🧪 Development
Install dependencies:
```bash
npm install
```
Run development server:
```bash
npm run dev
```
Build:
```bash
npm run build
```
Run production build:
```bash
npm start
```
---
# 🔍 MCP Inspector
The MCP Inspector is used to test the MCP server and inspect available tools during development.
Example:
```bash
npx @modelcontextprotocol/inspector npx tsx src/index.ts
```
The Inspector allows us to:
* Connect to the MCP server
* Discover tools
* Inspect tool schemas
* Execute tools
* Inspect responses
* Debug MCP communication
---
# 🧠 MCP Concepts Demonstrated
This project demonstrates the following MCP concepts:
### MCP Server
Provides capabilities to MCP clients.
### MCP Client
Connects to MCP servers and invokes their capabilities.
### Tools
Executable operations exposed to AI systems.
Examples:
```text
find_customer
get_customer_orders
create_support_ticket
```
### Resources
Read-only contextual data that can be exposed to an MCP client.
Potential future resources:
```text
customer://customer_123
order://order_123
```
### Prompts
Reusable prompt templates/workflows that can be exposed through MCP.
Potential example:
```text
customer_support_resolution
```
---
# 🏆 Production Architecture
The final architecture is planned to look like:
```text
┌───────────────┐
│ User │
└───────┬───────┘
│
▼
┌───────────────┐
│ LLM / AI │
└───────┬───────┘
│
▼
┌───────────────┐
│ MCP Client │
└───────┬───────┘
│
▼
┌────────────────────────┐
│ MCP Server │
│ │
│ Authentication │
│ Authorization │
│ Validation │
│ Rate Limiting │
│ Logging │
└───────────┬────────────┘
│
┌────────────────┼────────────────┐
▼ ▼ ▼
Customer Tool Order Tool Ticket Tool
│ │ │
└────────────────┼────────────────┘
▼
Service Layer
│
┌───────────────┼───────────────┐
▼ ▼ ▼
MongoDB Redis Logging
```
---
# 📌 Current Progress
| Phase | Feature | Status |
| ----- | ------------------------------ | ----------- |
| 1 | MCP Server Foundation | ✅ Completed |
| 2 | Multiple MCP Tools | 🚧 Planned |
| 3 | MongoDB Integration | 🚧 Planned |
| 4 | Service Layer | 🚧 Planned |
| 5 | MCP Client | 🚧 Planned |
| 6 | LLM Integration | 🚧 Planned |
| 7 | AI Agent Workflow | 🚧 Planned |
| 8 | Authentication & Authorization | 🚧 Planned |
| 9 | Error Handling | 🚧 Planned |
| 10 | Logging & Observability | 🚧 Planned |
| 11 | Rate Limiting | 🚧 Planned |
| 12 | Audit Logging | 🚧 Planned |
| 13 | Testing | 🚧 Planned |
| 14 | Dockerization | 🚧 Planned |
| 15 | CI/CD | 🚧 Planned |
---
# 💡 Example Future Conversation
Once all phases are complete, the system should support conversations such as:
**User**
> My latest order hasn't arrived. Can you check it and create a support ticket?
**AI**
```text
1. Find customer
2. Retrieve orders
3. Identify delayed order
4. Create support ticket
5. Return ticket information
```
**AI Response**
> Your order `ORD-123` is delayed. I've created support ticket `TICKET-456` for you.
---
# 🎓 Interview Topics Covered
This project can be used to demonstrate knowledge of:
* Model Context Protocol
* AI agents
* LLM tool calling
* Function calling
* MCP servers
* MCP clients
* Tool discovery
* Tool execution
* TypeScript
* Node.js
* MongoDB
* Mongoose
* Clean architecture
* Service-layer architecture
* Authentication
* Authorization
* RBAC
* Rate limiting
* Redis
* Logging
* Observability
* Docker
* CI/CD
* GitHub Actions
* Testing
* Scalable backend architecture
---
# 📈 Future Improvements
Potential future enhancements include:
* Multiple MCP servers
* Payment MCP tools
* Email MCP tools
* CRM integration
* Slack integration
* GitHub integration
* Vector database
* RAG
* Semantic search
* Human-in-the-loop approval
* Tool permission policies
* Tool execution tracing
* Distributed MCP deployment
* Kubernetes deployment
---
# 👨💻 Development Philosophy
The project follows these principles:
* Separation of concerns
* Strong typing
* Input validation
* Secure secret management
* Testable business logic
* Observable tool execution
* Least-privilege tool access
* Scalable architecture
* Clear MCP boundaries
---
# 📜 License
This project is intended for learning, experimentation, and demonstrating MCP/AI engineering concepts.
Add an appropriate open-source license before distributing it publicly.
This server cannot be deployed
Maintenance
ActivityMaintained
ResponsivenessNo issues