MultiCam is a self-hosted, real-time AI surveillance platform.
It detects, tracks, and recognises people across multiple camera feeds simultaneously —
and clusters unrecognised faces automatically so no one slips through unnoticed.

┌──────────────────────────────────────────────────────────┐
│                     FastAPI Backend                      │
│                                                          │
│  CameraManager ──► CameraHandler threads (non-blocking)  │
│        │                    │ raw frames                 │
│        ▼                    ▼                            │
│   process_camera()  ◄── frame queue                      │
│        │                                                 │
│   PersonDetector  (YOLOv8n)      every 5 frames          │
│        │                                                 │
│   ObjectTracker   (DeepSORT)     persistent IDs          │
│        │                                                 │
│   FaceRecognizer  (MTCNN + FaceNet)                      │
│        ├── known face → name + confidence                │
│        └── unknown   → UnknownFaceClusterer (DBSCAN)     │
│                              │                           │
│   DatabaseManager (SQLite)   │ sightings persisted       │
│        │                                                 │
│   StreamingResponse ──► MJPEG → browser                  │
└──────────────────────────────────────────────────────────┘

git clone https://github.com/tarunkumar-sys/MultiCam.git
cd MultiCam

# Windows
python -m venv venv
venv\Scripts\activate

# Linux / macOS
python3 -m venv venv
source venv/bin/activate

pip install -r requirements.txt

💡 For GPU acceleration install the CUDA build of PyTorch before running the above:

pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121

python app.py

Open your browser at http://localhost:8000

Model weights (YOLOv8n + FaceNet) download automatically on first run.

From the dashboard sidebar → Add Camera:

Passwords containing special characters like @ are automatically percent-encoded.

1. Go to the Dashboard
2. In the sidebar under Register Person, enter the full name
3. Upload a clear, front-facing photo
4. Click Register

The face encoding is extracted and stored immediately.

1. Go to Search & History
2. Type the registered person's name
3. Click Start Search

MultiCam scans every active camera in real time. When the person is spotted, a snapshot is saved and logged. Click Stop Search to end the mission.

Faces that don't match any registered person are not discarded as "Unknown".
Instead, MultiCam:

1. Extracts a 512-d FaceNet embedding for each unrecognised face
2. Assigns it to the nearest DBSCAN cluster (or creates a new one)
3. Labels clusters Unknown Person A, B, C …
4. Logs every sighting with camera ID and timestamp
5. Re-runs DBSCAN every 60 seconds to merge drifted clusters

On the Search & History page, scroll to Unknown Persons (Auto-Clustered) to see:

👤 Unknown Person A
   📍 Cam1  🕒 09:12:34
   📍 Cam3  🕒 09:45:01
   [ Enter name ]  [ Register ]

Click Register to promote the cluster directly into the known persons database — no re-upload needed.

MultiCam/
├── app.py                  # FastAPI app, routes, camera processing loop
├── cameras/
│   └── camera_manager.py   # Non-blocking camera capture threads
├── database/
│   └── db_manager.py       # SQLite — persons, detections, clusters, recordings
├── utils/
│   ├── detector.py         # YOLOv8 person detection
│   ├── tracker.py          # DeepSORT tracking
│   ├── recognizer.py       # MTCNN + FaceNet recognition
│   └── clustering.py       # DBSCAN unknown face clustering
├── templates/              # Jinja2 HTML templates
├── static/                 # CSS + JS
├── requirements.txt
└── .gitignore

RTSP stream not connecting

• Verify the URL in VLC first
• Ensure UDP port 554 is not blocked by your firewall
• Cameras are added non-blocking — the server starts immediately even if the stream is unreachable

Face not recognised

• Register with a well-lit, front-facing photo
• Default threshold is distance < 1.0 — lower to 0.8 in utils/recognizer.py for stricter matching

Low FPS / high CPU

• Detection runs every 5 frames, face recognition every 10 — tune frame_count % N in app.py
• Use a GPU: install the CUDA PyTorch build before other deps

scikit-learn not found

pip install scikit-learn

MIT — free to use, modify, and distribute.