Building a Smart Customer Service Agent from Scratch

Market Demand and Technical Challenges of Intelligent Customer Service

Intelligent customer service is one of the most successful tracks in AI commercialization. According to Gartner's prediction, by 2027, over 70% of customer service interactions will be handled by AI. Intelligent customer service can not only respond 24/7 and handle a large number of concurrent requests instantly, but also maintain stable and consistent service quality. However, building a truly useful intelligent customer service Agent is not simple - it needs to simultaneously handle natural language understanding (what the user is actually asking), knowledge retrieval (finding answers from massive product documents), sentiment perception (whether the user is anxious or angry), task execution (helping users with refunds/order inquiries/password resets), and intelligent transfer (deciding when human intervention is needed).

This article will build a fully functional intelligent customer service Agent, covering the entire chain from intent recognition to ticket creation. The code adopts a modular design, allowing you to flexibly replace and extend each component according to your business needs.

Core Architecture Design

Our intelligent customer service Agent adopts a five-layer architecture: access layer (unified API interface, supporting multi-channel access such as Web chat, WeChat, DingTalk, etc.), understanding layer (using DeepSeek for intent recognition, entity extraction, and sentiment analysis), decision layer (deciding whether to auto-reply, query knowledge base, create ticket, or transfer to human based on intent and confidence), execution layer (calling corresponding tools - knowledge retrieval, order inquiry, ticket system API, etc.), and memory layer (maintaining conversation state and user profile, supporting context-aware multi-turn dialogues).

from openai import OpenAI
import json, time

client = OpenAI(api_key="your-deepseek-api-key", base_url="https://api.deepseek.com")

class CustomerServiceAgent:
    def __init__(self):
        self.intents = ["order_query","refund_request","product_info","complaint","greeting","other"]
        self.sentiment_levels = ["positive","neutral","angry","urgent"]
        self.conversations = {}
        self.ticket_system = FakeTicketSystem()  # Simulated ticket system

    def understand(self, user_message, session_id):
        """Understanding layer: intent recognition + entity extraction + sentiment analysis"""
        prompt = f"""Analyze the following customer message and extract structured information.
Customer message: {user_message}

Output in JSON:
{{
  "intent": "{self.intents}",
  "entities": {{"order_id":"","product":"","amount":""}},
  "sentiment": "{self.sentiment_levels}",
  "urgency": 1-10,
  "summary": "Summary within 15 characters",
  "confidence": 0.0-1.0
}}"""
        response = client.chat.completions.create(
            model="deepseek-chat",
            messages=[{"role":"user","content":prompt}],
            temperature=0.1
        )
        return json.loads(response.choices[0].message.content)

    def decide_action(self, analysis):
        """Decision layer: decide next step based on analysis result"""
        if analysis["confidence"] < 0.6:
            return {"action":"clarify", "message":"Sorry, I didn't quite understand your question. Could you elaborate?"}
        if analysis["sentiment"] in ["angry","urgent"] and analysis["urgency"] >= 8:
            return {"action":"transfer_human", "reason":"User is emotionally agitated and urgency is high"}
        if analysis["intent"] == "refund_request":
            return {"action":"create_ticket", "category":"Refund", "priority":"high"}
        if analysis["intent"] == "order_query":
            return {"action":"query_knowledge_base", "query":analysis["summary"]}
        return {"action":"auto_reply", "intent":analysis["intent"]}

    def execute(self, action, analysis, session_id):
        """Execution layer: execute specific actions"""
        if action["action"] == "auto_reply":
            prompt = f"""You are a professional and friendly customer service representative. Please reply to the following customer question.
Customer question: {analysis["summary"]}
Intent: {analysis["intent"]}
Reply requirements: enthusiastic, professional, concise (within 100 characters)"""
            response = client.chat.completions.create(
                model="deepseek-chat",
                messages=[{"role":"user","content":prompt}],
                temperature=0.7
            )
            return response.choices[0].message.content
        elif action["action"] == "create_ticket":
            ticket_id = self.ticket_system.create_ticket(
                category=action["category"],
                priority=action["priority"],
                content=analysis
            )
            return f"A ticket has been created for you (ID: {ticket_id}). Our specialist will contact you within 30 minutes."
        elif action["action"] == "transfer_human":
            return "Your issue has been transferred to a human agent. Please wait..."
        return "I cannot handle this request. It has been transferred to a human agent."

    def chat(self, user_message, session_id):
        if session_id not in self.conversations:
            self.conversations[session_id] = {"history":[], "state":{}}
        conv = self.conversations[session_id]
        conv["history"].append({"role":"user","content":user_message})

        print(f"[Understanding] Analyzing user message...")
        analysis = self.understand(user_message, session_id)
        print(f"  Intent: {analysis['intent']}, Sentiment: {analysis['sentiment']}, Confidence: {analysis['confidence']}")

        print(f"[Decision] Deciding action...")
        action = self.decide_action(analysis)
        print(f"  Action: {action['action']}")

        print(f"[Execution] Executing action...")
        reply = self.execute(action, analysis, session_id)
        conv["history"].append({"role":"assistant","content":reply})
        return reply

class FakeTicketSystem:
    def __init__(self): self.ticket_counter = 0
    def create_ticket(self, category, priority, content):
        self.ticket_counter += 1
        return f"TK-{self.ticket_counter:05d}"

# Usage
agent = CustomerServiceAgent()
print(agent.chat("Hello, I bought a phone last week and it hasn't shipped yet. Order number is 20260715001. When will it arrive?", "session_001"))
print(agent.chat("Too slow! I want a refund!", "session_001"))

Human-Machine Collaboration Mechanism

The most important design of intelligent customer service is not how much AI can do, but when to seamlessly transfer the conversation to a human. Our Agent automatically triggers human transfer in the following situations: sentiment score ≥8 (user extremely dissatisfied or urgent), confidence below 0.6 (Agent is uncertain about user intent), user explicitly requests human service, failure to resolve the issue after 3 consecutive rounds, or involvement of sensitive operations (large refunds, account cancellation, etc.). During transfer, the Agent passes the conversation summary, user profile, and current state to the human agent, enabling a "hot transfer" - the human agent does not need to start from scratch.

Continuous Learning and Optimization

Quality improvement of intelligent customer service is a continuous process. After each conversation, collect user satisfaction ratings (1-5 stars); conduct manual review of low-rated conversations to identify failure reasons; add typical cases to training data to optimize intent recognition and reply strategies; regularly analyze high-frequency unresolved issues to supplement the knowledge base or optimize business processes. It is recommended to hold a weekly Agent performance review meeting to convert feedback into specific optimization tasks.

Multi-Channel Access and Unified Management

Customer service channels in modern enterprises have become highly diversified - Web online customer service, WeChat official accounts, Enterprise WeChat, in-app customer service, phone customer service, etc. The intelligent customer service Agent needs to have multi-channel access capability while sharing user profiles and conversation context across channels, so that "no matter which channel the user enters from, they can continue the previous conversation." Technically, we achieve this through a unified session management middleware - all channel messages are first standardized in format, then routed to the same Agent instance, and the Agent's replies are then format-adapted based on channel characteristics (WeChat does not support Markdown and needs conversion to plain text, while Web supports rich text display).Knowledge Base Management: The answer quality of intelligent customer service largely depends on the quality of the knowledge base. The knowledge base needs continuous maintenance - update promptly when product information changes, supplement more detailed answers for high-frequency questions, and ensure information accuracy for low-frequency but important questions (such as refund policies). It is recommended to establish a "version management" mechanism for the knowledge base - every update has a record, and you can roll back to the previous version if problems occur. At the same time, by analyzing customer service conversation logs, automatically identify "knowledge base gaps" - questions that users repeatedly ask but are not in the knowledge base are the content that needs to be supplemented.

Advanced Applications of Sentiment Computing

In addition to basic positive/negative sentiment recognition, advanced customer service Agents should also be able to: identify users' "potential churn signals" (such as users saying "I'll never use it again" or "Your competitor XX is much better than you"), identify "escalation requests" (users asking to speak to a manager/supervisor, indicating dissatisfaction with current service), and identify "social engineering attacks" (users attempting to obtain others' information by impersonation). These advanced sentiment recognition capabilities allow the Agent to trigger escalation mechanisms earlier in the process, avoiding problem escalation.

Future Outlook: With the enhancement of multimodal capabilities of large models, intelligent customer service will upgrade from pure text interaction to multimodal interaction - users can directly take photos of damaged products and upload them, record a voice message to describe the problem, or even have the customer service "see" the on-site situation through video calls. The Agent will be able to integrate this multimodal information to give more accurate judgments and solutions. At the same time, digital human customer service (combining 3D virtual avatars and natural language interaction) will also become standard in high-end customer service scenarios. The next five years of intelligent customer service will move from "being able to converse" to "being able to see, hear, understand, and empathize."