AI_CustomerService: An Intelligent Customer Service System Integrating Large Language Models and Traditional Machine Learning

AI_CustomerService is an open-source project demonstrating a hybrid AI architecture that combines Google Gemini large language model (LLM) with traditional Scikit-learn machine learning models. It implements sentiment analysis and logistics time prediction, building a state-aware end-to-end smart customer service assistant. The project addresses the trade-off between LLM's versatility and traditional ML's efficiency, leveraging each's strengths for a practical solution.

In AI application practice, developers often face a choice: use LLMs for all tasks (versatile but high cost/latency) or traditional ML models for specific tasks (efficient but less flexible in natural language). AI_CustomerService offers a pragmatic answer—combining both: Gemini API handles natural language understanding/generation, while Scikit-learn models process structured tasks like sentiment analysis and logistics prediction. This retains LLM's dialogue ability and achieves cost-effectiveness/interpretability via traditional ML.

The system consists of multiple collaborative modules:

1. Webhook Service Layer: Flask server as entry point, handling API routes and front-end interactions, separating business logic from HTTP transport.
2. LLM Orchestration Layer: Interacts with Gemini API, using prompt engineering (system prompts + few-shot examples) to guide intent recognition, entity extraction, emotion understanding, and reply generation in a professional customer service style.
3. ML Modules: Two Scikit-learn models—Logistic Regression for emotion analysis (local, fast, batch-processable) and Linear Regression for logistics time prediction (input features like origin/destination, package type).
4. Data Persistence Layer: SQLite database for recording user complaints, query history, and system logs, supporting issue tracking and trend analysis.

The system offers professional customer service features:

• State-Aware Dialogue: Maintains session-based memory for multi-turn interactions (e.g., adjusting tone if user expressed dissatisfaction earlier).
• Multi-Modal Interaction: Supports voice via gTTS (text-to-speech) for visually impaired or voice-preferring users.
• Operational Intelligence: Cargo tracking, automatic tax calculation for cross-border shopping, and complaint logging to database for follow-up.

• Emotion Analysis: Uses Logistic Regression (linear classifier) trained on labeled customer dialogue data. Features include TF-IDF/Bag of Words, emotion dictionary matching, and text stats (length, punctuation). Advantages: fast training, small size, interpretable (feature weights).
• Logistics Prediction: Linear Regression for delivery time (input: origin/destination codes, package type, order time, historical average). Can be replaced with complex models (Random Forest) without changing architecture.
• Session State Management: Uses Flask session to store dialogue history, user intent, extracted entities, and task status, enabling complex multi-turn flows (e.g., asking for order number before advising return policy).

• Environment Prep: Python 3.9+ with dependencies (Flask, Google Generative AI, Scikit-learn, gTTS).
• API Key: Get Gemini API key from Google AI Studio, configure in .env (add to .gitignore to avoid leakage).
• DB Initialization: Run db_simulasyon_kurulum.py to create SQLite tables.
• Start Service: Run webhook.py (Flask server at 127.0.0.1:5000). Production considerations: Use Gunicorn (WSGI server), add HTTPS, user authentication, DB backup.

Educational Value:

• Modular design (clear responsibilities, easy maintenance/testing).
• Hybrid architecture decision-making (when to use LLM vs traditional ML).
• Prompt engineering practice (guiding LLM behavior).
• Full-stack development (DB → Web → ML).

Limitations:

• Scalability: SQLite and single-process Flask can't handle high concurrency (improve: PostgreSQL, Redis cache, FastAPI).
• Model management: No version control or auto-update.
• Lack of test suite (need unit/integration tests).
• Missing Docker containerization (planned) and multi-language support.

AI_CustomerService exemplifies pragmatic tech selection—using LLM for natural language, traditional ML for structured tasks, and relational DB for data storage. It balances cost and effectiveness, representing mainstream AI application practice. For beginners, it's an ideal reference (moderate code, clear architecture, real business scenario). The project is open-source under MIT license; code/docs are available on GitHub.