World Intelligence MCP Server

Real-time global intelligence across 30+ domains with 132 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, 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: 132 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), 47 live SSE feeds, HUD bar, glassmorphic panels, per-source circuit breaker health.

intel markets              # stock indices
intel earthquakes --min-mag 5.0
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 50 sources in parallel and populates the vector store. Run once or as a daemon (default: 5-minute interval).
• 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.

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

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                       # 868 tests (886 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