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

💡 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.