World Intelligence MCP Server

Real-time global intelligence across 30+ domains with 139 MCP tools, a live ops-center dashboard, a CLI, and a Qdrant vector store for enterprise-grade semantic search across accumulated intelligence. All data comes from free, public APIs: no paid subscriptions required.

Built for AI agents that need world awareness: market conditions, geopolitical risk, military posture, aircraft-cohort early warning, refugee and migration flows, supply chain disruptions, cyber threats, and more — all queryable via the Model Context Protocol. The vector store enables natural language queries like "military activity near Taiwan" or "cyber threats targeting healthcare" across all historical data.

Total: 139 tools across 30+ intelligence domains.

git clone https://github.com/marc-shade/world-intel-mcp.git
cd world-intel-mcp
pip install -e .

# Optional extras
pip install -e ".[dashboard]"  # Live ops-center dashboard
pip install -e ".[vector]"     # Qdrant vector store + FastEmbed
pip install -e ".[dev]"        # pytest, respx, coverage

world-intel-mcp  # stdio mode for Claude Code, Cursor, etc.

Add to ~/.claude.json:

{
  "mcpServers": {
    "world-intel-mcp": {
      "command": "world-intel-mcp"
    }
  }
}

intel-dashboard              # http://localhost:8501
intel-dashboard --port 9000  # custom port

pip install -e ".[pdf]"      # requires: brew install pango (macOS)
intel report                 # full PDF report → ~/.cache/world-intel-mcp/
intel report --format html   # HTML (no native deps needed)
intel report -o brief.pdf    # custom output path
intel report -s markets,cyber,earthquakes  # select sections

Map-first ops center: Leaflet map with toggle-able layers (quakes, military, conflict, fires, convergence, nuclear, infrastructure, your AOI geofences with last-sweep counts, UNHCR migration corridors between capitals), 47 live SSE feeds, HUD bar, glassmorphic panels, per-source circuit breaker health.

intel markets              # stock indices
intel earthquakes --min-mag 5.0
intel migration-surges     # year-over-year displacement jumps (UNHCR)
intel migration-flows -o Sudan
intel status               # cache + circuit breaker health

server.py     (MCP stdio) ─┐                                               ┌─ VectorStore (Qdrant)
cli.py        (Click CLI)  ├─> sources/*.py ─> Fetcher ─> CircuitBreaker ─┤
dashboard.py  (SSE)        │    analysis/*.py                              └─ Cache (SQLite)
collector.py  (daemon)    ─┘

• Fetcher: Centralized async HTTP client (httpx). Retries, per-source rate limiting, stale-data fallback. Auto-stores results in vector store on fresh fetches.
• CircuitBreaker: Per-source tracking. 3 consecutive failures trips for 5 minutes. Each RSS feed gets its own breaker.
• Cache: SQLite WAL-mode TTL cache. get() returns live data, get_stale() returns expired data for fallback.
• VectorStore: Qdrant + FastEmbed (BAAI/bge-small-en-v1.5, 384-dim). Async background worker queue for non-blocking storage. Enables semantic search across all accumulated intelligence.
• Collector: Standalone daemon that fetches all 55 sources in parallel and populates the vector store. Run once or as a daemon (default: 5-minute interval). Includes the AOI change sweep, so a running daemon continuously watches every defined geofence.
• Sources (sources/*.py): 30+ modules, each exports async def fetch_*(fetcher, **kwargs) -> dict.
• Analysis (analysis/*.py): Cross-domain synthesis — signal aggregation, instability indexing, NLP, company enrichment, macro composite.
• Config (config/*.py): Curated datasets — 22 hotspots, 70+ bases, 40 ports, 24 pipelines, 24 nuclear facilities, 34 cables, 48 datacenters, 27 spaceports, 82 exchanges.

Cohort early warning. The three intel_jet_* tools watch a cohort of aircraft (business jets by ICAO type designator, or military) for activity that departs from its calendar baseline, and locate where an excess came from. Data: adsb.lol's live API and its public half-hour globe_history heatmaps (readsb format, ODbL 1.0, no key). Heatmaps are ~14 MB each and immutable once published, so they are cached on disk next to the cache DB (WORLD_INTEL_HEATMAP_CACHE_MB, default 1024) and fetched at most one at a time with a 2 s floor. The cohort is learned from live snapshots (run intel_jet_cohort_snapshot or the collector daemon, which now includes bizjet_cohort and military_cohort); the analyses only use members first seen min_learning_lead_hours (default 24) before the window, because a cohort learned during a window inflates that window (measured: 1,002 vs a 206 baseline median when the gate is bypassed). Until the cohort has that lead, the tools answer warming_up. The baseline is a handful of same-weekday slots fetched on demand, not a year-long backfill, so there are no learned holiday profiles or annual ratios.

Approach inspired by kylemcdonald/ews (Early Warning System: business-jet cohorts against calendar baselines, and the excess-origin detector). This is an independent implementation over a different, openly licensed data source; no ews code is used.

Static infrastructure results (bases, ports, nuclear, cables, datacenters, spaceports) draw on this repo's curated strategic datasets, which are global and deliberately sparse, not exhaustive local registries. A quiet AOI brief means nothing from those curated sets is in range, not that your area has no infrastructure.

Before the AOI family, only intel_signal_convergence accepted a real point-plus-radius, intel_military_flights took a bbox, and hotspot escalation scoring was restricted to the 22 hardcoded INTEL_HOTSPOTS. The intel_aoi_* tools let you name your own area (a city, a border region, a facility) and get the same cited, multi-domain treatment. Geofences survive the antimeridian (a Bering Strait or Fiji AOI queries both sides of the dateline), and pipelines/undersea cables are matched as line features via great-circle segment distance, not just by their endpoints.

Define an AOI once, then brief, score, edit, and watch it. Three shapes: a circle (point + radius), a polygon (3-64 vertices, for a border region or strait a radius cannot express), or a corridor (a waypoint route + width, for a shipping lane or supply road):

intel_aoi_define(name="Pittsburgh", lat=40.4406, lon=-79.9959, radius_km=50)
intel_aoi_define_polygon(name="Taiwan Strait", vertices=[[22.5, 118.0], [22.5, 121.5], [26.5, 122.0], [26.5, 118.5]])
intel_aoi_define_corridor(name="Suez Approach", waypoints=[[29.9, 32.55], [27.5, 34.0], [24.0, 36.0]], width_km=80)
intel_aoi_brief(name="Taiwan Strait")
intel_aoi_escalation(name="Pittsburgh")
intel_aoi_update(name="Pittsburgh", radius_km=100)   # resize/rename in place
intel_aoi_changes(name="Suez Approach")  # what entered/left since last sweep
intel_aoi_digest()  # one-call sweep across ALL your areas

The same nine operations are available from the terminal: intel aoi define|define-polygon|define-corridor|list|update|delete|brief|escalation|changes.

Membership is exact for the shape (an event inside a polygon's bounding circle but outside the polygon is excluded); corridor distances are measured to the route. Line-feature infrastructure (pipelines, undersea cables) matches the bounding circle for non-circle shapes, disclosed in data_gaps.

intel_aoi_changes is the alerting primitive: the first call records a baseline, and every later call reports what entered and left the fence per domain, with failed fetches reported as data_gaps rather than counted as departures.

intel_aoi_brief filters every geo-capable domain to the 50 km radius around Pittsburgh: earthquakes, military flights (bbox derived from the radius), wildfires (region-mapped, since NASA FIRMS has no point+radius query), ACLED conflict events, a sample of nearby aviation traffic, nearby static infrastructure (military bases, ports, pipelines, nuclear facilities, undersea cables, datacenters, spaceports) with distances in km, and news headline mentions of "Pittsburgh". Every item in the response carries a [n] citation into a numbered sources list, and data_gaps names any domain that couldn't be scoped to the AOI (for example, wildfires when the AOI falls outside NASA FIRMS's coverage regions, or conflict events when ACLED credentials aren't configured) instead of silently omitting it.

intel_aoi_escalation runs the same baseline/military/conflict/social- unrest scoring engine that powers intel_hotspot_escalation for the 22 built-in hotspots, but scoped to your AOI's own radius instead of a fixed 2-degree window.

AOIs persist in a dedicated table inside the same SQLite cache database the server already uses (~/.cache/world-intel-mcp/cache.db by default, or $WORLD_INTEL_CACHE_DB), so a scheduled agent can watch any named area across restarts with intel_aoi_list / intel_aoi_delete to manage them.

The optional Qdrant vector store accumulates intelligence over time for semantic retrieval. All data fetched through the Fetcher is automatically embedded and stored.

# Install Qdrant (Docker)
docker run -p 6333:6333 qdrant/qdrant

# Install vector dependencies
pip install -e ".[vector]"

# Run the collector daemon (populates vector store 24/7)
intel-collector --daemon              # every 5 minutes
intel-collector --daemon --interval 120  # every 2 minutes
intel-collector --sources markets,cyber  # specific domains only
intel-collector                        # single collection cycle
intel-collector --daemon --sources aoi --interval 900  # AOI watch only: sweep every geofence every 15 min

The aoi group runs intel_aoi_digest as a sweep: each cycle diffs every defined AOI against its stored snapshot and advances it, so the daemon interval is your geofence watch cadence. Change digests are logged and (when the vector store is enabled) stored for semantic search. Set WORLD_INTEL_AOI_WEBHOOK to get a POST whenever a sweep finds something entered or left a geofence (quiet sweeps never fire); with WORLD_INTEL_AOI_WEBHOOK_FORMAT=text the body is raw markdown with a Title header, which ntfy-style sinks render directly.

scripts/collector-daemon.sh manages the collector as a launchd agent so it survives reboots. It fills in com.agentic.intel-collector.plist.template with this checkout's own path (resolved from the script's own location, so it works from any clone) and installs the result to ~/Library/LaunchAgents/.

scripts/collector-daemon.sh start    # install + load the launchd job
scripts/collector-daemon.sh status   # check state and log info
scripts/collector-daemon.sh logs     # tail stdout (logs err for stderr)
scripts/collector-daemon.sh stop     # unload the launchd job
scripts/collector-daemon.sh restart
scripts/collector-daemon.sh render   # print the filled-in plist without installing it

Once data accumulates, AI agents can query across all domains:

• "military activity near Taiwan strait" — finds military flights, naval warnings, theater posture data
• "cyber threats targeting healthcare" — finds URLhaus, CISA KEV entries related to healthcare
• "economic indicators suggesting recession" — finds yield curve inversions, macro signals, FRED data

The vector store uses FastEmbed (ONNX-based, BAAI/bge-small-en-v1.5) for embeddings — no GPU required, ~3 second cold start.

Everything else uses free, unauthenticated public APIs.

pip install -e ".[dev]"
pytest                       # 973 tests (991 total, 18 live-network smoke tests deselected by default)
pytest --cov=world_intel_mcp # with coverage
pytest tests/test_forex.py -v # single module

1. Create sources/your_source.py with async def fetch_your_data(fetcher: Fetcher, **kwargs) -> dict
2. Use fetcher.get_json(url, source="your-source", cache_key=..., cache_ttl=300) — automatic caching, retries, circuit breaking, rate limiting
3. In server.py: add Tool(...) to TOOLS, add case to _dispatch() (use inline import)
4. Add tests using respx to mock HTTP (see tests/test_forex.py for pattern)
5. Optionally add to dashboard/app.py (SSE) and cli.py (Click)

MIT