Chuyển tới nội dung chính

UIP - Urban Intelligence Platform

Version License Python React Docker Build Status

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

Quick Start · Documentation · API Reference · Contributing

👥 Development Team​

NameRoleResponsibilities
Nguyễn Nhật QuangLead DeveloperArchitecture, Backend, DevOps, CV Integration
Nguyễn Việt HoàngFull-Stack DeveloperFrontend, API, Documentation
Nguyễn Đình Anh TuấnBackend DeveloperAgent 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):

# 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​

🛠️ 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​

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

💡 Next Steps​

🤝 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

Copyright (c) 2025 UIP Contributors (Nguyễn Nhật Quang, Nguyễn Việt Hoàng, Nguyễn Đình Anh Tuấn)