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.

                         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

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

find_customer

Input:

{
  "email": "ashwani@example.com"
}

Output:

{
  "id": "customer_123",
  "name": "Ashwani Yadav",
  "email": "ashwani@example.com"
}

Architecture

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

find_customer
get_customer_orders
create_support_ticket

Example

find_customer

find_customer(email)

get_customer_orders

get_customer_orders(customerId)

create_support_ticket

create_support_ticket(
    customerId,
    orderId,
    issue
)

Expected Architecture

                    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

customers
orders
support_tickets

Architecture

MCP Tool
   │
   ▼
Service Layer
   │
   ▼
Mongoose
   │
   ▼
MongoDB

Example

find_customer()
      │
      ▼
customer.service.ts
      │
      ▼
Customer Model
      │
      ▼
MongoDB

Benefits

• Persistent data
• Proper database queries
• Indexing
• Schema validation
• Scalable data access

Planned Index

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:

Tool
 ↓
Service
 ↓
Database

Example

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.

┌──────────────┐
│ MCP Client   │
└──────┬───────┘
       │
       ▼
┌──────────────┐
│ MCP Server   │
└──────────────┘

The client will be able to:

Discover tools

listTools()

Execute tools

callTool()

For example:

callTool(
    "find_customer",
    {
        email: "ashwani@example.com"
    }
)

Status

Planned 🚧

---

Phase 6 — LLM Integration

Objective

Connect an LLM to the MCP client.

The architecture becomes:

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:

Check my latest order.

AI:

I need the customer's orders.

Tool:

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:

Check my latest order and create a support
ticket if it is delayed.

The AI workflow:

             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:

customer.read
order.read
ticket.create
ticket.update
admin.refund

Example:

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:

CustomerNotFoundError
OrderNotFoundError
UnauthorizedError
ValidationError
DatabaseError
ToolExecutionError

MCP tool responses will clearly communicate failures.

Example:

{
  "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:

Request ID
User ID
Tool name
Arguments
Execution time
Status
Error
Timestamp

Example:

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:

User
 │
 ▼
Rate Limiter
 │
 ├── Allowed ──→ MCP Tool
 │
 └── Blocked ──→ Rate Limit Error

Redis can be introduced for distributed rate limiting.

Example:

100 requests / minute / user

Status

Planned 🚧

---

Phase 12 — Audit Logging

Objective

Record sensitive AI-driven operations.

For example:

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:

MCP Tool
   ↓
Service
   ↓
MongoDB

MCP Tests

Test:

MCP Client
   ↓
MCP Server
   ↓
Tool

Example

find_customer
    ↓
valid email
    ↓
customer returned

and:

find_customer
    ↓
invalid email
    ↓
validation error

Status

Planned 🚧

---

Phase 14 — Dockerization

Objective

Containerize the application.

Docker
│
├── MCP Server
│
├── MongoDB
│
└── Redis

Example production architecture:

                 ┌─────────────┐
                 │   AI App    │
                 └──────┬──────┘
                        │
                        ▼
                 ┌─────────────┐
                 │ MCP Server  │
                 └──────┬──────┘
                        │
             ┌──────────┼──────────┐
             ▼          ▼          ▼
          MongoDB     Redis      Logs

Status

Planned 🚧

---

Phase 15 — CI/CD

Objective

Automate testing and deployment.

Pipeline:

Developer
    │
    ▼
Git Push
    │
    ▼
GitHub Actions
    │
    ├── Install dependencies
    ├── Lint
    ├── Type check
    ├── Run tests
    ├── Build
    └── Deploy

Status

Planned 🚧

---

🔐 Environment Variables

Never commit .env to GitHub.

Use:

.env

for local development.

Example:

MONGODB_URI=mongodb://localhost:27017/mcp-support
OPENAI_API_KEY=your_api_key
JWT_SECRET=your_secret

Provide:

.env.example

instead:

MONGODB_URI=
OPENAI_API_KEY=
JWT_SECRET=

---

🧪 Development

Install dependencies:

npm install

Run development server:

npm run dev

Build:

npm run build

Run production build:

npm start

---

🔍 MCP Inspector

The MCP Inspector is used to test the MCP server and inspect available tools during development.

Example:

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:

find_customer
get_customer_orders
create_support_ticket

Resources

Read-only contextual data that can be exposed to an MCP client.

Potential future resources:

customer://customer_123
order://order_123

Prompts

Reusable prompt templates/workflows that can be exposed through MCP.

Potential example:

customer_support_resolution

---

🏆 Production Architecture

The final architecture is planned to look like:

                         ┌───────────────┐
                         │     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

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.