Building an AI support ticket classifier on Upsun

mkdir ticket-classifier
cd ticket-classifier
npm init -y

npm install express dotenv cors @langchain/core @langchain/openai
npm install -D typescript @types/node @types/express @types/cors tsx @biomejs/biome

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true,
    "declaration": true,
    "declarationMap": true,
    "sourceMap": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

{
  "type": "module",
  "scripts": {
    "dev": "tsx watch src/index.ts",
    "build": "tsc",
    "start": "node dist/index.js",
    "lint": "biome check .",
    "lint:fix": "biome check --write .",
    "format": "biome format --write ."
  }
}

import { ChatOpenAI } from "@langchain/openai";

const OPENAI_MODEL = process.env.OPENAI_MODEL || "gpt-4o-mini";

export interface ClassificationResult {
  category: string;
  urgency: string;
  sentiment: string;
  product: string | null;
  customerName: string | null;
  customerEmail: string | null;
  referenceNumbers: string[];
  summary: string;
  suggestedActions: string[];
}

const SYSTEM_PROMPT = `You are a support ticket classifier for Upsun, a Platform-as-a-Service (PaaS) hosting provider. Analyze support tickets and extract structured metadata.

Upsun products and services include:
- Web application hosting (PHP, Python, Node.js, Go, Java, Ruby, etc.)
- Database services (MySQL, PostgreSQL, MariaDB, MongoDB, Redis, Elasticsearch)
- Environment management (staging, production, preview environments)
- Git-based deployments
- CLI tools
- API access
- Domains and SSL certificates
- Resource scaling (CPU, RAM, disk)
- Backups and disaster recovery

Classify each ticket into exactly ONE category:
- Billing: Payment issues, invoices, pricing questions, plan changes, refunds
- Technical: Deployment failures, errors, performance issues, configuration help
- Feature Request: Suggestions for new features or improvements
- Bug Report: Reports of unexpected behavior or defects
- Account: Login issues, access management, team permissions, profile changes
- General Inquiry: Questions that don't fit other categories

Determine urgency level:
- Critical: Production down, security breach, data loss risk
- High: Major functionality impaired, blocking deployment
- Medium: Issue affecting workflow but workaround exists
- Low: General questions, minor issues, future planning

Determine sentiment:
- Positive: Happy, grateful, complimentary
- Neutral: Matter-of-fact, informational
- Negative: Frustrated, angry, disappointed

Extract:
- Product/service mentioned (if any)
- Customer name (if mentioned)
- Customer email (if mentioned)
- Reference numbers (ticket IDs, order numbers, project IDs, environment names)
- Brief summary (1 sentence)
- Suggested actions for support team (2-3 actionable items)

Respond ONLY with valid JSON matching this exact structure:
{
  "category": "string",
  "urgency": "string",
  "sentiment": "string",
  "product": "string or null",
  "customerName": "string or null",
  "customerEmail": "string or null",
  "referenceNumbers": ["array of strings"],
  "summary": "string",
  "suggestedActions": ["array of strings"]
}`;

export async function classifyTicket(ticketText: string): Promise<ClassificationResult> {
  const model = new ChatOpenAI({
    modelName: OPENAI_MODEL,
    temperature: 0,
  });

  const response = await model.invoke([
    { role: "system", content: SYSTEM_PROMPT },
    { role: "user", content: ticketText },
  ]);

  const content = response.content as string;

  // Extract JSON from response (handle potential markdown code blocks)
  let jsonStr = content;
  const jsonMatch = content.match(/```(?:json)?\s*([\s\S]*?)```/);
  if (jsonMatch) {
    jsonStr = jsonMatch[1].trim();
  }

  const result = JSON.parse(jsonStr) as ClassificationResult;

  // Validate required fields
  if (!result.category || !result.urgency || !result.sentiment) {
    throw new Error("Invalid classification response: missing required fields");
  }

  return result;
}

import type { NextFunction, Request, Response } from "express";

const MAX_TICKET_LENGTH = 10000;
const MIN_TICKET_LENGTH = 10;

export function validateTicketInput(req: Request, res: Response, next: NextFunction): void {
  const { ticket } = req.body;

  if (!ticket || typeof ticket !== "string") {
    res.status(400).json({ error: "Missing or invalid 'ticket' field" });
    return;
  }

  const trimmed = ticket.trim();

  if (trimmed.length < MIN_TICKET_LENGTH) {
    res.status(400).json({ error: `Ticket must be at least ${MIN_TICKET_LENGTH} characters` });
    return;
  }

  if (trimmed.length > MAX_TICKET_LENGTH) {
    res
      .status(400)
      .json({ error: `Ticket exceeds maximum length of ${MAX_TICKET_LENGTH} characters` });
    return;
  }

  req.body.ticket = trimmed;
  next();
}

import type { NextFunction, Request, Response } from "express";

const WINDOW_MS = 60 * 1000; // 1 minute
const MAX_REQUESTS = 20;

interface RateLimitEntry {
  count: number;
  resetAt: number;
}

const ipRequests = new Map<string, RateLimitEntry>();

// Cleanup old entries periodically
setInterval(() => {
  const now = Date.now();
  for (const [ip, entry] of ipRequests.entries()) {
    if (entry.resetAt < now) {
      ipRequests.delete(ip);
    }
  }
}, WINDOW_MS);

export function rateLimiter(req: Request, res: Response, next: NextFunction): void {
  const ip = req.ip || req.socket.remoteAddress || "unknown";
  const now = Date.now();

  let entry = ipRequests.get(ip);

  if (!entry || entry.resetAt < now) {
    entry = { count: 0, resetAt: now + WINDOW_MS };
    ipRequests.set(ip, entry);
  }

  entry.count++;

  if (entry.count > MAX_REQUESTS) {
    const retryAfter = Math.ceil((entry.resetAt - now) / 1000);
    res.setHeader("Retry-After", retryAfter.toString());
    res.status(429).json({
      error: "Too many requests. Please try again later.",
      retryAfter,
    });
    return;
  }

  next();
}

import "dotenv/config";
import { dirname, resolve } from "node:path";
import { fileURLToPath } from "node:url";
import cors from "cors";
import express from "express";
import { classifyTicket } from "./classifier.js";
import { rateLimiter } from "./rate-limiter.js";
import { validateTicketInput } from "./validation.js";

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
const PORT = Number.parseInt(process.env.PORT || "3000", 10);

if (!OPENAI_API_KEY) {
  console.error("ERROR: OPENAI_API_KEY environment variable is required");
  process.exit(1);
}

const app = express();
app.use(cors());
app.use(express.json({ limit: "50kb" }));
app.use(express.urlencoded({ extended: true, limit: "50kb" }));

app.use(express.static(resolve(__dirname, "../public")));

app.post("/api/classify", rateLimiter, validateTicketInput, async (req, res) => {
  const { ticket } = req.body;
  const startTime = performance.now();
  console.log(`[classify] Request: "${ticket.slice(0, 80)}..."`);

  try {
    const result = await classifyTicket(ticket);
    const elapsed = (performance.now() - startTime).toFixed(0);
    console.log(`[classify] Done in ${elapsed}ms | Category: ${result.category}`);
    res.json(result);
  } catch (err) {
    console.error(`[classify] Error after ${(performance.now() - startTime).toFixed(0)}ms:`, err);
    res.status(500).json({ error: "Classification failed. Please try again." });
  }
});

app.get("/health", (_req, res) => {
  res.json({ status: "ok" });
});

app.listen(PORT, () => {
  console.log(`[server] Support ticket classifier running on port ${PORT}`);
});

OPENAI_API_KEY=sk-your-actual-key-here
OPENAI_MODEL=gpt-4o-mini
PORT=3000

OPENAI_API_KEY=
OPENAI_MODEL=gpt-4o-mini
PORT=3000

npm run dev

applications:
  ticket-classifier:
    type: "nodejs:22"

    variables:
      env:
        OPENAI_MODEL: "gpt-4o-mini"

    build:
      flavor: none

    dependencies:
      nodejs:
        pnpm: "9.15.4"

    hooks:
      build: |
        set -e
        echo "Installing dependencies with pnpm..."
        pnpm install --frozen-lockfile

        echo "Compiling TypeScript..."
        pnpm build

        echo "Build complete!"

      deploy: |
        echo "Deploy hook: Nothing to do"

    web:
      commands:
        start: "node dist/index.js"
      locations:
        /:
          passthru: true
          allow: false
          scripts: false
          rules:
            \.(css|js|gif|jpe?g|png|svg|ico|woff2?|ttf|eot|html)$:
              allow: true

    mounts:
      "/.npm":
        source: "storage"
        source_path: "npm_cache"
      "/.pnpm-store":
        source: "storage"
        source_path: "pnpm_store"

    relationships: {}

routes:
  "https://{default}/":
    type: upstream
    upstream: "ticket-classifier:http"
  "https://www.{default}/":
    type: redirect
    to: "https://{default}/"

git init
git add .
git commit -m "Initial commit: Support ticket classifier"

upsun login
upsun project:create

upsun variable:create \
  --level project \
  --name env:OPENAI_API_KEY \
  --value "sk-your-actual-key-here" \
  --sensitive true \
  --visible-build false \
  --visible-runtime true

upsun push

upsun url

upsun logs --tail

// Add to the categories list
- Sales: Pricing inquiries, demo requests, enterprise questions
- Security: Vulnerability reports, compliance questions, audit requests

interface ClassificationResult {
  // ... existing fields
  language: string;           // Detected language
  escalationRequired: boolean; // Needs manager attention
  estimatedResolutionTime: string; // "< 1 hour", "1-4 hours", etc.
}

app.post("/api/classify", rateLimiter, validateTicketInput, async (req, res) => {
  const result = await classifyTicket(ticket);

  // Send to Zendesk, Freshdesk, Linear, etc.
  await fetch("https://api.zendesk.com/tickets", {
    method: "POST",
    headers: { "Authorization": `Bearer ${process.env.ZENDESK_TOKEN}` },
    body: JSON.stringify({
      subject: result.summary,
      priority: mapUrgency(result.urgency),
      tags: [result.category.toLowerCase()],
    }),
  });

  res.json(result);
});

app.post("/api/classify/batch", async (req, res) => {
  const { tickets } = req.body; // Array of strings

  const results = await Promise.all(
    tickets.map(ticket => classifyTicket(ticket))
  );

  res.json(results);
});

# .upsun/config.yaml
relationships:
  database: "postgresql:16"

import pg from "pg";

const pool = new pg.Pool({
  connectionString: process.env.DATABASE_URL,
});

app.post("/api/classify", async (req, res) => {
  const result = await classifyTicket(ticket);

  await pool.query(
    `INSERT INTO classifications (ticket_text, category, urgency, sentiment, created_at)
     VALUES ($1, $2, $3, $4, NOW())`,
    [ticket, result.category, result.urgency, result.sentiment]
  );

  res.json(result);
});

upsun variable:list

const SYSTEM_PROMPT = `...
IMPORTANT: You MUST use EXACTLY one of these categories:
- Billing
- Technical
- Feature Request
- Bug Report
- Account
- General Inquiry

Do not invent new categories or use variations.
...`;

const SYSTEM_PROMPT = `...
CRITICAL: Your response must contain ONLY valid JSON. No explanations, no markdown, no extra text.
Start with { and end with }
...`;

const MAX_REQUESTS = 50; // More generous