AI-Powered Project Management System (AI-PMS)

An Intelligent, Collaborative, and Privacy-Preserving Agile Platform

---

---

1. Project Overview

The AI-Powered Project Management System (AI-PMS) is a state-of-the-art, full-stack collaborative platform designed to automate the cognitive and operational overhead of Agile software development. Traditional project management systems (PMS) rely heavily on manual workflows for task breakdown, sprint estimation, and backlog prioritization. This project bridges that gap by integrating local Large Language Models (LLMs) directly into the project lifecycle.

In a pilot evaluation, AI-PMS reduced sprint planning duration by up to 61% while ensuring structural consistency and task dependency tracking. By utilizing a locally hosted LLaMA-8B model, the system maintains complete data privacy, ensuring that proprietary project descriptions, code requirements, and team details never leave local infrastructure.

---

2. System Architecture

AI-PMS is built using a decoupled, 4-tier architecture designed for high throughput, real-time collaboration, and independent scaling of the AI inference engine.

                     ┌────────────────────────────────────────┐
                     │ React SPA Frontend (Vite + Tailwind)   │
                     │  - State: UserContext, WorkspaceCtx   │
                     │  - Pages: Boards, Chats, Inbox, Retro  │
                     └───────────────────┬────────────────────┘
                                         │ REST API + WebSockets
                     ┌───────────────────▼────────────────────┐
                     │ Django REST Framework & Channels API   │
                     │  - Scoped Querysets via Header Middleware│
                     │  - Event-driven Signals                │
                     └─────────┬────────────────────┬─────────┘
            ORM (Postgres)     │                    │ HTTP Scoped Prompts
                     ┌─────────▼─────────┐        ┌─▼─────────────────┐
                     │ PostgreSQL DB     │        │ FastAPI Service   │
                     │  - 12 Models      │        │  - Prompt Temp.   │
                     │  - Audit Trails   │        │  - Pydantic Val.  │
                     └───────────────────┘        └─────────┬─────────┘
                                                            │ Ollama API
                                                  ┌─────────▼─────────┐
                                                  │ LLaMA-8B (Ollama) │
                                                  │  - Local Inference│
                                                  └───────────────────┘

Key Architectural Highlights:

• 3-Tier AI Pipeline: DECUPLES the AI microservice from the core backend. The frontend queries a lightweight FastAPI service, which orchestrates prompt templates and retries with Ollama, returning validated JSON schemas directly back to the app for preview before task insertion.
• Header-Based Scoping (HeaderIDMiddleware): Avoids URL path pollution. Scopes requests to workspace, project, or sprint resources dynamically by parsing custom HTTP headers (X-Workspace-ID, X-Project-ID, X-Sprint-ID) injected by the Axios API layer.
• Event-Driven Signal Handler (api/signals.py): Automatically dispatches email notifications, logs audit trails, and triggers user alerts on model updates (e.g., assignment changes, task transitions, sprint activation).

---

3. Tech Stack & Dependencies

Backend Ecosystem

• Django 5.2 / Django REST Framework: Robust relational API endpoint design.
• Django Channels: Asynchronous WebSocket server utilizing AsyncWebsocketConsumer for real-time collaboration.
• PostgreSQL: Production-grade relational database.
• WhiteNoise: High-performance static serving with caching and Gzip compression.
• SMTP Service: Automatic email OTP delivery with expiration checking.

Frontend Ecosystem

• React 19 & React Router DOM v7: Client-side routing and reactive UI.
• Vite: Sub-second hot-module replacement (HMR) build tool.
• Tailwind CSS: Premium styling framework.
• Framer Motion / Lottie-React: Premium micro-animations and smooth page transitions.
• Axios: Configured interceptors for JWT/Token injects and custom header scoping.

AI Backbone

• FastAPI: High-performance async microservice wrapper.
• Ollama: Local LLM runtime hosting llama3:8b (GGUF quantized formats).
• Pydantic: Validation layers enforcing structured JSON schemas from LLM outputs.

---

4. Detailed Feature Breakdown

AI-Augmented Engine

1. ProjectAnalyzer: Enter a high-level project statement (e.g., "Build an e-commerce platform"), and the engine auto-decomposes it into prioritized tasks, complete with role assignments, estimated durations, and task-to-task dependency arrays.
2. TaskAnalyzer: Automatically classifies user backlog tasks (Frontend, Backend, QA, etc.), scores urgency levels, and predicts story point/hour estimation metrics.
3. AI Chatbot Widget: Embedded persistent chatbot widget answering platform FAQs, suggesting templates, and giving planning advice.

Workspace & Project Management

• Workspace Member Tiers (RBAC): Five role types: Owner (full access), Admin (invite/manage), Team Leader (sprints/priorities), Member (task execution), and Viewer (read-only).
• Workspace Invitations: Secured with URL-safe cryptographically generated 32-byte tokens sent via email. Allows users to accept or decline memberships from their onboarding UI.

Sprint & Kanban Board

• Sprint Lifecycle: Time-boxed sprints with priority targets. Activating a sprint automatically flags and transitions active project states.
• Six-Stage Kanban Task State: Dynamic drag-drop visual routing matching: $$\text{Backlog} \longrightarrow \text{Ready} \longrightarrow \text{In Progress} \longrightarrow \text{In Review} \longrightarrow \text{Stuck} \longrightarrow \text{Done}$$
• Bug Tracker: Specialized issue tracker with prefix keys (e.g., PRJ-42), severity ratings, and resolution tracking.
• Sprint Retrospectives: Real-time post-sprint retrospective board with feedback categories (Improve, Keep, Discussion) and single-vote enforcement.

Real-Time Collaboration

• Isolated Workspace Chat: real-time multi-tenant messaging powered by WebSockets. Scopes chat rooms to active workspace keys, preventing message leak.
• Notification Center: Signal-driven notifications displaying badge alerts, unread counts, and group notifications for sprint changes, mentions, and assignments.

---

5. Installation & Setup

Prerequisites

• Python 3.10+
• Node.js v18+
• PostgreSQL
• Ollama (with the llama3 model downloaded)

---

Backend Setup (Django)

1. Navigate to the backend directory:

   cd backend

2. Create and activate a virtual environment:

   python -m venv venv
   # On Windows (PowerShell):
   .\venv\Scripts\Activate.ps1
   # On Unix/macOS:
   source venv/bin/activate

3. Install dependencies:

   pip install -r requirements.txt

4. Configure Environment Variables: Create a .env file from the example:

   cp .env.example .env

   Open .env and configure your database settings, CORS settings, and SMTP configuration (for OTP delivery).

5. Run Migrations:

   python manage.py migrate

6. Start the Development Server:

   python manage.py runserver

   The API will now be running at http://localhost:8000.

---

Frontend Setup (React)

1. Navigate to the frontend directory:

   cd frontend/pms

2. Install node packages:

   npm install

3. Start the React Development Server:

   npm run dev

   The application will launch at http://localhost:5173.

---

AI Service Setup (FastAPI & Ollama)

1. Install and launch Ollama: Follow instructions at Ollama to install the desktop application.

2. Download the LLaMA model:

   ollama pull llama3:8b

3. Run the AI microservice: Ensure you install FastAPI, Uvicorn, and Ollama client packages if running for the first time:

   pip install fastapi uvicorn ollama pydantic

   Launch the service:

   uvicorn main:app --host 127.0.0.1 --port 8001 --reload

   (Note: Ensure your backend and frontend point to port 8001 as configured for AI analysis requests).

---

6. Directory Layout

AI-Powered-Project-Management-System/
├── backend/                   # Core Django Application
│   ├── api/                   # REST API models, viewsets, signals, and serializers
│   │   ├── models.py          # 12 Core models (Workspace, Sprint, Task, etc.)
│   │   ├── views.py           # Endpoint controllers & scoping mixins
│   │   └── signals.py         # Signal hooks for event notifications
│   ├── backend/               # Django base configuration and URLs
│   ├── chat/                  # Django Channels WebSocket routing & consumers
│   ├── requirements.txt       # Python backend dependencies
│   └── manage.py
├── frontend/                  # React Application
│   └── pms/
│       ├── src/
│       │   ├── components/    # Reusable UI (Sidebar, ChatbotWidget, Invite panel)
│       │   ├── contexts/      # State management (Workspace & User contexts)
│       │   ├── pages/         # Page templates (Dashboard, Retro, Kanban, etc.)
│       │   └── App.jsx        # Routing (14 unique routes)
│       ├── package.json       # React dependencies and scripts
│       └── vite.config.js     # Vite configuration
├── project_abstract.md        # Technical research abstract
├── research_paper_ieee.md     # IEEE template paper outline and draft
└── README.md                  # Main Documentation (This file)

---

7. License

Distributed under the MIT License. See LICENSE for more information (if applicable).