🚀 NovaSupport — Agentic AI Support Ticket System

An intelligent, fully serverless support ticket system built on AWS that leverages Amazon Nova AI models to automate ticket routing, analysis, response generation, and escalation — with minimal human intervention.

You can explore NovaSupport using the live portals below:

Use the following credentials to test different roles in the system:

1. Open the User Portal
2. Log in using the User credentials
3. Create a support ticket
4. Log in as Admin or Team
5. Observe:
   • AI-based ticket routing
   • Priority classification
   • Suggested responses
   • Automated workflow

• Overview
• Key Features — How It Works
• Architecture
• AWS Services Used
• Prerequisites
• Installation
• Build & Deploy
• Running the Frontends
• AI Agents
• Services
• NovaSupport Ops Copilot (MCP-Powered Agent)
• Monitoring & Observability

NovaSupport is a three-portal support system:

All three portals share a single REST API backend deployed on AWS Lambda + API Gateway, with DynamoDB as the data store.

When a customer submits a support ticket, the AI (Amazon Nova) reads the ticket and automatically figures out which team should handle it — billing, authentication, general support, etc. Then it assigns the ticket to a specific team member using round-robin, so the workload is shared fairly across the team.

If a ticket mentions sensitive topics like security breaches, legal issues, or compliance problems — or if the AI isn't confident enough in its analysis — the system automatically flags it for human review instead of trying to handle it on its own.

End users can chat directly with an AI assistant to get quick answers without waiting for a human agent. The assistant uses the knowledge base and past ticket data to provide helpful responses.

The AI can analyze not just text, but also images, documents, and videos attached to tickets. It uses Amazon Nova's multimodal capabilities to understand what's in the attachments and include that in the ticket analysis. It also suggests AI-generated responses that agents can use or customize.

When a new ticket comes in, the system uses semantic search (Nova Embeddings) to find similar past tickets. This helps agents see how similar issues were resolved before, speeding up resolution time.

Tickets and messages can be translated into any language with one click. The system auto-detects the source language using Amazon Comprehend and translates using Amazon Translate. Translation is available on replies, messages, and resolution summaries.

Users can use voice input — the system transcribes speech to text (Amazon Transcribe) and can also read responses aloud using text-to-speech (Amazon Polly).

When a ticket is resolved, the system can send a styled resolution email to the customer via Amazon SES, so they know their issue has been addressed.

Admins get a dashboard showing ticket trends, response times, and SLA compliance. The system tracks how fast tickets are being responded to and resolved, and raises alarms if SLAs are at risk.

Full lifecycle management — create, edit, delete, merge duplicate tickets, track activity logs, manage status (open → in-progress → escalated → resolved), and let customers rate their experience after resolution.

WebSocket-based real-time notifications keep agents and users updated instantly when ticket status changes or new messages arrive.

The system automatically checks for tickets that need follow-up every 15 minutes and schedules reminders, so nothing falls through the cracks.

A searchable knowledge base stores proven solutions. The AI uses this to suggest solutions for new tickets, and agents can add new articles as they resolve issues.

The support agents remember how past tickets were resolved. When a ticket is resolved, the resolution is saved to Amazon Bedrock AgentCore Memory. When a new ticket comes in, the system recalls semantically similar past resolutions and uses them to route the ticket to the team that solved similar issues before and to ground the AI's suggested response in what actually worked previously. If the memory resource isn't configured, the system runs normally without it (safe fallback).

Every AI model call runs through an Amazon Bedrock Guardrail that redacts personally identifiable information (PII) and filters harmful content, keeping AI responses safe and privacy-compliant. Like memory, it's an optional layer — calls run normally if no guardrail is configured.

┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐
│  Admin Portal   │  │  User Portal    │  │  Team Portal    │
│                    │  │
└────────┬────────┘  └────────┬────────┘  └────────┬────────┘
         │                    │                    │
         └────────────────────┼────────────────────┘
                              │
                    ┌─────────▼─────────┐
                    │   API Gateway     │◄──── Cognito Authorizer
                    │   (REST + WS)     │      (2 User Pools)
                    └─────────┬─────────┘
                              │
              ┌───────────────┼───────────────┐
              │               │               │
     ┌────────▼──────┐ ┌─────▼─────┐ ┌───────▼───────┐
     │  Lambda Fns   │ │  SQS      │ │  EventBridge  │
     │  (30+ fns)    │ │  Queues   │ │  (Scheduled)  │
     └───────┬───────┘ └─────┬─────┘ └───────────────┘
             │               │
    ┌────────┼────────┬──────┼──────┬───────────┐
    │        │        │      │      │           │
┌───▼──┐ ┌──▼───┐ ┌──▼──┐ ┌▼────┐ ┌▼────────┐ ┌▼──────────┐
│Dynamo│ │  S3  │ │Nova │ │SES  │ │Translate│ │Polly/     │
│  DB  │ │      │ │(AI) │ │     │ │Comprehnd│ │Transcribe │
└──────┘ └──────┘ └─────┘ └─────┘ └─────────┘ └───────────┘

• Node.js 20.x or later
• AWS CLI configured with credentials (aws configure)
• AWS CDK CLI (npm install -g aws-cdk)
• AWS Account with access to Bedrock (Amazon Nova models enabled in us-east-1)

npm install

# Compile TypeScript
npx tsc

# Deploy infrastructure to AWS (first time may take ~5 min)
npx cdk deploy --require-approval never

If this is your first CDK deployment in the account/region:

npx cdk bootstrap

After deployment, CDK outputs the API Gateway URL, Cognito User Pool IDs, WebSocket endpoint, and other resource identifiers. Update the config.js in each portal with these values.

These two features are off by default and turn on once their AWS resources are provisioned and passed to the deploy:

# 1. Provision the AgentCore Memory resource (prints a MEMORY_ID)
node scripts/provision-agentcore-memory.js

# 2. Provision the Bedrock Guardrail (prints GUARDRAIL_ID and GUARDRAIL_VERSION)
node scripts/provision-guardrail.js

# 3. Redeploy with the values so the Lambdas pick them up
AGENTCORE_MEMORY_ID=<id> GUARDRAIL_ID=<id> GUARDRAIL_VERSION=<v> npx cdk deploy --require-approval never

# 4. (Optional) Backfill past resolved tickets into memory
AGENTCORE_MEMORY_ID=<id> node scripts/seed-agentcore-memory.js

The three portals are static HTML/JS/CSS apps. Serve them locally with any static file server:

# Admin Portal
npx http-server frontend -p 3000

# User Portal
npx http-server user-portal -p 3001

# Team Member Portal
npx http-server team-portal -p 3002

Then open in your browser:

• Admin: http://localhost:3000
• User: http://localhost:3001
• Team: http://localhost:3002

An interactive terminal copilot (in support-copilot/) that lets a support agent chat with NovaSupport's own ticket history — summarizing tickets, finding how similar issues were solved before, and drafting customer replies. It is built with the Strands Agents SDK, reasons with Amazon Nova Pro on Bedrock, and reads ticket data through the official filesystem MCP server.

It satisfies all five "Build Your Own MCP-Powered Agent" rules:

cd support-copilot
pip install -r requirements.txt

# One-time: export tickets from DynamoDB into data/ (requires AWS creds)
python export_tickets.py

# Start chatting
python copilot.py

Then ask things like summarize the auth-team tickets, how were password reset issues resolved before?, or draft a reply for the 2FA ticket. Type exit to quit. (Real ticket data under support-copilot/data/ is gitignored to protect PII.)

• CloudWatch Dashboard: NovaSupport-Metrics — API request volume, latency, errors, queue depth, DynamoDB capacity
• Alarms: High 5xx error rate, high API latency, DLQ messages, Lambda errors
• X-Ray Tracing: Enabled on API Gateway and key Lambda functions
• Logs: All Lambda functions log to /aws/novasupport CloudWatch log group