Traditional customer service chatbots frustrate users with canned responses, while raw LLMs pose massive liability risks due to hallucinations in policy coverage and billing. This enterprise-grade AI application - Intelligent Multi-Agent Support System solves this by establishing a LangGraph-orchestrated network of specialized agents.
The system leverages LangGraph to coordinate specialized AI agents, OpenAI GPT for intelligent responses, ChromaDB for semantic retrieval, SQLite for structured customer and policy information, and Chainlit to provide an interactive conversational interface.
In high-volume customer service operations, routine queries—like policy checks, premium due dates, and claim status checks—consume up to 70% of support resources. Standard chatbots fall short because they cannot pull live transactions, while raw LLMs present major compliance risks due to financial hallucinations.
This project introduces an Intelligent Agentic Mesh that:
- Deflects Core Ticket Volumes: Automatically handles structured lookup transactions and FAQs.
- Ensures Zero Hallucinations: Grounded in SQLite schemas to retrieve exact billing and claim records.
- Reduces Average Handling Time: Resolves common user issues in seconds with dynamic, multi-desk routing.
- Improves Operational Auditability: Traced via OpenTelemetry to ensure security boundaries and response quality.
Insurance companies receive a wide range of customer enquiries, including policy information, billing questions, payment history, and requests for human assistance. Traditional chatbots often struggle with conversations that require multiple reasoning steps or access to different information sources.
This project demonstrates how a Multi-Agent AI architecture can automate customer support by intelligently routing requests to specialized AI agents while maintaining conversational context.
The goal was to build a modular AI assistant capable of handling realistic insurance support workflows using modern Agentic AI techniques.
Customer support representatives spend significant time responding to repetitive enquiries such as:
- Insurance policy questions
- Premium and billing enquiries
- Payment history requests
- Customer information lookup
- Escalation to human representatives
A traditional chatbot usually relies on a single reasoning process, making it difficult to handle different responsibilities effectively.
This project demonstrates how multiple specialized AI agents can collaborate to provide more accurate and maintainable customer support.
- Multi-Agent workflow using LangGraph
- OpenAI GPT-powered conversational responses
- Intelligent routing to specialized agents
- Customer policy support
- Billing and payment information retrieval
- Human escalation workflow
- Vector search using ChromaDB
- SQLite database integration
- Interactive conversational interface using Chainlit
- Modular architecture for future expansion
- OpenAI GPT
- LangGraph
- Agentic AI
- ChromaDB
- SQLite
- Pandas
- NumPy
- Hugging Face Datasets
- Python
- Chainlit
- python-dotenv
- tqdm
The application follows a multi-agent architecture coordinated by LangGraph.
- The user submits an insurance-related question through the Chainlit interface.
- LangGraph analyzes the request and routes it to the appropriate specialized agent.
- The selected agent retrieves relevant information from SQLite or ChromaDB when required.
- OpenAI GPT generates a context-aware response.
- The final response is returned to the user while maintaining conversational context.
The assistant answers general insurance-related questions using the LLM together with the retrieval pipeline.
The Billing Agent retrieves premium information before generating a natural language response.
When a customer requests assistance from a human representative, the system detects the intent and routes the conversation accordingly.
The Billing Agent retrieves recent payment history and outstanding balances before generating a conversational response.
Multi-Agent-Insurance-System/
├── README.md
├── requirements.txt
├── .gitignore
├── LICENSE
├── multi_agent_insurance_support.ipynb
├── general_insurance_question.jpg
├── billing_query.jpg
├── human_escalation.jpg
└── payment_history.jpg
Clone the repository.
git clone https://github.com/AShirsat96/Multi-Agent-Insurance-System.gitInstall the required packages.
pip install -r requirements.txtCreate a .env file in the project root and add your OpenAI API key.
OPENAI_API_KEY=your_openai_api_key
Run the notebook using Jupyter Notebook or JupyterLab.
This project demonstrates practical experience with:
- Multi-Agent AI Systems
- Agent Orchestration using LangGraph
- Generative AI Applications
- OpenAI API Integration
- Retrieval-Augmented AI
- Vector Databases (ChromaDB)
- SQLite Database Integration
- Prompt Engineering
- Conversational AI
- Enterprise AI Workflow Design
- Refactor notebook into a modular Python application
- FastAPI backend
- Docker deployment
- User authentication
- AWS Bedrock integration
- Azure OpenAI integration
- Multi-language customer support
- Agent performance evaluation framework
Aniket Shirsat
AI Engineer | Data Scientist | Generative AI
- LinkedIn: https://www.linkedin.com/in/aniketshirsatsg/
- GitHub: https://github.com/AShirsat96
- Portfolio: https://aniketdshirsat.com
This project is licensed under the MIT License - see the LICENSE file for details.
Built with ❤️ using LangGraph, OpenAI, and ChromaDB