UIP - Urban Intelligence Platform

Real-time Traffic Management System powered by AI, Computer Vision & Linked Open Data

Quick Start · Documentation · API Reference · Contributing

👥 Development Team

Name	Role	Responsibilities
Nguyễn Nhật Quang	Lead Developer	Architecture, Backend, DevOps, CV Integration
Nguyễn Việt Hoàng	Full-Stack Developer	Frontend, API, Documentation
Nguyễn Đình Anh Tuấn	Backend Developer	Agent System, Data Processing, Testing

🎯 What is this project?

The UIP - Urban Intelligence Platform is a production-ready, multi-agent orchestration platform that:

🚦 Monitors real-time traffic from 1,000+ camera locations
🤖 Detects accidents using YOLOX computer vision
📊 Analyzes patterns with advanced analytics agents
🌐 Publishes Linked Open Data following NGSI-LD and SOSA/SSN standards
🗺️ Visualizes data on an interactive React + MapLibre GL map
📱 Collects citizen reports via mobile-friendly forms

🏗️ Architecture Overview

┌─────────────────────────────────────────────────────────┐
│                   Frontend (React)                       │
│  TrafficMap • Analytics Dashboard • Citizen Reports     │
└───────────────────┬─────────────────────────────────────┘
                    │ REST API + WebSocket
┌───────────────────┴─────────────────────────────────────┐
│              Python Orchestrator (main.py)               │
│  ┌──────────────────────────────────────────────────┐   │
│  │  30+ Specialized Agents                          │   │
│  │  • Data Collection  • Transformation             │   │
│  │  • Analytics        • Context Management         │   │
│  │  • RDF Processing   • Graph Database             │   │
│  └──────────────────────────────────────────────────┘   │
└───────────────────┬─────────────────────────────────────┘
                    │ Data Layer
┌───────────────────┴─────────────────────────────────────┐
│  Neo4j • Fuseki • Stellio • MongoDB • TimescaleDB       │
│  Redis • Kafka                                           │
└─────────────────────────────────────────────────────────┘

🚀 Quick Start

Get started in 3 steps (5 minutes):

Option 1: Docker Compose (Recommended)

# 1. Clone repository
git clone https://github.com/UIP-Urban-Intelligence-Platform/UIP-Urban_Intelligence_Platform.git
cd UIP-Urban_Intelligence_Platform

# 2. Configure environment
cp .env.example .env
# Edit .env with your API keys

# 3. Start all services
docker-compose up -d

# Wait for services to initialize (2-3 minutes)
docker-compose ps

# Access applications
# Frontend: http://localhost:5173
# Backend API: http://localhost:8001
# Neo4j Browser: http://localhost:7474
# Fuseki: http://localhost:3030

Option 2: Local Development

# Python backend
python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate
pip install -e .

# Start orchestrator
python main.py

# Frontend (separate terminal)
cd apps/traffic-web-app/frontend
npm install
npm run dev

📦 Key Features

🎥 Real-time Camera Monitoring

Fetch images from 1,000+ camera locations
Process with YOLOX for vehicle detection
Detect accidents and congestion automatically

🧠 Intelligent Agent System

30+ specialized agents working in parallel
Data collection, transformation, analytics
RDF/Linked Data publishing
State management and caching

🗺️ Interactive Map Interface

MapLibre GL traffic visualization
Multiple overlay layers (weather, AQI, speed zones)
Real-time updates via WebSocket
Advanced filtering and search

📊 Analytics Dashboard

7 chart types (line, bar, pie, area, radar)
Historical data analysis
Pattern recognition
Predictive insights

📱 Citizen Report System

Submit traffic reports with photos
Verify reports using YOLOX
Track report status
Integration with main system

🌐 Semantic Web Standards

NGSI-LD entities for interoperability
SOSA/SSN ontology for sensor observations
RDF triplestores (Apache Jena Fuseki)
SPARQL query support

📖 Documentation Structure

Installation - Setup guides
Architecture - System design
Backend - Python orchestrator
Agents - 30+ agent documentation
Frontend - React application
API Reference - REST & WebSocket APIs
Data Models - NGSI-LD, SOSA/SSN
DevOps - Deployment guides

🛠️ Technology Stack

Backend

Python 3.9+ - Main orchestrator
FastAPI - REST API server
AsyncIO - Asynchronous processing
YOLOX - Computer vision

Frontend

React 18.2 - UI framework
TypeScript 5.2 - Type safety
MapLibre GL JS - Map visualization
Zustand - State management
Recharts - Data visualization

Data Stores

Neo4j 5.12 - Graph database
Apache Jena Fuseki - RDF triplestore
MongoDB 7 - NGSI-LD entities
TimescaleDB - Time-series data
Redis 7 - Caching
Kafka - Streaming

🎓 Learning Path

Beginners: Start with Quick Start and Architecture Overview
Developers: Read Backend Guide and Agent System
Frontend Engineers: See Frontend Documentation
Data Scientists: Explore Data Models and SPARQL Queries
DevOps: Check Docker Compose and CI/CD

💡 Next Steps

📋 Prerequisites - Check system requirements
🐳 Docker Setup - Deploy with Docker
🔧 Local Setup - Development environment
📚 Architecture Deep Dive - Understand the system

🤝 Contributing

Contributions are welcome! See our contribution guide for details.

📄 License

This project is licensed under MIT License.

All components including computer vision modules are MIT licensed.

Computer Vision Stack:

YOLOX (Apache-2.0) - Vehicle and pedestrian detection
DETR (Apache-2.0) - Accident detection via HuggingFace Transformers

For more details, see the LICENSE file in the project root.

Ready to explore? Start with the Prerequisites page! 🚀

Built with ❤️ by the UIP Team

👥 Development Team​

🎯 What is this project?​

🏗️ Architecture Overview​

🚀 Quick Start​

Option 1: Docker Compose (Recommended)​

Option 2: Local Development​

📦 Key Features​

🎥 Real-time Camera Monitoring​

🧠 Intelligent Agent System​

🗺️ Interactive Map Interface​

📊 Analytics Dashboard​

📱 Citizen Report System​

🌐 Semantic Web Standards​

📖 Documentation Structure​

🛠️ Technology Stack​

Backend​

Frontend​

Data Stores​

🎓 Learning Path​

💡 Next Steps​

🤝 Contributing​

📄 License​