Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.
// SPDX-License-Identifier: MIT
// Copyright contributors to the kepler.gl project
import React, {useCallback, useEffect, useRef, useState} from 'react';
import styled, {ThemeProvider, StyleSheetManager} from 'styled-components';
import {useDispatch, useStore} from 'react-redux';
import cloneDeep from 'es-toolkit/compat/cloneDeep';
import isEqual from 'es-toolkit/compat/isEqual';
import {useSelector} from 'react-redux';
import isPropValid from '@emotion/is-prop-valid';
import {useParams, useSearchParams, useLocation} from 'react-router-dom';
import {WebMercatorViewport} from '@deck.gl/core';
import {setMapBoundary} from '@openassistant/kepler-assistant';
import {AiAssistantPanel} from '@openassistant/kepler-assistant';
import {KeplerWebMcp} from './kepler-webmcp';
import {KeplerMcpBridge} from './kepler-mcp-bridge';
import {panelBorderColor, theme} from '@kepler.gl/styles';
import {ParsedConfig} from '@kepler.gl/types';
import {getApplicationConfig} from '@kepler.gl/utils';
import {SqlPanel} from '@kepler.gl/duckdb/components';
import Banner from './components/banner';
import Announcement, {FormLink} from './components/announcement';
import {replaceLoadDataModal} from './factories/load-data-modal';
import {replaceMapControl} from './factories/map-control';
import {replacePanelHeader} from './factories/panel-header';
import {CLOUD_PROVIDERS_CONFIGURATION, DEFAULT_FEATURE_FLAGS} from './constants/default-settings';
import {messages} from './constants/localization';
import {getRuntimeConfig} from './utils/runtime-config';
import {
loadRemoteMap,
loadSampleConfigurations,
onExportFileSuccess,
onLoadCloudMapSuccess
} from './actions';
import {
loadCloudMap,
addDataToMap,
replaceDataInMap,
toggleMapControl,
toggleModal
} from '@kepler.gl/actions';
import {CLOUD_PROVIDERS} from './cloud-providers';
import {Panel, PanelGroup, PanelResizeHandle} from 'react-resizable-panels';
const KeplerGl = require('@kepler.gl/components').injectComponents([
replaceLoadDataModal(),
replaceMapControl(),
replacePanelHeader()
]);
// Sample data
/* eslint-disable no-unused-vars */
import sampleTripData, {testCsvData, sampleTripDataConfig} from './data/sample-trip-data';
// import sampleGeojson from './data/sample-small-geojson';
import sampleGeojsonPoints from './data/sample-geojson-points';
import sampleGeojsonConfig from './data/sample-geojson-config';
import sampleH3Data, {config as h3MapConfig} from './data/sample-hex-id-csv';
import sampleS2Data, {config as s2MapConfig, dataId as s2DataId} from './data/sample-s2-data';
import sampleA5Data, {config as a5MapConfig, dataId as a5DataId} from './data/sample-a5-data';
import sampleAnimateTrip, {
pointData,
pointDataId,
animateTripDataId,
replacePointData,
config as syncedTripConfig
} from './data/sample-animate-trip-data';
import sampleGpsData from './data/sample-gps-data';
import sampleRowData, {config as rowDataConfig} from './data/sample-row-data';
import {sampleFlowData, config as flowDataConfig} from './data/sample-flow-data';
import {createContourCsv, contourConfig, contourDataId} from './data/sample-contour-data';
import {processCsvData, processGeojson, processRowObject} from '@kepler.gl/processors';
/* eslint-enable no-unused-vars */
// This implements the default behavior from styled-components v5
function shouldForwardProp(propName: string, target: unknown) {
if (typeof target === 'string') {
// For HTML elements, forward the prop if it is a valid HTML attribute
return isPropValid(propName);
}
// For other elements, forward all props
return true;
}
const BannerHeight = 48;
const BannerKey = `banner-${FormLink}`;
const keplerGlGetState = state => state.demo.keplerGl;
const GlobalStyle = styled.div`
font-family: ff-clan-web-pro, 'Helvetica Neue', Helvetica, sans-serif;
font-weight: 400;
font-size: 0.875em;
line-height: 1.71429;
*,
*:before,
*:after {
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
}
ul {
margin: 0;
padding: 0;
}
li {
margin: 0;
}
a {
text-decoration: none;
color: ${props => props.theme.labelColor};
}
`;
const CONTAINER_STYLE = {
transition: 'margin 1s, height 1s',
position: 'absolute',
width: '100%',
height: '100%',
left: 0,
top: 0,
display: 'flex',
flexDirection: 'column',
backgroundColor: '#333'
};
const StyledResizeHandle = styled(PanelResizeHandle)`
background-color: ${panelBorderColor};
&:hover {
background-color: #555;
}
width: 100%;
height: 5px;
cursor: row-resize;
`;
const StyledVerticalResizeHandle = styled(PanelResizeHandle)`
background-color: ${panelBorderColor};
width: 4px;
height: 100%;
cursor: row-resize;
&:hover {
background-color: #555;
}
`;
const App = props => {
const [showBanner, toggleShowBanner] = useState(false);
const {id, provider} = useParams();
const [searchParams] = useSearchParams();
const location = useLocation();
const query = Object.fromEntries(searchParams.entries());
const dispatch = useDispatch();
const reduxStore = useStore();
// TODO find another way to check for existence of duckDb plugin
const duckDbPluginEnabled = (getApplicationConfig().plugins || []).some(p => p.name === 'duckdb');
const isSqlPanelOpen = useSelector(
state => duckDbPluginEnabled && state?.demo?.keplerGl?.map?.uiState.mapControls.sqlPanel?.active
);
const isAiAssistantPanelOpen = useSelector(
state => state?.demo?.keplerGl?.map?.uiState.mapControls.aiAssistant?.active
);
const prevQueryRef = useRef<{
provider?: string;
id?: string;
query: Record<string, string>;
} | null>(null);
const mapContainerRef = useRef<HTMLDivElement>(null);
const [mapDimensions, setMapDimensions] = useState({width: 0, height: 0});
const runtime = getRuntimeConfig();
useEffect(() => {
if (!mapContainerRef.current) return;
const observer = new ResizeObserver(entries => {
const {width, height} = entries[0].contentRect;
setMapDimensions({width, height});
});
observer.observe(mapContainerRef.current);
return () => observer.disconnect();
}, []);
// Handle OAuth callback on /auth route
useEffect(() => {
if (location.pathname === '/auth' && window.opener) {
const {getCloudProvider, DEFAULT_CLOUD_PROVIDER} = require('./cloud-providers');
const authProvider = getCloudProvider(DEFAULT_CLOUD_PROVIDER);
const token = authProvider.getAccessTokenFromLocation(location);
window.opener.postMessage({token}, window.location.origin);
}
}, [location]);
useEffect(() => {
// if we pass an id as part of the url
// we try to fetch along map configurations
const cloudProvider = CLOUD_PROVIDERS.find(c => c.name === provider);
if (cloudProvider) {
// Prevent constant reloading after change of the location
if (isEqual(prevQueryRef.current, {provider, id, query})) {
return;
}
dispatch(
loadCloudMap({
loadParams: query,
provider: cloudProvider,
onSuccess: onLoadCloudMapSuccess
})
);
prevQueryRef.current = {provider, id, query};
return;
}
// Load sample using its id
if (id) {
dispatch(loadSampleConfigurations(id));
}
// Load map using a custom URL. Prefer ?mapUrl=; otherwise use runtime config
// only when no /demo/:id sample is being loaded (avoids racing two map loads).
if (query.mapUrl) {
// TODO?: validate map url
dispatch(loadRemoteMap({dataUrl: query.mapUrl}));
} else if (!id && runtime.mapUrl) {
dispatch(loadRemoteMap({dataUrl: runtime.mapUrl}));
}
if (duckDbPluginEnabled && query.sql) {
dispatch(toggleMapControl('sqlPanel', 0));
dispatch(toggleModal(null));
}
// delay zs to show the banner
// if (!window.localStorage.getItem(BannerKey)) {
// window.setTimeout(_showBanner, 3000);
// }
// load sample data
_loadSampleData();
// Notifications
// no dependencies, as this was part of componentDidMount
// eslint-disable-next-line react-hooks/exhaustive-deps
}, []);
/**
* Update map boundary when view state changes, used by ai-assistant to
* get data from vector tiles when map boundary changes
*/
const onViewStateChange = useCallback(
viewState => {
const viewport = new WebMercatorViewport(viewState);
const nw = viewport.unproject([0, 0]);
const se = viewport.unproject([viewport.width, viewport.height]);
dispatch(setMapBoundary(nw, se));
},
[dispatch]
);
/*
const _showBanner = useCallback(() => {
toggleShowBanner(true);
}, [toggleShowBanner]);
*/
const hideBanner = useCallback(() => {
toggleShowBanner(false);
}, [toggleShowBanner]);
const _disableBanner = useCallback(() => {
hideBanner();
window.localStorage.setItem(BannerKey, 'true');
}, [hideBanner]);
const _loadRowData = useCallback(() => {
dispatch(
addDataToMap({
datasets: [
{
info: {
label: 'Sample Visit Data',
id: 'sample_visit_data'
},
data: processRowObject(sampleRowData)
}
],
config: rowDataConfig
})
);
}, [dispatch]);
const _loadVectorTileData = useCallback(() => {
dispatch(
addDataToMap({
datasets: [
{
info: {
label: 'Railroads',
id: 'railroads.pmtiles',
color: [255, 0, 0],
type: 'vector-tile'
},
data: {
rows: [],
fields: [
{
name: 'continent',
type: 'string',
format: '',
analyzerType: 'STRING'
}
]
},
metadata: {
name: 'output.pmtiles',
description: 'output.pmtiles',
type: 'remote',
remoteTileFormat: 'pmtiles',
tilesetDataUrl:
'https://4sq-studio-public.s3.us-west-2.amazonaws.com/pmtiles-test/161727fe-7952-4e57-aa05-850b3086b0b2.pmtiles',
tilesetMetadataUrl:
'https://4sq-studio-public.s3.us-west-2.amazonaws.com/pmtiles-test/161727fe-7952-4e57-aa05-850b3086b0b2.pmtiles',
id: 'sz6uy1xtj',
format: 'rows',
label: 'output.pmtiles',
metaJson: null,
bounds: [-150.1122219, -51.8952777, 179.3577783, 69.6043747],
center: [14.0625, 50.7026397, 6],
maxZoom: 6,
minZoom: 0,
fields: [
{
name: 'continent',
id: 'continent',
format: '',
filterProps: {
domain: [
'Africa',
'Asia',
'Europe',
'North America',
'Oceania',
'South America'
],
value: [],
type: 'multiSelect',
gpu: false
},
type: 'string',
analyzerType: 'STRING'
}
]
}
}
],
options: {
autoCreateLayers: true
}
})
);
}, [dispatch]);
const _loadPointData = useCallback(() => {
dispatch(
addDataToMap({
datasets: [
{
info: {
label: 'Sample Taxi Trips 1',
id: 'test_trip_data',
color: [255, 0, 0]
},
data: {
rows: sampleTripData.rows.slice(0, 20),
fields: cloneDeep(sampleTripData.fields)
}
},
{
info: {
label: 'Sample Taxi Trips 2',
id: 'test_trip_data_2',
color: [0, 255, 0]
},
data: {
rows: sampleTripData.rows.slice(5, sampleTripData.rows.length),
fields: cloneDeep(sampleTripData.fields)
}
}
],
options: {
// centerMap: true,
keepExistingConfig: true
},
config: sampleTripDataConfig
})
);
}, [dispatch]);
const _loadScenegraphLayer = useCallback(() => {
dispatch(
addDataToMap({
datasets: {
info: {
label: 'Sample Scenegraph Ducks',
id: 'test_trip_data'
},
data: processCsvData(testCsvData)
},
config: {
version: 'v1',
config: {
visState: {
layers: [
{
type: '3D',
config: {
dataId: 'test_trip_data',
columns: {
lat: 'gps_data.lat',
lng: 'gps_data.lng'
},
isVisible: true
}
}
]
}
}
}
})
);
}, [dispatch]);
const _loadIconData = useCallback(() => {
// Demonstrates all 3 icon sources:
// 1. CDN icons (e.g. 'accel') - fetched automatically
// 2. Inline custom icons (e.g. 'custom-star'') - via initApplicationConfig({ customIcons })
// 3. Remote custom icons (e.g. 'remote-triangle', 'remote-cross', 'remote-hexagon') - via customIconUrl
const csvData = [
'time,lat,lng,icon,annotation-severity,annotation-html',
'2016-06-28 20:10:00,37.780,-122.410,accel,5,"Default CDN icon"',
'2016-06-28 20:10:10,37.782,-122.415,custom-star,5,"Inline custom star"',
'2016-06-28 20:10:30,37.778,-122.405,remote-triangle,3,"Remote triangle icon"',
'2016-06-28 20:10:40,37.784,-122.420,remote-cross,2,"Remote cross icon"',
'2016-06-28 20:10:50,37.772,-122.412,remote-hexagon,4,"Remote hexagon icon"'
].join('\n');
dispatch(
addDataToMap({
datasets: [
{
info: {
label: 'Icon Data',
id: 'test_icon_data'
},
data: processCsvData(csvData)
}
],
config: {
version: 'v1',
config: {
visState: {
layers: [
{
type: 'icon',
config: {
dataId: 'test_icon_data',
label: 'Custom Icons',
columns: {
lat: 'lat',
lng: 'lng',
icon: 'icon'
},
isVisible: true,
visConfig: {
radius: 100
}
}
}
]
}
}
}
})
);
}, [dispatch]);
const _loadTripGeoJson = useCallback(() => {
dispatch(
addDataToMap({
datasets: [
{
info: {label: 'Trip animation', id: animateTripDataId},
data: processGeojson(sampleAnimateTrip)
}
]
})
);
}, [dispatch]);
const _loadGeojsonData = useCallback(() => {
// load geojson
const geojsonPoints = processGeojson(sampleGeojsonPoints);
const geojsonZip = null; // processGeojson(sampleGeojson);
dispatch(
addDataToMap({
datasets: [
geojsonPoints
? {
info: {label: 'Bart Stops Geo', id: 'bart-stops-geo'},
data: geojsonPoints
}
: null,
geojsonZip
? {
info: {label: 'SF Zip Geo', id: 'sf-zip-geo'},
data: geojsonZip
}
: null
].filter(d => d !== null),
options: {
keepExistingConfig: true
},
config: sampleGeojsonConfig as ParsedConfig
})
);
}, [dispatch]);
const _loadSyncedFilterWTripLayer = useCallback(() => {
dispatch(
addDataToMap({
datasets: [
{
info: {label: 'Trip animation', id: animateTripDataId},
data: processGeojson(sampleAnimateTrip)
},
{
info: {
label: 'Sample Taxi Trips',
id: pointDataId,
color: [255, 0, 0]
},
data: pointData
}
],
config: syncedTripConfig,
options: {
centerMap: true
}
})
);
}, [dispatch]);
const _replaceSyncedFilterWTripLayer = useCallback(() => {
window.setTimeout(() => {
dispatch(
replaceDataInMap({
datasetToReplaceId: pointDataId,
datasetToUse: {
info: {label: 'Sample Taxi Trips Replaced', id: `${pointDataId}-2`},
data: replacePointData
}
})
);
}, 1000);
}, [dispatch]);
const _replaceData = useCallback(() => {
// add geojson data
const sliceData = processGeojson({
type: 'FeatureCollection',
features: sampleGeojsonPoints.features.slice(0, 5)
});
_loadGeojsonData();
window.setTimeout(() => {
dispatch(
replaceDataInMap({
datasetToReplaceId: 'bart-stops-geo',
datasetToUse: {
info: {label: 'Bart Stops Geo Replaced', id: 'bart-stops-geo-2'},
data: sliceData
}
} as any)
);
}, 1000);
}, [dispatch, _loadGeojsonData]);
const _loadH3HexagonData = useCallback(() => {
// load h3 hexagon
dispatch(
addDataToMap({
datasets: [
{
info: {
label: 'H3 Hexagons V2',
id: 'h3-hex-id'
},
data: processCsvData(sampleH3Data)
}
],
config: h3MapConfig,
options: {
keepExistingConfig: true
}
})
);
}, [dispatch]);
const _loadS2Data = useCallback(() => {
// load s2
dispatch(
addDataToMap({
datasets: [
{
info: {
label: 'S2 Data',
id: s2DataId
},
data: processCsvData(sampleS2Data)
}
],
config: s2MapConfig as ParsedConfig,
options: {
keepExistingConfig: true
}
})
);
}, [dispatch]);
const _loadA5Data = useCallback(() => {
dispatch(
addDataToMap({
datasets: [
{
info: {
label: 'A5 Data',
id: a5DataId
},
data: processCsvData(sampleA5Data)
}
],
config: a5MapConfig as ParsedConfig,
options: {
keepExistingConfig: true
}
})
);
}, [dispatch]);
const _loadGpsData = useCallback(() => {
dispatch(
addDataToMap({
datasets: [
{
info: {
label: 'Gps Data',
id: 'gps-data'
},
data: processCsvData(sampleGpsData)
}
],
options: {
keepExistingConfig: true
}
})
);
}, [dispatch]);
const _loadContourData = useCallback(
(scattered = false) => {
dispatch(
addDataToMap({
datasets: [
{
info: {
label: scattered ? 'Synthetic scattered samples' : 'Synthetic scalar grid',
id: contourDataId
},
data: processCsvData(createContourCsv(scattered))
}
],
config: contourConfig as ParsedConfig,
options: {keepExistingConfig: true}
})
);
},
[dispatch]
);
const _loadFlowData = useCallback(() => {
dispatch(
addDataToMap({
datasets: [
{
info: {
label: 'NYC Flow Data',
id: 'flow_data'
},
data: processCsvData(sampleFlowData)
}
],
config: flowDataConfig,
options: {
keepExistingConfig: true
}
})
);
}, [dispatch]);
const _loadWmsLayer = useCallback(() => {
dispatch(
addDataToMap({
datasets: [
{
info: {
label: 'OpenStreetMap WMS',
id: 'osm-wms',
type: 'wms-tile'
},
data: {
fields: [],
rows: []
},
metadata: {
type: 'remote',
remoteTileFormat: 'wms',
tilesetDataUrl: 'https://ows.terrestris.de/osm/service',
tilesetMetadataUrl:
'https://ows.terrestris.de/osm/service?service=WMS&request=GetCapabilities',
version: '1.1.1',
layers: [
{
name: 'OSM-WMS',
title: 'OpenStreetMap WMS',
boundingBox: [-180, -88, 180, 88]
}
],
label: 'OpenStreetMap WMS'
},
disableDataOperation: true
}
],
options: {
autoCreateLayers: true,
centerMap: true
}
})
);
}, [dispatch]);
const _loadRasterTileLayer = useCallback(() => {
dispatch(
addDataToMap({
datasets: [
{
info: {
label: 'Swiss Historical Map',
id: 'swiss-historical-raster',
type: 'raster-tile'
},
data: {
fields: [],
rows: []
},
metadata: {
metadataUrl:
'https://public-bucket-for-tests.s3.us-east-1.amazonaws.com/historic-swis-18xx.pmtiles',
pmtilesType: 'raster'
},
disableDataOperation: true
}
],
options: {
autoCreateLayers: true,
centerMap: true
}
})
);
}, [dispatch]);
const _loadBitmapLayer = useCallback(() => {
dispatch(
addDataToMap({
datasets: [
{
info: {
label: 'SF Bitmap Overlay',
id: 'sf-bitmap',
type: 'bitmap'
},
data: {
fields: [],
rows: []
},
metadata: {
imageUrl:
'https://raw.githubusercontent.com/visgl/deck.gl-data/master/website/sf-districts.png',
bounds: [-122.5179, 37.70391916246189, -122.35462834588868, 37.830428246756696]
},
disableDataOperation: true
}
],
options: {
autoCreateLayers: true,
centerMap: true
}
})
);
}, [dispatch]);
const _loadTile3DLayer = useCallback(() => {
dispatch(
addDataToMap({
datasets: [
{
info: {
label: 'Royal Exhibition Building',
id: 'royal-exhibition-3d',
type: 'tile-3d'
},
data: {
fields: [],
rows: []
},
metadata: {
tile3dUrl:
'https://raw.githubusercontent.com/visgl/deck.gl-data/master/3d-tiles/RoyalExhibitionBuilding/tileset.json'
},
disableDataOperation: true
}
],
config: {
version: 'v1',
config: {
visState: {
effects: [
{
type: 'surfaceFog',
isEnabled: true,
parameters: {
density: 1,
height: 40,
thickness: 50,
fogColor: [70, 130, 180]
}
}
]
},
mapState: {
pitch: 0,
dragRotate: false
}
}
},
options: {
autoCreateLayers: true,
centerMap: true
}
})
);
}, [dispatch]);
const _loadSampleData = useCallback(() => {
const sample = new URLSearchParams(window.location.search).get('sample');
if (sample === 'contour' || sample === 'contour-scattered') {
_loadContourData(sample === 'contour-scattered');
}
// _loadPointData();
// _loadGeojsonData();
// _loadTripGeoJson();
// _loadIconData();
// _loadH3HexagonData();
// _loadS2Data();
// _loadA5Data();
// _loadScenegraphLayer();
// _loadGpsData();
// _loadRowData();
// _loadVectorTileData();
// _loadFlowData();
// _loadWmsLayer();
// _loadRasterTileLayer();
// _loadBitmapLayer();
// _loadTile3DLayer();
// _loadSyncedFilterWTripLayer();
// _replaceSyncedFilterWTripLayer();
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [
_loadPointData,
_loadGeojsonData,
_loadTripGeoJson,
_loadIconData,
_loadH3HexagonData,
_loadS2Data,
_loadA5Data,
_loadScenegraphLayer,
_loadGpsData,
_loadRowData,
_replaceData,
_loadVectorTileData,
_loadFlowData,
_loadContourData,
_loadWmsLayer,
_loadRasterTileLayer,
_loadBitmapLayer,
_loadTile3DLayer,
_loadSyncedFilterWTripLayer,
_replaceSyncedFilterWTripLayer
]);
return (
<StyleSheetManager shouldForwardProp={shouldForwardProp}>
<ThemeProvider theme={theme}>
<GlobalStyle
// this is to apply the same modal style as kepler.gl core
// because styled-components doesn't always return a node
// https://github.com/styled-components/styled-components/issues/617
// ref={node => {
// node ? (this.root = node) : null;
// }}
>
<Banner show={showBanner} height={BannerHeight} bgColor="#2E7CF6" onClose={hideBanner}>
<Announcement onDisable={_disableBanner} />
</Banner>
<div style={CONTAINER_STYLE}>
<PanelGroup direction="horizontal">
<Panel defaultSize={isAiAssistantPanelOpen ? 70 : 100}>
<PanelGroup direction="vertical">
<Panel defaultSize={isSqlPanelOpen ? 60 : 100}>
<div ref={mapContainerRef} style={{width: '100%', height: '100%'}}>
<KeplerGl
mapboxApiAccessToken={CLOUD_PROVIDERS_CONFIGURATION.MAPBOX_TOKEN}
id="map"
getState={keplerGlGetState}
width={mapDimensions.width}
height={mapDimensions.height}
cloudProviders={CLOUD_PROVIDERS}
localeMessages={messages}
onExportToCloudSuccess={onExportFileSuccess}
onLoadCloudMapSuccess={onLoadCloudMapSuccess}
featureFlags={DEFAULT_FEATURE_FLAGS}
onViewStateChange={onViewStateChange}
{...(Array.isArray(runtime.mapStyles)
? {
mapStyles: runtime.mapStyles,
mapStylesReplaceDefault: Boolean(runtime.mapStylesReplaceDefault)
}
: {})}
/>
</div>
</Panel>
{isSqlPanelOpen && (
<>
<StyledResizeHandle />
<Panel defaultSize={40} minSize={20}>
<SqlPanel initialSql={query.sql || ''} />
</Panel>
</>
)}
</PanelGroup>
</Panel>
{isAiAssistantPanelOpen && (
<>
<StyledVerticalResizeHandle />
<Panel defaultSize={30} minSize={20}>
<AiAssistantPanel
reduxStore={reduxStore}
stateAccessors={{
getVisState: () =>
(reduxStore?.getState() as any)?.demo?.keplerGl?.map?.visState,
getMapBoundary: () =>
(reduxStore?.getState() as any)?.demo?.aiAssistant?.keplerGl?.mapBoundary
}}
/>
</Panel>
</>
)}
</PanelGroup>
{/* Agent surfaces. Both render nothing: WebMCP registers the tools
with the browser; the bridge connects out to a local kepler-mcp
server when the page was opened with ?mcp=<token>. */}
<KeplerWebMcp reduxStore={reduxStore} />
<KeplerMcpBridge reduxStore={reduxStore} />
</div>
</GlobalStyle>
</ThemeProvider>
</StyleSheetManager>
);
};
export default App;