Home A - Z
Page Index

Project: CommNet

“The AI-driven network for client communication.”

👥 Team Members

  • Akash Raskar – Backend Developer
  • Vaishnavi Shinde – Backend Developer
  • Rakesh Lokhande – Frontend Developer
  • Kaushal Lamkhade – QA & Testing

Project Description

The Client Communication Management Application is a multi-tenant platform designed to help businesses manage customer interactions through AI-powered communication channels.
It allows each client to onboard their projects, configure communication channels (Telegram, Email, etc.), integrate with preferred AI models (ChatGPT, Perplexity, etc.), and leverage a knowledge base for context-aware responses.

The application provides:

  • A dedicated client dashboard for project setup, knowledge base upload, and communication channel configuration.
  • A customer-facing AI interface (chat page, Telegram bot, or email integration) where end-users can interact with the AI assistant.
  • An admin dashboard to monitor, review, and override AI responses when necessary.

Uploaded project documents and external resources are indexed in a knowledge base powered by vector embeddings (Postgres pgvector or external vector DB). This enables retrieval-augmented generation (RAG), ensuring AI responses are accurate and project-specific.

The platform supports multiple AI connectors, enabling flexibility for businesses to choose the best model for their needs. Clients can seamlessly manage communication, while administrators maintain oversight and control over all conversations.

The system is built on a Python backend (FastAPI/Django), PostgreSQL database, and integrates with external APIs for AI, messaging, email, and storage services.

System Architecture

Frontend

  • Client dashboard: onboarding, project setup, knowledge base upload, channel configuration
  • Customer-facing AI bot interface: chat page embedded in client’s site, Telegram, email, etc.
  • Admin dashboard: monitor conversations, override responses

Backend (Python)

  • Core app framework: Django / FastAPI (FastAPI recommended for async, API-first approach)
  • Authentication & Accounts: Multi-tenant user management (each client = tenant)
  • Project & Channel Management: Store client configs (Telegram bot keys, email SMTP creds, AI model choice)
  • Message Orchestration: Routes queries → preprocess → AI model → knowledge base → return response
  • Knowledge Base (MCP integration): Ingest docs, PDFs, Google Drive/OneDrive, index content, semantic search
  • AI Connector Layer: Wrappers for ChatGPT, Perplexity, and future LLMs
  • Monitoring & Logging: Store all conversations, admin can review & edit

Database

  • PostgreSQL: for structured data (users, projects, configs, logs)
  • Vector DB: Pinecone or open-source FAISS for knowledge base indexing

AI / NLP

  • Connector: OpenAI API (ChatGPT), Perplexity API, and pluggable LLMs
  • Pre-/Post-processing pipeline: inject context, system prompts, etc.
  • Retrieval Augmented Generation (RAG): option to fine-tune or use RAG with knowledge base

Communication Integrations

  • Telegram Bot API: customer chats
  • Email Gateway: SMTP + IMAP, or services like SendGrid
  • Optional: WhatsApp Business API, Slack, Web widget

File Handling & Knowledge Base

  • File parser: PDF, DOCX, TXT
  • Cloud storage integration: Google Drive/Dropbox API for linked knowledge sources
  • Embeddings generator: OpenAI embeddings, HuggingFace models
  • Indexing service: store embeddings into Vector DB

Infrastructure

  • Cloud deployment: AWS
  • Containerization: Docker
  • Background task runner: Celery / RQ for async jobs (e.g., doc parsing)
  • Caching: Redis for messages and sessions
  • CI/CD: GITLAB

System Architecutre Diagram

1. Tech Stack

  • Backend (Python)
    • FastAPI (async, lightweight, API-first approach) or Djangofeatures).
    • SQLAlchemy or Django ORM (for database interactions).
  • Database
    • PostgreSQL (perfectly suited for multi-tenant, relational data storage).
  • Frontend
    • React / Next.js (or Vue/Angular depending on preference).
    • Admin dashboard + Client dashboard.
  • AI/ML Integrations
    • OpenAI API / Perplexity API / Custom AI connectors.
    • Knowledge Base Indexing (e.g., LangChain + Vector DB like Postgres pgvector, Weaviate, or Pinecone).
    • MCP Server (for tool orchestration + context passing).
  • Communication Channels
    • Telegram Bot API integration.
    • Email integration (IMAP/SMTP or services like SendGrid/Mailgun).
  • Infrastructure
    • Docker for containerization.
    • Nginx / Traefik for reverse proxy.
    • Optional: Kubernetes for scaling.

2. Core Modules & Features

🔹 Client Onboarding

  • Form to capture client + project details.
  • Generate dedicated project page for embedding AI bot.
  • Multi-tenant user management (each client = tenant).

🔹 Communication Channels

  • Configurable options for each client:
    • Telegram bot setup.
    • Email inbox setup.
    • Future: WhatsApp, Slack, etc.

🔹 AI Model Connector

  • Ability to select which AI model:
    • ChatGPT (OpenAI).
    • Perplexity.
    • Others (pluggable architecture).
  • Standardized response pipeline regardless of model.

🔹 Knowledge Base

  • Upload project docs (PDF, DOCX, TXT).
  • Import from Drive links / Notion / Confluence.
  • Store embeddings in pgvector (Postgres extension).
  • Retrieval-Augmented Generation (RAG) for query responses.

🔹 Query Processing

  • Customer submits query → AI pipeline:
    1. Normalize input.
    2. Retrieve context from Knowledge Base.
    3. Feed context + query to chosen AI model.
    4. Return AI response.
  • Option for admin override & monitoring.

🔹 Monitoring & Admin Portal

  • View all conversations per client/project.
  • Override/edit AI responses.
  • Track usage per channel/model.
  • Analytics & logs.

Dataflow Diagram

Dataflow Diagram

3. Database Design (Postgres)

Tables (example):

  • clients → Client info (name, domain, etc.)
  • projects → Linked to clients (stores project metadata).
  • channels → Configured communication channels.
  • ai_models → Available model connectors.
  • knowledge_base → Documents & embeddings.
  • queries → User queries & responses.
  • users → Client admins & internal admins.

Use pgvector for embeddings storage and similarity search.

4. External Integrations

  • Telegram Bot API → Webhook for messages.
  • Email API → IMAP/SMTP or SendGrid.
  • AI APIs → OpenAI, Perplexity, etc.
  • Storage → AWS S3 / GCP Storage for uploaded files.
  • Drive APIs → Google Drive API (for fetching docs).
  • Authentication → JWT or OAuth2 (multi-tenant).

5. Deployment & Scaling

  • Containerize with Docker.
  • CI/CD (GitHub Actions / GitLab CI).
  • Cloud hosting (AWS/GCP/Azure/DigitalOcean).
  • Use Postgres + pgvector for persistence + semantic search.
  • Caching layer (Redis) for session storage & rate limiting.