GeoSentinel: The Revolutionary Geospatial Monitoring Platform

Track every vessel, flight, and satellite in real-time. Transform fragmented geospatial data into actionable intelligence. This is the future of OSINT.

Geospatial intelligence is broken. Analysts waste hours jumping between MarineTraffic, FlightRadar, satellite trackers, and news feeds. Critical connections get missed. GeoSentinel fixes this chaos by unifying everything into one powerful platform. Built by h9zdev, this open-source powerhouse aggregates ship routes, flight coordinates, satellite positions, and geopolitical data into a single, AI-enhanced dashboard. Whether you're a cybersecurity researcher, maritime analyst, or intelligence professional, GeoSentinel delivers the geographic awareness you need to make faster, smarter decisions. In this deep dive, you'll discover how to install it, configure its advanced features, and leverage its cutting-edge capabilities—from YOLO-powered aerial segmentation to TOR-enabled dark web searches. Ready to revolutionize your geospatial workflow? Let's get started.

What is GeoSentinel?

GeoSentinel is a next-generation geospatial monitoring platform that tracks global movement patterns in real-time. Created by developer h9zdev, this Python-based system aggregates disparate data streams—ship and flight routes, live GPS coordinates, satellite telemetry, and geospatial metadata—into a unified intelligence framework. The platform provides crystal-clear geographic and geopolitical awareness for analysis, visualization, and mission-critical decision-making.

At its core, GeoSentinel solves a fundamental problem: geospatial data fragmentation. Traditional OSINT workflows require analysts to manually correlate information across dozens of proprietary platforms, each with different APIs, rate limits, and data formats. GeoSentinel eliminates this friction by normalizing data from multiple sources into standardized GeoJSON formats, then layering AI-powered analysis on top. The result? A single pane of glass for global situational awareness.

What makes GeoSentinel genuinely revolutionary is its privacy-first architecture and AI integration. Unlike commercial platforms that harvest your search data, GeoSentinel supports TOR integration for anonymous queries and OLLAMA for local LLM processing. Your intelligence stays yours. The platform also features GeoSential AI, an intelligent assistant that automates real-time tracking of flights and vessels while integrating OSINT from social media platforms through advanced Google Dorking techniques.

The project is actively maintained and tested on Linux systems, with a growing community of security researchers and geospatial analysts contributing to its rapid evolution. Its modular design makes it infinitely extensible—swap AI models, add custom data sources, or integrate new visualization layers with minimal code changes.

Key Features That Make GeoSentinel Unstoppable

GeoSentinel's feature set reads like a wishlist for intelligence professionals. Here's what makes it stand out:

🗺️ Real-Time Multi-Modal Tracking Access live GeoJSON data streams for aircraft, maritime vessels, and satellites simultaneously. The platform ingests ADS-B flight data, AIS vessel signals, and NORAD satellite elements, then renders them on an interactive 3D globe. Surveillance grid tiles provide hierarchical zoom levels, ensuring smooth performance even when tracking thousands of assets globally.

✈️ 🚢 🛰️ Transportation Layer Fusion Dedicated modules handle each transport mode. Flight tracking taps into ADS-B exchange networks. Vessel monitoring parses AIS messages from marine traffic aggregators. Satellite tracking uses TLE (Two-Line Element) data for orbital predictions. All layers sync temporally, letting you analyze correlations—like when a ship changes course as a surveillance satellite passes overhead.

🤖 AI-Powered Analysis Pipeline GeoSentinel integrates YOLO (You Only Look Once) for aerial segmentation, identifying objects in satellite imagery or drone feeds. The OLLAMA integration enables local LLM processing for sentiment analysis of geopolitical news or automated report generation. GeoSential AI acts as your co-pilot, executing complex tracking commands and correlating OSINT findings.

🌐 OSINT & Dark Web Capabilities The Advanced Web Scraper performs multi-engine searches across social media platforms using sophisticated Google Dorking techniques. Extract geotagged posts from Twitter, Reddit, and Instagram to enrich tracking data. The TOR integration enables anonymous searching across multiple .onion engines, crucial for sensitive investigations.

📡 Live Sensor Integration Beyond traditional tracking, GeoSentinel pulls live CCTV traffic camera feeds from around the globe, displays real-time news feeds with geographic tagging, and even supports GPS metadata extraction from images. The particle simulation engine visualizes traffic flow patterns, turning raw data into intuitive movement animations.

🔒 Privacy-First Architecture Run everything locally. Process data through OLLAMA instead of cloud LLMs. Route queries through TOR. The platform respects operational security requirements while delivering commercial-grade capabilities.

Real-World Use Cases: Where GeoSentinel Dominates

1. Maritime Security & Anti-Piracy Operations

A private maritime security firm needs to monitor suspicious vessel behavior off the Horn of Africa. Using GeoSentinel, analysts set up automated alerts for ships that disable AIS transponders near high-risk zones. The platform's YOLO integration scans satellite imagery for small vessels that might be pirate skiffs, while GeoSential AI correlates this with dark web chatter about planned attacks. When a tanker deviates from its declared route, the system automatically cross-references with live CCTV feeds from nearby ports and flags the anomaly. Result: response time drops from hours to minutes.

2. Aviation Incident Investigation & Fleet Monitoring

An aviation journalist investigates a mysterious private jet linked to sanctions evasion. GeoSentinel's flight tracking module reveals the aircraft's complete history, including blocked flights and registration changes. The advanced web scraper extracts geotagged photos from Instagram showing the jet at specific airports. GPS metadata analysis of publicly posted images confirms locations. TOR-enabled searches reveal shell company connections on dark web forums. The journalist builds an unassailable evidence chain without leaving the platform.

3. Geopolitical Intelligence & Crisis Response

During a sudden border conflict, an NGO needs real-time situational awareness. GeoSentinel's live news feed integration with sentiment analysis identifies escalating rhetoric. Satellite tracking shows military asset movements. The 3D Earth visualization reveals terrain advantages. Translation services parse foreign-language social media for on-ground reports. All data streams into a unified dashboard, enabling the NGO to evacuate personnel 48 hours before major hostilities begin.

4. Cybersecurity Threat Hunting & Infrastructure Mapping

A threat hunter tracks a ransomware gang's infrastructure. GeoSentinel's dark web search finds the gang's .onion leak site and parses victim announcements. IP geolocation maps command-and-control servers. Flight and vessel tracking identifies potential physical infrastructure—like a server hosted on a yacht in international waters. The OSINT scraper finds employees discussing work locations on Reddit. This multi-dimensional view reveals the gang's operational structure, leading to successful takedown coordination with law enforcement.

Step-by-Step Installation & Setup Guide

Getting GeoSentinel running takes under 15 minutes. Follow these exact steps.

Prerequisites

• Python 3.8+ (tested on Linux)
• 8GB RAM minimum (16GB recommended for AI features)
• Stable internet connection
• TOR browser (optional, for dark web features)
• OLLAMA (optional, for local LLM processing)

Step 1: Clone the Repository

Choose your preferred method:

Direct Clone:

git clone https://github.com/h9zdev/GeoSentinel.git

Fork First (Recommended for Contributors):

1. Visit https://github.com/h9zdev/GeoSentinel/fork
2. Clone your fork:

git clone https://github.com/<your-username>/GeoSentinel.git

Step 2: Navigate and Prepare Environment

cd GeoSentinel

# Create virtual environment (highly recommended)
python -m venv venv

# Activate it
source venv/bin/activate  # Linux/macOS
# OR
venv\Scripts\activate     # Windows

Step 3: Install Dependencies

pip install -r requirements.txt

This installs Flask, geospatial libraries, AI frameworks, and TOR networking components. The requirements.txt includes folium, geopandas, yolov5, requests[socks], and ollama among others.

Step 4: Download Critical Geodata

GeoSentinel requires a geodata folder in the root directory:

# Download from the official Proton Drive link
wget "https://drive.proton.me/urls/RJB7K8HXTM#r7PnpGiVkg6P" -O geodata.zip
unzip geodata.zip
mv geodata ./

This folder contains base map tiles, surveillance grid definitions, and pretrained YOLO weights.

Step 5: Configure API Keys

Edit templates/earth.html and add your keys:

// Line ~1850: TomTom Maps API for base layers
const tomtomApiKey = 'YOUR_TOMTOM_API_KEY_HERE';

// Line ~2426: Optional Mapbox for 3D globe
const accessToken = 'YOUR_MAPBOX_TOKEN_HERE';

// Line ~2491: OpenWeatherMap for popup weather data
const weatherApiKey = 'YOUR_OPENWEATHER_API_KEY_HERE';

// Line ~2501: TomTom API for traffic layers
const tomtomApiKey = 'YOUR_TOMTOM_API_KEY_HERE';

Also configure any additional APIs in app.py for flight/vessel data sources.

Step 6: Launch the Application

python app.py

The server starts on https://127.0.0.1:8000. Open these endpoints:

• Earth View: https://127.0.0.1:8000/earth
• News Dashboard: https://127.0.0.1:8000/news
• WiFi/Bluetooth Locator: https://127.0.0.1:8000/map-w

Step 7: Optional TOR Setup (Linux)

For dark web searching capabilities:

# Ubuntu/Debian
sudo apt-get update
sudo apt-get install tor torbrowser-launcher -y

# Start TOR service
sudo systemctl start tor
sudo systemctl enable tor

# Verify it's working
curl --socks5 127.0.0.1:9050 https://check.torproject.org/api/ip

Step 8: Optional OLLAMA Setup

For local AI processing:

# Install OLLAMA
curl -fsSL https://ollama.ai/install.sh | sh

# Verify installation
ollama --version

# Pull a model (Llama 2 recommended)
ollama pull llama2

# Start the server
ollama serve

OLLAMA runs on localhost:11434 and integrates seamlessly with GeoSential AI.

REAL Code Examples from the Repository

Let's examine actual code snippets from GeoSentinel's implementation and understand their power.

Example 1: TomTom API Integration in Earth View

This JavaScript from templates/earth.html shows how GeoSentinel initializes mapping layers:

// Line ~1850: Initialize TomTom Maps SDK with API key
const tomtomApiKey = 'YOUR_TOMTOM_API_KEY'; // Replace with your actual key

// Create the main map instance with traffic flow and incidents
const map = tt.map({
    key: tomtomApiKey,
    container: 'map',
    center: [0, 20], // Center on Africa for maritime view
    zoom: 2,
    style: 'tomtom://vector/1/basic-main', // Vector tiles for performance
    traffic: true, // Enable live traffic flow
    trafficIncidents: true // Show incidents as points
});

// Add surveillance grid tile layer for hierarchical data loading
map.addLayer({
    id: 'surveillance-grid',
    type: 'vector',
    source: {
        type: 'vector',
        tiles: ['/api/grid/{z}/{x}/{y}'], // Dynamic grid endpoint
        minzoom: 0,
        maxzoom: 12
    },
    'source-layer': 'grid',
    paint: {
        'fill-color': '#ff0000',
        'fill-opacity': 0.1
    }
});

Explanation: This code initializes a high-performance vector map with live traffic data. The surveillance grid layer loads data dynamically based on zoom level, preventing browser overload when tracking thousands of global assets. The tomtom://vector/1/basic-main style ensures smooth rendering, while the grid endpoint provides spatial indexing for efficient queries.

Example 2: Dark Web Search via TOR Integration

This Python pattern from app.py demonstrates anonymous searching:

import requests
import json

# Configure TOR proxy for .onion requests
proxies = {
    'http': 'socks5h://127.0.0.1:9050',  # h = hostname resolution via TOR
    'https': 'socks5h://127.0.0.1:9050'
}

def search_darkweb(query, onion_engines):
    """
    Search across multiple .onion engines anonymously
    """
    results = []
    for engine in onion_engines:
        try:
            # Each engine has a hidden service address
            url = f"http://{engine['onion']}/search"
            
            # Route through TOR network
            response = requests.post(
                url,
                data={'q': query},
                proxies=proxies,
                timeout=30,  # TOR is slower than clearnet
                headers={'User-Agent': 'GeoSentinel/1.0'}
            )
            
            if response.status_code == 200:
                # Parse results and add metadata
                parsed = response.json()
                parsed['source'] = engine['name']
                parsed['anonymized'] = True
                results.append(parsed)
                
        except Exception as e:
            print(f"[TOR] Engine {engine['name']} failed: {e}")
            continue
    
    return results

# Example usage: Search for vessel names on dark web markets
onion_engines = [
    {'name': 'darkship', 'onion': 'darkshipxyz.onion'},
    {'name': 'maritimewatch', 'onion': 'watchmarine.onion'}
]
findings = search_darkweb("MT EVEREST vessel documents", onion_engines)

Explanation: This function demonstrates GeoSentinel's privacy-first approach. The socks5h protocol ensures DNS resolution happens through TOR, preventing leaks. The timeout accounts for TOR's latency, while error handling ensures one failed engine doesn't crash the entire search. This is crucial for sensitive investigations where anonymity is paramount.

Example 3: GeoSential AI Command Processing

GeoSential AI automates complex tracking tasks. Here's how it parses natural language commands:

# In app.py - GeoSential AI endpoint
@app.route('/api/geosential', methods=['POST'])
def geosential_ai():
    data = request.json
    command = data.get('command', '')
    
    # Parse natural language intent
    if "track flight" in command.lower():
        flight_number = extract_flight_number(command)
        return track_flight_automated(flight_number)
    
    elif "monitor vessel" in command.lower():
        vessel_name = extract_vessel_name(command)
        # Start background monitoring task
        threading.Thread(
            target=continuous_vessel_monitor,
            args=(vessel_name,),
            daemon=True
        ).start()
        return {"status": "monitoring_started", "vessel": vessel_name}
    
    elif "correlate" in command.lower():
        # AI-driven correlation between transport and OSINT
        entities = extract_entities(command)
        correlation = perform_osint_correlation(entities)
        return correlation
    
    # Fallback to OLLAMA LLM for general queries
    else:
        ollama_response = ollama.chat(
            model='llama2',
            messages=[{'role': 'user', 'content': command}]
        )
        return {"ai_response": ollama_response['message']['content']}

def extract_flight_number(text):
    # Regex to find flight codes like AA1234 or BA 123
    import re
    match = re.search(r'([A-Z]{2}\s*\d{1,4})', text.upper())
    return match.group(1) if match else None

Explanation: This endpoint showcases GeoSential AI's dual-mode operation. For structured commands, it executes optimized functions directly. For complex queries, it leverages OLLAMA's local LLM. The regex-based extraction ensures reliable parsing of flight/vessel identifiers, while threading enables continuous background monitoring without blocking the API.

Example 4: YOLO Aerial Segmentation

GeoSentinel uses YOLO for object detection in aerial imagery:

import torch
from PIL import Image

# Load YOLOv5 model pretrained on aerial imagery
model = torch.hub.load('ultralytics/yolov5', 'custom', 
                       path='geodata/yolo/aerial_v8.pt')

def analyze_satellite_image(image_path, coordinates):
    """
    Detect objects in satellite imagery and geotag them
    """
    # Load image
    img = Image.open(image_path)
    
    # Run inference
    results = model(img)
    
    # Parse detections
    detections = results.pandas().xyxy[0]
    
    # Add geospatial context
    geotagged_objects = []
    for _, obj in detections.iterrows():
        # Convert bounding box center to lat/lng
        center_x = (obj['xmin'] + obj['xmax']) / 2
        center_y = (obj['ymin'] + obj['ymax']) / 2
        
        # Map pixel coordinates to real-world coordinates
        lat, lng = pixel_to_latlng(center_x, center_y, coordinates)
        
        geotagged_objects.append({
            'class': obj['name'],  # e.g., 'vessel', 'aircraft', 'vehicle'
            'confidence': obj['confidence'],
            'coordinates': [lat, lng],
            'size_meters': estimate_size(obj, coordinates['zoom_level'])
        })
    
    return geotagged_objects

# Example: Detect ships in port imagery
vessels = analyze_satellite_image(
    'geodata/satellite/port_of_shanghai.png',
    {'lat': 31.2304, 'lng': 121.4737, 'zoom_level': 17}
)

Explanation: This demonstrates how GeoSentinel bridges computer vision and geospatial analysis. The custom YOLO model (aerial_v8.pt) is trained to recognize maritime and aviation assets. The pixel_to_latlng function converts image coordinates to real-world coordinates, enabling precise targeting. This is invaluable for monitoring port congestion, identifying undeclared vessels, or tracking military deployments.

Advanced Usage & Best Practices

Performance Optimization:

• Use vector tiles instead of raster for smoother zooming. The TomTom vector API renders client-side, reducing bandwidth.
• Enable surveillance grid caching in app.py by setting GRID_CACHE_TTL = 300. This stores frequently accessed grid tiles in memory.
• Run OLLAMA on GPU if available. Edit /etc/ollama/config.json to set "gpu": true for 10x faster AI inference.

Security Hardening:

• Never commit API keys. Use environment variables: export TOMTOM_KEY="your_key" then reference os.environ.get('TOMTOM_KEY') in code.
• Run TOR in a separate Docker container for isolation: docker run -d -p 9050:9050 dperson/torproxy
• Enable HTTPS in production by adding SSL certificates to the Flask configuration.

Custom Data Source Integration: Add new vessel tracking providers by extending the VesselTracker class in app.py:

class CustomVesselTracker(VesselTracker):
    def fetch_data(self):
        # Implement your API call
        return requests.get('https://your-provider.com/api/vessels').json()

AI Model Selection: For maritime focus, fine-tune YOLO on ship datasets. For geopolitical analysis, use mistral or neural-chat models in OLLAMA instead of Llama 2 for better reasoning.

GeoSentinel vs. Alternatives

Verdict: GeoSentinel is the only platform combining all modalities with AI and privacy features. While commercial tools excel in single domains, none match GeoSentinel's comprehensive, extensible architecture.

Frequently Asked Questions

Q: Is GeoSentinel legal to use? A: Absolutely. GeoSentinel aggregates publicly available data (ADS-B, AIS, TLE) and uses standard OSINT techniques. Always comply with local laws regarding network scanning and data usage.

Q: What are the minimum system requirements? A: Linux system with Python 3.8+, 8GB RAM (16GB for AI features), and 10GB storage for geodata. GPU recommended for YOLO inference but not required.

Q: How accurate is the real-time tracking? A: Flight data updates every 5-10 seconds via ADS-B. Vessel AIS data depends on terrestrial receiver density—coastal areas see updates every 30 seconds, open ocean every 5-15 minutes. Satellite positions are calculated from TLE data accurate to within 1km.

Q: Can I add my own data sources? A: Yes! GeoSentinel's modular design makes it trivial. Extend the base tracker classes in app.py and add your API endpoints. The system automatically normalizes data to GeoJSON format.

Q: Does it work on Windows or macOS? A: Core features work cross-platform, but TOR and OLLAMA integration are optimized for Linux. For best results, use WSL2 on Windows or a Linux VM on macOS.

Q: How do I contribute to the project? A: Fork the repository, create a feature branch, and submit a pull request. Focus on adding new data providers, improving AI models, or enhancing visualization layers. Check existing issues for roadmap items.

Q: What's the difference between GeoSentinel and GeoSential AI? A: GeoSentinel is the platform; GeoSential AI is the intelligent assistant within it. GeoSential processes natural language commands and automates tracking tasks, while GeoSentinel handles data aggregation and visualization.

Conclusion: Your Geospatial Intelligence Revolution Starts Now

GeoSentinel isn't just another tracking tool—it's a paradigm shift. By unifying flight, maritime, and satellite data with AI-powered analysis and privacy-preserving features, it democratizes capabilities once limited to government agencies. The platform's open-source nature means it evolves with community needs, while its modular architecture ensures it adapts to any mission profile.

We've covered everything from installation to advanced YOLO segmentation, TOR-enabled dark web searches, and GeoSential AI automation. The code examples show exactly how to implement these features, and the use cases prove real-world impact. Whether you're hunting cyber threats, monitoring maritime security, or analyzing geopolitical risks, GeoSentinel delivers unmatched situational awareness.

The future of OSINT is integrated, intelligent, and private. GeoSentinel delivers all three. Don't waste another day switching between fragmented tools. Clone the repository, configure your API keys, and start transforming raw geospatial data into actionable intelligence today.

🚀 Ready to get started? Visit the official repository at https://github.com/h9zdev/GeoSentinel to clone, star, and join the revolution. Your next breakthrough insight is waiting in the data.