Multi-Agent Customer Support System

A production-ready customer support system powered by CrewAI's multi-agent framework. This system uses specialized AI agents working together to provide intelligent, context-aware customer support through a modern web interface.

Overview

This project demonstrates how multiple specialized AI agents can collaborate to handle customer support inquiries. Each agent has a specific role and expertise, working together to provide comprehensive support that adapts to the complexity and priority of each issue.

Key Features

Multi-Agent Architecture

The system uses four specialized CrewAI agents:

• Support Agent: First-line support, handles general inquiries and provides initial responses
• Technical Agent: Deep technical expertise for complex technical issues
• Escalation Agent: Manages high-priority issues and coordinates multiple agents
• QA Agent: Reviews responses for quality, accuracy, and professionalism

Modern Tech Stack

• CrewAI: Role-based multi-agent framework (different from LangChain)
• FastAPI: High-performance REST API backend
• SQLite/PostgreSQL: Persistent data storage
• Modern Web UI: Clean, responsive chat interface
• RESTful API: Well-structured API endpoints

Core Capabilities

• Intelligent Routing: Automatically routes inquiries to the appropriate agent based on complexity
• Ticket Management: Full ticket lifecycle management
• Conversation History: Maintains context across conversations
• Priority Handling: Different workflows for different priority levels
• Agent Collaboration: Multiple agents can work together on complex issues

Installation

Prerequisites

• Python 3.8 or higher
• Gemini API key
• pip package manager

Setup

1. Clone the repository (or navigate to the project directory):

cd customer_support_agent

1. Install dependencies:

pip install -r requirements.txt

1. Set up environment variables:

# On Linux/Mac
export GEMINI_API_KEY="your-api-key-here"

# On Windows (PowerShell)
$env:GEMINI_API_KEY="your-api-key-here"

# Or create a .env file
echo "GEMINI_API_KEY=your-api-key-here" > .env

1. Initialize the database: The database will be automatically created on first run.

Quick Start

Running the Server

Start the FastAPI server:

python main.py

Or using uvicorn directly:

uvicorn backend.api.main:app --reload --host 0.0.0.0 --port 8000

The server will start on http://localhost:8000

Using the Web Interface

1. Open your browser and navigate to http://localhost:8000/chat
2. Enter your customer ID (or use the default)
3. Start chatting with the AI support agents

Using the API

Send a Message

curl -X POST "http://localhost:8000/api/support/message" \
  -H "Content-Type: application/json" \
  -d '{
    "customer_id": "customer_001",
    "message": "I need help with my account",
    "priority": "medium"
  }'

Create a Ticket

curl -X POST "http://localhost:8000/api/tickets" \
  -H "Content-Type: application/json" \
  -d '{
    "customer_id": "customer_001",
    "subject": "Account Issue",
    "description": "I cannot log into my account",
    "priority": "high"
  }'

Project Structure

customer_support_agent/
├── backend/
│   ├── agents/              # CrewAI agents
│   │   ├── support_agent.py
│   │   ├── technical_agent.py
│   │   ├── escalation_agent.py
│   │   ├── qa_agent.py
│   │   └── crew_manager.py
│   ├── api/                 # FastAPI endpoints
│   │   └── main.py
│   ├── models/              # Data models
│   │   ├── ticket.py
│   │   └── conversation.py
│   ├── services/            # Business logic
│   │   ├── ticket_service.py
│   │   ├── conversation_service.py
│   │   └── support_service.py
│   └── database/            # Database configuration
│       └── database.py
├── frontend/
│   └── templates/
│       └── chat.html        # Web chat interface
├── main.py                  # Application entry point
└── requirements.txt

API Endpoints

Tickets

• POST /api/tickets - Create a new ticket
• GET /api/tickets - Get all tickets
• GET /api/tickets/{ticket_id} - Get a specific ticket
• GET /api/tickets/customer/{customer_id} - Get customer's tickets
• PATCH /api/tickets/{ticket_id} - Update a ticket
• DELETE /api/tickets/{ticket_id} - Delete a ticket

Conversations

• POST /api/conversations - Create a new conversation
• GET /api/conversations/{conversation_id} - Get a conversation
• GET /api/conversations/ticket/{ticket_id} - Get conversation for a ticket

Support

• POST /api/support/message - Handle a customer message
• POST /api/support/ticket - Create ticket and start conversation

How It Works

1. Customer sends a message through the web interface or API
2. System determines priority and complexity
3. Appropriate agent(s) are selected:
   • Standard issues → Support Agent
   • Technical issues → Technical Agent
   • High priority → Escalation Agent coordinates multiple agents
4. Agent processes the inquiry using CrewAI
5. Response is generated and stored in the database
6. Customer receives the response in real-time

Configuration

Environment Variables

• GEMINI_API_KEY: Required for CrewAI agents
• DATABASE_URL: Database connection string (defaults to SQLite)

Best Practices

1. Start with simple inquiries to understand how agents respond
2. Use appropriate priorities - high priority triggers escalation workflow
3. Monitor conversations to see which agents are being used
4. Review ticket history to track issue resolution
5. Customize agent prompts for your specific use case

Differences from Other Frameworks

This project uses CrewAI instead of LangChain, which provides:

• Role-based agent teams
• Built-in agent collaboration
• Task delegation between agents
• Different workflow patterns

The UI uses FastAPI + HTML/JS instead of Streamlit, providing:

• Production-ready REST API
• More control over frontend
• Better performance
• Standard web technologies

Future Enhancements

• WebSocket support for real-time bidirectional communication
• Agent performance analytics
• Custom agent training
• Integration with external ticketing systems
• Multi-language support
• Voice interface

Tech Stack

• CrewAI: Multi-agent framework with role-based agents
• FastAPI: High-performance REST API backend
• SQLite/PostgreSQL: Persistent data storage
• Python 3.8+: Core language

Use Cases

• Customer Support: Automated customer service with intelligent routing
• Ticket Management: Full ticket lifecycle management
• Multi-Agent Collaboration: Specialized agents working together
• Priority Handling: Different workflows for different priority levels

Development

Running Tests

# Run all tests
pytest

# Run tests with coverage
pytest --cov=backend tests/

Linting and Formatting

This project uses ruff for linting and formatting.

# Check for linting issues
ruff check .

# Fix linting issues automatically
ruff check --fix .

# Format code
ruff format .

CI/CD

This project uses GitHub Actions for continuous integration. The workflow includes:

• Linting with ruff
• Running tests with pytest

Contributing

Contributions are welcome! Please read our CONTRIBUTING.md for details on our code of conduct and the process for submitting pull requests.

Community Files

• CODE_OF_CONDUCT.md
• SECURITY.md
• LICENSE